💻 computer science

SemanticVul: Evidence-Grounded Structured LLM Explanations for Vulnerability Detection

SemanticVul is a reproducible framework for C/C++ vulnerability detection that leverages locally generated, evidence-grounded semantic explanations to significantly improve accuracy and minority-class recall over existing baselines, while rigorously validating claims through deterministic code matching and dataset auditing.

Original authors: Abdul Razak, Ihtesham Ul Islam, Rabia Khan

Published 2026-10-15

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Abdul Razak, Ihtesham Ul Islam, Rabia Khan

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Software vulnerabilities are the hidden cracks in the digital world, the small mistakes in code that allow attackers to break into systems, steal data, or cause chaos. Because modern software is written in massive volumes, often in languages like C and C++ that are powerful but prone to these errors, human experts cannot possibly read every line to find the weak spots. To keep up, researchers have turned to artificial intelligence, specifically large language models, which are computer programs trained on vast amounts of text and code to understand patterns and meaning. These models can read a piece of software and explain what it is doing, offering a new way to spot dangerous flaws automatically. However, a significant problem has emerged: when these models are asked to explain code, they sometimes invent details that aren't there or accidentally reveal the answer before the analysis is even finished, making their help unreliable for critical security work.

A team of researchers at the National University of Sciences and Technology in Pakistan has developed a new system called SemanticVul to solve this problem. Instead of relying on expensive, commercial AI services that generate free-flowing, unverified text, their system uses a locally run, open-source model to produce structured, evidence-based explanations. The researchers built a pipeline where the AI must point to specific lines of code to back up every claim it makes about a security risk. If the AI cannot find the code it is talking about, the system discards that claim. They then tested this approach on two major collections of real-world software functions, known as Devign and Reveal, to see if this grounded, evidence-backed method could find more vulnerabilities than previous techniques.

The results show that this careful, evidence-first approach works significantly better than the standard methods currently in use. On the Reveal dataset, which contains a very small number of vulnerable functions mixed among many safe ones, the new system improved the ability to find those rare dangerous functions from about 40 percent to 63 percent. This is a crucial improvement because missing a vulnerability in a real-world system can be catastrophic. The system also managed to double the number of times it correctly linked its warnings to actual code snippets, while cutting the number of times it hallucinated or invented code references in half. By forcing the AI to stick to the facts present in the code and scrubbing out any language that might accidentally give away the answer, the researchers created a more trustworthy and effective tool for security analysis.

The researchers also explored how to best combine the raw code data with these new explanations. They tested three different ways of merging this information: using the code alone, mixing the code and explanation with a fixed method, and using a smart switch that decides for each piece of code how much weight to give the explanation. While the smart switch performed slightly better in some initial tests, the improvement was not consistent enough to be considered a definitive breakthrough. The most reliable finding was that the explanation channel itself—the part that provides the evidence-grounded reasoning—was the primary driver of the success. The system proved that when you strip away the guesswork and force the AI to anchor its reasoning in the actual text of the program, it becomes a far more powerful detector of security flaws.

Beyond just finding bugs, the study also uncovered issues with the data sets used to train and test these systems. The researchers found that some of the standard benchmarks contained duplicate code with conflicting labels, where the same function was marked as both safe and dangerous in different parts of the data. This kind of error can trick a computer into thinking it has learned something it hasn't actually learned. By auditing these data sets and cleaning out the contradictions, the team ensured that their results were based on genuine learning rather than memorizing errors. This attention to data quality, combined with the new method of generating explanations, suggests a path forward for building more reliable security tools that do not just guess, but actually understand the code they are protecting.

Technical Summary: SemanticVul

Problem Statement
While Large Language Models (LLMs) offer promising semantic information for vulnerability detection, their application in security-critical contexts is hindered by three primary issues: the high cost and lack of reproducibility associated with proprietary API inference, the generation of unsupported or "hallucinated" claims, and the leakage of ground-truth labels into explanations (e.g., using verdict words like "vulnerable" in the reasoning). Furthermore, existing fusion methods often rely on a single, fixed mechanism, making it difficult to distinguish whether performance gains stem from the explanation content itself or the additional parameters of the fusion block. Previous work, such as FuSEVul, utilizes commercial, free-form prose explanations that are un-audited and prone to these failure modes.

Methodology
SemanticVul is a function-level binary vulnerability detection framework for C/C++ code that addresses these gaps through two core innovations: an evidence-grounded structured explanation pipeline and a controlled fusion ladder.

Evidence-Grounded Structured Explanation Pipeline:
- Local Generation: Instead of relying on commercial APIs, SemanticVul uses a locally served, open-weight code LLM (Qwen2.5-Coder 14B) to generate explanations offline.
- Schema Constraints: The model is forced to output a schema-constrained JSON object containing specific fields: purpose, data flow, risky operations, missing checks, evidence tokens, safety indicators, risk summary, and risk level.
- Deterministic Validation: A validator enforces a "grounding contract." It performs whitespace-insensitive code matching to ensure that claims about risky operations or missing checks are linked to actual substrings within the analyzed function. Unsupported claims are dropped, and the explanation is regenerated if necessary.
- Leakage Safety: The pipeline scrubs all verdict-related vocabulary (e.g., "vulnerable," "exploit") from the text before encoding.
- Confidence Measurement: Instead of self-reported confidence, the system measures a scalar confidence value ( $\kappa$ ) based on the decode-time log-probabilities of the generated risk level tokens. This value is fed to the detector as an auxiliary feature.
- Encoding: The validated, scrubbed JSON text is encoded using RoBERTa, while the source code is encoded using CodeT5+.
Controlled Fusion Ladder (L1–L3):
To isolate the contribution of the explanation channel from the fusion mechanism, the authors train three configurations under matched conditions:
- L1 (Code-Only): A baseline using only the code encoder output.
- L2 (Static Attention Fusion): A fixed cross-attention mechanism (similar to FuSEVul) that fuses code and explanation token states.
- L3 (Adaptive Gating): A per-sample adaptive gate that learns a convex combination weight ( $w$ ) to mix the pooled code and explanation vectors. The gate takes the explanation vector and the measured confidence $\kappa$ as input.

Key Contributions

Local, Grounded Explanation Pipeline: Replaces commercial free-form prose with a local, schema-constrained, evidence-grounded generator. On matched Reveal functions, this approach more than doubles API-mention grounding (from 26.2% to 55.4%), halves hallucinated call mentions, and provides explicit evidence anchors for 87% of functions.
Controlled Fusion Ladder: Introduces an L1–L3 training framework that separates the utility of the explanation channel from the fusion mechanism. The results show the explanation channel provides the most durable gain (up to +17.5 F1 over code-only), while the adaptive gate's advantage over static fusion is not statistically resolved.
Performance Improvements: Under a base-comparable protocol, SemanticVul achieves substantial gains over the reported FuSEVul reference results: +8.60 accuracy and +7.31 F1 on Devign, and +1.23 accuracy and +15.09 F1 on Reveal. Notably, minority-class recall on Reveal increases from 39.52% to 63.00%.
Data-Quality Audit: A public audit of the distributed Devign and Reveal splits reveals significant data quality issues, including label-conflicting duplicates and cross-split leakage, which imply conditional memorization bounds of ~99.0% (Devign) and ~96.96% (Reveal).

Experimental Results

Overall Performance: SemanticVul outperforms the published FuSEVul reference on both datasets. The L2 (static fusion) configuration is identified as the primary configuration because its improvements hold under both base-comparable and held-out evaluation protocols.
Explanation Utility: Moving from L1 (code-only) to L2 (with explanations) yields significant F1 gains (+9.56 on Devign, +17.16 on Reveal), confirming the value of grounded semantic signals.
Grounding Quality: The validation pipeline successfully reduces hallucinations. API-mention grounding improved from 26.2% to 55.4%, and the rate of absent-call claims dropped from 76.0% to 46.7%.
Adaptive Gating: While the L3 adaptive gate achieved the highest F1 under the base-comparable protocol, five-seed paired t-tests showed no statistically significant difference between L3 and L2. The advantage of the gate was not consistent under held-out evaluation, suggesting it should not yet be interpreted as a definitive contribution over static fusion.
Threshold and Ensembling: Threshold tuning and multi-seed ensembling provided additional gains, particularly on the imbalanced Reveal dataset, though these are reported as optimistic upper bounds rather than deployment estimates.

Significance and Claims
The paper claims that locally generated, evidence-grounded explanations can provide a reproducible semantic signal for vulnerability detection, effectively replacing costly and un-audited commercial APIs. The study emphasizes that rigorous split auditing and held-out evaluation are critical when assessing explanation-driven improvements, as data leakage and label contradictions can inflate reported scores.

The authors maintain a modest stance regarding the adaptive gating mechanism, noting that while it performs well in specific settings, its superiority over static fusion is not statistically robust. The primary contribution is validated as the grounded explanation channel itself, which significantly improves detection utility, particularly for minority classes in imbalanced datasets, without relying on proprietary infrastructure or unverified reasoning. The work underscores the necessity of separating the explanation's content from the fusion mechanism to accurately measure its impact.

Technical Summary: SemanticVul

More like this