Paper deep dive
VICBench: A Multi-Language Benchmark for Code Vulnerability Detection
Jin Lu, Xuening Han, Yang Zhong, Lin Tan, Kevin Luo, Andrew Gacek, Neha Rungta
Intelligence
Status: not_run | Model: - | Prompt: - | Confidence: 0%
Entities (0)
Relation Signals (0)
No relation signals yet.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Evaluating security vulnerability detection tools requires benchmark datasets with vulnerability-inducing commits (VICs) - the commits that first introduce vulnerabilities into codebases. VICs are essential for determining the full range of vulnerable software versions. Existing vulnerability datasets suffer from limited programming language coverage, restricted patch complexity, and narrow project scope. Through our dual annotation by human experts and an agentic workflow, we create a benchmark - VICBench - of 100 verified VICs for 100 CVEs across 88 projects in Python, Java, and C++, covering 48 CWE types. VICBench features complex real-world vulnerability fixes averaging 38.6 lines and corresponding VICs of 252.5 lines - significantly larger than prior work. Our evaluation shows that state-of-the-art algorithms V-SZZ and LLM4SZZ achieve only 33.3%-40.1% F1, confirming that using existing approaches still entails significant manual effort. VICBench enables robust evaluation of vulnerability detection approaches.
Tags
Links
- Source: https://arxiv.org/abs/2608.12246v1
- Canonical: https://arxiv.org/abs/2608.12246v1
Trouble viewing inline? Open PDF directly â
Full Text
30,034 characters extracted from source content.
Expand or collapse full text
VICBench: A Multi-Language Benchmark for Code Vulnerability Detection Jin Lu Xuening Han Yang Zhong Affiliation: University of Pittsburgh Lin Tan Affiliation: Purdue University[-0.5em] jinlu2@asu.eduxuenihan@amazon.comyaz118@pitt.edulintan@purdue.edu Kevin Luo Andrew Gacek Neha Rungta [-0.2em] Amazon Web Services Abstract Evaluating security vulnerability detection tools requires benchmark datasets with vulnerability-inducing commits (VICs)âthe commits that first introduce vulnerabilities into codebases. VICs are essential for determining the full range of vulnerable software versions. Existing vulnerability datasets suffer from limited programming language coverage, restricted patch complexity, and narrow project scope. Through our dual annotation by human experts and an agentic workflow, we create a benchmarkâVICBenchâof 100 verified VICs for 100 CVEs across 88 projects in Python, Java, and C++, covering 48 CWE types. VICBench features complex real-world vulnerability fixes averaging 38.6 lines and corresponding VICs of 252.5 linesâsignificantly larger than prior work. Our evaluation shows that state-of-the-art algorithms V-SZZ and LLM4SZZ achieve only 33.3%â40.1% F1, confirming that using existing approaches still entails significant manual effort. VICBench enables robust evaluation of vulnerability detection approaches. 1 Introduction Software vulnerability detection is critical for system security. Proactive detectionâidentifying vulnerabilities before they reach productionâhas become increasingly important as detection approaches evolve from static analyzers to deep learning models (11; 22; 16) and LLM-powered code review assistants (10; 1). Robust evaluation of these diverse approaches requires high-quality benchmark datasets with vulnerability-inducing commits (VICs). Following 2, we define VICs as the commits that first introduce vulnerabilities into codebases. VICs mark the beginning of vulnerability lifecycles and represent the transition from non-vulnerable to exploitable code, enabling evaluation on original vulnerability patterns before refactoring obscures the initial flaw. A comprehensive benchmark requires repository context, CVE descriptions, fixing commits, and critically, VICs. While the National Vulnerability Database (14) provides CVE descriptions and fixes, VICs are not documented. This allows assessing whether tools can detect vulnerabilities at their source and tracking detection capability throughout vulnerability evolution. Without VICs, benchmarks can only evaluate tools on evolved vulnerability forms before fixes, missing evaluation on the earliest and most critical vulnerability patterns. Existing VIC datasets have significant limitations. V-SZZ (2) verified 172 CVEs but restricted annotations to 1-5 deleted lines, excluding complex multi-file patches. 8 contributed 1,000+ VICs but focused solely on Linux kernel (C/C++), limiting generalizability. 5 annotated 1,128 C/C++ vulnerabilities at high cost (0.5 person-hours each) but did not release VIC annotations. Modern approaches require greater language diversity, patch complexity, and project coverage. Moreover, automated VIC detection faces challenges. Tracing-based methods such as SZZ (21) and variants (2; 23) use git-blame heuristics, which struggle with file refactoring, cross-file code movement, and complex vulnerability semantics. Unlike regular bugs, vulnerabilities persist longer due to fundamental design flaws (13) and often involve addition-only fixes without deleted lines (5), making traditional approaches ineffective, with studies showing SZZ variants achieve as low as 9% precision and a best-case F-measure of only 61% even on regular bugs (19). Our contributions include: âą A benchmark of 100 verified VICs for 100 CVEs across 88 projects, 3 programming languages (Python, Java, and C++), and 48 CWE types. Our dataset features significantly larger patches than prior work: fix commits average 38.6 lines and VICs average 252.5 lines. âą A dual-annotation approach with human expert verification and agentic workflow assistance achieving Îș=0.707 agreement, ensuring data quality and scalable dataset construction. âą An evaluation showing that existing VIC detection algorithms achieve only 33.3%â40.1% F1, indicating that existing automated approaches are not substitutes for manual annotation. Availability: https://zenodo.org/records/18944736 2 Background and Related Work Vulnerability-Inducing Commit Detection Tracing-based approaches for identifying VICs build on the Ćliwerski-Zimmermann-Zeller (SZZ) algorithm (21), originally designed for bug-inducing commits. VCCFinder (15) first adapted SZZ to vulnerabilities, followed by variants including AG-SZZ (9), MA-SZZ (7), and RA-SZZ (12) evaluated in V-SZZ (2). Recent approaches like SEM-SZZ (24) use semantic analysis with data and control flow, while Vercation (6) and LLM4SZZ (23) incorporate LLMs for improved analysis. However, these methods struggle with file refactoring, cross-file code movement, and addition-only fixes (5). Concurrent work by 20 addresses some of these limitations using graph-based reasoning for general bug-inducing commits, though without released datasets or security-specific focus. These challenges motivate the need for manually curated benchmarks that capture real-world complexity. Vulnerability-Inducing Datasets Given the distinction between bug-inducing and vulnerability-inducing tasks (3), several VIC datasets have been developed. VCCFinder (15) constructed 718 CVEs but was found unreproducible (17). V-SZZ (2) manually verified 172 CVEs across 46 projects but restricted annotations to fixes with 1-5 deleted lines, limiting coverage of complex patches. 8 contributed 1,000+ VICs but focused solely on Linux kernel (C/C++), limiting language diversity. Concurrent work by 5 curated 1,128 C/C++ vulnerabilities from nine projects at high annotation cost (0.5 person-hours each) but did not release VIC annotations. Our dataset addresses these limitations by covering 100 CVEs across three programming languages (Python, Java, and C++) and 88 projects with significantly larger and more complex patches (Table 1), providing a robust publicly-available benchmark for evaluating vulnerability detection approaches. 3 Motivating Example CVE-2021-44878, a pac4j vulnerability accepting unsigned ID tokens, demonstrates cross-file code movement defeats git-blame approaches (Figure 1). 201620182021c06d1dbAug 2016 Initial VIC OidcProfileCreator d60a490Nov 2018 V-SZZ & LLM4SZZ stopped here to TokenValidator 22b82ffDec 2021 Security Fix Added validation Vulnerability Persists Figure 1: CVE-2021-44878 evolution timeline. V-SZZ and LLM4SZZ stopped at the 2018 refactoring commit (d60a490) where code moved to a new file, missing the true VIC (c06d1db) from 2016. Step 1: Initial Introduction (c06d1db, Aug 2016) The vulnerability was introduced in OidcProfileCreator.java, accepting unsigned tokens without validation: ⏠if ("none".equals(jwsAlgorithm.getName())) jwsAlgorithm = null; // UNSAFE: Accept unsigned tokens ... if (jwsAlgorithm == null) this.idTokenValidator = new IDTokenValidator( issuer, clientID); // No signature verification! Step 2: Code Movement (d60a490, Nov 2018) Code extracted to TokenValidator.java, preserving the vulnerable pattern: ⏠if ("none".equals(jwsAlgorithm.getName())) jwsAlgorithm = null; // STILL UNSAFE ... if (jwsAlgorithm == null) idTokenValidator = new IDTokenValidator( issuer, clientID); // STILL no verification! Step 3: Security Fix (22b82ffd, Dec 2021) Added validation to reject unsigned tokens: ⏠-if ("none".equals(jwsAlgorithm.getName())) - jwsAlgorithm = null; - final IDTokenValidator idTokenValidator; -if (jwsAlgorithm == null) +if ("none".equals(jwsAlgorithm.getName())) + if (!configuration.isAllowUnsignedIdTokens()) + throw new TechnicalException(...) + logger.warn("Allowing unsigned ID tokens"); idTokenValidator = new IDTokenValidator(...); Git Blame Limitation Both V-SZZ and LLM4SZZ rely solely on git blame, which returns commit d60a490 with âNew Fileâ markers when tracing TokenValidator.java. Git blame cannot track cross-file code movementâonly file renamesâcausing both algorithms to misidentify the refactoring commit as the vulnerability origin. Pattern-Based Identification VIC-Agent combines git blame with LLM-guided pattern search using git log -S to cross file boundaries. By extracting the vulnerable pattern and searching across all files and history, it found two candidates: d60a490 (2018) in TokenValidator.java and c06d1db (2016) in OidcProfileCreator.java. It classified d60a490 as refactoring and verified c06d1db as the true VIC. This example demonstrates that VIC detection requires reasoning about vulnerability semantics and code evolution across file boundaries, motivating the need for manually curated benchmarks. An additional case study (CVE-2019-15477) in Appendix A.1 illustrates complementary challenges. 4 Benchmark Creation 4.1 Annotation Approach To ensure accurate labeling of VICs, we design a workflow (Figure 2) in which two independent procedures identify VICs for each vulnerability, and their results are then cross-validated to resolve discrepancies. 4.1.1 Procedure 1: Human Annotation One author with nine years of programming experience annotated VICs for all 100 instances. Following 18 and V-SZZ (2), the annotator iteratively traced modified lines using CVE/CWE descriptions, commit messages, and git blame. While V-SZZ identifies the earliest commit containing vulnerable lines (2), our annotation focuses on when the vulnerability as a security flaw was semantically introducedâcritical for cases involving refactoring or code movement. This required: (1) examining function names and program logic for addition-only fixes; (2) tracking only security-relevant lines. Data Sources CVE Instances Human A Annot. VIC- Agent Compare Disagree Agree Human B Resolve Ground Truth Expert Valid. Final Dataset Figure 2: Annotation workflow: data collection, independent annotation procedures (human and agentic), disagreement resolution, and expert validation. 4.1.2 Procedure 2: VIC-Agent To validate the robustness of our manual annotations and enable scalable dataset construction, we developed VIC-Agent, an automated workflow powered by large language models. Unlike traditional SZZ algorithms that rely on fixed heuristics, VIC-Agent brings critical flexibility through adaptive decision-making at each step, dynamically selecting between git tools (git blame, git log -S, git show) and employing LLM-based vulnerability analysis and commit verification. The agent first analyzes the CVE description and fixing commit to understand the vulnerabilityâs security semantics. When examining candidate commits, it uses LLM reasoning to verify whether a commit introduced new vulnerable logic or merely refactored existing vulnerable code. For refactored commits, it continues searching backwards through the pattern evolution chain. This enables VIC-Agent to handle real-world complexitiesâfile renames, cross-file movements, and refactoring patternsâthat static algorithms cannot address. VIC-Agent achieved 84.4% recall and 94.9% precision in agreement with human annotations (see Section 5), reflecting its role as a construction tool and validating the dataset quality. 4.2 Quality Validation Two annotations were considered in agreement if and only if both identified the exact same commit. Inter-Annotator Agreement: Human A and VIC-Agent achieved 71% observed agreement (71 of 100 cases). Computing Cohenâs kappa with chance agreement correction (see Appendix A.3 for details), we obtained Îș=0.707Îș=0.707, indicating substantial agreement. The observed agreement (71%) far exceeds chance expectation (1.15%). Disagreement Resolution: For the 29 disagreement cases, a second human annotator (Human B) independently reviewed each instance, examining commit context, vulnerability semantics, and code evolution history. Human B incorporated insights from Human Aâs annotations and VIC-Agentâs reasoning to establish the ground truth annotations. Expert Validation: To further validate dataset quality, a principal security engineer with 16 years of security experience independently reviewed a random sample of 11 instances from the final dataset (11%). This validation confirmed the correctness of the vulnerability-inducing commit identifications and provided additional confidence in the datasetâs reliability. 4.3 Data Sources We randomly sampled 100 instances from 88 projects across Python, Java, and C/C++ from three datasets: (1) ReposVul (25), filtered for entries with CVE-relevant files, (2) CWE-Bench-Java (10), and (3) VJBench (26). Our data set cover diverse CWE and patch types. 5 Dataset Analysis 5.1 Dataset Composition and Characteristics Vulnerability Type Coverage: Our dataset encompasses 48 unique CWE types across 100 CVEs, with Cross-site Scripting (CWE-79, 12%) and Path Traversal (CWE-22, 10%) being most prevalent (see Appendix A.2). This diversity ensures comprehensive evaluation across varied security contexts. Patch Complexity: Table 1 compares VICBench with existing benchmarks. Fix commits average 38.6 lines changed (median: 22), while VICs average 252.5 lines (median: 181). This 6.5X difference reflects real-world scenarios where vulnerabilities occur in larger feature implementations. Dataset N Lang Prj Fix/VIC Pub V-SZZ (2) 172 C/Ja 46 1-5 / - Y Jiang et al. (8) 1000+ C 1 - / - Y Chen et al. (5) 1128 C 9 Div / - N Ours 100 Py/Ja/C 88 39 / 253 Y Table 1: Dataset comparison. Fix/VIC Lines show mean changed lines. Pub: Y/N indicates publicly available/unavailable. Our dataset has larger patches, languages (Python/Java/C++), and more projects than prior work. 5.2 VIC Detection Performance and Dataset Construction Validation To demonstrate that our dataset could not be trivially acquired by running existing algorithms, we evaluated V-SZZ (2) (Java/C++ subset, 40 CVEs) and LLM4SZZ (23) (all 100 instances). Table 2 shows that V-SZZ achieves 33.3% F1 and LLM4SZZ achieves 40.1% F1, demonstrating that our dataset captures complexities beyond current automated approaches. Accurate VIC identification has practical implications for version range determination: 2 found that 99 out of 172 CVEs had spurious version information in NVD and proposed an improved SZZ algorithm to address this. However, cases involving code refactoring and cross-file movement remain challengingâfor example, in our motivating example of CVE-2021-44878 (Section 3), identifying the 2018 refactoring rather than the 2016 true VIC would incorrectly exclude two years of vulnerable versions. Our VIC-Agent achieves 89.3% F1 by focusing on semantic vulnerability introduction, extending prior work to handle such complex scenarios. Note that VIC-Agentâs performance should be interpreted as a construction-tool reference ceiling rather than an independent evaluation, as it participated in the annotation process (4). Method Recall Precision F1 Score V-SZZâ 52.3% 24.5% 33.3% LLM4SZZ 56.9% 31.0% 40.1% VIC-Agent 84.4% 94.9% 89.3% Table 2: VIC detection performance. â V-SZZ on Java/C++ only (40 CVEs), LLM4SZZ and VIC-Agent on all 100 instances. 6 Conclusion We present a benchmark of 100 verified vulnerability-inducing commits across Python, Java, and C++, addressing critical gaps in existing VIC datasets. Through dual annotation achieving Îș=0.707 agreement, our dataset captures real-world complexity with significantly larger patches than prior work. Evaluation shows state-of-the-art algorithms achieve only 33.3%â40.1% F1, confirming the necessity of manual curation. This benchmark enables robust evaluation of vulnerability detection approaches and supports research in proactive security tooling. Limitations While our dataset advances VIC benchmarking, several limitations should be acknowledged: Dataset Scale and Coverage: Our dataset contains 100 manually verified CVEs, which is smaller than some automatically constructed datasets but prioritizes annotation quality over quantity. The dataset covers three programming languages (Python, Java, C++), which may not generalize to other languages such as JavaScript, Go, or Rust. Additionally, C++ is underrepresented at 8% (8 CVEs), reflecting its limited availability in our source datasets (ReposVul, CWE-Bench-Java, VJBench) rather than a deliberate design choice; this may limit the benchmarkâs utility for evaluating tools targeting C/C++ codebases specifically. Future work could expand coverage to additional languages and larger scale while maintaining annotation quality. Data Source Selection: Our CVEs were sampled from existing curated datasets (ReposVul, CWE-Bench-Java, VJBench), which may introduce sampling bias toward certain project types, vulnerability patterns, or temporal distributions. The dataset focuses on open-source projects from public repositories, and findings may not fully generalize to proprietary or closed-source codebases. Single VIC Assumption: Our annotation focused on identifying the primary vulnerability-inducing commit for each CVE. Some vulnerabilities may result from multiple contributing commits across different timeframes, which our current annotation does not capture exhaustively. Ethical Considerations This work presents a benchmark dataset for evaluating vulnerability-inducing commit (VIC) detection tools. All CVEs and source code used in this benchmark are publicly available through the National Vulnerability Database (14) and open-source repositories. No private or proprietary data was collected. We acknowledge the dual-use nature of security benchmarks: while VICBench is intended to advance the evaluation of defensive security tools, detailed vulnerability information could theoretically inform offensive use. To mitigate this risk, all CVEs included in this dataset are already publicly disclosed and patched. The benchmark does not introduce new vulnerability information beyond what is already publicly available. No human subjects were involved in dataset construction. The annotation process was conducted by the authors and a security expert reviewer. References Anthropic (2025) Anthropic Automate security reviews with claude code. Anthropic. Note: Accessed: 2025 External Links: Link Cited by: §1. Bao et al. (2022) L. Bao, X. Xia, A. E. Hassan, and X. Yang V-szz: automatic identification of version ranges affected by cve vulnerabilities. In 2022 IEEE/ACM 44th International Conference on Software Engineering (ICSE), Vol. , p. 2352â2364. External Links: Document Cited by: §1, §1, §2, §2, §4.1.1, §5.2, Table 1. Camilo et al. (2015) F. Camilo, A. Meneely, and M. Nagappan Do bugs foreshadow vulnerabilities? a study of the chromium project. In 2015 IEEE/ACM 12th Working Conference on Mining Software Repositories, Vol. , p. 269â279. External Links: Document Cited by: §2. Cao et al. (2025) J. Cao et al. Rigor, reliability, and reproducibility matter: a decade-scale survey of 572 code benchmarks. arXiv preprint. Cited by: §5.2. Chen et al. (2025) X. Chen, C. Liu, J. Cao, Y. Xiao, X. Cai, Y. Li, J. Shi, T. Sun, H. Chen, and W. Huo Vulnerability-affected versions identification: how far are we?. External Links: 2509.03876, Link Cited by: §1, §2, §2, Table 1. Cheng et al. (2025) Y. Cheng, T. Zhang, L. K. Shar, S. Yang, C. Dong, D. Lo, S. Lv, Z. Shi, and L. Sun VERCATION: precise vulnerable open-source software version identification based on static analysis and llm. IEEE Transactions on Software Engineering (), p. 1â19. External Links: Document Cited by: §2. da Costa et al. (2017) D. A. da Costa, S. McIntosh, W. Shang, U. Kulesza, R. Coelho, and A. E. Hassan A framework for evaluating the results of the szz approach for identifying bug-introducing changes. IEEE Transactions on Software Engineering 43 (7), p. 641â657. External Links: Document Cited by: §2. Jiang et al. (2024) M. Jiang, J. Jiang, T. Wu, Z. Ma, X. Luo, and Y. Zhou Understanding vulnerability inducing commits of the linux kernel. ACM Trans. Softw. Eng. Methodol. 33 (7). External Links: ISSN 1049-331X, Link, Document Cited by: §1, §2, Table 1. Kim et al. (2006) S. Kim, T. Zimmermann, K. Pan, and E. J. Jr. Whitehead Automatic identification of bug-introducing changes. In 21st IEEE/ACM International Conference on Automated Software Engineering (ASEâ06), Vol. , p. 81â90. External Links: Document Cited by: §2. Li et al. (2025) Z. Li, S. Dutta, and M. Naik IRIS: LLM-assisted static analysis for detecting security vulnerabilities. In The Thirteenth International Conference on Learning Representations, External Links: Link Cited by: §1, §4.3. Lin et al. (2020) G. Lin, J. Zhang, W. Luo, L. Pan, Y. Xiang, O. De Vel, and P. Montague Software vulnerability detection using deep neural networks: a survey. Proceedings of the IEEE 108 (10), p. 1825â1848. External Links: Document Cited by: §1. Neto et al. (2018) E. C. Neto, D. A. da Costa, and U. Kulesza The impact of refactoring changes on the szz algorithm: an empirical study. In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER), Vol. , p. 380â390. External Links: Document Cited by: §2. Nguyen et al. (2016) V. H. Nguyen, S. Dashevskyi, and F. Massacci An automatic method for assessing the versions affected by a vulnerability. Empirical Softw. Engg. 21 (6), p. 2268â2297. External Links: ISSN 1382-3256, Link, Document Cited by: §1. NIST (2026) NIST National vulnerability database. National Institute of Standards and Technology. Note: Accessed: 2026 External Links: Link Cited by: §1, Ethical Considerations. Perl et al. (2015) H. Perl, S. Dechand, M. Smith, D. Arp, F. Yamaguchi, K. Rieck, S. Fahl, and Y. Acar VCCFinder: finding potential vulnerabilities in open-source projects to assist code audits. In Proceedings of the 22nd ACM SIGSAC Conference on Computer and Communications Security, CCS â15, New York, NY, USA, p. 426â437. External Links: ISBN 9781450338325, Link, Document Cited by: §2, §2. Rahman et al. (2024) M. M. Rahman, I. Ceka, C. Mao, S. Chakraborty, B. Ray, and W. Le Towards causal deep learning for vulnerability detection. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, ICSE â24, New York, NY, USA. External Links: ISBN 9798400702174, Link, Document Cited by: §1. Riom et al. (2021) T. Riom, A. Sawadogo, K. Allix, T. F. BissyandĂ©, N. Moha, and J. Klein Revisiting the vccfinder approach for the identification of vulnerability-contributing commits. Empirical Softw. Engg. 26 (3). External Links: ISSN 1382-3256, Link, Document Cited by: §2. Rodriguez-Perez et al. (2020) G. Rodriguez-Perez, G. Robles, A. Serebrenik, A. Zaidman, J. M. German, and J. M. Gonzalez-Barahona How bugs are born: a model to identify how bugs are introduced in software components. Empirical Software Engineering 25 (6), p. 1294â1340. Cited by: §4.1.1. Rosa et al. (2021) G. Rosa, L. Pascarella, S. Scalabrino, R. Tufano, G. Bavota, M. Lanza, and R. Oliveto Evaluating szz implementations through a developer-informed oracle. In Proceedings of the 43rd International Conference on Software Engineering, ICSE â21, p. 436â447. External Links: ISBN 9781450390859, Link, Document Cited by: §1. Shi et al. (2026) Y. Shi, H. Li, B. Adams, and A. E. Hassan Beyond blame: rethinking szz with knowledge graph search. arXiv preprint arXiv:2602.02934. Cited by: §2. Ćliwerski et al. (2005) J. Ćliwerski, T. Zimmermann, and A. Zeller When do changes induce fixes?. In Proceedings of the 2005 International Workshop on Mining Software Repositories, MSR â05, New York, NY, USA, p. 1â5. External Links: ISBN 1595931236, Link, Document Cited by: §1, §2. Steenhoek et al. (2023) B. Steenhoek, M. M. Rahman, R. Jiles, and W. Le An empirical study of deep learning models for vulnerability detection. In Proceedings of the 45th IEEE/ACM International Conference on Software Engineering, ICSE â23, p. 2133â2145. External Links: Link, Document Cited by: §1. Tang et al. (2025) L. Tang, J. Liu, Z. Liu, X. Yang, and L. Bao LLM4SZZ: enhancing szz algorithm with context-enhanced assessment on large language models. Proc. ACM Softw. Eng. 2 (ISSTA). External Links: Link, Document Cited by: §1, §2, §5.2. Tang et al. (2024) L. Tang, C. Ni, Q. Huang, and L. Bao Enhancing bug-inducing commit identification: a fine-grained semantic analysis approach. IEEE Transactions on Software Engineering 50 (11), p. 3037â3052. External Links: Document Cited by: §2. Wang et al. (2024) X. Wang, R. Hu, C. Gao, X. Wen, Y. Chen, and Q. Liao ReposVul: a repository-level high-quality vulnerability dataset. In Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings, ICSE-Companion â24, New York, NY, USA, p. 472â483. External Links: ISBN 9798400705021, Link, Document Cited by: §4.3. Wu et al. (2023) Y. Wu, N. Jiang, H. V. Pham, T. Lutellier, J. Davis, L. Tan, P. Babkin, and S. Shah How effective are neural networks for fixing security vulnerabilities. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis, ISSTA 2023, New York, NY, USA, p. 1282â1294. External Links: ISBN 9798400702211, Link, Document Cited by: §4.3. Appendix A Appendix A.1 Additional Case Study: CVE-2019-15477 CVE-2019-15477 is an XSS vulnerability in Joobyâs default error handler that allowed unescaped error messages to be rendered in HTML responses. This case demonstrates why automated VIC detection fails when vulnerabilities persist through file deletions and architectural refactorings. Figure 3 shows the 5-year evolution of this vulnerability across major code transformations. 20142015201620172019d548655Jun 2014 Initial VIC RouteHandler 2071f2eFeb 2015 File Deletion to Err.java 49b524cMay 2015 LLM4SZZ stopped 8a3308cSep 2017 V-SZZ stopped 27b4af2Aug 2019 XSS Fix Merge PR Vulnerability Persists Figure 3: CVE-2019-15477 evolution timeline showing vulnerability persistence through file deletion and refactorings from Jun 2014 to Aug 2019. Commit Evolution History The vulnerability followed this evolution through the codebase: 1. Initial Introduction (d548655, Jun 2014): Created RouteHandler.java with unescaped error model: ⏠private Map<String,Object> errorModel( Request request, Exception ex, HttpStatus status) Map<String,Object> error = new LinkedHashMap<>(); String message = ex.getMessage(); message = message == null ? status.reason() : message; error.put("message", message); // UNESCAPED error.put("stackTrace", dump(ex)); error.put("status", status.value()); error.put("reason", status.reason()); // UNESCAPED error.put("referer", request.header("Referer")...); return error; 2. File Deletion (2071f2e, Feb 2015): RouteHandler.java deleted; error logic moved to Err.java interface default method. The unescaped message handling persisted. 3. LLM4SZZ Stopped (49b524c, May 2015): Refactored to use toMap() method in DefHandler class. The vulnerability remained: ⏠Results.when(MediaType.html, () -> Results.html(VIEW).put("err", ex.toMap())) 4. V-SZZ Stopped (8a3308c, Sep 2017): Added stacktrace parameter toMap(stackstrace). Still unescaped: ⏠err.put("message", message); // Still unescaped! err.put("reason", status.reason()); // Still unescaped! 5. Fix Applied (27b4af2, Aug 2019): Merge commit integrating PR #1368 that added XSS filtering after 5 years: ⏠Function<Object,String> xssFilter = env.xss("html")...; details.compute("message", escaper); // FIXED details.compute("reason", escaper); // FIXED Algorithm Performance Analysis The V-SZZ stopped at commit 8a3308c (Sep 2017), which only added a boolean parameter for stacktrace visibility. Git blame cannot trace beyond the Feb 2015 file deletion, treating Err.java as unrelated to the deleted RouteHandler.java. LLM4SZZ stopped at commit 49b524c (May 2015), misidentifying architectural refactoring as vulnerability introduction and hallucinating a false root cause about "Supplier patterns." VIC-Agent identified d548655 (Jun 2014) through iterative backward search using git log -S to trace the vulnerability pattern (unescaped error messages) through 6 commits: 8a3308c (parameter addition), 49b524c (method refactoring), 2071f2e (package move), 3f19db103 (file extraction), and finally d548655 (origin). The approach tracked semantic continuity across 3 method names (errorModel() â err() â toMap()) and multiple files despite transformations that broke line-based and blame-based tracing. A.2 CWE Type Distribution Table 3 shows the distribution of CWE types in our dataset. CWE Count Description CWE-79 12 Cross-site Scripting (XSS) CWE-22 10 Path Traversal CWE-20 8 Improper Input Validation CWE-611 4 XML External Entity (XXE) CWE-601 4 URL Redirection to Untrusted Site Other (43) 63 Diverse types Table 3: Top 5 CWE types in our dataset. Total of 48 unique CWE types across 100 instances. A.3 Cohenâs Kappa Calculation Details Cohenâs kappa is defined as: Îș=PoâPe1âPeÎș= P_o-P_e1-P_e (1) where PoP_o is the observed agreement proportion and PeP_e is the expected agreement by chance. Agreement Criteria: Two annotations were considered in agreement if and only if both identified the exact same commit. This strict definition avoids circular reasoning about ground truth. For VIC annotation, the probability of random agreement depends on the commit pool size from which annotators could select. For each CVE, we identified the earliest VIC between the two annotations and counted commits from this earliest VIC (inclusive) to the fix commit (exclusive) using git history. Pool sizes ranged from 2 to 212,671 commits with a median of 1,690 commits. Expected agreement was computed as: Pe=1Nââi=1N1niP_e= 1N _i=1^N 1n_i (2) where N=100N=100 is the number of CVEs and nin_i is the commit pool size for CVE i. In our case, Po=0.71P_o=0.71 (71 agreements out of 100 cases) and Pe=0.0115P_e=0.0115 (1.15%), yielding Îș=0.707Îș=0.707.