WorksComputer Science
RootSink: Reproducible C/C++ Crashes with Tested Repair Sites
Abstract
When a C or C++ program crashes on a crafted input, the line that crashes is often not the line that is wrong. Tools and models that repair or locate vulnerabilities need examples showing both, with evidence for each, which existing datasets rarely provide. RootSink provides 3341 records from 354 open-source projects. Most give the crash site a memory-error detector reported and a candidate location for its root cause, and label each with a weakness type and its evidence. For the 1954 records in the Reproduced tier, we re-ran the crash ourselves and confirmed that the fixed version runs cleanly. In 1275 of these, a single hunk of the developer's fix stopped the crash on its own. That marks a tested repair site, though not necessarily the defect, and 1273 records use it as the root. In a blind audit of an earlier version, two co-author raters called 68% and 92% of the tested repair sites they saw the defect, but only 37% and 51% of that version's located Reproduced-tier roots. RootSink ships with tasks, a patch scorer and run logs.
Introduction
Memory-safety bugs in C and C++, such as reading past the end of a buffer, often crash far from their cause. In Figure 1, from the pjsip library, a STUN network message declares each attribute’s length. The decoder checks that length against the remaining bytes but forgets the 4-byte header, so a crafted message makes a copy three calls deeper read past the buffer. The program crashes in the copy, yet the defect is the check.

Figure 1. A RootSink record from pjsip, simplified. The check omits the 4-byte attribute header, which the highlighted term adds, so the copy reads past the buffer. Applied alone, the hunk that adds the bold line, one of the fix’s eight, stops the crash.
Repair tools and AI coding agents are usually judged by replaying the crashing input on their patch [1], [2]. A patch that only guards the copy passes that test and leaves the defect in place. On bugs fixed away from the crash, this test inflated the solve rates of 11 agents 1.83-fold on average over stricter checks against input variants and normal behavior [3].
Training and testing such tools need examples marking both the crash and its cause. Commit-mined datasets label vulnerable functions with advisory weakness types, but they neither locate each weakness nor show that it caused anything [4]–[6]. In the widely used BigVul [7] and CVEfixes [8], only 25% and 51.7% of sampled functions labeled vulnerable were vulnerable [9]. Reproducible-crash collections record the crash and its fix [10], but few mark the cause, as PatchBench’s curated root-cause patches do [3].
RootSink narrows this gap with evidence from execution. For each crash it records the crash point, a candidate location for the cause and the strength of the evidence for each. We re-run each crashing input we can obtain on both versions and apply each hunk (contiguous block of changed lines) of the developer’s fix on its own, since a hunk that alone stops the crash marks a tested repair site. RootSink contributes (1) 3341 records from 354 projects, 1954 reproduced by us with every log archived; (2) candidate root-cause sites with evidence, 1273 where one hunk alone stopped the crash, and a blind audit; (3) three tasks, baseline and patch scorer; and (4) versioned rules with logged corrections.
Background and terms
Sanitizers: Reading past a buffer or using freed memory (use after free) does not always crash an ordinary build, so sanitizers catch them with checks the compiler inserts. AddressSanitizer (ASan) catches out-of-bounds and use-after-free accesses [11], MemorySanitizer (MSan) catches uses of uninitialized values [12], UndefinedBehaviorSanitizer (UBSan) catches integer overflows [13], and KASAN is the Linux kernel’s ASan [14]. A sanitizer reports the error type, call stack and, for ASan and KASAN, whether the access read or wrote.
Sink and root cause: We call the bad access that a sanitizer reports the sink, and the earlier mistake that enables it the root cause. In Figure 1 the sink is the read in pj_memcpy and the root cause is the incomplete check.
CWE: The Common Weakness Enumeration (CWE) is MITRE’s public catalog of software weakness types [15], such as CWE-125, an out-of-bounds read. CWE records which weaknesses can lead to which (CanPrecede) and which are special cases of which (ChildOf), and it discourages mapping to broad types such as CWE-20, improper input validation. Advisories in the National Vulnerability Database (NVD) [16] and the Open Source Vulnerabilities database (OSV) [17] often give a bug’s CWE and its fixing commit.
Crash sources: A fuzzer feeds generated inputs to a small program, the fuzz target, which passes each to the code under test, and the fuzzer logs each input it has run. OSS-Fuzz fuzzes many open-source projects and records each crash [18]. ARVO packages such crashes as Docker images of the vulnerable and the fixed version, with the crashing input [10]. syzbot fuzzes the Linux kernel and often publishes a C reproducer [19].
How RootSink is built
We take crashes from ARVO and syzbot (Figure 2), label each by written rules, re-run both versions, and assign a tier. Another 428 records come from NVD and OSV advisories, which seldom have a crash we could run, and none is in the Reproduced tier. Code applies every rule, each dated in a rule log shipped with the data, so no person or model labels a record by hand, and every correction is a logged script change.

Figure 2. How RootSink is built, with records per source and tier. The single-hunk test is optional, and a success adds a tested repair site.
Records and labels: A record is an ordered list of CWE instances from the root cause to the sink, each with a CWE, a site (file, line and function) when known, and its own evidence. Most records have two instances, and 67 in the Reproduced tier add a middle step that a sanitizer also reported, such as an integer overflow before a write. Each pair of consecutive CWEs must be admissible in our catalog of CWE pairs, and the record states whether CWE supports it by CanPrecede directly, only through a parent, or not at all (Table S2 in the release’s docs/SUPPLEMENT.md). This order does not establish causality or imply separate defects. The sink’s CWE follows from the report, so an ASan out-of-bounds read is CWE-125, a write CWE-787, an MSan uninitialized read CWE-457, and, by our rule, a read of freed memory CWE-125. Roots have three kinds of site. A tested repair site comes from the single-hunk test. An origin site comes from the report. MSan names where uninitialized memory was allocated, and ASan, MSan or syzbot’s KASAN report where use-after-free memory was freed, so the site marks where bad state began and the report determines the root’s CWE (CWE-456, missing initialization, or CWE-416, use after free). That site need not be the defect, so since release 1.0.7 a root with a tested site in source code uses it and keeps the origin (§ 5). A suggested site comes from a fix pattern or static analysis.
Each instance carries an evidence category. It is hunk-named when one hunk stopped the crash and the check it adds names the CWE, sanitizer-reported when a report names it, fix-suggested when the fix adds the check but no run shows it matters, dataflow when only a static path supports it, or inferred when only a labeling rule does. Where a root would get CWE-20, we use CWE-1285 (improper validation of an index) when the fix compares variables like idx or offset, and CWE-1284 (of a quantity) for len or size. Of 995 such Reproduced-tier roots, 425 fit neither and stay CWE-20.
Reproduction and tiers: A run crashes when a sanitizer reports. It is clean only when nothing is reported and the fuzzer’s log shows the input was processed (for the kernel, that the reproducer ran its full time), so a silently failed run never counts as fixed. Kernels are built with syzbot’s configuration and booted in a VM. A record is in the Reproduced tier when five criteria hold. (a) Our run of the vulnerable version crashes, and the report places the sink. (b) The fixed version runs clean twice. (c) The report agrees with the labels, so the sink’s CWE matches its read or write and no root from static analysis is contradicted, as a buffer overflow contradicts a use-after-free root. (d) The fix changes non-test code under a recorded commit. (e) Any middle step was reported by a sanitizer. This tier certifies the crash, its sink and reproduction, not the root cause. A record is Upstream when it meets (d) and (e) and only the reporter’s logs show its crash, unless our fixed kernel crashed the same way (15). Our kernel runs reached 195 Upstream records but completed no two-sided run, mostly because the bug did not reproduce (142), and their logs were not kept. Every other record our runs reached is Partial and lists the criteria it fails. Any remaining record is Partial when its own material supports the root CWE, such as a dataflow path, a check or lock the fix adds, or the reporter’s sanitizer report. Otherwise it is Candidate, since only an advisory’s listed CWEs or our catalog’s default root for the sink support it. ARVO’s fixed image almost always holds other changes (28 of 29 checked), so we record whether the fix alone removes the crash (fix-attributed), which for ARVO is the scorer’s readiness test and holds by construction for the kernel.
Single-hunk test: We rebuild the vulnerable version and confirm it still crashes, then apply each non-test hunk of the fix on its own, smallest first, rebuilding and replaying each time. The first hunk that alone stops the crash marks a tested repair site, and a rule reads the check it adds to name the root’s CWE, such as CWE-476 (NULL pointer dereference) for a NULL test. A success shows this hunk suffices for this input, not that it is the only or best repair or that the rule’s CWE is right. A hunk next to the crash may only guard the symptom, so each record places its site relative to the crash.
The dataset
Contents: Table 1 summarizes RootSink. Projects are counted after merging aliases, bugs after grouping records that share a crash, advisory or fix. Single-hunk tests succeeded for 1275 Reproduced-tier records, and 1273 take the tested site as root. For 754 the hunk’s check also named the CWE. For 749 (59%) the fix has one code hunk, so the test has only one hunk to try. Common chains go from input-validation failures to out-of-bounds reads (750) and writes (310), from missing initialization to uninitialized reads (441) and from use after free to reads (344), more in tbl:S2.
| All tiers | Reproduced root site | |
| Records | 3341 | tested repair site 1273 |
| Reproduced | 1954 | origin site 434 |
| Upstream | 410 | suggested site 70 |
| Partial | 751 | none 177 |
| Candidate | 226 | |
| Projects (with Reproduced) | 354 (226) | hunk-named 754 |
| Reproduced tier | sanitizer-reported 748 | |
| Distinct bugs | 1746 | fix-suggested 69 |
| Fix-attributed | 1429 | dataflow 19 |
| Not fix-attributed | 123 | inferred 362 |
| Attribution untested | 402 | none 2 |
| Recommended core (projects) | 1128 (183) |
Table 1. What RootSink contains (latest release, v1.0.10).
Storage and use: The release is one JSON Lines file (37 MB) with Croissant metadata [20] and a datasheet [21], plus 1.5 GB of run logs and inputs. Each record’s chain lists its instances, and other fields hold the fix, every run, the pinned images or kernel reproducer, the tier with any failed criteria, a duplicate group and a split (key fields in Table S5). Field values keep earlier names, such as gold for Reproduced (see the datasheet). The release ships the crashing input of every ARVO record, copied from its pinned image. The split keeps each project, and each kernel subsystem, in one of train, validation and test (1333, 306 and 315 Reproduced-tier records), except a catch-all of advisory-only kernel races, and no duplicate group spans two splits. Of 1898 dated Reproduced-tier fixes, 118 are from 2025 or later, for a temporal holdout. Users filter records, for example to the recommended core, which holds the Reproduced-tier records whose instances were all hunk-named or sanitizer-reported and whose fix alone removes the crash. They then take each record’s task view (Table II) and score predictions against the record or with the scorer. Unit tests check that no input leaks a target, though crash reports can reveal one. RootSink has no prior published uses.
| Task | Model input | Target and scoring |
| Repair | ARVO image with the fix scrubbed from history; crashing input or kernel reproducer; crash report | a patch, scored by rebuilding and replaying the input |
| Localize | Repair’s input + the sink’s CWE and site | tested repair location; file/function agreement where the root is a tested site |
| Label | Repair’s input + every instance’s site, in order | each instance’s CWE, in order |
Table 2. The three tasks.
Baselines: Crash reports name the line of only 81 of 1273 tested sites, against 411 of 434 origins, and the function of 843 tested sites. Tested sites the report reveals stay in evaluation. On the test split, the crashing function is the root function for 37% of 208 tested sites, and the root function lies on the crash stack for 67%. The modal root CWE per crash type is right for 58% of test records (98% before the CWE-20 mapping, when crash type nearly determined the root CWE).
Patch scorer: The scorer applies a candidate patch to the vulnerable image, rebuilds it, and replays the input twice. A pass means the input ran to completion with no sanitizer report, not that the patch is correct. A record is ready when the unmodified build crashes and the developer’s fix passes. A patch that just rejects the input also passes, so for the 377 ready records that ship a seed corpus the scorer also replays the corpus, and its reward can reject a patch that keeps less than 90% of the unmodified build’s feature coverage. Of 1763 Reproduced-tier ARVO records, 1730 were scored and 1238 are ready, and most others did not apply cleanly or build (Table S3). Kernel records are scored in a VM, where 173 are ready. On GitHub-hosted machines, the unmodified kernel ran 157 of 163 reproducers and reproduced the bug in 147.
Where fixes lie: In 50% of all 1954 Reproduced-tier records, the fix misses the crashing frame’s file. In 21% of the 1763 Reproduced-tier ARVO records (our kernel KASAN traces lack file names) it touches no file on the crash stack, or 14% counting allocation and free stacks. Of 1162 tested repair sites with a function, 234 lie within five lines of the crash and may only guard the symptom, 209 elsewhere in the crashing function, 306 in a caller and 413 off the stack.
Validation
Do the crashes reproduce? Using only the release and its pinned images, GitHub-hosted machines re-ran a stratified random sample of 100 ARVO records that were Reproduced when drawn (96 still are), and 100% reproduced (95% CI 96–100%). They use the same images, so this shows portability, not independent confirmation. Rebuilt from source, 13 of 60 records built at both versions and 11 reproduced, so the images are needed. Re-applying 1145 successful ARVO hunk tests of all tiers with exact context withdrew 46 that applied loosely.
Are the root causes right? A blind audit, whose protocol we dated in the rule log before recruiting raters, samples 130 Reproduced-tier and 20 other records from an earlier version, and the sample and its scored labels ship with the release. Since then, among other corrections, the CWE-20 mapping relabeled 34 of their roots, later single-hunk tests and the rule below made 9 suggested and 33 origin roots tested repair sites, and 2 records were dropped. Raters see the crash report, the fix, the recorded sites and the dataset’s CWE conventions, but not our CWEs or site kinds. They name the CWEs and the root-cause function, and call each site the defect, a valid repair location, the crash site, unrelated or unclear. The raters are co-authors who did not build the dataset, and blinding is the safeguard. Each rater worked alone, and no disagreement was settled, so all figures come from the sheets as returned. Both are graduate students, the first with a year of secure-code-generation research but little sanitizer experience, the second with C/C++ systems experience but none in security. They agreed on the root CWE in 83% of 150 items (Cohen’s 0.80, 95% CI 0.72–0.86; Gwet’s AC1 0.82) and on the root-site answer in 75% ( 0.70). The site figure compares answers as written and counts 17 items both called unclear as agreement. A function-level comparison added after scoring gives 84%. Unclear never confirms a label.
Paired figures give the first rater, then the second. On the Reproduced tier the raters agreed with our sink CWE in 97% of items each and with our root CWE in 64% and 70%. Root agreement rises to 79% and 84% when one CWE may specialize the other, and to 72% and 78% by that test against today’s labels, where a rater’s CWE-20 matches our CWE-1284 or CWE-1285. They judged 68% (95% CI 55–79%) and 92% (82–97%) of 53 tested repair sites the defect, but only 8% (3–18%) and 14% (7–26%) of 51 origin sites and none of the 13 suggested sites. They matched our root CWE on only 26 and 32 of the tested sites. For origins they matched it in 50 of 51 cases each but put the defect where the fix edits in 24 and 21. For the 30 origin roots that also had a tested hunk, both in known functions, the raters named the hunk’s function in 25 and 21 cases, 6 and 6 of them by choosing the crash site there. Where the two functions differ, they named the origin’s in only 0 and 1 of 27. Release 1.0.7 then made such tested sites roots, so these figures describe the rule rather than test it. Raters see the fix, which contains every tested site, and may favor those sites. These rates cover 117 Reproduced-tier items with a located root. Weighted by each kind’s share of the audited version’s 1458 such records with an archived report (708 tested, 691 origin and 59 suggested), the raters judged 37% and 51% of these roots the defect. Tested repair sites are thus localization targets, not confirmed defects.
Comparison with curated patches: Of Reproduced-tier records, 30 share a fix with a PatchBench bug, whose authors curated a root-cause patch [3]. Of these records’ 22 tested repair sites, 8 lie in or near a function the patch edits, 6 more in an edited file and 8 elsewhere. All 6 origin sites lie outside its files, and the 2 suggested sites in or near an edited function. These measure location agreement, not CWE correctness.
Related work
Table III compares the closest datasets. Magma hand-ports 118 bugs with checks at their sites [22]. ARVO reproduces crashes, and CyberGym and AutoPatchBench build agent tasks on them [10, 23, 24]. MITRE’s chains and NIST’s Bugs Framework modeled how weaknesses chain, not executions [25, 26]. AURORA and ARCUS perform root-cause analysis [27, 28], and Wang et al. find replay checks cannot tell root-cause from superficial repairs, which experts can [29]. PatchBench curates patches by hand; RootSink tests hunks automatically.
| Dataset | Size | What is labeled | Checked by | Evidence | Checked by |
| MegaVul [4] | 17,380 vulns. | unordered advisory CWE IDs | – | – | – |
| PrimeVul [5] | 6,968 functions | advisory CWE per function | manual sample | – | – |
| Magma [22] | 118 bugs (v1.0) | bug type | – | forward-ported bugs | bug-trigger checks |
| ARVO [10] | 6,100+ vulns. | crash type; fix commit | patch accuracy (89.4%) | vulnerable, fixed images | reproduction |
| PatchBench [3] | 213 tasks | CWE type; curated patch | manual patch audit | crashing-input replay | input variants, behavior tests |
| RootSink | 3341 records | ordered CWEs with evidence; sites where known | two-rater blind audit; patch-location overlap | replay logs for executed records; single-hunk tests | our re-runs; re-runs on fresh machines |
Table III. RootSink and the closest C/C++ datasets. A dash means none.
Research questions, limits and next steps
RootSink supports questions such as these. (1) How often do repair agents stop the crash, and how often do they edit the tested repair site? A passing replay and matching location do not prove root-cause repair. (2) Can models predict tested repair sites better than the crashing-function baseline?
ARVO supplies 90% of the Reproduced tier, which inherits OSS-Fuzz’s bias toward fuzzable bugs. Of all Reproduced-tier roots, 679 (35%) have no successful single-hunk test, audited origin sites seldom matched the defect, and neither rater is a security specialist. Rule-log dates are self-reported, and each rule from 2026-10-19 on predates its outcomes unless its entry says otherwise. Replay still needs ARVO’s images, pinned by digest but hosted in an unarchived personal Docker Hub account, n132/arvo. Next, we will extend hunk-pair tests, use our KASAN runs’ free sites as origins and archive the images.
Availability
Data, logs, task views, scorer and code are at https://github.com/SuryanshSS1011/RootSink and archived at https://doi.org/10.5281/zenodo.24068722 with Croissant metadata, per the FAIR principles [30]. The README covers setup. We fix errors reported as GitHub issues in versioned releases. In our runs, a scored rebuild took a median of 88 s and used 0.8 GB (95th percentiles 20 min and 11 GB). Code is MIT and labels CC BY 4.0. Crashing inputs are not under CC BY 4.0, and diffs, logs and inputs derived from a project’s files keep its license, named per record where known. All Reproduced-tier and ARVO bugs are fixed and public, and the only personal data are developer names and emails the projects publish and our raters’ initials and backgrounds.
References
- [1]H. Lee, Z. Zhang, H. Lu, and L. Zhang, “SEC-bench: Automated benchmarking of LLM agents on real-world software security tasks,” in Advances in Neural Information Processing Systems (NeurIPS), 2025, arXiv:2506.11791.arxiv.org/abs/2506.11791
- [2]A. Mathai, C. Huang, P. Maniatis, A. Nogikh, F. Ivančić, J. Yang, and B. Ray, “K-Gym: A platform and dataset to benchmark large language models on Linux kernel crash resolution,” in Advances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track, 2024, arXiv:2407.02680.arxiv.org/abs/2407.02680
- [3]C. Shen, J. Li, A. Mahajan, J. S. Tian, Y. Kwon, and Y. Chen, “PatchBench: Evaluating AI agents for vulnerability patching,” arXiv:2609.04075, 2026.arxiv.org/abs/2609.04075
- [4]C. Ni, L. Shen, X. Yang, Y. Zhu, and S. Wang, “MegaVul: A C/C++ vulnerability dataset with comprehensive code representations,” in Proc. 21st International Conference on Mining Software Repositories (MSR), 2024, pp. 738–742.DOI
- [5]Y. Ding, Y. Fu, O. Ibrahim, C. Sitawarin, X. Chen, B. Alomair, D. Wagner, B. Ray, and Y. Chen, “Vulnerability detection with code language models: How far are we?” in Proc. 47th IEEE/ACM International Conference on Software Engineering (ICSE), 2025, pp. 1729–1741.
- [6]C. Croft, M. A. Babar, and M. M. Kholoosi, “Data quality for software vulnerability datasets,” in Proc. 45th IEEE/ACM International Conference on Software Engineering (ICSE), 2023, pp. 121–133.
- [7]J. Fan, Y. Li, S. Wang, and T. N. Nguyen, “A C/C++ code vulnerability dataset with code changes and CVE summaries,” in Proc. 17th International Conference on Mining Software Repositories (MSR), 2020, pp. 508–512.DOI
- [8]G. Bhandari, A. Naseer, and L. Moonen, “CVEfixes: Automated collection of vulnerabilities and their fixes from open-source software,” in Proc. 17th International Conference on Predictive Models and Data Analytics in Software Engineering (PROMISE), 2021, pp. 30–39.DOI
- [9]Y. Chen, Z. Ding, L. Alowain, X. Chen, and D. Wagner, “DiverseVul: A new vulnerable source code dataset for deep learning based vulnerability detection,” in Proc. 26th International Symposium on Research in Attacks, Intrusions and Defenses (RAID), 2023, pp. 654–668.arxiv.org/abs/2304.00409
- [10]X. Mei, J. Del Castillo, P. S. Singaria, H. Xi, A. Benchikh, T. Bao, R. Wang, Y. Shoshitaishvili, A. Doupé, H. Pearce, and B. Dolan-Gavitt, “ARVO: Atlas of reproducible vulnerabilities for open-source software,” in Proc. IEEE European Symposium on Security and Privacy (EuroS&P), 2026, arXiv:2606.17283.arxiv.org/abs/2606.17283
- [11]K. Serebryany, D. Bruening, A. Potapenko, and D. Vyukov, “AddressSanitizer: A fast address sanity checker,” in Proc. USENIX Annual Technical Conference (ATC), 2012, pp. 309–318.
- [12]E. Stepanov and K. Serebryany, “MemorySanitizer: Fast detector of uninitialized memory use in C++,” in Proc. IEEE/ACM International Symposium on Code Generation and Optimization (CGO), 2015, pp. 46–55.DOI
- [13]LLVM Project, “UndefinedBehaviorSanitizer,” https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html, 2026, accessed 2026-11-07.
- [14]The Linux Kernel Developers, “The Kernel Address Sanitizer (KASAN),” https://docs.kernel.org/dev-tools/kasan.html, 2026, accessed 2026-11-08.
- [15]The MITRE Corporation, “CWE: Common Weakness Enumeration,” https://cwe.mitre.org, 2026, version 4.20, Apr. 2026.
- [16]National Institute of Standards and Technology, “National Vulnerability Database,” https://nvd.nist.gov, 2026, accessed 2026-11-07.
- [17]Google, “OSV: A distributed vulnerability database for open source,” https://osv.dev, 2026, accessed 2026-11-07.
- [18]——, “OSS-Fuzz: Continuous fuzzing for open source software,” https://github.com/google/oss-fuzz, 2026, accessed 2026-11-02.
- [19]——, “syzbot: Continuous kernel fuzzing,” https://syzkaller.appspot.com, 2026, accessed 2026-11-02.
- [20]M. Akhtar, O. Benjelloun, C. Conforti, L. Foschini, P. Gijsbers, J. Giner-Miguelez et al., “Croissant: A metadata format for ML-ready datasets,” in Advances in Neural Information Processing Systems (NeurIPS), Datasets and Benchmarks Track, vol. 37, 2024, pp. 82 133–82 148.
- [21]T. Gebru, J. Morgenstern, B. Vecchione, J. W. Vaughan, H. Wallach, H. Daumé III, and K. Crawford, “Datasheets for datasets,” Communications of the ACM, vol. 64, no. 12, pp. 86–92, 2021.arxiv.org/abs/1803.09010
- [22]A. Hazimeh, A. Herrera, and M. Payer, “Magma: A ground-truth fuzzing benchmark,” Proc. ACM on Measurement and Analysis of Computing Systems, vol. 4, no. 3, pp. 49:1–49:29, 2020.
- [23]Z. Wang, T. Shi, J. He, M. Cai, J. Zhang, and D. Song, “CyberGym: Evaluating AI agents’ real-world cybersecurity capabilities at scale,” in Proc. International Conference on Learning Representations (ICLR), 2026, arXiv:2506.02548.arxiv.org/abs/2506.02548
- [24]T. J. Byun, C. Aschermann, K. Y. Thng, W. Zhou, Y. Yang, L. Deason, and J. Saxe, “AutoPatchBench: A benchmark for AI-powered security fixes,” Meta Engineering blog, https://engineering.fb.com/2025/04/29/ai-research/autopatchbench-benchmark-ai-powered-security-fixes/, 2025, part of CyberSecEval 4.
- [25]The MITRE Corporation, “CWE: Chains and composites,” https://cwe.mitre.org/data/reports/chains_and_composites.html, 2026, accessed 2026-10-07.
- [26]I. Bojanova, “Bugs Framework (BF): Formalizing cybersecurity weaknesses and vulnerabilities,” National Institute of Standards and Technology, NIST Special Publication 800-231, Jul. 2024.DOI
- [27]T. Blazytko, M. Schlögel, C. Aschermann, A. Abbasi, J. Frank, S. Wörner, and T. Holz, “AURORA: Statistical crash analysis for automated root cause explanation,” in Proc. 29th USENIX Security Symposium, 2020, pp. 235–252.DOI
- [28]C. Yagemann, M. Pruett, S. P. Chung, K. Bittick, B. Saltaformaggio, and W. Lee, “ARCUS: Symbolic root cause analysis of exploits in production systems,” in Proc. 30th USENIX Security Symposium, 2021, pp. 1989–2006.
- [29]H. Wang, Z. L. Basque, J. Hu, A. P. Bajaj, Y. Liu, G. Zhu, G. Kobakhia, N. Chapre, W. Rosenberg, S. Mishra, A. M. Gabani, M. Schloegel, A. Doupé, Y. Shoshitaishvili, R. Wang, and T. Bao, “Root-cause-driven automated vulnerability repair,” arXiv:2605.04251, 2026.arxiv.org/abs/2605.04251
- [30]M. D. Wilkinson, M. Dumontier, I. J. Aalbersberg et al., “The FAIR guiding principles for scientific data management and stewardship,” Scientific Data, vol. 3, p. 160018, 2016.