Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

Fuzzing: Randomness? Reasoning! Efficient Directed Fuzzing via Large Language Models

T0 review · 4 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read This paper claims that directed fuzzing is slow because its seeds and mutators are random, and that LLM reasoning can replace that randomness with reachable seeds and bug-specific mutators, yielding 2.1× to 4.8× average speedups and eight…

desk verdict Novel LLM-for-directed-fuzzing design; evaluation has a data contradiction and a memorization confound that keep it from being convincing. read the letter →

arxiv 2507.22065 v1 pith:FAPAWW6V submitted 2025-06-30 cs.SE cs.AIcs.CRcs.PL

Xiaotao Feng , Xiaogang Zhu , Kun Hu , Jincheng Wang , Yingjie Cao , Guang Gong , Jianfeng Pan This is my paper · ORCID
classification cs.SEcs.AIcs.CRcs.PL
keywords directedfuzzinglargelanguagemodelsreachableseedgenerationbug-specificmutatorsfunctioncallchainrandomnessreductionvulnerabilitydiscoveryRAG-assistedprogramunderstanding
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

Directed fuzzing is slow because the two ingredients that determine bug discovery — the starting seed and the mutation operators — are chosen randomly. The paper argues that this randomness is not a necessary price: a large language model can reason over a function call chain and generate seeds that already reach the vulnerable location, and can analyze the bug report to write mutation code tailored to the specific bug. The proposed system, RandLuzz, does both and hands the results to existing directed fuzzers. On a 14-vulnerability benchmark, the LLM-generated seeds produce average speedups of 2.1× to 4.8× over standard seed sets across four directed fuzzers, and the full system exposes 8 bugs within 60 seconds. If this is right, bug discovery shifts from random trial and error to reasoning-guided input generation, turning day-long campaigns into minute-long ones.

What carries the argument

The load-bearing mechanism is a two-part substitution of reasoning for randomness. The first part is the Function Call Chain (FCC), the static call path from program entry to the vulnerable function, used to decompose seed generation: instead of asking the LLM for an entire bug-triggering file, RandLuzz asks it to modify the current input to reach the next function on the chain, checks the actual execution path, and repeats until the target is reached. When the FCC is unavailable, the method falls back on retrieval-augmented generation (RAG), which pulls small relevant code and documentation chunks as context, plus function summaries and reasoning about neighbor-function functionality. The second part is the bug-specific mutator: the bug report and function summary are converted into a bug analysis, then into mutation suggestions, then into C mutator code, which is compiled and trial-run before fuzzing. This two-part mechanism is what carries the reported speedup.

What would settle it

Run the seed-optimization loop on a family of bugs where the target is a small leaf function with no complete call chain and no neighbor functions and measure how often the LLM-generated seed reaches the target within the one-hour budget; the paper's own timeout on CVE-2018-17360 is already one such observation. The decisive counterexample to the strongest version of the claim would be a bug with a complete Function Call Chain where the LLM seed-optimization loop times out while ordinary random seeds still trigger the bug within 24 hours — that would show the reasoning step can be slower than the randomness it replaces.

Watch

Extended reading notes

Core claim

The paper's central claim is that the dominant inefficiency in directed fuzzing is not the guidance metric but the randomness in seeds and mutators, and that both can be made near-deterministic with LLM reasoning. RandLuzz generates 'reachable seeds' by tracing a Function Call Chain from the program entry to the vulnerable function and iteratively asking the LLM to modify an input so that execution advances one function closer to the target; when a complete chain is unavailable, it reasons from the functionality of neighbor functions. For the mutation half, RandLuzz asks the LLM to analyze the bug cause, propose mutation strategies, and emit C code implementing them, then loads that code into an existing fuzzer that supports user-defined mutators. On 14 vulnerabilities from 8 programs, fuzzers starting from these seeds were 2.1× to 4.8× faster on average than fuzzers starting from standard seed corpora, and the full RandLuzz pipeline exposed 8 bugs in under 60 seconds. The paper itself documents a limiting case in its case study: when static analysis provides neither a complete call chain nor any neighbor functions, as with CVE-2018-17360, seed optimization times out and the bug is never triggered.

Load-bearing premise

The whole speedup rests on the assumption that a language model can reconstruct, from partial context — a single function body, function names, and retrieved usage snippets — the conditions an input must satisfy to reach the target function, and this assumption fails when the target has no complete call chain and no neighbor functions, as in the paper's CVE-2018-17360 case.

Editorial extensions

If this is right

  • If the claim is right, directed fuzzers no longer need to spend hours rediscovering how to reach a deep target; the seed already encodes that knowledge, so the fuzzer can spend its entire budget on execution-state exploration.
  • Bug-specific mutators plug into any fuzzer with a custom-mutation interface, so the benefit is not confined to the prototype's exact configuration.
  • The division of labor implies that reachability and bug-triggering can be optimized separately — seeds handle the former, mutators the latter — rather than blurred into one distance metric.
  • A preparation cost of a few minutes per bug is small relative to 24-hour fuzzing campaigns, so the method is cost-effective whenever the fuzzing budget exceeds preparation time.
  • The documented failure on a target with no complete FCC and no neighbor functions marks a boundary: the method's universality is only as strong as the static analysis that supplies call-chain context.

Reading between the lines

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

  • The same seed-reasoning pipeline would likely also accelerate coverage-guided fuzzing, since reaching deep code is a general problem and not specific to directed targets.
  • An ablation separating the two contributions — LLM seeds alone versus LLM mutators alone — would quantify which half of the observed speedup is larger; the full-system evaluation conflates them.
  • The method's benefit should concentrate on targets with rich, statically analyzable call graphs, and I would expect near-zero benefit on leaf utilities with no neighbors, consistent with the paper's documented timeout case.
  • As language models gain longer context, generating complex binary inputs directly instead of through scripting code could remove the biggest remaining bottleneck the paper reports for ELF-like formats.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes RandLuzz, a directed fuzzing framework that uses an LLM (GPT-4o) to replace random initial seeds with LLM-generated reachable seeds and to replace generic AFL mutators with bug-specific mutators. The seed-generation pipeline extracts bug information from CVE reports, obtains program usage via RAG, builds function summaries, and then reasons along a function call chain (or, failing that, from neighboring functions) to produce inputs that reach the target. The mutator-generation pipeline asks the LLM for a bug cause analysis, mutation strategy, and compilable C mutator code. The evaluation compares RandLuzz with AFLGo, Beacon, WindRanger, and SelectFuzz on 14 CVEs, reporting that RandLuzz-generated seeds yield average speedups of 2.1x–4.8x, that RandLuzz is fastest on 7 of 13 exposed bugs, and that 8 bugs are exposed within 60 seconds. Section 5.3 includes one post-training-cutoff CVE (CVE-2024-34459) as evidence that the LLM is reasoning rather than recalling.

Significance. If the central claim holds, the paper makes a useful contribution to directed fuzzing: it demonstrates a concrete way to use LLM reasoning to shorten the path from an initial seed to a target location and to tailor mutation operators to specific bug causes. The idea is well motivated, the system design is described in enough detail to be replicated, and the paper is honest about limitations (e.g., Section 4.5.1 admits the failure on CVE-2018-17360). The authors also include a post-training-cutoff control, which is the right kind of evidence for the reasoning-versus-memorization concern, even though the control is currently only one bug. The main weakness is that the quantitative evidence, as reported, contains an internal contradiction between Table 3 and Table 4, and the headline speedup claim is stated more broadly than the per-fuzzer results in Section 4.2 support. Those issues need to be resolved before the efficiency claims can be accepted.

major comments (4)
  1. [Section 4.3 / Table 4, CVE-2017-14940 row] Table 3 reports T.O. for every fuzzer and every seed set for CVE-2017-14940, including AFLGo, WindRanger, and RANDLUZZ with RLS. Table 4, which also states that all fuzzers use RANDLUZZ-generated reachable seeds, reports 26s for AFLGo, 139s for WindRanger, and 458s for RANDLUZZ for the same CVE. These two entries cannot both be correct under the stated experimental setup; this is a load-bearing inconsistency because CVE-2017-14940 is one of only two rows excluded from the average speedup calculation, and it directly affects the claim that RLS improves exposure time. Please correct the tables or explicitly explain the differing experimental conditions (e.g., different seed batches, separate reruns, or a typo in one table).
  2. [Abstract and Section 4.2, Table 3 discussion] The abstract's claim that 'the fuzzers achieve an average speedup ranging from 2.1x to 4.8x' is not supported for all four fuzzers: Section 4.2 states that 'SelectFuzz with RLS discovers bugs slower than OS and SS' and reports no speedup for SelectFuzz. In addition, the speedup averages exclude the two timeout cases (CVE-2018-17360 and CVE-2017-14940), and this exclusion is not stated in the abstract. Please report per-fuzzer speedups over all 14 benchmark rows with an explicit timeout-handling convention, and revise the abstract to state which fuzzers realize the 2.1x–4.8x range and under what inclusion rule.
  3. [Section 5.3 and Table 1] The central claim that LLM reasoning, rather than memorization, drives the reported speedups is not yet adequately supported. Thirteen of the 14 benchmark CVEs predate GPT-4o's October 2023 training cutoff, and the seed-generation prompt is built directly from each CVE report (Section 3.2.1); the LLM may therefore be reproducing known crashing inputs or PoC fragments rather than deriving path constraints from the FCC. The single post-cutoff experiment (CVE-2024-34459, one bug, 941s) is a useful start but is too small a sample to rule out memorization as the dominant factor. Please add additional post-cutoff vulnerabilities or an ablation that removes or paraphrases the bug-identifying information from the CVE prompt and shows that RLS quality does not collapse; this is necessary to support the reasoning mechanism claimed in the title and abstract.
  4. [Section 4.5.1 / Table 2] The paper reports that CVE-2018-17360's seed optimization times out and that the bug is never triggered (Table 4, T.O.), attributing this to the absence of both a complete FCC and neighbor functions. This is an honest and important limitation, but it also means that the system's reachable-seed mechanism is not demonstrated for a complete class of targets (those with no usable FCC and no neighbor functions). The paper should state explicitly, in the abstract or contributions, that the reported speedups apply to the subset of vulnerabilities for which seed optimization succeeds, and should quantify how many of the 14 benchmark CVEs fall into that category.
minor comments (5)
  1. [Section 4.4] There is a typo in the second paragraph: 'GTP-4' should be 'GPT-4'.
  2. [Section 4.1] 'WindRange' should be 'WindRanger' in the preparation-time discussion.
  3. [Table 2] In the CVE-2017-8397 row, the RANDLUZZ Total column reads '663' without a unit; it should be '663s'.
  4. [Section 3.3.3] The method randomly selects a neighboring function when no complete FCC is available, which is at odds with the paper's 'random-less' framing; this is not a fatal flaw, but the text should acknowledge that this fallback retains a random choice.
  5. [Table 3 / Table 4] The tables use T.O. for 24-hour timeouts, but the text describing the preparation-time table (Table 2) also uses T.O. for a 3600-second timeout; please state the timeout value in each table caption to avoid ambiguity.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the LLM is a frozen external component, targets are standard directed-fuzzing inputs, and the paper includes a post-training-cutoff control that separates reasoning from memorization.

full rationale

The derivation chain is self-contained: RANDLUZZ takes a bug report, extracts target locations, retrieves program usage, summarizes functions, generates reachable seeds along function call chains, builds bug-specific mutators, and measures time-to-bug against baseline fuzzers. None of these steps is defined in terms of the measured outcome, and no equation or fitted parameter is renamed as a prediction. The LLM is a fixed external model, not fine-tuned or fitted on the benchmark bugs, so the speedups are empirical outcomes rather than construction-identical to the inputs. The use of CVE reports both as input and as the fuzzing target is inherent to directed fuzzing, not circularity. RQ2 and RQ3 are controlled comparisons: RQ2 varies only the seed set while holding each fuzzer fixed, and RQ3 gives all fuzzers the same RANDLUZZ seeds to isolate the mutator contribution. The paper's self-citations are to general fuzzing and LLM-survey related work, and none is load-bearing for the claimed speedup. The main legitimate concern is that 13 of the 14 benchmark CVEs predate GPT-4o's knowledge cutoff, so memorized crashing inputs could inflate the results; however, the paper explicitly acknowledges this risk in Section 5.3 and provides a post-cutoff CVE, CVE-2024-34459, as a control. Whether one post-cutoff data point is sufficient evidence is a validity or correctness question, not a circularity of derivation. No specific reduction from output to input by construction or by author-imported uniqueness can be exhibited, so the appropriate finding is no significant circularity.

Assumptions & free parameters 3 free parameters · 3 assumptions · 0 invented entities

The central claim rests on the empirical reliability of LLMs and static analysis, not on a closed-form derivation. The free parameters are policy choices such as top-k and timeouts, and the axioms are engineering assumptions about LLM reasoning and static-analysis completeness. No new physical entities are introduced.

free parameters (3)
  • RAG top-k = 10
    Section 3.2.2: "Empirically, we select the top 10 relevant chunks"; this hand-chosen constant controls which program and documentation context the LLM sees when constructing program usage and ultimately seeds.
  • Seed optimization timeout = 3600 seconds
    Section 3.3.4: if no seed reaches the target within one hour, the tool falls back to a subset of generated seeds; this timeout shapes which bugs are reachable and therefore which speedups are reported.
  • Mutation strategy refresh interval = 1 hour
    Section 3.4: "we request the LLM to generate a new set of mutation strategies every hour"; the frequency is arbitrary and affects the balance between diversity and LLM query cost.
assumptions (3)
  • domain assumption LLM code and semantic reasoning is reliable enough to generate reachable seeds and correct mutator code
    Sections 3.3.4 and 3.4 rely on iterative LLM code repair and trial runs; when this fails, as for CVE-2018-17360, the bug is never exposed.
  • domain assumption Clang AST static analysis can produce a complete FCC or at least neighbor functions for the target
    Sections 3.3.2 and 3.3.3 require an FCC or neighbor functions for seed generation; if neither is available, seed generation degrades and can time out.
  • domain assumption CVE reports used for evaluation state or imply the vulnerable function at function-level granularity
    Section 5.1 states that when a report does not identify the vulnerable function, RandLuzz cannot locate the vulnerability.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Fuzzing: Randomness? Reasoning! Efficient Directed Fuzzing via Large Language Models." pith.science (2026). https://pith.science/paper/FAPAWW6V

@misc{pith2026250722065,
  author       = {Pith},
  title        = {Pith review of: Fuzzing: Randomness? Reasoning! Efficient Directed Fuzzing via Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FAPAWW6V}},
  note         = {Machine review of arXiv:2507.22065}
}
abstract

Fuzzing is highly effective in detecting bugs due to the key contribution of randomness. However, randomness significantly reduces the efficiency of fuzzing, causing it to cost days or weeks to expose bugs. Even though directed fuzzing reduces randomness by guiding fuzzing towards target buggy locations, the dilemma of randomness still challenges directed fuzzers. Two critical components, which are seeds and mutators, contain randomness and are closely tied to the conditions required for triggering bugs. Therefore, to address the challenge of randomness, we propose to use large language models (LLMs) to remove the randomness in seeds and reduce the randomness in mutators. With their strong reasoning and code generation capabilities, LLMs can be used to generate reachable seeds that target pre-determined locations and to construct bug-specific mutators tailored for specific bugs. We propose RandLuzz, which integrates LLMs and directed fuzzing, to improve the quality of seeds and mutators, resulting in efficient bug exposure. RandLuzz analyzes function call chain or functionality to guide LLMs in generating reachable seeds. To construct bug-specific mutators, RandLuzz uses LLMs to perform bug analysis, obtaining information such as bug causes and mutation suggestions, which further help generate code that performs bug-specific mutations. We evaluate RandLuzz by comparing it with four state-of-the-art directed fuzzers, AFLGo, Beacon, WindRanger, and SelectFuzz. With RandLuzz-generated seeds, the fuzzers achieve an average speedup ranging from 2.1$\times$ to 4.8$\times$ compared to using widely-used initial seeds. Additionally, when evaluated on individual bugs, RandLuzz achieves up to a 2.7$\times$ speedup compared to the second-fastest exposure. On 8 bugs, RandLuzz can even expose them within 60 seconds.

Figures

Figures reproduced from arXiv: 2507.22065 by the authors.

Figure 1
Figure 1. Randomness in initial seeds for cjpeg. Different seeds explore different input space, resulting in differences in time to bugs. factor that impacts the efficiency of directed fuzzing. • We introduce LLMs to remove randomness in generat￾ing reachable seeds and reduce randomness in gener￾ating bug-specific mutators. • We develop RANDLUZZ1 incorporating LLMs to demonstrate the effectiveness and efficiency of our idea, … view at source ↗
Figure 2
Figure 2. Workflow of RANDLUZZ. Reachable indicates that the execution can reach the target vulnerable location. The use of LLM is to generate reachable seeds and generate specific mutators for target bugs. FCC is short for Function Call Chain [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. LLM query scheme. Each task is based on this query scheme to create a query template, which further generates queries. [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figures from the paper (5 more)
Figure 4
Figure 4. Figure 4: Program usage and its options. RANDLUZZ uses RAG to retrieve relevant and small chunks from documents and source code, and the small chunks are used as the context when querying LLMs [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: An example of Function Summary. It includes the summaries of [PITH_FULL_IMAGE:figures/full_fig_p006_5.png]
Figure 6
Figure 6. Figure 6: Reasoning along FCC. The aim is to generate a seed that can reach the target vulnerable function [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]
Figure 7
Figure 7. Figure 7: Bug-specific Mutator. Based on LLM, RANDLUZZ generates code to perform mutations. path constraint compares a variable named maxval with a macro-defined value MAXJSAMPLE. Since only the relevant function definition is provided in the LLM query, without the macro definit…
Figure 8
Figure 8. Figure 8: Function body of [PITH_FULL_IMAGE:figures/full_fig_p011_8.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

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

  1. 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

45 extracted references · 43 canonical work pages · cited by 1 Pith paper

  1. [1]

    Directed greybox fuzzing

    Marcel B ¨ohme, Van-Thuan Pham, Manh-Dung Nguyen, and Abhik Roychoudhury. Directed greybox fuzzing. In Proceedings of the 2017 ACM SIGSAC conference on computer and communications security , pages 2329–2344, 2017

    work page 2017

  2. [2]

    Coverage-based greybox fuzzing as markov chain

    Marcel B ¨ohme, Van-Thuan Pham, and Abhik Roychoudhury. Coverage-based greybox fuzzing as markov chain. In Proceedings of the 2016 ACM SIGSAC Conference on Computer and Communi- cations Security, pages 1032–1043, 2016

    work page 2016

  3. [3]

    Oddfuzz: Discovering java deserialization vulnerabilities via structure-aware directed greybox fuzzing

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

    work page 2023

  4. [4]

    Hawkeye: Towards a desired directed grey-box fuzzer

    Hongxu Chen, Yinxing Xue, Yuekang Li, Bihuan Chen, Xiaofei Xie, Xiuheng Wu, and Yang Liu. Hawkeye: Towards a desired directed grey-box fuzzer. In Proceedings of the 2018 ACM SIGSAC conference on computer and communications security , pages 2095–2108, 2018

    work page 2018

  5. [5]

    Large language models are zero-shot fuzzers: Fuzzing deep-learning libraries via large language models

    Yinlin Deng, Chunqiu Steven Xia, Haoran Peng, Chenyuan Yang, and Lingming Zhang. Large language models are zero-shot fuzzers: Fuzzing deep-learning libraries via large language models. In Pro- ceedings of the 32nd ACM SIGSOFT international symposium on software testing and analysis , pages 423–435, 2023

    work page 2023

  6. [6]

    Large language models are edge-case generators: Crafting unusual programs for fuzzing deep learning libraries

    Yinlin Deng, Chunqiu Steven Xia, Chenyuan Yang, Shizhuo Dylan Zhang, Shujing Yang, and Lingming Zhang. Large language models are edge-case generators: Crafting unusual programs for fuzzing deep learning libraries. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering , pages 1–13, 2024

    work page 2024

  7. [7]

    The faiss library

    Matthijs Douze, Alexandr Guzhva, Chengqi Deng, Jeff Johnson, Gergely Szilvasy, Pierre-Emmanuel Mazar ´e, Maria Lomeli, Lucas Hosseini, and Herv ´e J ´egou. The faiss library. 2024

    2024

  8. [8]

    Windranger: A directed greybox fuzzer driven by deviation basic blocks

    Zhengjie Du, Yuekang Li, Yang Liu, and Bing Mao. Windranger: A directed greybox fuzzer driven by deviation basic blocks. In Proceed- ings of the 44th International Conference on Software Engineering , pages 2440–2451, 2022

    work page 2022

Show all 45 references
  1. [9]

    Snipuzz: Black-box fuzzing of iot firmware via message snippet inference

    Xiaotao Feng, Ruoxi Sun, Xiaogang Zhu, Minhui Xue, Sheng Wen, Dongxi Liu, Surya Nepal, and Yang Xiang. Snipuzz: Black-box fuzzing of iot firmware via message snippet inference. In Proceedings Of The 2021 ACM SIGSAC Conference On Computer And Commu- nications Security, pages 33...

    2021

  2. [10]

    AFL++: Combining incremental steps of fuzzing research

    Andrea Fioraldi, Dominik Maier, Heiko Eißfeldt, and Marc Heuse. AFL++: Combining incremental steps of fuzzing research. In 14th USENIX Workshop on Offensive Technologies (WOOT 20) . USENIX Association, August 2020

    2020

  3. [11]

    Terrain diffusion network: Climatic-aware terrain generation with geological sketch guidance

    Zexin Hu, Kun Hu, Clinton Mo, Lei Pan, and Zhiyong Wang. Terrain diffusion network: Climatic-aware terrain generation with geological sketch guidance. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pages 12565–12573, 2024

    2024

  4. [12]

    Beacon: Directed grey-box fuzzing with provable path pruning

    Heqing Huang, Yiyuan Guo, Qingkai Shi, Peisen Yao, Rongxin Wu, and Charles Zhang. Beacon: Directed grey-box fuzzing with provable path pruning. In 2022 IEEE Symposium on Security and Privacy (SP), pages 36–50. IEEE, 2022

    2022

  5. [13]

    Titan: Efficient multi-target directed greybox fuzzing

    Heqing Huang, Peisen Yao, Hung-Chun Chiu, Yiyuan Guo, and Charles Zhang. Titan: Efficient multi-target directed greybox fuzzing. In Proceedings of the 2024 IEEE Symposium on Security and Privacy (SP), San Francisco, CA, USA , pages 20–22, 2024

    2024

  6. [14]

    Everything is good for something: Counterexample-guided directed fuzzing via likely invariant inference

    Heqing Huang, Anshunkang Zhou, Mathias Payer, and Charles Zhang. Everything is good for something: Counterexample-guided directed fuzzing via likely invariant inference. In 2024 IEEE Sympo- sium on Security and Privacy (SP) , pages 142–142. IEEE Computer Society, 2024

    2024

  7. [15]

    Large language models are few-shot testers: Exploring llm-based general bug reproduction

    Sungmin Kang, Juyeon Yoon, and Shin Yoo. Large language models are few-shot testers: Exploring llm-based general bug reproduction. In 2023 IEEE/ACM 45th International Conference on Software En- gineering (ICSE), pages 2312–2323. IEEE, 2023

    2023

  8. [16]

    Evaluating directed fuzzers: Are we heading in the right direc- tion? Proceedings of the ACM on Software Engineering, 1(FSE):316– 337, 2024

    Tae Eun Kim, Jaeseung Choi, Seongjae Im, Kihong Heo, and Sang Kil Cha. Evaluating directed fuzzers: Are we heading in the right direc- tion? Proceedings of the ACM on Software Engineering, 1(FSE):316– 337, 2024

    2024

  9. [17]

    Evaluating fuzz testing

    George Klees, Andrew Ruef, Benji Cooper, Shiyi Wei, and Michael Hicks. Evaluating fuzz testing. In Proceedings of the 2018 ACM SIGSAC conference on computer and communications security, pages 2123–2138, 2018

    2018

  10. [18]

    Constraint- guided directed greybox fuzzing

    Gwangmu Lee, Woochul Shim, and Byoungyoung Lee. Constraint- guided directed greybox fuzzing. In 30th USENIX Security Sympo- sium (USENIX Security 21) , pages 3559–3576, 2021

    2021

  11. [19]

    Retrieval-augmented generation for knowledge-intensive nlp tasks

    Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich K ¨uttler, Mike Lewis, Wen-tau Yih, Tim Rockt¨aschel, et al. Retrieval-augmented generation for knowledge-intensive nlp tasks. Advances in Neural Information Processing Syst...

    2020

  12. [20]

    Sdfuzz: Target states driven directed fuzzing

    Penghui Li, Wei Meng, and Chao Zhang. Sdfuzz: Target states driven directed fuzzing. In Proceedings of the 33rd USENIX Security Symposium (Security). Philadelphia, PA, USA , 2024

    2024

  13. [21]

    Deepgo: Predictive directed greybox fuzzing

    Peihong Lin, Pengfei Wang, Xu Zhou, Wei Xie, Gen Zhang, and Kai Lu. Deepgo: Predictive directed greybox fuzzing. In Network and Distributed System Security (NDSS) Symposium , 2024

    2024

  14. [22]

    Labrador: Response guided di- rected fuzzing for black-box iot devices

    Hangtian Liu, Shuitao Gan, Chao Zhang, Zicong Gao, Hongqi Zhang, Xiangzhi Wang, and Guangming Gao. Labrador: Response guided di- rected fuzzing for black-box iot devices. In 2024 IEEE Symposium on Security and Privacy (SP) , pages 127–127. IEEE Computer Society, 2024

    2024

  15. [23]

    Autoregressive omni-aware outpainting for open-vocabulary 360- degree image generation

    Zhuqiang Lu, Kun Hu, Chaoyue Wang, Lei Bai, and Zhiyong Wang. Autoregressive omni-aware outpainting for open-vocabulary 360- degree image generation. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 38, pages 14211–14219, 2024

    2024

  16. [24]

    Selectfuzz: Efficient directed fuzzing with selective path exploration

    Changhua Luo, Wei Meng, and Penghui Li. Selectfuzz: Efficient directed fuzzing with selective path exploration. In 2023 IEEE Symposium on Security and Privacy (SP) , pages 2693–2707. IEEE, 2023

    2023

  17. [25]

    MOPT: Optimized mutation scheduling for fuzzers

    Chenyang Lyu, Shouling Ji, Chao Zhang, Yuwei Li, Wei-Han Lee, Yu Song, and Raheem Beyah. MOPT: Optimized mutation scheduling for fuzzers. In 28th USENIX Security Symposium (USENIX Security 19), pages 1949–1966, 2019

    1949

  18. [26]

    From one thousand pages of specification to unveiling hidden bugs: Large language model assisted fuzzing of matter {IoT} devices

    Xiaoyue Ma, Lannan Luo, and Qiang Zeng. From one thousand pages of specification to unveiling hidden bugs: Large language model assisted fuzzing of matter {IoT} devices. In 33rd USENIX Security Symposium (USENIX Security 24) , pages 4783–4800, 2024

    2024

  19. [27]

    Large language model guided protocol fuzzing

    Ruijie Meng, Martin Mirchev, Marcel B ¨ohme, and Abhik Roychoud- hury. Large language model guided protocol fuzzing. In Proceedings of the 31st Annual Network and Distributed System Security Sympo- sium (NDSS), 2024

    2024

  20. [28]

    M C2: Rigorous and efficient directed greybox fuzzing

    Abhishek Shah, Dongdong She, Samanway Sadhu, Krish Singal, Peter Coffman, and Suman Jana. M C2: Rigorous and efficient directed greybox fuzzing. In Proceedings of the 2022 ACM SIGSAC Conference on Computer and Communications Security, pages 2595– 2609, 2022

    2022

  21. [29]

    Crfuzz: Fuzzing multi-purpose programs through input validation

    Suhwan Song, Chengyu Song, Yeongjin Jang, and Byoungyoung Lee. Crfuzz: Fuzzing multi-purpose programs through input validation. In Proceedings of the 28th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Soft- ware Engineering, ...

    2020

  22. [30]

    Syzdirect: Directed greybox fuzzing for linux kernel

    Xin Tan, Yuan Zhang, Jiadong Lu, Xin Xiong, Zhuang Liu, and Min Yang. Syzdirect: Directed greybox fuzzing for linux kernel. In Proceedings of the 2023 ACM SIGSAC Conference on Computer and Communications Security , pages 1630–1644, 2023

    2023

  23. [31]

    Llmif: Augmented large language model for fuzzing iot devices

    Jincheng Wang, Le Yu, and Xiapu Luo. Llmif: Augmented large language model for fuzzing iot devices. In 2024 IEEE Symposium on Security and Privacy (SP) , pages 196–196. IEEE Computer Society, 2024

    2024

  24. [32]

    Minilm: Deep self-attention distillation for task-agnostic com- pression of pre-trained transformers

    Wenhui Wang, Furu Wei, Li Dong, Hangbo Bao, Nan Yang, and Ming Zhou. Minilm: Deep self-attention distillation for task-agnostic com- pression of pre-trained transformers. Advances in Neural Information Processing Systems, 33:5776–5788, 2020

    2020

  25. [33]

    Fuzz4all: Universal fuzzing with large lan- guage models

    Chunqiu Steven Xia, Matteo Paltenghi, Jia Le Tian, Michael Pradel, and Lingming Zhang. Fuzz4all: Universal fuzzing with large lan- guage models. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering , pages 1–13, 2024

    2024

  26. [34]

    Critical code guided directed greybox fuzzing for commits

    Yi Xiang, Xuhong Zhang, Peiyu Liu, Shouling Ji, Xiao Xiao, Hong Liang, Jiacheng Xu, and Wenhai Wang. Critical code guided directed greybox fuzzing for commits. In USENIX, 2024

    2024

  27. [35]

    1dfuzz: Reproduce 1- day vulnerabilities with directed differential fuzzing

    Songtao Yang, Yubo He, Kaixiang Chen, Zheyu Ma, Xiapu Luo, Yong Xie, Jianjun Chen, and Chao Zhang. 1dfuzz: Reproduce 1- day vulnerabilities with directed differential fuzzing. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis, page...

    2023

  28. [36]

    Ddrace: Finding concurrency uaf vulnerabilities in linux drivers with directed fuzzing

    Ming Yuan, Bodong Zhao, Penghui Li, Jiashuo Liang, Xinhui Han, Xiapu Luo, and Chao Zhang. Ddrace: Finding concurrency uaf vulnerabilities in linux drivers with directed fuzzing. In USENIX Security Symposium, pages 2849–2866, 2023

    2023

  29. [37]

    Mm-llms: Recent advances in multimodal large language models

    Duzhen Zhang, Yahan Yu, Jiahua Dong, Chenxing Li, Dan Su, Chen- hui Chu, and Dong Yu. Mm-llms: Recent advances in multimodal large language models. arXiv preprint arXiv:2401.13601 , 2024

    2024 arXiv

  30. [38]

    Your fix is my exploit: Enabling comprehensive dl library api fuzzing with large language models

    Kunpeng Zhang, Shuai Wang, Jitao Han, Xiaogang Zhu, Xian Li, Shaohua Wang, and Sheng Wen. Your fix is my exploit: Enabling comprehensive dl library api fuzzing with large language models. In 2025 IEEE/ACM 47th International Conference on Software Engi- neering (ICSE). IEEE, 2025

    2025

  31. [39]

    Shapfuzz: Efficient fuzzing via shapley-guided byte selection

    Kunpeng Zhang, Xiaogang Zhu, Xi Xiao, Minhui Xue, Chao Zhang, and Sheng Wen. Shapfuzz: Efficient fuzzing via shapley-guided byte selection. In NDSS, 2024

    2024

  32. [40]

    Predecessor- aware directed greybox fuzzing

    Yujian Zhang, Yaokun Liu, Jinyu Xu, and Yanhao Wang. Predecessor- aware directed greybox fuzzing. In 2024 IEEE Symposium on Security and Privacy (SP) , pages 40–40. IEEE Computer Society, 2024

    2024

  33. [41]

    Regression greybox fuzzing

    Xiaogang Zhu and Marcel B ¨ohme. Regression greybox fuzzing. In Proceedings Of The 2021 ACM SIGSAC Conference On Computer And Communications Security , pages 2169–2182, 2021

    2021

  34. [42]

    CSI-Fuzz: Full-speed edge tracing using coverage sensitive instrumentation

    Xiaogang Zhu, Xiaotao Feng, Xiaozhu Meng, Sheng Wen, Seyit Camtepe, Yang Xiang, and Kui Ren. CSI-Fuzz: Full-speed edge tracing using coverage sensitive instrumentation. IEEE Transactions On Dependable And Secure Computing , 19(2):912–923, 2020

    2020

  35. [43]

    Fuzzing: a survey for roadmap

    Xiaogang Zhu, Sheng Wen, Seyit Camtepe, and Yang Xiang. Fuzzing: a survey for roadmap. ACM Computing Surveys (CSUR) , 54(11s):1– 36, 2022

    2022

  36. [44]

    When software security meets large language models: A survey

    Xiaogang Zhu, Wei Zhou, Qing-Long Han, Wanlun Ma, Sheng Wen, and Yang Xiang. When software security meets large language models: A survey. IEEE/CAA Journal Of Automatica Sinica , 2024

    2024

  37. [45]

    Fuzzguard: Filtering out unreachable inputs in directed grey-box fuzzing through deep learning

    Peiyuan Zong, Tao Lv, Dawei Wang, Zizhuang Deng, Ruigang Liang, and Kai Chen. Fuzzguard: Filtering out unreachable inputs in directed grey-box fuzzing through deep learning. In 29th USENIX security symposium (USENIX security 20) , pages 2255–2269, 2020

    2020

Pith tools

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