🤖 AI

VulTriage: Triple-Path Context Augmentation for LLM-Based Vulnerability Detection

VulTriage is a novel framework that enhances LLM-based vulnerability detection by integrating control flow, domain-specific knowledge, and semantic summaries through a triple-path context augmentation strategy, achieving state-of-the-art performance on benchmark datasets.

Original authors: Wenxin Tang, Xiang Zhang, Junliang Liu, Jingyu Xiao, Xi Xiao, Jinlong Yang, Yuehe Ma, Zhenyu Liu, Zhengheng Li, Zicheng Wang, Wang Luo, Qing Li, Lei Wang, Peng Xiangli

Published 2026-05-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Wenxin Tang, Xiang Zhang, Junliang Liu, Jingyu Xiao, Xi Xiao, Jinlong Yang, Yuehe Ma, Zhenyu Liu, Zhengheng Li, Zicheng Wang, Wang Luo, Qing Li, Lei Wang, Peng Xiangli

Original paper licensed under CC BY 4.0 (http://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

Imagine you are hiring a brilliant but slightly distracted detective to find hidden traps in a massive, complex building blueprint. This detective is an AI (Large Language Model). While the AI is incredibly smart and knows a lot about language, if you just hand it the raw blueprint (the source code) and ask, "Is there a trap here?", it often misses subtle dangers or raises false alarms. It might get lost in the thousands of tiny lines of text without seeing the big picture of how the building is actually put together.

The paper introduces a new system called VulTriage (think of it as a "Triage" or sorting system for vulnerabilities). Instead of just handing the AI the raw blueprint, VulTriage acts as a smart assistant that prepares three specific "cheat sheets" to help the detective solve the case.

Here is how the Triple-Path Context Augmentation works, using simple analogies:

1. The Control Path: The "Traffic Map"

The Problem: Raw code is like a list of words. It doesn't show you how a car moves through a city. A vulnerability might happen because a car (data) takes a specific route that skips a stop sign (a safety check).
The Solution: The Control Path takes the code and draws three specific maps for the AI:

AST (The Skeleton): Shows the building's structure (walls, floors, rooms).
CFG (The Traffic Flow): Shows the order of operations (which road leads to which).
DFG (The Water Pipes): Shows how data flows from one place to another.
The Magic: Instead of showing the AI a messy, giant graph, this path translates those maps into a simple, plain-English summary. It tells the AI, "Hey, look here: this variable travels from the user input, through a loop, and ends up in a memory spot without checking the size first." This fixes the AI's "structural blindness."

2. The Knowledge Path: The "Criminal Database"

The Problem: The AI was trained on general internet text. It knows what a "buffer overflow" is in a vague sense, but it doesn't have a specific, organized list of known trap types or examples of how bad guys usually build them.
The Solution: Before the AI makes a judgment, the Knowledge Path acts like a librarian. It looks at the code and asks, "What kind of trap might this be?" It then goes to a massive, official database of known weaknesses (called CWE) and pulls out the top 3-5 most relevant "Wanted Posters" and examples of similar crimes.
The Magic: It hands these specific examples to the AI, saying, "Remember this specific type of trap? Check if the code looks like it." This gives the AI explicit, expert-level knowledge it might have forgotten or never learned clearly.

3. The Semantic Path: The "Plain English Summary"

The Problem: Real-world code is full of confusing shortcuts, hidden loops, and tricky math. Even a smart AI can misinterpret what a piece of code is actually trying to do if it gets bogged down in the details.
The Solution: The Semantic Path asks the AI to take a step back and write a short, clean summary of what the code is supposed to do, ignoring the confusing syntax.
The Magic: It's like asking a translator to explain a complex legal document in simple terms before asking a judge to rule on it. This "denoised" view helps the AI understand the intent of the programmer, making it harder to miss a subtle logic error.

How They Work Together

Once these three "cheat sheets" are ready, VulTriage combines them into one giant, super-instruction for the AI:

"You are an expert security detective. Here is the Blueprint (Code). Here is the Traffic Map (Control Path). Here are the Wanted Posters for similar crimes (Knowledge Path). Here is a Simple Summary of what the building does (Semantic Path). Based on all this, is there a trap?"

The Results

The authors tested this system on a difficult dataset called PrimeVul, where the "traps" (vulnerable code) and "safe" code look almost identical, differing only by tiny, subtle details.

The Winner: VulTriage beat all other methods, including other AI models and deep learning tools. It was much better at spotting the subtle differences that other systems missed.
The Proof: When they removed any one of the three "cheat sheets" (the maps, the database, or the summary), the AI's performance dropped. This proved that all three parts are necessary to solve the puzzle.
The Bonus: They also tested it on a different, less common programming language (Kotlin) with very little data available. Even in this "low-resource" setting, VulTriage still performed better than the competition, showing it's a flexible tool.

In short: VulTriage doesn't just ask the AI to guess; it gives the AI the right tools, the right reference books, and a clear explanation of the problem, turning a confused detective into a master investigator.

Technical Summary: VulTriage

Problem Statement

Automated vulnerability detection remains a critical challenge in software security. While existing deep learning methods (e.g., GNNs and pre-trained code models) have made progress, they face significant limitations: GNN-based approaches often require complex graph construction and high-quality labels, while pre-trained models typically treat code as linear token sequences, struggling to capture structural dependencies and execution semantics.

Recent Large Language Models (LLMs) show promise in code understanding but suffer from three specific deficiencies when applied directly to raw source code for vulnerability detection:

Structural Blindness: LLMs process code as token sequences, making it difficult to identify cross-statement control-flow paths and data-propagation chains essential for detecting vulnerabilities like buffer overflows.
Knowledge Deficiency: General-purpose pre-training yields implicit and scattered security knowledge. LLMs lack explicit domain priors, such as vulnerability taxonomies (e.g., CWE) and specific vulnerable code patterns.
Semantic Gap: Complex program logic involving pointer operations, nested branches, and implicit type conversions can lead to subtle semantic misunderstandings, causing false positives or missed vulnerabilities.

Methodology: VulTriage

To address these limitations, the authors propose VulTriage, a framework that augments LLM-based vulnerability detection through Triple-Path Context Augmentation. Instead of prompting the LLM with raw code alone, VulTriage constructs three complementary context streams that are integrated into a unified instruction to guide the final reasoning.

1. Control Path (Structural Context)

This path aims to alleviate structural blindness by extracting and verbalizing static structural information.

Process: The source code is parsed into three structural graphs: Abstract Syntax Tree (AST), Control-Flow Graph (CFG), and Data-Flow Graph (DFG).
Filtering: To manage context window limits and reduce noise, a multi-granularity filtering mechanism is applied. It retains skeleton nodes (functions, branches, loops) and key operators while removing semantically irrelevant nodes (e.g., type expansions).
Verbalization: The filtered graphs are converted into compact natural-language descriptions summarizing code composition, execution paths, and data propagation chains.

2. Knowledge Path (Domain Priors)

This path addresses knowledge deficiency by injecting explicit vulnerability patterns via Retrieval-Augmented Generation (RAG).

Knowledge Base: A corpus is built from the Common Weakness Enumeration (CWE) database, containing vulnerability names, descriptions, and code examples.
Query Generation: The LLM first generates a coarse prediction of potential vulnerability types for the input code to serve as a retrieval query.
Hybrid Retrieval: A hybrid dense–sparse retrieval mechanism (using BGE-M3) matches the query against the CWE corpus. This combines semantic generalization (dense vectors) with lexical precision (sparse weights) to ensure critical terms are not lost.
Assembly: The top-k retrieved CWE entries are concatenated to form a knowledge context $K$ that anchors the LLM's judgment.

3. Semantic Path (Functional Explanation)

This path mitigates the semantic gap by providing a denoised functional view of the code before the final verdict.

Process: The LLM is queried to analyze the code and generate a concise natural-language explanation ( $E$ ) of its functional behavior.
Focus: The explanation highlights key operations (input handling, memory ops, system calls) and observable data flows, while explicitly avoiding speculation about unobservable intent.

Unified Instruction

The original code ( $C$ ), structural context ( $S$ ), knowledge context ( $K$ ), and semantic explanation ( $E$ ) are assembled into a single instruction prompt. The LLM is instructed to act as a security engineer, inspecting the code through the lens of the retrieved knowledge and structural dependencies before issuing a strict "Yes/No" verdict.

Key Contributions

VulTriage Framework: A novel LLM-based detection system driven by Triple-Path Context Augmentation, integrating structural, knowledge-based, and semantic contexts.
Control Path Design: A mechanism to compress AST, CFG, and DFG information into LLM-friendly natural language, enabling better perception of control and data dependencies.
Knowledge Path Design: A hybrid dense–sparse retrieval system that dynamically retrieves CWE-derived patterns to provide explicit domain priors.
Comprehensive Evaluation: Extensive experiments demonstrating the framework's effectiveness and generalization capabilities.

Experimental Results

The framework was evaluated on the PrimeVul pair test set, a benchmark designed to test fine-grained discrimination between vulnerable and fixed code pairs.

Performance: VulTriage achieved state-of-the-art performance, outperforming both deep learning baselines (CodeBERT, CodeT5, UniXCoder, LineVul) and existing LLM-based methods (VulTrial, ConColl, GPTLens).
- It achieved 147 Pair-wise Correct (P-C) predictions, significantly outperforming the next best LLM-based baseline (VulTrial at 81).
- It attained an Accuracy of 0.6356 and an F1-score of 0.6907, leading all baselines on these primary metrics.
Ablation Studies: Removing any of the three paths (Control, Knowledge, or Semantic) resulted in performance degradation.
- Removing the Control Path increased errors, highlighting the need for structural evidence.
- Removing the Knowledge Path increased the False Positive Rate (FPR), indicating the value of explicit vulnerability patterns.
- Removing the Semantic Path lowered Accuracy and F1, confirming the importance of functional understanding.
Generalization: Experiments on a low-resource Kotlin dataset (class-imbalanced) showed VulTriage achieving an F1-score of 0.57, outperforming ConColl (0.44) and other baselines, demonstrating robustness in low-resource settings.
Attention Analysis: Analysis of attention scores revealed that the model utilizes all input contexts complementarily: Source Code and Semantic explanations are weighted heavily in early layers, Knowledge in middle layers, and Structural Info in late layers.

Significance

The paper claims that VulTriage demonstrates that structured, knowledge-aware, and semantic context augmentation is an effective direction for improving LLM-based vulnerability detection. By moving beyond raw token sequences and explicitly providing structural dependencies, domain-specific knowledge, and functional summaries, the framework enables LLMs to reason more reliably about subtle vulnerability differences. The results suggest that this approach effectively bridges the gap between the general capabilities of LLMs and the specific, rigorous demands of software security analysis.