Pith. sign in

REVIEW 3 major objections 5 minor 3 cited by

Locus: Agentic Predicate Synthesis for Directed Fuzzing

T0 review · 3 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Locus claims that verified progress predicates—guards that safely terminate executions which cannot reach a target bug—produce average 70.3x speedups for directed fuzzers and 13x for coverage-guided fuzzers.

desk verdict Locus is a promising engineering contribution that automates intermediate predicate synthesis for directed fuzzing, but the formal admissibility guarantee is not actually delivered, and the evaluation would benefit from missing baselines and an artifact. read the letter →

arxiv 2508.21302 v3 pith:ZDUEFJBQ submitted 2025-08-29 cs.CR cs.AIcs.SE

Jie Zhu , Chihao Shen , Ziyang Li , Jiahao Yu , Yizheng Chen , Kexin Pei This is my paper · ORCID
classification cs.CRcs.AIcs.SE
keywords directedfuzzingpredicatesynthesissymbolicexecutionvalidationLLMagentsprograminstrumentationadmissibilityvulnerabilitycanaryearlytermination
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Locus is built around a simple guarantee: if a synthesized predicate is a strict relaxation of the vulnerability canary, meaning every execution that reaches the vulnerable state also satisfies the predicate, then terminating executions that violate the predicate can never discard an input that would have found the bug. The paper argues that existing directed-fuzzing feedback, such as branch distances or hand-written input constraints, is too coarse or too specialized, and that an LLM-based agent with code-navigation tools can synthesize better milestone predicates at arbitrary program points, then iteratively push them earlier in the program. A validator compiles each candidate, prunes the control-flow graph, and runs symbolic execution to search for a path that violates the predicate yet satisfies the canary; if none is found, the predicate is accepted. On a published benchmark of real-world vulnerabilities across eight fuzzers, the paper reports that instrumenting with these predicates reduces time-to-exposure by 70.3x on average for directed fuzzers and 13x for coverage-guided fuzzers, and that the approach has surfaced several previously unpatched bugs. If correct, this turns directed fuzzing from a search over raw inputs into a search guided by semantically meaningful intermediate states, and it makes LLM-suggested code usable because every suggestion is checked before deployment.

What carries the argument

The central object is the progress-capturing predicate, a boolean condition over program state placed at an arbitrary program point, required to be a strict relaxation of the canary: whenever the canary holds, the predicate also holds. A canary is an explicit predicate that is true exactly in the vulnerable program state. The carrying mechanism is an agentic synthesizer-validator loop: the synthesizer localizes a candidate function, generates the predicate, and iteratively propagates it toward the program entry, while the validator checks syntactic correctness by compiling and semantic correctness by symbolic execution over a pruned control-flow graph, searching for a counterexample path whe

What would settle it

Take one of the accepted predicates and symbolically explore all entry-to-canary paths with a bounded number of loop iterations; if any path satisfies the canary but violates the predicate, the validator's no-counterexample verdict was an artifact of pruning. Concretely, for a known crashing input, instrument the program with the predicate and run it: if the instrumented run exits before the canary, the predicate is not a relaxation and the fuzzing-admissibility guarantee fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that progress toward a target bug can be represented as a sequence of predicates that dominate all paths to the canary, and that such predicates can be synthesized automatically and verified before use. Formally, a predicate is admissible when it is a strict relaxation of the canary: for every state, canary true implies predicate true. The instrumented program is then fuzzing admissible to the original program, meaning it never rejects an input that would have reached the vulnerability. Synthesis is done by an agent that reasons about the canary, localizes candidate functions, generates predicates, validates them, and iteratively refines placement toward the prog

Load-bearing premise

The guarantee that a predicate is safe rests on the validator's ability to search all relevant execution paths: if that search misses a path that reaches the target despite violating the predicate, early termination could wrongly discard a bug-finding input.

Editorial extensions

If this is right

  • Any fuzzer can be accelerated without modifying the fuzzer itself, because Locus's source-level instrumentation is agnostic to fuzzer implementation and is a one-time offline cost.
  • Coverage-guided fuzzers also benefit, because synthesized predicates add extra coverage feedback and early-exit guards, not just distance signals.
  • The strict-relaxation property makes early termination safe in principle: no validated predicate rejects an input that would have reached the target canary.
  • Predicates can be refined backward toward the program entry, letting invalid inputs be rejected earlier and increasing the effective number of mutations per unit time.
  • Canary conditions can themselves be generated from security patches and static-analysis alerts, extending the approach beyond pre-defined target states; the paper reports that 27 of 28 tested patches were translated correctly, with one case producing a more precise canary than the manually written one.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The practical soundness of the whole approach rests on how thoroughly the symbolic validator explores paths: if chopping or loop unrolling causes it to miss a violating path, early termination could silently discard an input that reaches the target, and the reported time-to-exposure gains would be partially an artifact of that bias.
  • The relaxation-checked predicate machinery could be reused beyond fuzzing, for example as runtime guards in production that are only deployed after proving they cannot reject inputs reaching a critical state, or as filters that discard test cases guaranteed not to exercise a target.
  • Because refinement pushes predicates toward the entry while preserving meaning, the validated predicates may double as human-readable documentation of the deep precondition chain guarding a bug, which could aid debugging and patch review even when fuzzing is not the goal.
  • A natural next experiment is to compare accepted predicates against exhaustive bounded verification on small programs to measure the validator's miss rate, and to test whether pushing every predicate to the earliest possible program point is always beneficial relative to the added runtime overhead of evaluating it.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper proposes Locus, an LLM-agent-based system that synthesizes predicates at arbitrary program points to guide directed fuzzing toward a given target state (canary). The synthesized predicates are validated by compilation and by KLEE-based symbolic execution to ensure they are 'strict relaxations' of the canary, enabling early termination of executions that cannot reach the target. The framework is fuzzer-agnostic and is evaluated on the Magma benchmark with eight fuzzers, reporting large average TTE speedups (e.g., 70.3x for directed fuzzers) and seven newly discovered bugs.

Significance. The core idea—synthesizing semantic milestones at arbitrary program points via an LLM agent, then validating them before deployment—is novel and practically relevant. The evaluation is unusually broad: eight fuzzers, ten vulnerability classes, ten trials per setting, and statistical tests. The discovery of previously unpatched bugs in well-fuzzed targets (VLC, libarchive, libming) lends credibility to the practical value of the approach. The paper also ships a detailed cost analysis. However, the central theoretical guarantee (fuzzing admissibility via absolutely reliable predicate relaxation) is not soundly established, and the headline speedup numbers are affected by the treatment of timeouts. The contribution would remain significant if reframed as a best-effort, empirically successful guidance mechanism with a clearly bounded validation oracle.

major comments (3)
  1. [§3.4 and §6] The semantic validator is not a sound decision procedure for the relaxation property, so Theorem 1's premise is not established. KLEE explores with loop-unrolling and path limits, and the Chopper-style CFG pruning can drop alias- or indirect-call-dependent paths. The paper itself concedes in §6 that 'we cannot formally guarantee that the relaxation brought by the generated predicates is always valid.' This is load-bearing because an invalid predicate that fails to reject a canary-reaching execution (i.e., a missed ¬φ ∧ ψ path) would violate fuzzing admissibility and could inflate TTE improvements without making progress toward the canary. Please either provide a sound (even if conservative) validation method, or explicitly reframe the guarantee as empirical and quantify how often validation is inconclusive.
  2. [§3.1, Def. 3 and Thm. 1] The formalization does not connect Definition 3 to the actual instrumentation semantics. Definition 3 states a pointwise implication ψ(s) ⇒ φ(s), but φ is evaluated at a different program point than ψ; the required property is path-based: every execution that reaches ψ must have φ true at the instrumented point. As written, Theorem 1 does not follow from Definition 3 because the state s is ambiguous. The validation in §3.4 checks path feasibility between ¬φ and ψ, which is closer to the correct property, but the paper's formal apparatus should be aligned with that operational meaning.
  3. [§4.1 and Tables 2/3] Timeouts are recorded as the 24h cap and treated as exact TTE when computing speedup ratios. For baseline timeouts this is conservative, but for Locus timeouts (e.g., SSL001 in Table 3, ratio 0.9) it overstates Locus's performance, because the true TTE is >24h and the ratio would be smaller. The reported averages also exclude rows where both sides time out, changing the comparison population. The headline speedups (70.3x, 41.6x, etc.) therefore mix censored and exact observations in a way that biases the results. Please report censored outcomes separately, use survival analysis, or provide a sensitivity analysis with conservative bounds (e.g., treating all timeouts as >24h and computing worst-case ratios).
minor comments (5)
  1. [Abstract vs. §4.5/Table 7 vs. Conclusion] The abstract reports 'eight previously unpatched bugs,' while Section 4.5 and Table 7 list seven and the conclusion says 'seven.' Please reconcile these numbers.
  2. [Figure 2] The diff snippet shows 'if (a > b) EXIT 0;' which exits when the predicate is true. The text (and Algorithm 1) says early exit occurs when the predicate is not satisfied. The figure appears to have inverted polarity and should be corrected.
  3. [Theorem 2] Theorem 2 uses φ′ for the canary, which is confusing and inconsistent with the rest of the paper (the canary is ψ). Please rewrite the statement with consistent notation.
  4. [§3.3, Algorithm 1 header] The Ensure line says 'target-conditional equivalent program,' but the paper only argues for fuzzing admissibility, not program equivalence. The header should match the weaker property.
  5. [§3.4] The phrase 'strictly relaxes' does not match Definition 3, which is an ordinary implication (non-strict relaxation). If a strict version is intended, it should be defined.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: predicates are independently validated and speedups are measured against the external Magma benchmark.

full rationale

Locus's derivation chain is not circular. The central load-bearing step is Theorem 1, which follows directly from the paper's definitions: if every synthesized predicate phi satisfies the relaxation condition (psi => phi, Definition 3), then no canary-reaching execution is early-terminated, so the instrumented program is fuzzing-admissible (Definition 1 / Theorem 1). This is a definition-driven proof, not a conclusion smuggled into the premise. The predicates themselves are produced by an LLM and then checked by an independent semantic validator (Section 3.4) that uses KLEE over a Chopper-pruned CFG to search for a path satisfying not phi and psi. That validation is external to the fuzzing experiments and is not equivalent to the reported TTE reductions. The empirical claims are measured against the external Magma benchmark with the fuzzers' own triggering inputs as ground truth. There are no fitted parameters renamed as predictions, no author-imported uniqueness theorem forcing a choice, and no ansatz smuggled in via citation; self-citations such as [23] and [45] are contextual and not load-bearing. The only substantive weakness is explicitly acknowledged in Section 6: bounded symbolic execution cannot formally guarantee that every generated predicate is a true relaxation, so a missed violating path could in principle break fuzzing admissibility. That is an incompleteness/correctness limitation, not a circularity step, because the paper does not redefine relaxation, admissibility, or TTE to make its conclusion true by construction.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

No new physical, mathematical, or theoretical entities are introduced. Predicates and canaries are program expressions over existing program state. The load-bearing assumptions are about the exactness of the canary, the completeness of symbolic validation, the behavioral neutrality of instrumentation, and the adequacy of static graphs.

free parameters (2)
  • MaxIterations
    Algorithm 1 stops refinement after n > MaxIterations; the value and sensitivity are not reported, and this parameter controls how far predicates can be propagated toward the program entry.
  • KLEE loop-unrolling bound
    Section 6 says loop unrolling is used to bound path explosion; the bound is not specified, yet the completeness of semantic validation depends on it.
assumptions (4)
  • domain assumption The canary psi exactly characterizes all vulnerability states (Definition 2).
    Used to define fuzzing admissibility and to connect predicate relaxation with rejecting inputs. The paper's own SQLite example shows that benchmark canaries can be imprecise.
  • domain assumption KLEE, after Chopper-style CFG pruning, can soundly refute non-relaxation by finding no path that satisfies the negated predicate while the canary holds.
    Section 3.4 relies on this for semantic validation; Section 6 explicitly disclaims a formal guarantee due to path explosion and loop handling.
  • domain assumption Source-level instrumentation with early exit does not alter fuzzer-visible behavior other than the intended pruning.
    The admissibility theorem assumes instrumentation only rejects executions that cannot reach the canary; any semantic side effect would break the equivalence.
  • domain assumption Static call and reference graphs are adequate for localization, and missing indirect calls are inferred by the LLM.
    Section 3.2 notes that static graphs may miss dynamic dispatch and indirect calls, then relies on LLM knowledge to bridge the gap, for example resolving tif_decoderow.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Locus: Agentic Predicate Synthesis for Directed Fuzzing." pith.science (2026). https://pith.science/paper/ZDUEFJBQ

@misc{pith2026250821302,
  author       = {Pith},
  title        = {Pith review of: Locus: Agentic Predicate Synthesis for Directed Fuzzing},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZDUEFJBQ}},
  note         = {Machine review of arXiv:2508.21302}
}
read the original abstract

Directed fuzzing aims to find program inputs that lead to specified target program states. It has broad applications, such as debugging system crashes, confirming reported bugs, and generating exploits for potential vulnerabilities. This task is inherently challenging because target states are often deeply nested in the program, while the search space manifested by numerous possible program inputs is prohibitively large. Existing approaches rely on branch distances or manually-specified constraints to guide the search; however, the branches alone are often insufficient to precisely characterize progress toward reaching the target states, while the manually specified constraints are often tailored for specific bug types and thus difficult to generalize to diverse target states and programs. We present Locus, a novel framework to improve the efficiency of directed fuzzing. Our key insight is to synthesize predicates to capture fuzzing progress as semantically meaningful intermediate states, serving as milestones towards reaching the target states. When used to instrument the program under fuzzing, they can reject executions unlikely to reach the target states, while providing additional coverage guidance. To automate this task and generalize to diverse programs, Locus features an agentic framework with program analysis tools to synthesize and iteratively refine the candidate predicates, while ensuring the predicates strictly relax the target states to prevent false rejections via symbolic execution. Our evaluation shows that Locus substantially improves the efficiency of eight state-of-the-art fuzzers in discovering real-world vulnerabilities, achieving an average speedup of 41.6x. So far, Locus has found nine previously unpatched bugs, with three already acknowledged with draft patches.

Figures

Figures reproduced from arXiv: 2508.21302 by the authors.

Figure 1
Figure 1. A motivating example (CVE-2013-6954) showing how [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Overview of Locus workflow. Locus takes as inputs the program codebase 𝑃 and the canary 𝜓, and produces a program 𝑃 ′ instrumented with the progress-capturing predicates. The predicate branches provide extra coverage feedback and guards (via early termination) to guide the fuzzer toward reaching the target state, i.e., canary 𝜓, more efficiently. PLTE chunk must appear before the IDAT chunk. Therefore, by the time t… view at source ↗
Figure 3
Figure 3. Locus can sometimes synthesize canary conditions even more precisely than those in Magma, even when pro￾vided only with the security patch. Prior to the fix, a dequot￾ing flag was erroneously set to 1, enabling attackers to access uninitialized memory by forcing dequoting. (where Magma relied on manual analysis), such that the unpatched version satisfies the generated canary, while the patched version violates it. B… view at source ↗
Figures from the paper (1 more)
Figure 4
Figure 4. Figure 4: A previously unknown vulnerability in libarchive 5 Related Work Direct grey-box fuzzing Directed grey-box fuzzing is particularly challenging, primarily due to the prohibitively large search space with sparse rewards [46, 56], i.e., unlike undirected fuzzing where any …

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 3 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Mystra: Declarative Dynamic Taint Analysis via Shadow Virtual Machine

    cs.PL 2026-07 conditional novelty 7.0 of 10

    A Shadow Virtual Machine plus declarative Mystra rules delivers portable multi-level DTA for JS/Python with 95.5% recall and 1.85× overhead on Node.js.

  2. SeedSmith: LLM-Driven Seed Synthesis for Directed Fuzzing

    cs.CR 2026-07 conditional novelty 7.0 of 10

    An agentic LLM seed generator that recovers missing call edges and crash preconditions yields 11–15× geometric-mean crash-time speedups on Magma and unlocks 16 previously unreachable ARVO bugs.

  3. PBFuzz: Agentic Directed Fuzzing for PoV Generation

    cs.CR 2025-12 conditional novelty 6.0 of 10

    An agentic fuzzing system lets LLM agents infer vulnerability constraints, encode them as parameter generators, and solve them with property-based testing; it triggered 57 Magma CVEs, 17 missed by other fuzzers.

Reference graph

Works this paper leans on

108 extracted references · 45 canonical work pages · cited by 3 Pith papers

  1. [1]

    Cornelius Aschermann, Sergej Schumilo, Ali Abbasi, and Thorsten Holz. 2020. Ijon: Exploring Deep State Spaces via Fuzzing. In 2020 IEEE Symposium on Security and Privacy (SP) . 1597–1612. doi:10.1109/SP40000.2020.00117 ISSN: 2375-1207

    arXiv 2020

  2. [2]

    Jinsheng Ba, Marcel Böhme, Zahra Mirzamomen, and Abhik Roychoudhury

  3. [3]

    Davide Balzarotti. 2021. The use of likely invariants as feedback for fuzzers. In 30th USENIX Security Symposium (USENIX Security 21)

    2021

  4. [4]

    Marcel Böhme, Bruno C d S Oliveira, and Abhik Roychoudhury. 2013. Regression tests to expose change interaction errors. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering

    2013

  5. [5]

    David Brumley, Pongsin Poosankam, Dawn Song, and Jiang Zheng. 2008. Auto- matic patch-based exploit generation is possible: Techniques and implications. In 2008 IEEE Symposium on Security and Privacy (sp 2008)

    2008

  6. [6]

    Marcel Böhme, Van-Thuan Pham, Manh-Dung Nguyen, and Abhik Roychoud- hury. 2017. Directed Greybox Fuzzing. In Proceedings of the 2017 ACM Sigsac Conference on Computer and Communications Security . ACM, Dallas Texas USA, 2329–2344. doi:10.1145/3133956.3134020

    arXiv 2017

  7. [7]

    Cristian Cadar, Daniel Dunbar, and Dawson R. Engler. 2008. KLEE: unassisted and automatic generation of high-coverage tests for complex systems programs. In 8th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2008, December 8-10, 2008, San Diego, California, USA, Proceedings , Richard Draves and Robbert van Renesse (Eds.). USENIX Ass...

    2008

  8. [8]

    Sicong Cao, Biao He, Xiaobing Sun, Yu Ouyang, Chao Zhang, Xiaoxue Wu, Ting Su, Lili Bo, Bin Li, Chuanlei Ma, et al . 2023. Oddfuzz: Discovering java deserialization vulnerabilities via structure-aware directed greybox fuzzing. In 2023 IEEE Symposium on Security and Privacy (SP) . IEEE

    2023

Show all 108 references
  1. [9]

    Saikat Chakraborty, Shuvendu K Lahiri, Sarah Fakhoury, Madanlal Musuvathi, Akash Lal, Aseem Rastogi, Aditya Senthilnathan, Rahul Sharma, and Nikhil Swamy. 2023. Ranking llm-generated loop invariants for program verification. arXiv preprint arXiv:2310.09342 (2023)

    2023 arXiv

  2. [10]

    Chuyang Chen, Brendan Dolan-Gavitt, and Zhiqiang Lin. 2025. ELFuzz: Efficient Input Generation via LLM-driven Synthesis Over Fuzzer Space. arXiv preprint arXiv:2506.10323 (2025)

    2025 arXiv

  3. [12]

    Peng Chen and Hao Chen. 2018. Angora: Efficient Fuzzing by Principled Search. In 2018 IEEE Symposium on Security and Privacy (SP) . 711–725. doi:10.1109/SP. 2018.00046 ISSN: 2375-1207

    2018

  4. [13]

    Tianyu Chen, Shuai Lu, Shan Lu, Yeyun Gong, Chenyuan Yang, Xuheng Li, Md Rakib Hossain Misu, Hao Yu, Nan Duan, Peng Cheng, et al. 2024. Automated proof generation for rust code via self-evolution.arXiv preprint arXiv:2410.15756 (2024)

    2024

  5. [14]

    Yuanliang Chen, Yu Jiang, Fuchen Ma, Jie Liang, Mingzhe Wang, Chijin Zhou, Xun Jiao, and Zhuo Su. 2019. EnFuzz: Ensemble fuzzing with seed synchro- nization among diverse fuzzers. In 28th USENIX Security Symposium (USENIX Security 19)

    2019

  6. [15]

    Maria Christakis, Peter Müller, and Valentin Wüstholz. 2016. Guiding dynamic symbolic execution toward unverified program executions. In Proceedings of the 38th International Conference on Software Engineering

    2016

  7. [16]

    Samuel Colvin. 2025. PydanticAI. https://ai.pydantic.dev/ Version 0.4.3

    2025

  8. [17]

    DARPA. 2024. DARPA AI Cyber Challenge. https://aicyberchallenge.com/

    2024

  9. [18]

    DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Zhibin Gou, and Zhihong Shao. 2025. DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Rein...

    2025 doi arXiv

  10. [19]

    Yinlin Deng, Chunqiu Steven Xia, Haoran Peng, Chenyuan Yang, and Lingming Zhang. 2023. Large Language Models Are Zero-Shot Fuzzers: Fuzzing Deep- Learning Libraries via Large Language Models. In Proceedings of the 32nd ACM Sigsoft International Symposium on Software Testing an...

    2023

  11. [20]

    Yinlin Deng, Chunqiu Steven Xia, Chenyuan Yang, Shizhuo Dylan Zhang, Shu- jing Yang, and Lingming Zhang. 2024. Large language models are edge-case generators: Crafting unusual programs for fuzzing deep learning libraries. In Proceedings of the 46th IEEE/ACM international confe...

    2024

  12. [21]

    Yangruibo Ding, Yanjun Fu, Omniyyah Ibrahim, Chawin Sitawarin, Xinyun Chen, Basel Alomair, David Wagner, Baishakhi Ray, and Yizheng Chen. 2024. Vulnerability detection with code language models: How far are we? arXiv preprint arXiv:2403.18624 (2024)

    2024 arXiv

  13. [22]

    Yangruibo Ding, Jinjun Peng, Marcus Min, Gail Kaiser, Junfeng Yang, and Baishakhi Ray. 2024. Semcoder: Training code language models with com- prehensive semantics reasoning. Advances in Neural Information Processing Systems 37 (2024), 60275–60308

    2024

  14. [23]

    Yangruibo Ding, Benjamin Steenhoek, Kexin Pei, Gail Kaiser, Wei Le, and Baishakhi Ray. 2024. TRACED: Execution-aware Pre-training for Source Code. In Proceedings of the IEEE/ACM 46th International Conference on Software Engi- neering. ACM, Lisbon Portugal, 1–12. doi:10.1145/35...

    2024

  15. [24]

    Zhengjie Du, Yuekang Li, Yang Liu, and Bing Mao. 2022. WindRanger: a directed greybox fuzzer driven by deviation basic blocks. In Proceedings of the 44th International Conference on Software Engineering . ACM, Pittsburgh Pennsylvania, 2440–2451. doi:10.1145/3510003.3510197

    2022

  16. [25]

    Rafael Dutra, Rahul Gopinath, and Andreas Zeller. 2023. Formatfuzzer: Effective fuzzing of binary file formats. ACM Transactions on Software Engineering and Methodology 33, 2 (2023), 1–29

    2023

  17. [26]

    Andrea Fioraldi, Daniele Cono D’Elia, and Davide Balzarotti. 2021. The Use of Likely Invariants as Feedback for Fuzzers. In 30th USENIX Security Symposium (USENIX Security 21). USENIX Association, 2829–2846. https://www.usenix. org/conference/usenixsecurity21/presentation/fioraldi

    2021

  18. [27]

    Andrea Fioraldi, Dominik Maier, Heiko Eißfeldt, and Marc Heuse. 2020. AFL++ : Combining incremental steps of fuzzing research. In 14th Usenix Workshop on Offensive Technologies (woot 20). USENIX Association. https://www.usenix.org/ conference/woot20/presentation/fioraldi

    2020

  19. [28]

    Linyuan Gong, Sida Wang, Mostafa Elhoushi, and Alvin Cheung. 2024. Eval- uation of llms on syntax-aware code fill-in-the-middle tasks. arXiv preprint arXiv:2403.04814 (2024)

    2024 arXiv

  20. [29]

    Peter Goodman. 2025. Multiplier. https://github.com/trailofbits/multiplier Version 1705339

    2025

  21. [30]

    Google DeepMind. 2024. Gemini 2.0 Flash. https://deepmind.google/ technologies/gemini/flash/. Accessed: 2025-03-29

    2024

  22. [31]

    Alex Gu, Baptiste Rozière, Hugh Leather, Armando Solar-Lezama, Gabriel Syn- naeve, and Sida I Wang. 2024. CRUXEval: A Benchmark for Code Reasoning, Understanding and Execution. InProceedings of the 41st International Conference on Machine Learning. 16568–16621

    2024

  23. [32]

    Ahmad Hazimeh, Adrian Herrera, and Mathias Payer. 2020. Magma: A Ground- Truth Fuzzing Benchmark. In Proceedings of the ACM on Measurement and Analysis of Computing Systems, Vol. 4. 1–29. doi:10.1145/3428334

    2020 doi

  24. [33]

    Christian Holler, Kim Herzig, and Andreas Zeller. 2012. Fuzzing with code fragments. In 21st USENIX Security Symposium (USENIX Security 12)

    2012

  25. [34]

    Jie Hu, Qian Zhang, and Heng Yin. 2023. Augmenting greybox fuzzing with generative ai. arXiv preprint arXiv:2306.06782 (2023)

    2023 arXiv

  26. [35]

    Heqing Huang, Yiyuan Guo, Qingkai Shi, Peisen Yao, Rongxin Wu, and Charles Zhang. 2022. BEACON: Directed Grey-Box Fuzzing with Provable Path Pruning. In 2022 IEEE Symposium on Security and Privacy (SP) . IEEE, San Francisco, CA, USA, 36–50. doi:10.1109/SP46214.2022.9833751

    2022

  27. [36]

    Heqing Huang, Peisen Yao, Hung-Chun Chiu, Yiyuan Guo, and Charles Zhang

  28. [37]

    Heqing Huang, Anshunkang Zhou, Mathias Payer, and Charles Zhang. 2024. Everything is Good for Something: Counterexample-Guided Directed Fuzzing via Likely Invariant Inference. In 2024 IEEE Symposium on Security and Privacy (sp). 1956–1973. doi:10.1109/SP54263.2024.00142 ISSN: ...

    2024

  29. [38]

    Kyriakos Ispoglou, Daniel Austin, Vishwath Mohan, and Mathias Payer. 2020. {FuzzGen}: Automatic fuzzer generation. In 29th USENIX Security Symposium (USENIX Security 20). 12

    2020

  30. [39]

    Zongze Jiang, Ming Wen, Jialun Cao, Xuanhua Shi, and Hai Jin. 2024. Towards Understanding the Effectiveness of Large Language Models on Directed Test Input Generation. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering

    2024

  31. [40]

    Tae Eun Kim, Jaeseung Choi, Kihong Heo, and Sang Kil Cha. 2023. DAFL: Directed grey-box fuzzing guided by data dependency. In 32nd USENIX Security Symposium (USENIX Security 23) . USENIX Association, Anaheim, CA, 4931–

    2023

  32. [41]

    George Klees, Andrew Ruef, Benji Cooper, Shiyi Wei, and Michael Hicks. 2018. Evaluating Fuzz Testing. In Proceedings of the 2018 ACM SIGSAC Conference on Computer and Communications Security . ACM, Toronto Canada, 2123–2138. doi:10.1145/3243734.3243804

    2018

  33. [42]

    Andrei Kozyrev, Gleb Solovev, Nikita Khramov, and Anton Podkopaev. 2024. CoqPilot, a plugin for LLM-based generation of proofs. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering

    2024

  34. [43]

    Gwangmu Lee, Woochul Shim, and Byoungyoung Lee. 2021. Constraint-guided Directed Greybox Fuzzing. In 30th Usenix Security Symposium (usenix Security 21). USENIX Association, 3559–3576. https://www.usenix.org/conference/ usenixsecurity21/presentation/lee-gwangmu

    2021

  35. [44]

    Haonan Li, Yu Hao, Yizhuo Zhai, and Zhiyun Qian. 2024. Enhancing static analysis for practical bug detection: An llm-integrated approach. Proceedings of the ACM on Programming Languages 8, OOPSLA1 (2024), 474–499

    2024

  36. [45]

    Haonan Li, Hang Zhang, Kexin Pei, and Zhiyun Qian. 2025. The Hitchhiker’s Guide to Program Analysis, Part II: Deep Thoughts by LLMs. arXiv preprint arXiv:2504.11711 (2025)

    2025 arXiv

  37. [46]

    Penghui Li, Wei Meng, and Chao Zhang. 2024. SDFuzz: Target States Driven Di- rected Fuzzing. In 33rd Usenix Security Symposium (usenix Security 24) . USENIX Association, Philadelphia, PA, 2441–2457. https://www.usenix.org/conference/ usenixsecurity24/presentation/li-penghui

    2024

  38. [47]

    Yuekang Li, Bihuan Chen, Mahinthan Chandramohan, Shang-Wei Lin, Yang Liu, and Alwen Tiu. 2017. Steelix: program-state based binary fuzzing. InProceedings of the 2017 11th joint meeting on foundations of software engineering

    2017

  39. [48]

    Ziyang Li, Saikat Dutta, and Mayur Naik. 2024. Llm-assisted static analysis for detecting security vulnerabilities. arXiv preprint arXiv:2405.17238 (2024)

    2024 arXiv

  40. [49]

    Hongliang Liang, Lin Jiang, Lu Ai, and Jinyi Wei. 2020. Sequence directed hybrid fuzzing. In 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER) . IEEE

    2020

  41. [50]

    libarchive contributors. 2025. libarchive: Multi-format archive and compression library. https://www.libarchive.org/ Computer software

    2025

  42. [51]

    libming contributors. 2025. libming: SWF (Flash) file creation library . https: //www.libming.org/ Computer software

    2025

  43. [52]

    Dongge Liu, Oliver Chang, Jonathan Metzman, Martin Sablotny, and Mihai Maruseac. 2024. OSS-fuzz-gen: Automated fuzz target generation. https: //github.com/google/oss-fuzz-gen

    2024

  44. [53]

    Jiawei Liu, Songrun Xie, Junhao Wang, Yuxiang Wei, Yifeng Ding, and Lingming Zhang. 2024. Evaluating language models for efficient code generation. arXiv preprint arXiv:2408.06450 (2024)

    2024 arXiv

  45. [54]

    Zhe Liu, Chunyang Chen, Junjie Wang, Mengzhuo Chen, Boyu Wu, Zhilin Tian, Yuekai Huang, Jun Hu, and Qing Wang. 2024. Testing the Limits: Unusual Text Inputs Generation for Mobile App Crash Detection with Large Language Model. In Proceedings of the IEEE/ACM 46th International C...

    2024

  46. [55]

    Minghai Lu, Benjamin Delaware, and Tianyi Zhang. 2024. Proof automation with large language models. In Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering

    2024

  47. [56]

    Changhua Luo, Wei Meng, and Penghui Li. 2023. SelectFuzz: Efficient Directed Fuzzing with Selective Path Exploration. In 2023 IEEE Symposium on Security and Privacy (sp). IEEE, San Francisco, CA, USA, 2693–2707. doi:10.1109/SP46215. 2023.10179296

    2023

  48. [57]

    Chenyang Lyu, Shouling Ji, Chao Zhang, Yuwei Li, Wei-Han Lee, Yu Song, and Raheem Beyah. 2019. MOPT: Optimized Mutation Scheduling for Fuzzers. In 28th USENIX security symposium (USENIX security 19) . USENIX Asso- ciation, Santa Clara, CA, 1949–1966. https://www.usenix.org/con...

    2019

  49. [58]

    Yunlong Lyu, Yuxuan Xie, Peng Chen, and Hao Chen. 2024. Prompt Fuzzing for Fuzz Driver Generation. In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security. ACM, Salt Lake City UT USA, 3793–

    2024

  50. [59]

    H. B. Mann and D. R. Whitney. 1947. On a Test of Whether one of Two Random Variables is Stochastically Larger than the Other. Annals of Mathematical Statistics 18, 1 (March 1947), 50–60. doi:10.1214/aoms/1177730491

    1947

  51. [60]

    Paul Dan Marinescu and Cristian Cadar. 2013. KATCH: High-coverage testing of software patches. In Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering

    2013

  52. [61]

    Ruijie Meng, Zhen Dong, Jialin Li, Ivan Beschastnikh, and Abhik Roychoudhury

  53. [62]

    Charalambos Mitropoulos, Thodoris Sotiropoulos, Sotiris Ioannidis, and Dim- itris Mitropoulos. 2023. Syntax-aware mutation for testing the solidity compiler. In European Symposium on Research in Computer Security . Springer

    2023

  54. [63]

    Aniruddhan Murali, Noble Mathews, Mahmoud Alfadel, Meiyappan Nagappan, and Meng Xu. 2024. Fuzzslice: Pruning false positives in static analysis warnings through function-level fuzzing. InProceedings of the 46th IEEE/ACM International Conference on Software Engineering

    2024

  55. [64]

    Manh-Dung Nguyen, Sébastien Bardin, Richard Bonichon, Roland Groz, and Matthieu Lemerre. 2020. Binary-level directed fuzzing for {use-after-free} vulnerabilities. In23rd International Symposium on Research in Attacks, Intrusions and Defenses (RAID 2020)

    2020

  56. [65]

    Rohan Padhye, Caroline Lemieux, Koushik Sen, Laurent Simon, and Hayawardh Vijayakumar. 2019. Fuzzfactory: domain-specific fuzzing with waypoints. Pro- ceedings of the ACM on Programming Languages 3, OOPSLA (2019), 1–29

    2019

  57. [66]

    Jibesh Patra and Michael Pradel. 2016. Learning to fuzz: Application- independent fuzz testing with probabilistic, generative models of input data. TU Darmstadt, Department of Computer Science, Tech. Rep. TUD-CS-2016-14664 (2016)

    2016

  58. [67]

    In Proceedings of the 44th International Conference on Software Engineering

    Linear-time temporal logic guided greybox fuzzing. In Proceedings of the 44th International Conference on Software Engineering . ACM, Pittsburgh Pennsylvania, 1343–1355. doi:10.1145/3510003.3510082

  59. [68]

    Hui Peng, Yan Shoshitaishvili, and Mathias Payer. 2018. T-Fuzz: Fuzzing by Program Transformation. In 2018 IEEE Symposium on Security and Privacy (sp) . IEEE, San Francisco, CA, 697–710. doi:10.1109/SP.2018.00056

    2018

  60. [69]

    Manuel Rigger and Zhendong Su. 2020. Finding bugs in database systems via query partitioning. Proceedings of the ACM on Programming Languages (2020)

    2020

  61. [70]

    Niklas Risse and Marcel Böhme. 2024. Uncovering the limits of machine learning for automatic vulnerability detection. In 33rd USENIX Security Symposium (USENIX Security 24)

    2024

  62. [71]

    Niklas Risse, Jing Liu, and Marcel Böhme. 2025. Top Score on the Wrong Exam: On Benchmarking in Machine Learning for Vulnerability Detection. In Proceedings of the ACM on Software Engineering , Vol. 2. 388–410. doi:10.1145/ 3728887

    2025

  63. [72]

    Pranab Sahoo, Prabhash Meharia, Akash Ghosh, Sriparna Saha, Vinija Jain, and Aman Chadha. 2024. A comprehensive survey of hallucination in large language, image, video and audio foundation models. arXiv preprint arXiv:2405.09589 (2024)

    2024 arXiv

  64. [73]

    Paul Gauthier. 2024. Aider, AI pair programming in your terminal. https: //aider.chat

    2024

  65. [74]

    Abhishek Shah, Dongdong She, Samanway Sadhu, Krish Singal, Peter Coff- man, and Suman Jana. 2022. MC2: Rigorous and Efficient Directed Grey- box Fuzzing. In Proceedings of the 2022 ACM SIGSAC Conference on Com- puter and Communications Security . ACM, Los Angeles CA USA, 2595–...

    2022

  66. [75]

    Dongdong She, Adam Storek, Yuchong Xie, Seoyoung Kweon, Prashast Sri- vastava, and Suman Jana. 2024. FOX: Coverage-guided Fuzzing as Online Stochastic Control. In Proceedings of the 2024 on ACM SIGSAC Conference on Computer and Communications Security. ACM, Salt Lake City UT U...

    2024

  67. [76]

    Gabriel Sherman and Stefan Nagy. 2025. No harness, no problem: Oracle- guided harnessing for auto-generating C API fuzzing harnesses. In IEEE/ACM International Conference on Software Engineering (ICSE)

    2025

  68. [77]

    Wenxuan Shi, Yunhang Zhang, Xinyu Xing, and Jun Xu. 2024. Harnessing Large Language Models for Seed Generation in Greybox Fuzzing.arXiv preprint arXiv:2411.18143 (2024)

    2024 arXiv

  69. [78]

    Prashast Srivastava, Stefan Nagy, Matthew Hicks, Antonio Bianchi, and Mathias Payer. 2022. One Fuzz Doesn’t Fit All: Optimizing Directed Fuzzing via Target- tailored Program State Restriction. In Proceedings of the 38th Annual Computer Security Applications Conference. ACM, Au...

    2022

  70. [79]

    2012.{AddressSanitizer}: A fast address sanity checker

    Konstantin Serebryany, Derek Bruening, Alexander Potapenko, and Dmitriy Vyukov. 2012.{AddressSanitizer}: A fast address sanity checker. In2012 USENIX annual technical conference (USENIX ATC 12) . 309–318

    2012

  71. [80]

    Yulei Sui and Jingling Xue. 2016. SVF: interprocedural static value-flow anal- ysis in LLVM. In Proceedings of the 25th International Conference on Compiler Construction. ACM, Barcelona Spain, 265–266. doi:10.1145/2892208.2892235

    2016

  72. [81]

    Xin Tan, Yuan Zhang, Jiadong Lu, Xin Xiong, Zhuang Liu, and Min Yang. 2023. SyzDirect: Directed Greybox Fuzzing for Linux Kernel. In Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security . ACM, Copenhagen Denmark, 1630–1644. doi:10.1145/3576915.3623146

    2023

  73. [82]

    David Trabish, Andrea Mattavelli, Noam Rinetzky, and Cristian Cadar. 2018. Chopped symbolic execution. In Proceedings of the 40th International Conference on Software Engineering . ACM, Gothenburg Sweden, 350–360. doi:10.1145/ 3180155.3180251

    2018

  74. [83]

    VideoLAN. 2025. VLC media player. https://www.videolan.org/vlc/ Computer software. 13

    2025

  75. [84]

    Chengpeng Wang, Wuqi Zhang, Zian Su, Xiangzhe Xu, Xiaoheng Xie, and Xiangyu Zhang. 2024. LLMDFA: Analyzing dataflow in code with large language models. In Advances in Neural Information Pro- cessing Systems , A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Pa- quet, J. Tomcza...

    2024

  76. [85]

    Prashast Srivastava, Stefan Nagy, Matthew Hicks, Antonio Bianchi, and Mathias Payer. 2022. One fuzz doesn’t fit all: Optimizing directed fuzzing via target- tailored program state restriction. In Proceedings of the 38th Annual Computer Security Applications Conference

    2022

  77. [86]

    Junjie Wang, Yuhan Ma, Xiaofei Xie, Xiaoning Du, and Xiangwei Zhang. 2025. PatchFuzz: Patch Fuzzing for JavaScript Engines.arXiv preprint arXiv:2505.00289 (2025)

    2025 arXiv

  78. [87]

    Yanhao Wang, Xiangkun Jia, Yuwei Liu, Kyle Zeng, Tiffany Bao, Dinghao Wu, and Purui Su. 2020. Not All Coverage Measurements Are Equal: Fuzzing by Coverage Accounting for Input Prioritization.. In NDSS

    2020

  79. [88]

    Felix Weissberg, Jonas Möller, Tom Ganz, Erik Imgrund, Lukas Pirch, Lukas Seidel, Moritz Schloegel, Thorsten Eisenhofer, and Konrad Rieck. 2024. SoK: Where to Fuzz? Assessing Target Selection Methods in Directed Fuzzing. In Proceedings of the 19th ACM Asia Conference on Comput...

    2024

  80. [89]

    Chunqiu Steven Xia, Matteo Paltenghi, Jia Le Tian, Michael Pradel, and Ling- ming Zhang. 2024. Fuzz4all: Universal fuzzing with large language models. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineer- ing

    2024

  81. [90]

    Hanxiang Xu, Yanjie Zhao, and Haoyu Wang. 2025. Directed Greybox Fuzzing via Large Language Model. doi:10.48550/arXiv.2505.03425 arXiv:2505.03425 [cs]

    2025 doi arXiv

  82. [91]

    Krishna- murthy, and Nael Abu-Ghazaleh

    Daimeng Wang, Zheng Zhang, Hang Zhang, Zhiyun Qian, Srikanth V. Krishna- murthy, and Nael Abu-Ghazaleh. 2021. SyzVegas: Beating kernel fuzzing odds with reinforcement learning. In 30th USENIX Security Symposium (USENIX Secu- rity 21). USENIX Association, 2741–2758. https://www...

    2021

  83. [92]

    Chenyuan Yang, Xuheng Li, Md Rakib Hossain Misu, Jianan Yao, Weidong Cui, Yeyun Gong, Chris Hawblitzel, Shuvendu Lahiri, Jacob R Lorch, Shuai Lu, et al

  84. [93]

    Chenyuan Yang, Zijie Zhao, Zichen Xie, Haoyu Li, and Lingming Zhang. 2025. KNighter: Transforming Static Analysis with LLM-Synthesized Checkers. doi:10. 48550/arXiv.2503.09002 arXiv:2503.09002 [cs]

    2025 doi arXiv

  85. [94]

    Chenyuan Yang, Zijie Zhao, and Lingming Zhang. 2023. Kernelgpt: Enhanced kernel fuzzing via large language models.arXiv preprint arXiv:2401.00563 (2023)

    2023 arXiv

  86. [95]

    Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press

    John Yang, Carlos E. Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. 2024. SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering. In Advances in Neu- ral Information Processing Systems , A. Globerson, L. Mackey, D....

    2024

  87. [96]

    Yupeng Yang, Shenglong Yao, Jizhou Chen, and Wenke Lee. 2025. Hybrid Language Processor Fuzzing via LLM-Based Constraint Solving. In34th USENIX Security Symposium (USENIX Security 25)

    2025

  88. [97]

    Chenyuan Yang, Yinlin Deng, Runyu Lu, Jiayi Yao, Jiawei Liu, Reyhaneh Jab- barvand, and Lingming Zhang. 2024. WhiteFox: White-Box Compiler Fuzzing Empowered by Large Language Models. In Object-oriented Programming, Sys- tems, Languages, and Applications, Vol. 8. 709–735. doi:1...

    2024 doi

  89. [98]

    Zijun Yao, Yantao Liu, Yanxu Chen, Jianhui Chen, Junfeng Fang, Lei Hou, Juanzi Li, and Tat-Seng Chua. 2025. Are Reasoning Models More Prone to Hallucination? arXiv preprint arXiv:2505.23646 (2025)

    2025 arXiv

  90. [99]

    arXiv preprint arXiv:2409.13082 (2024)

    AutoVerus: Automated proof generation for Rust code. arXiv preprint arXiv:2409.13082 (2024)

    2024 arXiv

  91. [100]

    Cen Zhang, Yuekang Li, Hao Zhou, Xiaohan Zhang, Yaowen Zheng, Xian Zhan, Xiaofei Xie, Xiapu Luo, Xinghua Li, Yang Liu, et al . 2023. Automata- Guided Control-Flow-Sensitive Fuzz Driver Generation.. In USENIX Security Symposium

    2023

  92. [101]

    Cen Zhang, Yaowen Zheng, Mingqiang Bai, Yeting Li, Wei Ma, Xiaofei Xie, Yuekang Li, Limin Sun, and Yang Liu. 2024. How effective are they? Exploring large language model based fuzz driver generation. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Te...

    2024

  93. [103]

    Hongxiang Zhang, Yuyang Rong, Yifeng He, and Hao Chen. 2024. Lla- mafuzz: Large language model enhanced greybox fuzzing. arXiv preprint arXiv:2406.07714 (2024)

    2024

  94. [104]

    Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik R Narasimhan, and Yuan Cao. 2023. ReAct: Synergizing reasoning and acting in language models. In The Eleventh International Conference on Learning Repre- sentations. https://openreview.net/forum?id=WE_vluYUL-X

    2023

  95. [105]

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. 2024. AutoCodeRover: Autonomous Program Improvement. InProceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis . ACM, Vienna Austria, 1592–1604. doi:10.1145/3650212.3680384 14

    2024

  96. [106]

    Michal Zalewski. 2020. American Fuzzy Lop. https://github.com/google/AFL

    2020

  97. [111]

    Qiang Zhang, Yuheng Shen, Jianzhong Liu, Yiru Xu, Heyuan Shi, Yu Jiang, and Wanli Chang. 2024. ECG: Augmenting Embedded Operating System Fuzzing via LLM-Based Corpus Generation. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 43, 11 (2024), 4238–4249

    2024

  98. [2022]

    In 31st USENIX security symposium (USENIX security 22)

    Stateful greybox fuzzing. In 31st USENIX security symposium (USENIX security 22). USENIX Association, Boston, MA, 3255–3272. https://www.usenix. org/conference/usenixsecurity22/presentation/ba

  99. [2024]

    In 2024 IEEE Symposium on Security and Privacy (sp)

    Titan : Efficient Multi-target Directed Greybox Fuzzing. In 2024 IEEE Symposium on Security and Privacy (sp) . IEEE, San Francisco, CA, USA, 1849–

    2024

  100. [4948]

    https://www.usenix.org/conference/usenixsecurity23/presentation/kim- tae-eun

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.