Learning paths

Fuzzing learning path

18 resources, ordered. Work down the list — each stage assumes the one above it.

Fuzzing

A route through the library rather than a dump of it. Items are drawn from the full Fuzzing collection, filtered to teaching material (news items are excluded) and ordered within each stage by depth signals — whether the piece carries code, how substantial it is, and what readers actually open.

1

Start here

5 resources

Orientation and first principles — what the bug class is and how it behaves.

  1. Web fuzzing for hackers
    17 min readintigriti.com2026
    Library for web fuzzing techniques, detailing its importance for discovering unreferenced API endpoints, unexpected behavior, and security vulnerabilities. It emphasizes the criticality of crafting specific wordlists and outlines popular tools like ffuf, Burp Suite Intruder, OWASP Amass, Arjun, and Param Miner for various fuzzing objectives, including content discovery, subdomain bruteforcing, and parameter discovery.
  2. GPT-5.5-Cyber built a zlib fuzzing lab in a day
    5 min readblog.trailofbits.com2026
    Tool that demonstrates GPT-5.5-Cyber's capability to autonomously construct a zlib fuzzing lab within a single day, including writing harnesses for multiple entrypoints like inflate and uncompress2, leveraging ASan/UBSan builds, and repurposing edge-case tests for seeds, surpassing typical OSS-Fuzz coverage by targeting valid states and using OS backpressure.
  3. AI fuzzing: where AI helps and what the evidence shows
    9 min readxhack.io2026
    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.
  4. ffuf explained: web fuzzing, wordlists, detection
    9 min readinvadel.com2026
    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.
  5. Bringing Fuzz Testing to Kotlin with kotlinx.fuzz
    7 min readblog.jetbrains.com2026
    Library for fuzz testing Kotlin applications. Developed by JetBrains Research, this fuzzer, named kotlinx.fuzz, leverages existing Java fuzzers like Jazzer to identify edge cases and uncover hidden vulnerabilities by automatically generating random or invalid inputs for target functions such as `Duration.parseIsoStringOrNull`. It simplifies the fuzzing process, offering improved configuration, execution, and result analysis for Kotlin projects.
2

Build depth

5 resources

Real testing methodology, tooling, and writeups that show the work.

  1. WinPE as a stateless harness for Windows driver testing and fuzzing
    6 min readbednars.me2026
    Library for transforming Windows PE into an idempotent testing environment. This library details low-level mechanisms including BCD and QEMU modifications for faster VM spins, enabling kernel-mode driver testing and fuzzing. It covers aggressive boot optimizations with `bcdedit`, disabling VBS/HVCI via `hypervisorlaunchtype off` and `testsigning yes`, utilizing the older `pc` QEMU machine profile for stability, configuring KDNET with `busparams`, and customizing the boot process by disabling NDIS initialization and replacing `cmd.exe` with a custom test agent in `winpeshl.ini`.
  2. Sparkplug B Protocol Fuzzing with AI Assistance
    9 min readbishopfox.com2026
    Tool for fuzzing the Sparkplug B protocol, an MQTT-based standard for industrial control systems. This fuzzer systematically targets message types, data types, and field paths, identifying crashes, protocol violations, and state-handling bugs. AI assistance refined the Python implementation, improving coverage, efficiency, and adding CLI functionality for security testing of ICS and SCADA devices.
  3. On the Effectiveness of Mutational Grammar Fuzzing
    8 min readprojectzero.google2026
    Technique analyzing the flaws of mutational grammar fuzzing, particularly how increased coverage doesn't always equate to more bugs and how samples tend to remain highly similar. It highlights issues found in XSLT implementations and JIT engines, suggesting potential improvements by exploring dataflow coverage or combining generative and mutational fuzzing approaches.
  4. Go fuzzing was missing half the toolkit. We forked the toolchain to fix it.
    5 min readblog.trailofbits.com2026
    Library, gosentry, is a fork of the Go toolchain that enhances native fuzzing capabilities. It integrates LibAFL, Nautilus for grammar-based fuzzing, and capabilities for structured inputs, integer overflow detection (building on go-panikint), goroutine leak detection (via goleak), data race detection, and timeout detection. Existing Go fuzz harnesses can be used with gosentry without modification, offering improved bug detection and coverage reporting for vulnerabilities like those found in Optimism and Revm.
  5. AFL - American Fuzzy Lop: A Security-Oriented Fuzzer
    13 min readgithub.com2026
    Library for security-oriented fuzzing, American Fuzzy Lop (AFL) employs an instrumentation-guided genetic algorithm to identify vulnerabilities. It leverages modified edge coverage to detect program control flow changes and uses an input queue that grows as new states are discovered. AFL supports both compile-time instrumentation for source code availability and experimental binary instrumentation via QEMU user-space emulation for black-box targets. The tool generates a corpus of interesting test cases useful for other testing regimes and offers options for hardening and heap corruption detection.
3

Go deep

8 resources

Novel research, edge cases, and the techniques that push the class forward.

  1. Autonomous fuzzing process under LLM supervision
    20 min readcert.pl2026
    Library for autonomous fuzzing, codenamed fuzzlab, utilizes Large Language Models (LLMs) under strict procedural guidance to automate software security testing. This Python-based system analyzes code, generates test programs, classifies findings, and prepares reports. It has successfully identified vulnerabilities in ModSecurity and Oracle VirtualBox, demonstrating its capability to supervise fuzzing campaigns, adapt to anomalies, and improve test generation without constant human intervention, supporting various AI models through a standardized interface.
  2. Catch Go bugs that fuzzing misses with Gemini and a constraint solver
    10 min readdevelopers.googleblog.com2026
    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.
  3. What the test suite does not find: hardening a JSONPath library with fuzzing
    6 min readchristoph-sens.com2026
    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.
  4. mishegos for differential fuzzing of x86 instruction decoders
    5 min readoffsecblog.com2026
    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.
  5. Fuzzers vs. AI: Comparing Fuzzilli and BigSleep on JavaScript Engines
    29 min readprojectzero.google2026
    Library comparing Fuzzilli, a generative JavaScript engine fuzzer, and BigSleep, an LLM-based bug finding system, on their effectiveness in finding vulnerabilities in V8. In a six-month period, BigSleep found more vulnerabilities (45 vs. 37), with an estimated 60% overlap, highlighting that fuzzing and LLMs are complementary.
  6. Advanced binary fuzzing using AFL++-QEMU and libprotobuf
    20 min readairbus-seclab.github.io2026
    Tool for advanced binary-only fuzzing utilizing AFL++-QEMU, focusing on grammar-aware in-memory persistent fuzzing. This practical guide demonstrates step-by-step configuration, including instrumentation tuning for specific code paths and optimizing execution speed, using a case study of a weak X509 parser with a buffer overflow vulnerability in `parse_cert_buf`. It details corpus preparation with `afl-cmin` and `afl-tmin`, and explores AFL++-QEMU features like `AFL_CUSTOM_MUTATOR_LIBRARY` and persistent mode addresses for performance enhancements.
  7. LLM-Based Harness Synthesis for Unfuzzed Projects
    11 min readblog.oss-fuzz.com2026
    Library for LLM-based fuzzing harness synthesis that automates the creation of OSS-Fuzz and ClusterFuzzLite projects for C/C++ software. It takes a GitHub repository URL as input and generates fuzzing harnesses by first building the project using generalized build heuristics, then extracting program analysis data with Fuzz Introspector, and finally synthesizing harnesses with LLMs based on that data. The process has demonstrated coverage increases and vulnerability discovery in prior work.
  8. Bugs That Survive Continuous Fuzzing
    15 min readgithub.blog2026
    Library detailing vulnerabilities that persist despite continuous fuzzing in open-source projects like Gstreamer, Poppler, and Exiv2. It highlights issues arising from insufficient code coverage, unmonitored dependencies (e.g., DjVuLibre in Poppler), and neglected encoding logic, demonstrating the ongoing need for human oversight and expertise beyond automated fuzzing initiatives like OSS-Fuzz.