Awesome Fuzzing 
Fuzzing or fuzz testing is an automated software testing technique that involves providing invalid, unexpected, or random data as inputs to a computer program. The program is then monitored for exceptions such as crashes, failing built-in code assertions, or potential memory leaks. Typically, fuzzers are used to test programs that take structured inputs.
A curated list of references to awesome Fuzzing for security testing. Additionally there is a collection of freely available academic papers, tools and so on.
Your favorite tool or your own paper is not listed? Fork and create a Pull Request to add it!
Contents
Books
Talks
Papers
To achieve a well-defined scope, I have chosen to include publications on fuzzing from 4 top major security conferences (2008–2026): (i) Network and Distributed System Security Symposium (NDSS), (ii) IEEE Symposium on Security and Privacy (S&P), (iii) USENIX Security Symposium (USEC), and (iv) ACM Conference on Computer and Communications Security (CCS).
Note: Papers are selected based on whether the title contains the keyword "fuzz." If a paper is related to fuzzing but does not include "fuzz" in its title, it may have been missed. In that case, please open a Pull Request and it will be reviewed for inclusion.
The Network and Distributed System Security Symposium (NDSS)
2026 (13 papers)
- ADGFUZZ: Assignment Dependency-Guided Fuzzing for Robotic Vehicles, 2026
- An LLM-Driven Fuzzing Framework for Detecting Logic Instruction Bugs in PLCs, 2026
- BSFuzzer: Context-Aware Semantic Fuzzing for BLE Logic Flaw Detection, 2026
- DOM-XSS Detection via Webpage Interaction Fuzzing and URL Component Synthesis, 2026
- FirmAgent: Leveraging Fuzzing to Assist LLM Agents with IoT Firmware Vulnerability Discovery, 2026
- Fuzzilicon: A Post-Silicon Microcode-Guided x86 CPU Fuzzer, 2026
- GoldenFuzz: Generative Golden Reference Hardware Fuzzing, 2026
- HyperMirage: Direct State Manipulation in Hybrid Virtual CPU Fuzzing, 2026
- MUTATO: Enhancing Fuzz Drivers with Adaptive API Option Mutation, 2026
- PhyFuzz: Detecting Sensor Vulnerabilities with Physical Signal Fuzzing, 2026
- PortRush: Detect Write Port Contention Side-Channel Vulnerabilities via Hardware Fuzzing, 2026
- ReFuzz: Reusing Tests for Processor Fuzzing with Contextual Bandits, 2026
- RTCON: Context-Adaptive Function-Level Fuzzing for RTOS Kernels, 2026
2025 (10 papers)
- Automatic Library Fuzzing through API Relation Evolvement, 2025
- Blackbox Fuzzing of Distributed Systems with Multi-Dimensional Inputs and Symmetry-Based Feedback Pruning, 2025
- DUMPLING: Fine-grained Differential JavaScript Engine Fuzzing, 2025
- FUZZUER: Enabling Fuzzing of UEFI Interfaces on EDK-2, 2025
- ICSQuartz: Scan Cycle-Aware and Vendor-Agnostic Fuzzing for Industrial Control Systems, 2025
- MALintent: Coverage Guided Intent Fuzzing Framework for Android, 2025
- Moneta: Ex-Vivo GPU Driver Fuzzing by Recalling In-Vivo Execution States, 2025
- MSan: Efficiently Detecting Uninitialized Memory Errors During Fuzzing, 2025
- Truman: Constructing Device Behavior Models from OS Drivers to Fuzz Virtual Devices, 2025
- TWINFUZZ: Differential Testing of Video Hardware Acceleration Stacks, 2025
2024 (7 papers)
2023 (4 papers)
2022 (4 papers)
2021 (4 papers)
2020 (4 papers)
2019 (5 papers)
2018 (4 papers)
2017 (2 papers)
2016 (1 paper)
2008 (1 paper)
IEEE Symposium on Security and Privacy (IEEE S&P)
2026 (14 papers)
- Batch Me If You Can: Coverage-guided RPKI Fuzzing at Scale, 2026
- Camveil: Unveiling Security Camera Vulnerabilities through Multi-Protocol Coordinated Fuzzing, 2026
- deepSURF: Detecting Memory Safety Vulnerabilities in Rust Through Fuzzing LLM-Augmented Harnesses, 2026
- Fizzle: A Framework for Deterministic and Reproducible Network Fuzzing, 2026
- Fuzzing the Physical Space: Physics-Aware Testing of Black-Box Industrial Control Systems, 2026
- Jazzer: Coverage-Guided Fuzzing for Semantic Vulnerabilities in the Java Ecosystem, 2026
- PILOT: Command-line Interface Fuzzing via Path-Guided, Iterative Large Language Model Prompting, 2026
- SmuFuzz: Enable Deep System Management Mode Fuzzing in Fully Featured UEFI Runtime Environment, 2026
- Specializing Language Models for Textual Fuzzing via Reinforcement Learning, 2026
- StepStone: LLM-Based GPU Kernel Driver Fuzzing via User-Space Libraries, 2026
- Stop Starving or Stuffing Me: Boosting Firmware Fuzzing Efficiency with On-demand Input Delivery, 2026
- TrigFuzz: Triggering Conditions Guided Directed Fuzzing, 2026
- Web Application Vulnerability Repair via Context-Aware Fault Localization and Directed Differential Fuzzing, 2026
- zkFuzz: Foundation and Framework for Effective Fuzzing of Zero-Knowledge Circuits, 2026
2025 (7 papers)
2024 (14 papers)
- AFGen: Whole-Function Fuzzing for Applications and Libraries, 2024
- Chronos: Finding Timeout Bugs in Practical Distributed Systems by Deep-Priority Fuzzing with Transient Delay, 2024
- DY Fuzzing: Formal Dolev-Yao Models Meet Cryptographic Protocol Fuzz Testing, 2024
- Everything is Good for Something: Counterexample-Guided Directed Fuzzing via Likely Invariant Inference, 2024
- LABRADOR: Response Guided Directed Fuzzing for Black-box IoT Devices, 2024
- LLMIF: Augmented Large Language Model for Fuzzing IoT Devices, 2024
- Predecessor-aware Directed Greybox Fuzzing, 2024
- SATURN: Host-Gadget Synergistic USB Driver Fuzzing, 2024
- SoK: Prudent Evaluation Practices for Fuzzing, 2024
- SyzGen++: Dependency Inference for Augmenting Kernel Driver Fuzzing, 2024
- SyzTrust: State-aware Fuzzing on Trusted OS Designed for IoT Devices, 2024
- Titan: Efficient Multi-target Directed Greybox Fuzzing, 2024
- To Boldly Go Where No Fuzzer Has Gone Before: Finding Bugs in Linux' Wireless Stacks through VirtIO Devices, 2024
- Towards Smart Contract Fuzzing on GPU, 2024
2023 (10 papers)
- TEEzz: Fuzzing Trusted Applications on COTS Android Devices, 2023
- SEGFUZZ: Segmentizing Thread Interleaving to Discover Kernel Concurrency Bugs through Fuzzing, 2023
- RSFuzzer: Discovering Deep SMI Handler Vulnerabilities in UEFI Firmware with Hybrid Fuzzing, 2023
- Toss a Fault to Your Witcher: Applying Grey-box Coverage-Guided Mutational Fuzzing to Detect SQL and Command Injection Vulnerabilities, 2023
- UTOPIA: Automatic Generation of Fuzz Driver using Unit Tests, 2023
- SelectFuzz: Efficient Directed Fuzzing with Selective Path Exploration, 2023
- Finding Specification Blind Spots via Fuzz Testing, 2023
- ODDFUZZ: Discovering Java Deserialization Vulnerabilities via Structure-Aware Directed Greybox Fuzzing, 2023
- VIDEZZO: Dependency-aware Virtual Device Fuzzing, 2023
- DEVFUZZ: Automatic Device Model-Guided Device Driver Fuzzing, 2023
2022 (5 papers)
2021 (5 papers)
2020 (5 papers)
2019 (4 papers)
2018 (3 papers)
2017 (1 paper)
2015 (1 paper)
2010 (1 paper)
USENIX Security
2026 (4 papers)
2025 (15 papers)
- AidFuzzer: Adaptive Interrupt-Driven Firmware Fuzzing via Run-Time State Recognition, 2025
- ChainFuzz: Exploiting Upstream Vulnerabilities in Open-Source Supply Chains, 2025
- CoreCrisis: Threat-Guided and Context-Aware Iterative Learning and Fuzzing of 5G Core Networks, 2025
- Effective Directed Fuzzing with Hierarchical Scheduling for Web Vulnerability Detection, 2025
- Encarsia: Evaluating CPU Fuzzers via Automatic Bug Injection, 2025
- From Alarms to Real Bugs: Multi-target Multi-step Directed Greybox Fuzzing for Static Analysis Result Verification, 2025
- Fuzzing the PHP Interpreter via Dataflow Fusion, 2025
- GenHuzz: An Efficient Generative Hardware Fuzzer, 2025
- IDFuzz: Intelligent Directed Grey-box Fuzzing, 2025
- Lost in Translation: Enabling Confused Deputy Attacks on EDA Software with TransFuzz, 2025
- Low-Cost and Comprehensive Non-textual Input Fuzzing with LLM-Synthesized Input Generators, 2025
- MBFuzzer: A Multi-Party Protocol Fuzzer for MQTT Brokers, 2025
- PAPILLON: Efficient and Stealthy Fuzz Testing-Powered Jailbreaks for LLMs, 2025
- Robust, Efficient, and Widely Available Greybox Fuzzing for COTS Binaries with System Call Pattern Feedback, 2025
- Waltzz: WebAssembly Runtime Fuzzing with Stack-Invariant Transformation, 2025
2024 (12 papers)
- Atropos: Effective Fuzzing of Web Applications for Server-Side Vulnerabilities, 2024
- Cascade: CPU Fuzzing via Intricate Program Generation, 2024
- Critical Code Guided Directed Greybox Fuzzing for Commits, 2024
- EL3XIR: Fuzzing COTS Secure Monitors, 2024
- Fuzzing BusyBox: Leveraging LLM and Crash Reuse for Embedded Bug Unearthing, 2024
- HYPERPILL: Fuzzing for Hypervisor-bugs by Leveraging the Hardware Virtualization Interface, 2024
- MultiFuzz: A Multi-Stream Fuzzer For Testing Monolithic Firmware, 2024
- ResolverFuzz: Automated Discovery of DNS Resolver Vulnerabilities with Query-Response Fuzzing, 2024
- SDFuzz: Target States Driven Directed Fuzzing, 2024
- SHiFT: Semi-hosted Fuzz Testing for Embedded Applications, 2024
- Towards Generic Database Management System Fuzzing, 2024
- WhisperFuzz: White-Box Fuzzing for Detecting and Locating Timing Vulnerabilities in Processors, 2024
2023 (19 papers)
- AIFORE: Smart Fuzzing Based on Automatic Input Format Reverse Engineering, 2023
- autofz: Automated Fuzzer Composition at Runtime, 2023
- Automata-Guided Control-Flow-Sensitive Fuzz Driver Generation, 2023
- Automated Exploitable Heap Layout Generation for Heap Overflows Through Manipulation Distance-Guided Fuzzing, 2023
- Bleem: Packet Sequence Oriented Fuzzing for Protocol Implementations, 2023
- BoKASAN: Binary-only Kernel Address Sanitizer for Effective Kernel Fuzzing, 2023
- CarpetFuzz: Automatic Program Option Constraint Extraction from Documentation for Fuzzing, 2023
- DDRace: Finding Concurrency UAF Vulnerabilities in Linux Drivers with Directed Fuzzing, 2023
- DynSQL: Stateful Fuzzing for Database Management Systems with Complex and Valid SQL Query Generation, 2023
- Forming Faster Firmware Fuzzers, 2023
- FuzzJIT: Oracle-Enhanced Fuzzing for JavaScript Engine JIT Compiler, 2023
- Fuzztruction: Using Fault Injection-based Fuzzing to Leverage Implicit Domain Knowledge, 2023
- GLeeFuzz: Fuzzing WebGL Through Error Message Guided Mutation, 2023
- Intender: Fuzzing Intent-Based Networking with Intent-State Transition Guidance, 2023
- KextFuzz: Fuzzing macOS Kernel EXTensions on Apple Silicon via Exploiting Mitigations, 2023
- MINER: A Hybrid Data-Driven Approach for REST API Fuzzing, 2023
- MorFuzz: Fuzzing Processor via Runtime Instruction Morphing enhanced Synchronizable Co-simulation, 2023
- MTSan: A Feasible and Practical Memory Sanitizer for Fuzzing COTS Binaries, 2023
- PolyFuzz: Holistic Greybox Fuzzing of Multi-Language Systems, 2023
2022 (14 papers)
- StateFuzz: System Call-Based State-Aware Linux Driver Fuzzing, 2022
- FIXREVERTER: A Realistic Bug Injection Methodology for Benchmarking Fuzz Testing, 2022
- SGXFuzz: Efficiently Synthesizing Nested Structures for SGX Enclave Fuzzing, 2022
- AmpFuzz: Fuzzing for Amplification DDoS Vulnerabilities, 2022
- Stateful Greybox Fuzzing, 2022
- BrakTooth: Causing Havoc on Bluetooth Link Manager via Directed Fuzzing, 2022
- Fuzzing Hardware Like Software, 2022
- Drifuzz: Harvesting Bugs in Device Drivers from Golden Seeds, 2022
- FuzzOrigin: Detecting UXSS vulnerabilities in Browsers through Origin Fuzzing, 2022
- TheHuzz: Instruction Fuzzing of Processors Using Golden-Reference Models for Finding Software-Exploitable Vulnerabilities, 2022
- MundoFuzz: Hypervisor Fuzzing with Statistical Coverage Testing and Grammar Inference, 2022
- Fuzzware: Using Precise MMIO Modeling for Effective Firmware Fuzzing, 2022
- SyzScope: Revealing High-Risk Security Impacts of Fuzzer-Exposed Bugs in Linux kernel, 2022
- Morphuzz: Bending (Input) Space to Fuzz Virtual Devices, 2022
2021 (6 papers)
2020 (10 papers)
- FANS: Fuzzing Android Native System Services via Automated Interface Analysis, 2020
- Analysis of DTLS Implementations Using Protocol State Fuzzing, 2020
- EcoFuzz: Adaptive Energy-Saving Greybox Fuzzing as a Variant of the Adversarial Multi-Armed Bandit, 2020
- Fuzzing Error Handling Code using Context-Sensitive Software Fault Injection, 2020
- FuzzGen: Automatic Fuzzer Generation, 2020
- ParmeSan: Sanitizer-guided Greybox Fuzzing, 2020
- SpecFuzz: Bringing Spectre-type vulnerabilities to the surface, 2020
- FuzzGuard: Filtering out Unreachable Inputs in Directed Grey-box Fuzzing through Deep Learning, 2020
- Montage: A Neural Network Language Model-Guided JavaScript Engine Fuzzer, 2020
- GREYONE: Data Flow Sensitive Fuzzing, 2020
2019 (2 papers)
2018 (3 papers)
2017 (2 papers)
2015 (1 paper)
2014 (1 paper)
2013 (1 paper)
2012 (1 paper)
ACM Conference on Computer and Communications Security (ACM CCS)
2025 (11 papers)
- A Qualitative Analysis of Fuzzer Usability and Challenges, 2025
- ConTest: Taming the Cyber-physical Input Space in Fuzz Testing with Control Theory, 2025
- DiveFuzz: Enhancing CPU Fuzzing via Diverse Instruction Construction, 2025
- Error Messages to Fuzzing: Detecting XPS Parsing Vulnerabilities in Windows Printing Components, 2025
- Fuzzing Processing Pipelines for Zero-Knowledge Circuits, 2025
- Intent-aware Fuzzing for Android Hardened Application, 2025
- PromeFuzz: A Knowledge-Driven Approach to Fuzzing Harness Generation with Large Language Models, 2025
- Protocol-Aware Firmware Rehosting for Effective Fuzzing of Embedded Network Stacks, 2025
- RVISmith: Fuzzing Compilers for RVV Intrinsics, 2025
- SyzParam: Incorporating Runtime Parameters into Kernel Driver Fuzzing, 2025
- SyzSpec: Specification Generation for Linux Kernel Fuzzing via Under-Constrained Symbolic Execution, 2025
2024 (19 papers)
- Collapse Like A House of Cards: Hacking Building Automation System Through Fuzzing, 2024
- CountDown: Refcount-guided Fuzzing for Exposing Temporal Memory Errors in Linux Kernel, 2024
- CrossFire: Fuzzing macOS Cross-XPU Memory on Apple Silicon, 2024
- DarthShader: Fuzzing WebGPU Shader Translators & Compilers, 2024
- FOX: Coverage-guided Fuzzing as Online Stochastic Control, 2024
- Fuzz to the Future: Uncovering Occluded Future Vulnerabilities via Robust Fuzzing, 2024
- FuzzCache: Optimizing Web Application Fuzzing Through Software-Based Data Cache, 2024
- Fuzzing JavaScript Engines with a Graph-based IR, 2024
- Leveraging Binary Coverage for Effective Generation Guidance in Kernel Fuzzing, 2024
- LIFTFUZZ: Validating Binary Lifters through Context-aware Fuzzing with GPT, 2024
- No Peer, no Cry: Network Application Fuzzing via Fault Injection, 2024
- On Understanding and Forecasting Fuzzers Performance with Static Analysis, 2024
- OSmart: Whitebox Program Option Fuzzing, 2024
- Program Environment Fuzzing, 2024
- Prompt Fuzzing for Fuzz Driver Generation, 2024
- ProphetFuzz: Fully Automated Prediction and Fuzzing of High-Risk Option Combinations with Only Documentation via Large Language Model, 2024
- RANsacked: A Domain-Informed Approach for Fuzzing LTE and 5G RAN-Core Interfaces, 2024
- RIoTFuzzer: Companion App Assisted Remote Fuzzing for Detecting Vulnerabilities in IoT Devices, 2024
- Toss a Fault to BpfChecker: Revealing Implementation Flaws for eBPF runtimes with Differential Fuzzing, 2024
2023 (9 papers)
2022 (6 papers)
2021 (8 papers)
2020 (1 paper)
2019 (3 papers)
2018 (2 papers)
2017 (7 papers)
2016 (3 papers)
2013 (2 papers)
2012 (1 paper)
2008-2009 (2 papers)
ArXiv (Fuzzing with Artificial Intelligence & Machine Learning)
- MEUZZ: Smart Seed Scheduling for Hybrid Fuzzing, 2020
- A Review of Machine Learning Applications in Fuzzing, 2019
- Evolutionary Fuzzing of Android OS Vendor System Services, 2019
- MoonLight: Effective Fuzzing with Near-Optimal Corpus Distillation, 2019
- Coverage-Guided Fuzzing for Deep Neural Networks, 2018
- DLFuzz: Differential Fuzzing Testing of Deep Learning Systems, 2018
- TensorFuzz: Debugging Neural Networks with Coverage-Guided Fuzzing, 2018
- NEUZZ: Efficient Fuzzing with Neural Program Learning, 2018
- EnFuzz: From Ensemble Learning to Ensemble Fuzzing, 2018
- REST-ler: Automatic Intelligent REST API Fuzzing, 2018
- Deep Reinforcement Fuzzing, 2018
- Not all bytes are equal: Neural byte sieve for fuzzing, 2017
- Faster Fuzzing: Reinitialization with Deep Neural Models, 2017
- Learn&Fuzz: Machine Learning for Input Fuzzing, 2017
- Complementing Model Learning with Mutation-Based Fuzzing, 2016
The others
A curated collection of open-source fuzzing tools, grouped by their primary testing target. Each tool appears in one category; its description identifies the relevant interfaces and techniques. Tools are selected for research relevance, availability of official implementations, and documented capabilities.
File
- G2FUZZ (2025) - An AFL++-based fuzzer that uses LLMs to synthesize and mutate input generators for grammar-aware fuzzing of non-textual formats.
- LibAFL (2022) - A Rust framework for building custom fuzzers from reusable components, with support for multiple platforms and scaling across cores and machines.
- WINNIE (2021) - A Windows application fuzzer that combines harness synthesis with fast process cloning to test code beyond graphical interfaces.
- AFL++ (2019) - A superior fork to Google's AFL with more speed, more and better mutations, more and better instrumentation, and custom module support.
- MOpt-AFL (2019) - An AFL-based fuzzer that uses particle swarm optimization to adapt mutation operator selection probabilities for more effective fuzzing.
- REDQUEEN (2019) - A binary fuzzer that uses input-to-state correspondence to overcome magic bytes and checksums without symbolic execution.
- Angora (2018) - A mutation-based coverage guided fuzzer that increases branch coverage by solving path constraints without symbolic execution.
- InsTrim (2018) - A lightweight instrumentation approach for AFL that uses control-flow analysis to reduce the number of instrumented basic blocks while preserving execution path distinguishability.
- QSYM (2018) - A concolic execution engine designed for hybrid fuzzing that works with AFL to generate inputs for new execution paths.
- AFLGo (2017) - An AFL-based directed greybox fuzzer that generates inputs to reach specified target locations in a program.
- VUzzer (2017) - An application-aware binary fuzzer that uses static analysis and dynamic taint analysis to guide input mutations, with a 64-bit implementation.
- AFLFast (2016) - An AFL-based greybox fuzzer that uses power schedules to focus fuzzing effort on low-frequency execution paths.
- Driller (2016) - A hybrid fuzzer that augments AFL with selective symbolic execution using angr to generate inputs for paths that fuzzing cannot reach.
- AFL (2014) - A coverage-guided fuzzer that uses instrumentation and genetic mutations to discover bugs. Its GitHub repository is archived; AFL++ is recommended for new projects.
- Valgrind (2000) - A dynamic analysis framework with tools for detecting memory management and threading errors and profiling program execution.
Kernel
- Moneta (2025) - A GPU driver fuzzer that recalls execution states captured on real hardware for ex-vivo fuzzing.
- SyzSpec (2025) - A specification generator for Linux kernel fuzzing that uses under-constrained symbolic execution to infer syscall interfaces.
- CountDown (2024) - A kernel fuzzer that uses shared reference counts to guide syscall sequences toward use-after-free bugs.
- MOCK (2024) - A Linux kernel fuzzer that learns contextual dependencies between syscalls to generate context-aware test cases.
- SyzTrust (2024) - An on-device fuzzer for IoT trusted operating systems that uses state and branch coverage to guide input generation.
- VirtFuzz (2024) - A LibAFL-based Linux kernel fuzzer that injects inputs through VirtIO devices to test wireless stacks.
- ACTOR (2023) - An action-guided kernel fuzzing framework that generates inputs leveraging triggered actions and their temporal relationships.
- FuzzNG (2023) - A Linux kernel syscall fuzzer designed to minimize reliance on manually written system call descriptions.
- KextFuzz (2023) - A fuzzing prototype for macOS kernel extensions on Apple Silicon that instruments extensions and patches entitlement checks.
- SegFuzz (2023) - A kernel concurrency fuzzer that uses interleaving segment coverage and mutation-based thread scheduling to discover bugs.
- SyzDirect (2023) - A directed greybox fuzzer for reaching target locations in the Linux kernel.
- DR.FUZZ (2022) - A semantic-informed driver fuzzer that tests Linux device drivers without their hardware devices or device emulators.
- Drifuzz (2022) - A hardware-free device driver fuzzer that combines concolic execution with high-quality initial seed generation.
- FuzzUSB (2022) - A hybrid stateful fuzzing framework for USB gadget stacks in the Linux kernel.
- StateFuzz (2022) - A Linux driver fuzzer that identifies state variables through static analysis and uses their values as fuzzing feedback.
- NTFuzz (2021) - A type-aware Windows kernel fuzzer that statically analyzes system binaries to infer system call types for more effective fuzzing.
- SyzGen (2021) - A syscall specification generator that analyzes closed-source macOS drivers to enable interface-aware fuzzing.
- KRACE (2020) - A coverage-guided fuzzing framework that detects data races in kernel file systems by exploring concurrency through multi-threaded syscall sequences.
- PeriScope (2019) - A probing and fuzzing framework that tests device drivers at the hardware-OS boundary through MMIO and DMA inputs.
- Razzer (2019) - A kernel fuzzer that uses static analysis and two-phase fuzzing to detect race conditions and concurrency bugs in Linux kernels.
- Hydra (2019) - A fuzzing framework for automatically discovering semantic bugs in file systems using input mutators, feedback engines, and customizable checkers.
- Janus (2019) - A file system fuzzer that finds memory corruptions in Linux kernel file systems by mutating both filesystem images and syscall sequences simultaneously.
- DIFUZE (2017) - An interface-aware fuzzer for Linux kernel drivers that automatically recovers ioctl interfaces via LLVM analysis and generates targeted test cases.
- IMF (2017) - A kernel API fuzzer that leverages automated API model inference to discover vulnerabilities in macOS kernel APIs.
- kAFL (2017) - A hardware-assisted x86-64 VM kernel fuzzing framework with performant VM reloads for finding OS kernel vulnerabilities.
- syzkaller (2015) - An unsupervised coverage-guided kernel fuzzer supporting FreeBSD, Fuchsia, gVisor, Linux, NetBSD, OpenBSD, and Windows.
- Trinity (2012) - A Linux system call fuzzer that generates semi-intelligent random arguments to syscalls, including valid file descriptors, flags, and range-biased values.
Libraries & APIs
- Hopper (2023) - A library fuzzer that interprets generated API calls and learns argument constraints without requiring manually written fuzz drivers.
- IvySyn - A fully-automated framework for discovering memory error vulnerabilities in Deep Learning (DL) frameworks.
- GraphFuzz - An experimental framework for building structure-aware, library API fuzzers.
Network & Protocols
- ChatAFL (2024) - An AFLNet-based protocol fuzzer that uses LLMs to infer message grammars, enrich seeds, and generate messages that explore new protocol states.
- ResolverFuzz (2024) - A DNS fuzzer that combines query-response generation with differential analysis to detect non-crash vulnerabilities in resolvers.
- SGFuzz (2022) - A libFuzzer-based fuzzer that adds state-transition feedback to explore stateful software, including network protocol implementations.
Web Applications & APIs
- WuppieFuzz - A coverage-guided REST API fuzzer developed on top of LibAFL.
- MINER - A REST API fuzzer that utilizes three data-driven designs working together to guide sequence generation, improve request generation quality, and capture unique errors caused by incorrect parameter usage.
- RestTestGen - A robust tool and framework designed for automated black-box testing of RESTful web APIs.
- TEFuzz - A tailored fuzzing-based framework to facilitate the detection and exploitation of template escape bugs.
- Witcher - A web application fuzzer that utilizes mutational fuzzing to explore web applications and fault escalation to detect command and SQL injection vulnerabilities.
Browsers
- FuzzOrigin (2022) - A browser fuzzer that tests origin handling to discover universal cross-site scripting vulnerabilities.
- CorbFuzz (2021) - A browser security policy testing framework that synthesizes web application responses to test cross-origin response blocking implementations.
- FreeDom (2020) - A DOM fuzzer that generates HTML documents and DOM interactions to discover browser vulnerabilities.
Compilers & Language Runtimes
- RGFuzz (2025) - A WebAssembly runtime fuzzer that uses compiler rules to guide test generation and compares execution results across runtimes and architectures.
- FuzzJIT (2023) - A Fuzzilli-based JavaScript engine fuzzer that uses an oracle to detect incorrect behavior introduced by JIT compilation.
- CodeAlchemist (2019) - A JavaScript engine fuzzer that assembles code fragments while respecting semantic constraints to generate valid test programs.
Firmware & Embedded Systems
- Hoedur (2023) - An embedded firmware fuzzer that uses multiple input streams to represent interactions with different hardware interfaces.
- Fuzzware (2022) - A firmware fuzzer that models memory-mapped I/O accesses to test microcontroller firmware without full peripheral emulation.
- FIRM-AFL (2019) - An IoT firmware fuzzer that combines user-mode and system-mode emulation to improve fuzzing throughput for POSIX-compatible firmware.
Hypervisors & Virtual Devices
- HyperPill (2024) - A hypervisor fuzzer that uses the hardware virtualization interface to exercise hypervisor behavior without hypervisor-specific input grammars.
- ViDeZZo (2023) - A virtual device fuzzing framework that models dependencies within and between messages to test devices in QEMU and VirtualBox.
- V-SHUTTLE (2021) - An AFL-based fuzzer for virtual devices in hosted hypervisors, with semantics-aware input generation.
Hardware & Microarchitecture
- DifuzzRTL - A differential fuzz testing approach for CPU verification.
- MorFuzz - A generic RISC-V processor fuzzing framework that can efficiently detect software triggerable functional bugs.
- SpecFuzz - A tool that exposes speculative execution paths through software instrumentation so fuzzers can detect Spectre-type vulnerabilities in programs.
- Transynther - Automatically generates and tests building blocks for Meltdown attacks with various faults and microcode assists.
Android & Mobile Systems
- AHA-Fuzz (2025) - An intent-aware greybox fuzzer that uses eBPF-based analysis to test hardened Android applications.
- MALintent (2025) - A coverage-guided Android fuzzer that generates and mutates intents to test application intent receivers.
- FANS - A fuzzing tool for Android native system services with four components: interface collector, interface model extractor, dependency inferer, and fuzzer engine.
Blockchain & Smart Contracts
- Fluffy - A multi-transaction differential fuzzer for finding consensus bugs in Ethereum.
- LOKI - A Blockchain consensus protocol fuzzing framework that detects consensus memory related and logic bugs.
- ILF (2019) - An Ethereum smart contract fuzzer that learns a transaction-generation policy from symbolic execution through imitation learning.
DBMS
- BuzzBee (2024) - A DBMS fuzzer that uses semantic abstraction, context-sensitive constraints, and dependency-guided mutations to generate database queries.
- SQLRight (2022) - A DBMS fuzzer that combines coverage feedback, validity-oriented query mutations, and result-checking oracles to detect logical bugs.
- Squirrel - A fuzzer for database management systems (DBMSs).
Contributing
Contributions welcome! Read the contribution guidelines first.