Fuzzing
Fuzz testing (fuzzing) is an automated software testing technique that sends invalid, malformed, or unexpected inputs to a system to discover bugs, crashes, and security vulnerabilities. It has become one of the most effective methods for finding memory corruption, parsing errors, and input validation flaws at scale.
Fuzzing operates on a simple principle: programs that crash on unexpected input likely have exploitable bugs. Modern fuzzers go far beyond random input generation. Coverage-guided fuzzers like AFL++, libFuzzer, and Honggfuzz use code coverage feedback to evolve inputs that explore new code paths, dramatically increasing the chance of finding deep bugs. Grammar-based fuzzers generate structurally valid inputs for complex formats like JSON, XML, HTTP, and custom protocols.
In web application security, fuzzing is used for directory and file discovery, parameter brute-forcing, and finding injection points. Tools like ffuf, wfuzz, and Burp Intruder allow rapid testing of URL paths, query parameters, headers, and form fields against wordlists. API fuzzing tools specifically target REST and GraphQL endpoints with schema-aware mutation strategies.
At the systems level, fuzzing has uncovered thousands of vulnerabilities in browsers, operating system kernels, file format parsers, network protocol implementations, and cryptographic libraries. Google's OSS-Fuzz project alone has found over 10,000 bugs across hundreds of open-source projects.
This page collects fuzzing tools, techniques, research, and guides for both web application and systems-level fuzzing.
Fuzzing is mostly harness engineering
The mental image of fuzzing — point a tool at a program, wait, collect crashes — describes only the easiest case. In practice the fuzzer is the commodity component, and the results are determined by decisions around it: what the harness exposes, what the corpus contains, how fast an iteration is, and whether the target crashes in a detectable way at all.
Coverage-guided fuzzing changed the field because it made the fuzzer responsive to the program's structure: inputs that reach new code are kept and mutated further, so the search concentrates where there is something to find. Everything downstream follows from that feedback loop working well. If the harness re-initializes expensive state on every iteration, the loop is slow. If it accepts a format the target immediately rejects, coverage stalls at the parser. If a checksum guards the input, nothing past the check is ever explored until the harness recomputes it.
Corpus and dictionary work is the cheapest large win available. Seeds drawn from real files or captured traffic start the fuzzer inside valid structure rather than making it discover the format; a dictionary of magic values, keywords and field names lets mutation produce tokens that random bit-flipping essentially never will. Minimizing the corpus keeps iteration fast.
Sanitizers determine what counts as a bug. Plenty of memory-safety errors do not crash, and without AddressSanitizer or its relatives they are simply missed — the campaign looks clean because nothing was watching. For logic bugs, differential and property-based approaches replace the crash oracle with a comparison against another implementation or an invariant, which is how fuzzing reaches parsers, protocol stacks and cryptographic code where a wrong answer matters more than a segfault.
Triage is the last real cost. A campaign produces many crashes that deduplicate to few bugs, and deciding which are exploitable is separate work again. The material below covers all of it, and the harness-design pieces are the ones worth reading first.
| Date Added | Link | Excerpt |
|---|---|---|
| 2026-11-19 NEW 2026 | GStreamer qtdemux OOB read found via targeted fuzzing (CVE-2026-125041) intermediate | A critical out-of-bounds read vulnerability, CVE-2026-125041, has been discovered in GStreamer's `qtdemux` component, which is part of the `gst-plugins-good` package. This vulnerability affects how GStreamer handles MOV and MP4 media files. The flaw was identified through targeted fuzzing techniques. Exploiting this vulnerability could allow an attacker to read data outside of allocated buffer boundaries, potentially leading to information disclosure or denial-of-service. |
| 2026-11-18 NEW 2026 | THEMIS: fuzzing tool for WordPress plugin vulnerabilities intermediate 4 min read | Tool, THEMIS, a context-aware grey-box fuzzing framework, identifies server-side security vulnerabilities in WordPress plugins. Developed by CISPA researcher Matteo Leonelli, it extends the ATROPOS fuzzing framework with WordPress-specific instrumentation, an adaptive harness, and a bug oracle. In testing, THEMIS uncovered 10 new vulnerabilities, reproduced 27 known ones (including CVEs), and achieved faster vulnerability discovery and greater code coverage compared to ATROPOS. |
| 2026-11-17 NEW 2026 | Microsoft: Lessons from 59 Linux kernel bug reports news 7 min read | Library detecting and reporting Linux kernel vulnerabilities, including CVE-2026-64563. This effort utilized tools like Sonnet 4.6 and GPT models for code scanning and proof-of-concept generation, ultimately leading to 59 upstream reports and 33 CVEs. The process involved extensive filtering and expert review to identify exploitable flaws and craft patches, with many bugs existing in the kernel for years before discovery. → microsoft.com |
| 2026-11-17 NEW 2026 | Atredis: Crafting targeted MP4 fuzzers advanced 12 min read | Library for crafting targeted MP4 fuzzers, detailing challenges with conventional mutation-based strategies and presenting custom fuzzers developed for GStreamer's MP4 demuxer. This work led to the discovery of vulnerabilities including heap out-of-bounds reads (CVE-2025-47183, CVE-2025-47219) and null pointer dereferences or buffer overflows in subtitle parsing (CVE-2025-47808, CVE-2025-47807, CVE-2025-47806). |
| 2026-11-17 NEW 2026 | oss-sydr-fuzz for hybrid fuzzing of open source C projects beginner 4 min read | Library for hybrid fuzzing of C projects, oss-sydr-fuzz extends Google's OSS-Fuzz with Sydr dynamic symbolic execution (DSE) to find deeper bugs by layering symbolic reasoning over coverage-guided mutation. This approach combines the speed of fuzzers with the depth of symbolic executors, allowing researchers to tackle hard branches and uncover vulnerabilities or stability issues. The tool inherits OSS-Fuzz's infrastructure for build integration and crash triage, offering an evolutionary step for projects experiencing fuzzing plateaus. → offsecblog.com |
| 2026-11-17 NEW 2026 | Introducing Wake 5: agent-written Solidity fuzzing in Python intermediate 3 min read AI Python | Framework for agent-written Solidity fuzzing; Wake 5 integrates an EVM within Python, uses an MCP server for agent access to static contract facts, and generates Python types for improved code analysis. Compared to Foundry and Echidna, Wake 5 achieves significantly higher transaction throughput and demonstrably outperforms other fuzzing tools on complex benchmarks by leveraging agent-generated harnesses. |
| 2026-11-16 NEW 2026 | libFuzzer fork mode NULL dereference bug report news 4 min read | Bug report detailing a NULL dereference and function fallthrough vulnerability in libFuzzer's fork mode, triggered by missing or empty feature files. This issue stems from an optimization defect where the compiler, processing small input files, omits necessary termination instructions, causing execution to fall into an unintended function. The bug can manifest as a SEGV in the parent fuzzer process, and reproduction involves creating an empty feature file during a fork-mode run. |
| 2026-11-16 NEW 2026 | AFL++ releases (v5.03c) news 13 min read | Library for fuzzing, AFL++ v5.03c, introduces a Value Profile implementation for improved efficiency, lifting macOS POSIX shared memory ceilings and fixing shared memory leakage. Enhancements to `afl-fuzz` include an execution-based mode switching, a "starved" mode for increased variability, and improved trimming saving crashes, hangs, and new coverage. The `afl-cc` compiler now removes classic instrumentation in favor of LLVM-based alternatives and introduces new environment variables for fine-grained instrumentation, alongside improvements to IJON and various script tools. |
| 2026-11-16 NEW 2026 | Evaluating agent-written fuzz tests intermediate 6 min read AI | Library for generating fuzzing harnesses; this work evaluates agent-written fuzz tests on the Origin Dollar (OUSD) stablecoin and Drips streaming-payments protocol. Results show agent-written tests reproduce six of twelve known OUSD bugs, matching human-written harness recall. However, for Drips, the agent-written test failed to reproduce its sole known bug due to missing crucial scenarios, highlighting limitations in agent-generated test coverage. |
| 2026-11-15 NEW 2026 | wtf: snapshot-based fuzzing of Windows user- and kernel-mode targets advanced 4 min read | Tool for snapshot-based fuzzing of Windows user and kernel-mode targets, supporting distributed execution via bochscpu, Windows Hypervisor Platform, or KVM backends. It has uncovered memory corruption vulnerabilities in software like IDA Pro, AAA games, the Windows kernel, and NVIDIA GPU drivers, and includes companion tools like `snapshot` and `symbolizer-rs` for deeper analysis. → offsecblog.com |
| 2026-11-15 NEW 2026 | AI fuzzing: where AI helps and what the evidence shows beginner 9 min read AI | Tool demonstrating AI fuzzing, where language models assist in tasks like harness drafting, seed suggestion, and crash triage, while traditional fuzzers like AFL++ or libFuzzer handle input generation and execution. Evidence from OSS-Fuzz, an ISSTA 2024 study, and DARPA's AIxCC indicates AI can extend code coverage and identify vulnerabilities, such as CVE-2024-9143 in OpenSSL. However, AI struggles with complex APIs, and distinguishing actual bugs from common errors remains a crucial human element. |
| 2026-11-15 NEW 2026 | When the input is a conversation: Fandango 1.1 stateful protocol fuzzing advanced 1 min read | Library for stateful protocol fuzzing, Fandango 1.1, extends its grammar and constraint approach to describe conversations between clients and servers. It can act as either side of an exchange, generate messages, interpret replies, and transition between states. This stateful capability is crucial for detecting bugs that only manifest after specific interaction sequences, as demonstrated with FTP and DNS examples. |
| 2026-11-15 NEW 2026 | binutils: OSS-Fuzz-found xcoff armap traversal fix news 2 min read | Patch for binutils addresses an xcoff armap traversal vulnerability identified by OSS-Fuzz. The fix corrects the `xcoff_write_armap_big` function in `coff-rs6000.c` to properly handle armap counts, preventing out-of-bounds reads and potential buffer overflows. |
| 2026-11-14 NEW 2026 | Echidna 2.4.0: MCP support for interactive fuzzing and improved symbolic execution intermediate 2 min read | Library for enhanced smart contract fuzzing, Echidna 2.4.0 introduces experimental MCP support for interactive fuzzing guidance by external tools and AI assistants. It also features significantly improved symbolic execution via an updated hevm backend, benefiting arithmetic-heavy properties, mappings, and hashes, with notable speedups demonstrated on a multiplication-monotonicity property. Compatibility with Foundry, corpus reuse, and memory usage are also enhanced. |
| 2026-11-14 NEW 2026 | WuppieFuzz 1.8.1: REST API fuzzer adds Web Fuzzing Commons reports and injection signatures intermediate 7 min read API Sec | Library for fuzzing REST APIs, WuppieFuzz, now supports Web Fuzzing Commons reports for cross-tool comparisons and includes improved injection signature detection for SQLi, XSS, and more. Enhancements in version 1.8.1 also fix path parameter handling and refine OpenAPI/Swagger spec parsing to accommodate non-standard inputs, bolstering its robustness in identifying vulnerabilities. Earlier versions introduced grammar-based mutators for varied injection payloads and content-based detection of injection side-effects. |
| 2026-11-14 NEW 2026 | InterceptFuzz: interception-based stateful fuzzing of single-process targets intermediate 63 min read | Library for stateful fuzzing of single-process targets, InterceptFuzz, enables stateless fuzzing engines like AFL++ to achieve deeper protocol states by intercepting packet exchanges. It builds a Prefix Tree of observed packet sequences, replaying recorded paths before injecting fuzzed packets. Evaluated on OpenThread and ns-3 Wi-Fi, InterceptFuzz significantly improved branch coverage and discovered seven previously unknown crash signatures in OpenThread, outperforming baselines like Concat and an adapted AFLNet. → arxiv.org |
| 2026-11-14 NEW 2026 | Catch Go bugs that fuzzing misses with Gemini and a constraint solver intermediate 10 min read | Library using Gemini and Z3 for Go vulnerability detection, complementing traditional fuzzing. This approach translates compiled Go code, focusing on surviving bounds check traps after optimization, into constraint solver rules. Z3 then synthesizes concrete Go reproducers for latent bugs, as demonstrated by catching out-of-bounds panics in slice operations that standard fuzzing techniques missed. |
| 2026-11-14 NEW 2026 | Schemathesis 4.33.0: GraphQL coverage phase and unary gRPC fuzzing intermediate 4 min read API Sec GraphQL Python | Library release v4.33.0 adds a coverage phase for GraphQL schemas and fuzzing for unary gRPC methods, improving response schema conformance checks and XML body serialization. This update also introduces performance enhancements for pytest collection, fixes numerous issues related to data generation, request serialization, and schema loading across Open API and GraphQL formats, and refines reporting for various checks, timeouts, and test execution scenarios. |
| 2026-11-13 2026 | Fuzzing a framing takeoff validator: one shared null bug intermediate | Library for fuzzing a wall-framing takeoff validator, uncovering a shared null bug in a 13-line helper function. This issue, allowing a `TypeError` when called with `null` or no input, was identified by fuzzing the helper with malicious values and subsequently fixed with a seeded 400-case test. The library's MIT-licensed code and tests are available for use, and the fix ensures no errors for missing settings values, leaving validation to calling functions. |
| 2026-11-13 2026 | Catch Go bugs that fuzzing misses with Gemini and a constraint solver advanced 10 min read | Library for static analysis of Go code, this resource details a novel approach to catching runtime panics that traditional fuzzing misses. It leverages Google's Gemini LLM to translate Go assembly and survive bounds check traps into rules for the Z3 constraint solver. The solver then synthesizes concrete Go reproducers, effectively identifying subtle bugs in slice and index operations, such as the one found in `skill-lint`'s markdown parser, by working backward from failure conditions rather than random input generation. |
| 2026-11-13 2026 | LibAFL 0.16.1 release news | Library LibAFL 0.16.1 enhances grammar fuzzing for Frida mode, improves Unicode token support in dictionaries, and refines documentation, including fixes for docs.rs. This release also includes path cleanup for LibFuzzer and updates to target-bytes converters within FridaHelperObserver, marking a significant step for the fuzzing framework. |
| 2026-11-12 2026 | Concolic execution does not have to be slow (SymSan vs CmpLog) advanced 7 min read | Tool demonstrating that concolic execution, when paired with lightweight input-to-state (i2s) solving, can outperform traditional methods like AFL++'s CmpLog/RedQueen in fuzzing applications. Experiments show SymSan+i2s achieving higher fuzzing throughput and median line coverage across various targets, even when standard mutations are disabled. This suggests that upfront symbolic tracing, combined with an efficient i2s solver, offers a viable alternative to purely heuristic-based dependency inference, especially when dealing with complex branch conditions. |
| 2026-11-12 2026 | Fuzzing libming with AFL++: from 177 crashes to a root cause intermediate 4 min read | Library for fuzzing libming 0.4.8 with AFL++ and AddressSanitizer, resulting in the discovery and analysis of memory corruption bugs. The process involved setting up a containerized environment with AFL++ for coverage-guided mutation and ASan to detect out-of-bounds accesses. Triage focused on grouping crashes by ASan summary, identifying stack overflows and heap buffer overflows, and analyzing a specific overflow in `swftophp`'s `decompile.c` caused by an unbounded `strcat` into a reallocated buffer. |
| 2026-11-12 2026 | Fuzzy: an agent-built Solana program fuzzer intermediate 9 min read AI | Library for fuzzing Solana programs, Fuzzy provides agents with a method to assess program risk before use. It attacks, records, and grades programs, checking for vulnerabilities like missing signer checks, account substitution, and arithmetic overflow. Fuzzy's findings are recorded and can be certified by an AI jury on Verafy Devnet, offering agents a verifiable record tied to specific deployed bytecode, and drawing from known exploit classes documented in resources such as Coral's Sealevel Attacks and Helius's guides. |
| 2026-11-12 2026 | Snapshotting our way to CVE-2026-9539 (Quarkslab) intermediate 15 min read | Library leveraging LibAFL-Qemu for fuzzing complex state machines via incremental snapshots. This approach was used to target libslirp's TCP code and explore CVE-2026-9539, an "heartbleed-like" Out-Of-Bound Read vulnerability. The library details its development, the nature of CVE-2026-9539, and methods for its detection using UBSAN and customized ASAN, alongside state machine fuzzing techniques like persistent mode, splitting inputs, multipart inputs, and snapshotting. |
| 2026-11-12 2026 | Fuzzing Siemens PROFINET DCP with Unicorn-AFL intermediate 14 min read | Tool for fuzzing Siemens PROFINET DCP implementations using Unicorn-AFL. This approach leverages snapshot fuzzing with the Unicorn CPU emulator and AFL++ fuzzer to efficiently discover memory corruption vulnerabilities in industrial control system protocols. The research identified four vulnerabilities in the Siemens SCALANCE LPE9403's DCP daemon, allowing unauthenticated remote attackers to crash the service and potentially blind SCADA systems or prevent device IP configuration. The method involves creating process snapshots, loading them into Unicorn, and crafting harnesses to inject inputs for fuzzing. |
| 2026-11-11 2026 | WuppieFuzz: coverage-guided REST API fuzzing beginner 4 min read API Sec | Library for coverage-guided REST API fuzzing, WuppieFuzz, built on LibAFL, aids authorized security teams in validating APIs against OpenAPI specifications. It supports black, grey, and white-box testing, integrating coverage instrumentation with tools like JaCoCo and LCOV. WuppieFuzz features layered configuration, detailed endpoint and code coverage reports, and a Grafana dashboard for triaging results and performance. It uses the Z3 SMT solver for schema-aware request construction and is available via prebuilt binaries, Homebrew, or Docker. → offsecblog.com |
| 2026-11-11 2026 | The rewrite behind fuzzing parsers intermediate 1 min read | Library for API discovery and AI agent development, this resource details Telnyx's approach to fuzzing parsers. It highlights tools and techniques for full API discovery, including the `telnyx` CLI for provisioning resources, and covers common error scenarios like "421 Unauthorized" and "AI response slow/empty." Key components like agent signup, agent CLI commands, and LLM-optimized documentation are also referenced. |
| 2026-11-11 2026 | Building an XNU bug-hunting harness: 141 findings, 17 reports advanced 3 min read Mobile | Harness for XNU bug-hunting detailing the creation of a deterministic system for validating vulnerability findings, leading to 141 proposed issues and 17 reported, including CVE-2026-112524, CVE-2026-65350, and CVE-2026-112507. The work highlights the challenges of proving exploitability amidst AI-generated findings and emphasizes the importance of rigorous validation, particularly for race conditions and unreachable code paths within the XNU kernel. |
| 2026-11-11 2026 | USENIX WOOT '26: Squeezing juicy variant bugs out of modern browsers advanced Talks | Researchers at USENIX WOOT '26 presented a novel technique for discovering variant bugs in modern web browsers. Their method focuses on generating numerous, subtle variations of known vulnerability patterns to uncover previously undetected flaws. This approach aims to extract more "juicy" bugs, implying those with higher impact or exploitability, by systematically exploring the browser's complex codebase. The research highlights the ongoing challenge of browser security and the need for advanced, automated bug-finding strategies. |
| 2026-11-11 2026 | Wake 5: a Python framework for Solidity testing, fuzzing and static analysis intermediate 2 min read Python | Framework for Solidity smart-contract testing, fuzzing, and static analysis. Wake 5 features an in-process EVM (revm) for higher throughput and exposes static analysis to language-model agents via an MCP server. It achieves 29,931 transactions per second, outperforming Echidna by 11.5x, and demonstrates that integer generator priors, not throughput, bound shallow assertion exhaustion in stateful fuzzing. Language-model agents using Wake reached all 153 assertions on the Daedaluzz maze benchmark in under 80 minutes. → arxiv.org |
| 2026-11-10 2026 | What the test suite does not find: hardening a JSONPath library with fuzzing advanced 6 min read | Library hardening techniques, including fuzzing with Jazzer, differential testing against independent implementations like Eclipse Parsson and Apache Johnzon, and mutation testing with PIT, are applied to the Treetrail JSONPath library. These methods uncovered bugs in Treetrail, Parsson's `skipObject()` and `skipArray()`, and Apache Johnzon for handling large numbers, in addition to a discrepancy between RFC 9535 and its compliance test suite regarding regex anchors. The article emphasizes setting resource limits for untrusted input, comparing implementations, and verifying test suite effectiveness. |
| 2026-11-10 2026 | Microsoft FORGE Lab uses agentic tools to find memory safety issues in Rust std advanced 17 min read AI | Library for finding memory safety issues in Rust's standard library, including instances where safe Rust triggers undefined behavior. This work utilized Hyenas, an AI-powered vulnerability-scanning system, to uncover patterns of misplaced trust in unsafe code, specifically regarding panics, user-provided implementations, and underlying system trust. The findings highlight challenges in upholding Rust's safety guarantees when dealing with `unsafe` blocks and their interaction with safe APIs, offering insights into panic safety bugs like the one found in `MapWindows::clone`. → microsoft.com |
| 2026-11-10 2026 | ffuf explained: web fuzzing, wordlists, detection beginner 9 min read Recon | Tool for web fuzzing, ffuf efficiently discovers hidden content like backup files and admin consoles by substituting words from a list into HTTP requests. It aids in penetration testing and API security assessments, with features for filtering responses by status code, size, or content, and can replay raw requests. Detection in logs can be achieved by monitoring request volume, 404 error patterns, and its default User-Agent string. Mitigation strategies include serving only necessary content, enforcing authorization on all routes, and securing non-production environments. |
| 2026-11-09 2026 | TabuFuzz: efficient greybox fuzzing with tabu search advanced | TabuFuzz is an efficient greybox fuzzing framework that leverages tabu search to improve coverage-guided fuzzing. It addresses the common challenge of fuzzers getting stuck in local optima by incorporating a tabu list mechanism. This prevents the fuzzer from repeatedly exploring unproductive input states. By intelligently guiding the search process, TabuFuzz aims to discover more bugs and uncover deeper vulnerabilities in software, enhancing the effectiveness of fuzz testing. |
| 2026-11-09 2026 | mishegos for differential fuzzing of x86 instruction decoders advanced 5 min read | Library from Trail of Bits for differential fuzzing of x86 instruction decoders. Mishegos compares outputs from multiple decoders on the same input to find semantic disagreements, addressing security-critical parsing problems in disassembly engines, emulators like Unicorn, and symbolic execution frameworks. This technique helps identify vulnerabilities like those caused by misinterpreting instruction prefixes, VEX/EVEX, or REX bytes, preventing attackers from exploiting tooling discrepancies. The Apache-2.0 licensed C++ project focuses on surfacing decoder "nonsense" and improving hardening of binary analysis tools. → offsecblog.com |
| 2026-11-09 2026 | Coverage-guided fuzzing with libFuzzer and AFL++ intermediate 4 min read | Library for coverage-guided fuzzing using libFuzzer and AFL++. This resource details writing harnesses for `config_parse` and `kv_store_put`, building fuzzers with AddressSanitizer (ASan) and UndefinedBehaviorSanitizer (UBSan), seeding corpora with real inputs, and using dictionaries for token-heavy formats. It covers running fuzzers with specific options, triaging and minimizing crashes, and integrating fuzzing into CI pipelines, extending the approach to memory-safe languages like Rust, Go, Python, and Java. |
| 2026-11-09 2026 | DEF CON 34: Finding prompt injection vulns via mutated prompt generation intermediate 3 min read AI Bug Bounty Talks | Tool presenting the Mutated Prompt Generator (MPG) framework, a divergent search tool for automating the discovery of residual prompt injection vulnerabilities. It mutates payloads to test patch generalization beyond specific exploits, addressing indirect prompt injection attacks and exploiting markdown/HTML parser leniency. MPG employs a divergent search, unlike traditional convergent methods, and uses subtree viability scoring to identify architectural mitigation needs, having resurfaced 19% of previously patched vulnerabilities in internal testing. → cpebuddy.com |
| 2026-11-09 2026 | grizzly for modular cross-platform browser fuzzing beginner 4 min read Python | Tool for modular, cross-platform browser fuzzing; grizzly enables finding stability and memory bugs by separating fuzzer engines (Adapters) from browser support (Targets). It generates standalone test cases for reproducible bug reporting, supports Windows, Linux, and MacOS, and includes companion tools like grizzly-reduce and grizzly-replay. Integration with Bugzilla allows replaying historical crash reports for regression testing, making it valuable for browser vendors and researchers. → offsecblog.com |
| 2026-11-08 2026 | The Fast Guide to Fuzzing Parsers beginner 1 min read | Guide to fuzzing parsers, detailing how to effectively test and secure parsing logic. This resource emphasizes practical techniques and common pitfalls encountered when fuzzing parsers, aiming to improve the robustness and security of applications that handle structured data. It provides actionable advice for developers and security professionals looking to identify vulnerabilities in parsing components. |
| 2026-11-08 2026 | Fuzzing closed-source binaries with AFL++ QEMU mode intermediate 8 min read | Library for fuzzing closed-source binaries using AFL++'s QEMU mode, which employs a patched QEMU user-mode emulator for JIT-instrumentation at translation time. This technique enables fuzzing of binaries without source code by emitting coverage into AFL's expected bitmap, though it incurs a 2-5x slowdown compared to source-instrumented builds. The library details building and running in QEMU mode, optimizing with persistent-mode fuzzing for significant throughput gains, and triaging crashes. For targets where QEMU is too slow, it mentions Unicorn mode as an alternative. |
| 2026-11-08 2026 | Jazzer.js for coverage-guided fuzzing of Node.js and TypeScript beginner 4 min read | Library for coverage-guided, in-process fuzzing of Node.js and TypeScript, based on libFuzzer. Jazzer.js integrates with Jest for seamless inclusion in development workflows, turning failing inputs into regression tests. It helps find bugs in parsers, decoders, and other attack-surface-heavy code by instrumenting code and preferentially evolving inputs that reach new paths. → offsecblog.com |
| 2026-11-08 2026 | From Finding to Fixing: reducing maintainer burden with automated patches beginner 3 min read | Library that automates vulnerability patching by integrating OSS-Fuzz with Google DeepMind's CodeMender AI agent. This system identifies memory safety vulnerabilities in C/C++ projects, diagnoses root causes, and generates validated patches. CodeMender analyzes crash details and source code, then develops fixes while ensuring functionality integrity and respecting project-specific AI contribution policies, significantly reducing maintainer burden and accelerating secure code deployment. |
| 2026-11-08 2026 | OWASP Global AppSec USA 2026: When Finding Bugs Is the Easy Part, lessons from an agentic vulnerability harness news AI Talks | Talk from OWASP Global AppSec USA 2026 on an agentic vulnerability harness developed at Visa. The harness aims to reduce noise from SAST, SCA, and DAST tools, with a key metric being Mean Time to Adapt. The presentation focuses on lessons learned from building software factories that integrate multi-agent orchestration, model fine-tuning, and automated evaluation for software security. |
| 2026-11-07 2026 | DEF CON 34: From Fuzzer Noise to Zend Engine 0day advanced RCE Talks | This DEF CON 34 talk, "From Fuzzer Noise to Zend Engine 0day," details the process of discovering a Zend Engine 0-day vulnerability. The presentation likely explains how fuzzing techniques were used to generate "noise" or unexpected behavior, which was then analyzed to pinpoint and exploit a previously unknown vulnerability in the Zend Engine, the core of PHP. The talk probably covers the methodology, tools, and steps involved in turning raw fuzzer output into a critical security finding. → media.defcon.org |
| 2026-11-07 2026 | Why does shuffling the schedule find so many bugs? beginner 8 min read | Library for deterministic virtual machines like Rewind VM, which finds bugs by running code under many different schedules. This approach exposes schedule-dependent bugs that standard testing often misses, such as race conditions like the `counter++` example where 18 out of 20 interleavings result in lost updates. Rewind VM facilitates this by allowing thread switching at specific `rewind_point()` locations within the code. |
| 2026-11-07 2026 | FuzzMedic: repairing fuzzing build breakages in OSS-Fuzz intermediate 1 min read | Tool for repairing fuzzing build breakages in OSS-Fuzz. FuzzMedic automates diagnosis and repair of build failures that affect continuous fuzzing coverage. It employs evidence-guided diagnosis across project and infrastructure artifacts, exploring repairs within a repair-state graph to recover from unproductive paths. Candidate patches are validated to restore executable fuzz targets, achieving a 48.44% repair rate on real-world OSS-Fuzz failures and merging 29 patches upstream. |
| 2026-11-06 2026 | AI-Assisted Fuzzing: Generating libFuzzer Harnesses with a Local LLM intermediate 33 min read AI | Library for generating libFuzzer harnesses using a local LLM. This approach automates the creation of boilerplate code required for fuzzing C libraries, enabling quicker bug discovery by bypassing the manual harness-writing bottleneck. The process involves using an LLM to produce the harness, compiling it with AddressSanitizer, and then running it to find vulnerabilities like stack-buffer-overflows in target functions such as `parse_records`. |
| 2026-11-06 2026 | Towards Effective Fuzzing of EDK2 Components (Metis) intermediate 1 min read | Library for fuzzing UEFI bootloader components. Metis employs a Direct-dependency Component Rehosting (DCR) strategy to rehost edk2 protocols in user-space, enabling input injection across dependency interactions. It uses static analysis and LLM-guided harness synthesis. Evaluated on 60 drivers, Metis achieved 73.1% coverage, outperforming FuzzUEr, and discovered 137 new bugs, 12 of which were remotely triggerable. → arxiv.org |
| 2026-11-06 2026 | Introducing agentic capabilities in OSS-Fuzz intermediate 8 min read AI | Library introducing agentic capabilities into OSS-Fuzz, building on CLI agents like gemini-cli and Claude Code, and earlier tools such as OSS-Fuzz-Gen and Fuzz Introspector. It provides agent skills and lightweight infrastructure for automating tasks like onboarding new projects, improving code coverage, and fixing broken builds, with specific skills for Go, Java, C/C++, Python, and Rust fuzzing, and a helper script for large-scale operations. |
Frequently Asked Questions
- What is the difference between dumb and smart fuzzing?
- Dumb fuzzing generates random inputs with no knowledge of the target's expected format. Smart fuzzing uses coverage feedback (coverage-guided) or grammar definitions (grammar-based) to generate inputs that explore new code paths and conform to expected structures. Smart fuzzers like AFL++ and libFuzzer find deeper bugs more efficiently.
- How is web fuzzing different from binary fuzzing?
- Web fuzzing tests HTTP parameters, paths, and headers using wordlists and mutation rules — tools like ffuf and Burp Intruder. Binary fuzzing tests compiled programs by mutating file inputs or network data to trigger crashes — tools like AFL++, libFuzzer, and Honggfuzz. Both aim to find bugs through unexpected inputs but operate at different layers.
- What has fuzzing discovered in the real world?
- Fuzzing has found thousands of critical vulnerabilities. Google's OSS-Fuzz has discovered over 10,000 bugs across hundreds of open-source projects including Chrome, OpenSSL, and the Linux kernel. Heartbleed-class vulnerabilities, parser bugs in image and document formats, and memory corruption in network protocol implementations have all been found through fuzzing.
Weekly AppSec Digest
Get new resources delivered every Monday.