Published Sep 16, 2025 ⦁ Updated Nov 10, 2026 ⦁ 12 min read
Open Source Fuzzing Tools: A Beginner's Guide

Open Source Fuzzing Tools: A Beginner's Guide

The best open source fuzzing tool to start with is the one built for your language: libFuzzer or AFL++ for C and C++, Go's built-in go test -fuzz, cargo-fuzz for Rust, Atheris for Python, Jazzer for Java and Jazzer.js for JavaScript. For REST APIs, use Schemathesis or RESTler, which generate requests from your OpenAPI spec. To keep fuzzing running after you go home, add ClusterFuzzLite to your CI, or apply to Google's free OSS-Fuzz if your project is widely used open source.

13,000+
vulnerabilities OSS-Fuzz helped identify and fix (plus 50,000 bugs), as of May 2025
1,403
entries in the OSS-Fuzz projects/ folder, Nov 10, 2026
v5.03c
latest AFL++ release (September 2, 2026)
Go 1.18
first Go version with fuzzing in the standard toolchain
3.11-3.14
Python versions supported by current Atheris source
4.33.1
latest Schemathesis release (November 4, 2026)

This guide covers fuzzing basics, a tool-by-tool comparison, a C example I compiled and ran on this machine (with the real AddressSanitizer report), a Go example, corpus and dictionary basics, and a copy-paste CI setup for continuous fuzzing. It's written for beginner fuzzing: you write code, you've never fuzzed it, and you want a first crash this afternoon.

What is fuzzing?

Fuzzing (fuzz testing) runs your code on a huge number of generated inputs and watches for crashes, hangs, failed assertions and memory errors. You don't write the inputs. You write a small piece of fuzzing code, called a harness or fuzz target, that hands the fuzzer's bytes to the function you want to test. The fuzzer does the rest, thousands of times per second.

Modern fuzzers are coverage-guided. They compile your code with instrumentation that records which branches each input reached. An input that reaches a new branch is saved to the corpus and mutated further (bits flipped, bytes inserted, chunks spliced from other inputs). Over minutes and hours this walks deep into parsers in a way random input never would. The libFuzzer docs describe it as tracking "which areas of the code are reached" and generating mutations "to maximize the code coverage".

Fuzzers find the bugs you didn't think to test: a length field nobody checked against the buffer size, an integer overflow in a size calculation, a recursive parser that blows the stack on deeply nested input, a panic on an odd Unicode string. That's why fuzzing is used most on code that reads untrusted data: file formats, network protocols, compilers, image and font libraries, deserializers.

Fuzzing alone only notices crashes. Sanitizers make more bugs crash. AddressSanitizer (ASan) stops the program on out-of-bounds reads and writes, use-after-free and similar memory errors that would otherwise corrupt memory silently. UndefinedBehaviorSanitizer (UBSan) catches signed overflow, bad shifts and similar problems. In memory-safe languages, the "crash" is an uncaught exception or panic, and your own assertions do the rest.

Types of fuzzing

Type How it works Example tools
Coverage-guided (grey-box) Instruments the code, keeps inputs that hit new paths AFL++, libFuzzer, Honggfuzz, Go fuzzing, cargo-fuzz, Atheris, Jazzer, Jazzer.js
Mutation-based black-box Mutates sample inputs with no view into the code radamsa, zzuf, AFL++ in QEMU mode on binaries
Generation / grammar-based Builds inputs from a model or grammar of the format boofuzz, FuzzTest domains, Schemathesis (from OpenAPI)
Web / wordlist fuzzing Substitutes words into URLs, headers and parameters ffuf, wfuzz
Property-based / API fuzzing Generates requests from a schema and checks responses Schemathesis, RESTler

Beginners get the most from coverage-guided fuzzing of a single function that parses input. It's the cheapest to set up, it runs on your laptop, and it's the most likely to find a real bug in your first hour. Black-box and protocol fuzzing make sense when you don't have the source, or when the thing you test is a running network service.

Open source fuzzing tools by language and job

These are the open source fuzzing tools worth knowing as of November 2026. If you've compared fuzz testing tools, open source ones cover every major language, and the commercial products are mostly built on these same engines. Versions, licenses and star counts come from each project's GitHub repo or package registry, checked on November 10, 2026.

Tool Best for License Notes
AFL++ C/C++ programs and binaries AGPL-3.0-or-later (code compiled into your harness stays Apache-2.0) Latest release v5.03c (Sept 2026); fuzzes binaries without source in QEMU and Frida modes
libFuzzer C/C++ library functions Apache-2.0 with LLVM exception Built into Clang; maintenance mode (bug fixes only)
Honggfuzz C/C++, multi-process, hardware feedback Apache-2.0 Accepts libFuzzer-style targets; Linux, macOS, Android, NetBSD, FreeBSD, Windows (Cygwin)
FuzzTest C++ with GoogleTest Apache-2.0 Google's newer framework; FUZZ_TEST macros; Bazel or CMake
Go fuzzing Go BSD (part of Go) Built into go test since Go 1.18
cargo-fuzz Rust MIT/Apache-2.0 libFuzzer under the hood; needs nightly Rust; v0.13.2 (June 2026)
Atheris Python and native extensions Apache-2.0 Python 3.11 to 3.14 in current source; Linux and macOS
Jazzer Java and JVM Apache-2.0 JUnit 5 @FuzzTest; v0.30.0 (Feb 2026)
Jazzer.js JavaScript / Node.js Apache-2.0 Jest integration; v4.0.0 (April 2026)
boofuzz Network protocols GPL-2.0 Python successor to Sulley; model the protocol, fuzz a live service
ffuf / wfuzz Web paths, parameters, vhosts MIT / GPL-2.0 Both packaged in Kali Linux (ffuf, wfuzz)
Schemathesis REST and GraphQL APIs MIT Generates requests from your OpenAPI or GraphQL schema; v4.33.1
RESTler Stateful REST API fuzzing MIT Microsoft Research; compiles an OpenAPI spec into a grammar, then test, fuzz-lean and fuzz modes
GitHub stars of open source fuzzing tools
ffuf 17,028
OSS-Fuzz 12,941
AFL++ 6,867
Schemathesis 3,766
Honggfuzz 3,411
RESTler 2,969
boofuzz 2,375
cargo-fuzz 1,934
Atheris 1,701
Jazzer 1,270
FuzzTest 1,069
Jazzer.js 366

Stars measure attention, not quality. ffuf is a web fuzzer, not a code fuzzer. Source: GitHub API, Nov 10, 2026

C and C++ fuzzing engines compared

Most C++ fuzzing starts with three engines, and the good news is that one harness runs on all of them.

libFuzzer is an in-process engine that ships with Clang. You link your harness with -fsanitize=fuzzer and get a binary that fuzzes itself. It is fast because it calls your function in a loop with no process restart. Its Status section says the original authors "have stopped active work on it and switched to working on another fuzzing engine, Centipede", and that libFuzzer "is still fully supported in that important bugs will get fixed", but you shouldn't expect major new features. In practice that means it's stable and still everywhere (OSS-Fuzz and ClusterFuzzLite both use it), so it's still the right first engine to learn. Limitation: one crash stops the run, and it needs a Clang whose version matches its runtime.

AFL++ is the community successor to Michal Zalewski's AFL and the most actively developed of the three (the repo had commits on November 8, 2026). It runs a separate process per input or uses a fast "persistent mode", ships many mutators, and can fuzz closed-source binaries through QEMU, Frida or Unicorn. Its in-depth guide calls libFuzzer LLVMFuzzerTestOneInput() harnesses "the defacto standard for fuzzing" and builds them with afl-clang-fast++ -fsanitize=fuzzer. Limitation: the license changed to AGPL-3.0-or-later, which matters if you modify and redistribute AFL++ itself, though the README states that everything compiled into a harness stays Apache-2.0.

Honggfuzz is Google's multi-process, multi-threaded fuzzer with software and hardware (Intel BTS/PT) coverage feedback and a persistent mode. Limitation: the last tagged release is 2.6, and new work lands mostly as commits, so you build from source.

FuzzTest is the one to look at if your C++ code already uses GoogleTest. You write FUZZ_TEST(Suite, Name) with typed parameters instead of raw bytes, which reads like a property test. Limitation: it expects Bazel or CMake and Linux-style toolchains.

Language-native fuzzers

You don't need a C toolchain to fuzz memory-safe code. Each of these runs in your normal test workflow:

  • Go ships fuzzing in go test. A fuzz test is a FuzzXxx(f *testing.F) function, and arguments can be string, []byte, integer, float and bool types (Go docs). Coverage instrumentation currently works on AMD64 and ARM64.
  • cargo-fuzz wraps libFuzzer for Rust. The setup page says it needs the nightly compiler because it uses a -Z flag for AddressSanitizer, and that it works on x86-64 Linux, macOS (Intel and Apple Silicon) and Windows. Panics, out-of-bounds indexing and failed assert!s count as crashes.
  • Atheris fuzzes Python code and native extensions with libFuzzer. You wrap imports in atheris.instrument_imports(), then call atheris.Setup() and atheris.Fuzz() (README). Any uncaught exception is a finding.
  • Jazzer brings libFuzzer to the JVM and integrates with JUnit 5.9.0 or newer. Annotate a test with @FuzzTest; it runs saved crash inputs as a normal test, and fuzzes when you set JAZZER_FUZZ=1 (README).
  • Jazzer.js does the same for Node.js. Install @jazzer.js/core and run npx jazzer FuzzTarget, or use its Jest integration, which the README recommends.

API fuzzers

Schemathesis reads an OpenAPI or GraphQL schema, generates requests, and checks responses for server errors and schema violations. Each failure comes with a curl command to reproduce it. RESTler, from Microsoft Research, goes further on stateful APIs: it learns that POST /orders returns an ID that GET /orders/{id} needs, and chains requests. It needs Python and .NET 8 to build, and its README warns that the aggressive fuzz mode "may create outages" in a poorly implemented service. Both are tools for fuzzing a running test environment, never production. If you're new to API failures, our guide to 400 Bad Request errors in REST APIs covers what correct error responses should look like, which is exactly what these tools check.

What about Peach Fuzzer?

Peach was a well-known commercial protocol and file-format fuzzer. GitLab acquired Peach Tech and Fuzzit in 2020 and later published GitLab Protocol Fuzzer Community Edition under the MIT license, described as "based on Peach Fuzzer Professional with some features removed". It's still usable if you already have Peach pit files. If you're new and want an actively used, scriptable alternative for network protocols, boofuzz is the common choice, and coverage-guided tools (AFL++, libFuzzer) are better whenever you have the source code.

Choose a fuzzer by language

You write Start with Harness looks like First command
C libFuzzer int LLVMFuzzerTestOneInput(const uint8_t*, size_t) clang -g -O1 -fsanitize=fuzzer,address,undefined ...
C++ libFuzzer, then AFL++ or FuzzTest same, extern "C" clang++ -g -O1 -fsanitize=fuzzer,address,undefined ...
C/C++ binary, no source AFL++ QEMU mode your program reads a file afl-fuzz -Q -i seeds -o out -- ./prog @@
Go go test -fuzz func FuzzX(f *testing.F) go test -fuzz=FuzzX
Rust cargo-fuzz fuzz_target!(|data: &[u8]| { ... }) cargo +nightly fuzz run target
Python Atheris def TestOneInput(data: bytes) python fuzz_x.py corpus/
Java, Kotlin Jazzer @FuzzTest void f(byte[] data) JAZZER_FUZZ=1 mvn test
JavaScript, TypeScript Jazzer.js module.exports.fuzz = (data) => ... npx jazzer FuzzTarget
REST / GraphQL API Schemathesis your OpenAPI spec uvx schemathesis run <spec-url>
Network protocol boofuzz a Python model of the protocol python my_session.py
Best for the easiest first fuzz test: go test -fuzz
Nothing to install. Seeds and crashers live in testdata/ and replay on every plain go test.
Best for C and C++ libraries: libFuzzer
One flag in Clang. The harness you write also runs under AFL++, Honggfuzz, OSS-Fuzz and ClusterFuzzLite.
Best for whole programs and binaries without source: AFL++
The most actively developed engine, with QEMU and Frida modes for closed binaries.
Best for continuous fuzzing of any repo, private included: ClusterFuzzLite
A GitHub Actions or GitLab job that fuzzes every pull request for a fixed number of seconds.

Your first fuzz test, step by step

Every harness follows the same three rules, and most fuzzing tutorials skip them:

  1. Call one thing. Pass the bytes to one parser or decoder. Don't start servers, open sockets or read config.
  2. Be deterministic and fast. The fuzzer calls your function thousands of times a second, in parallel and in random order. No global state that survives between calls, no randomness, no sleeps.
  3. Let bad input fail quietly. Returning an error is fine. Only crashes, panics, sanitizer reports and your own assertions should count as bugs.

C/C++ with libFuzzer

This is a complete worked example: a small record parser with a real bug, a harness, the build, the crash report, the fix and the minimized test case. I ran it on November 10, 2026 on macOS (Apple Silicon) with Apple clang 17.0.0. Everything below except the libFuzzer run itself is real output from that machine; the section after the code explains why.

The code under test reads a record: the bytes REC, one length byte, the name, then a payload.

// parse.h
#include <stddef.h>
#include <stdint.h>

/* Parses "REC" + 1-byte name length + name + payload.
   Returns the name length, or -1 if the input is not a record. */
int parse_record(const uint8_t *data, size_t size, char *name_out, size_t name_cap);
// parse.c (buggy version)
#include <string.h>
#include "parse.h"

int parse_record(const uint8_t *data, size_t size, char *name_out, size_t name_cap) {
  if (size < 4 || memcmp(data, "REC", 3) != 0) return -1;
  size_t len = data[3];
  if (len >= name_cap) return -1;      /* checks the output buffer... */
  memcpy(name_out, data + 4, len);     /* ...but not how much input is left */
  name_out[len] = '\0';
  return (int)len;
}

The harness is the whole fuzzing code you write:

// fuzz_parse.c
#include <stddef.h>
#include <stdint.h>
#include "parse.h"

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  char name[64];
  parse_record(data, size, name, sizeof name);
  return 0;  /* always 0; non-zero values are reserved */
}

In C++, put extern "C" in front of the function so the linker finds the unmangled name.

1. Build with sanitizers. These are the flags from the libFuzzer docs: -g for line numbers, -O1 for speed that still gives readable stacks, fuzzer to link the engine and its main(), address for ASan, undefined for UBSan.

clang -g -O1 -fsanitize=fuzzer,address,undefined \
  -fno-sanitize-recover=undefined \
  fuzz_parse.c parse.c -o fuzz_parse

-fno-sanitize-recover=undefined matters: by default UBSan prints a report and keeps going, so the fuzzer never sees a crash. With this flag it exits, per the UBSan docs. If your project has a build system, compile the library with -fsanitize=fuzzer-no-link,address and only link the harness with -fsanitize=fuzzer.

On my Mac, that first command failed with this exact error:

ld: library '/Library/Developer/CommandLineTools/usr/lib/clang/17/lib/darwin/libclang_rt.fuzzer_osx.a' not found
clang: error: linker command failed with exit code 1 (use -v to see invocation)

2. Seed a corpus. A corpus is a folder of inputs. Start it with a few small, valid examples so the fuzzer doesn't have to discover the REC header from nothing:

mkdir corpus
printf 'REC\x05helloPAYLOAD' > corpus/valid.bin
printf 'REC\x00' > corpus/empty-name.bin

3. Run it.

./fuzz_parse corpus/ -max_total_time=300

libFuzzer adds every new interesting input to corpus/ and, when it hits a bug, prints the sanitizer report and writes the input to a file named crash-<sha1> in the current directory (the docs' sample output shows Test unit written to ./crash-7a8dc...). Here it needs one mutation: a length byte larger than the bytes that follow.

4. Read the crash. Because I couldn't link libFuzzer locally, I built the same harness with a 20-line driver that calls LLVMFuzzerTestOneInput once per file (compiled with clang -g -O1 -fno-omit-frame-pointer -fsanitize=address,undefined), and fed it the input the fuzzer would find: REC, length 0x30 (48), then only two bytes. This is the real AddressSanitizer report, trimmed:

==67553==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x6020000000d6 at pc 0x000101237284 bp 0x00016f22e470 sp 0x00016f22dc20
READ of size 48 at 0x6020000000d6 thread T0
    #0 0x000101237280 in __asan_memcpy+0x3f4 (libclang_rt.asan_osx_dynamic.dylib:arm64e+0x3b280)
    #1 0x000100bd0a54 in parse_record parse.c:8
    #2 0x000100bd08f8 in LLVMFuzzerTestOneInput fuzz_parse.c:7
    #3 0x000100bd0c34 in main run_one.c:16

0x6020000000d6 is located 0 bytes after 6-byte region [0x6020000000d0,0x6020000000d6)
allocated by thread T0 here:
    #0 0x00010123938c in malloc+0x78 (libclang_rt.asan_osx_dynamic.dylib:arm64e+0x3d38c)
    #1 0x000100bd0c04 in main run_one.c:13

SUMMARY: AddressSanitizer: heap-buffer-overflow parse.c:8 in parse_record

Read it top down:

  • Bug type: heap-buffer-overflow, a READ of size 48. The code read 48 bytes from a buffer.
  • Where: frame #1, parse.c:8, the memcpy. Frame #0 is ASan's own wrapper; skip it.
  • Why: "0 bytes after 6-byte region". The input was 6 bytes long, so the read ran off its end. The length byte said 48, and the code never checked that 48 bytes were left.

Without ASan this program wouldn't crash at all. It would copy 42 bytes of whatever sits after the input into name and carry on, which is how this kind of bug leaks memory in real software.

5. Fix it and replay. Check the length against the input you actually have:

  if (len >= name_cap || len > size - 4) return -1;

After rebuilding, the same three files run clean:

ok: corpus/empty-name.bin (4 bytes)
ok: corpus/valid.bin (16 bytes)
ok: crash-input.bin (6 bytes)

With libFuzzer you replay a crash by passing the file instead of a folder: ./fuzz_parse crash-<sha1>.

6. Minimize and keep it. Fuzzer crash inputs are often long and noisy. libFuzzer can shrink one to the smallest input that still crashes the same way (docs):

./fuzz_parse -minimize_crash=1 -runs=10000 crash-<sha1>

Then copy the minimized file into a regression/ folder in your repo and replay that folder in your normal test run, so the bug can't come back unnoticed.

For harnesses that need several typed values instead of one byte string, Clang ships FuzzedDataProvider (#include <fuzzer/FuzzedDataProvider.h>), which splits the input into integers, strings and byte vectors. This one I did not compile here, because this Mac's command line tools are missing the C++ standard headers:

#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
#include <fuzzer/FuzzedDataProvider.h>
extern "C" {
#include "parse.h"
}

extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  FuzzedDataProvider fdp(data, size);
  size_t cap = fdp.ConsumeIntegralInRange<size_t>(1, 128);  // vary the output buffer too
  std::vector<uint8_t> input = fdp.ConsumeRemainingBytes<uint8_t>();
  std::string name(cap, '\0');
  parse_record(input.data(), input.size(), name.data(), cap);
  return 0;
}

The same target works with AFL++ and Honggfuzz, so you aren't locked in. For a longer path through libFuzzer, Google's libFuzzer tutorial is the best free follow-up.

C/C++ programs with AFL++

The quickest setup is the official Docker image, available for x86_64 and arm64 (AFL++ README):

docker pull aflplusplus/aflplusplus
docker run -ti -v "$PWD":/src aflplusplus/aflplusplus

Inside the container you have two options. Reuse the libFuzzer harness from above (AFL++ compiles it into a fast persistent-mode binary):

cd /src
AFL_USE_ASAN=1 afl-clang-fast -fsanitize=fuzzer -g fuzz_parse.c parse.c -o fuzz_parse_afl
afl-fuzz -i corpus -o out -- ./fuzz_parse_afl

Or fuzz a whole program that reads a file, by building it with the AFL++ compiler and passing @@, which is replaced by the path of each generated file:

CC=afl-clang-fast CXX=afl-clang-fast++ ./configure --disable-shared && make
afl-fuzz -i seeds -o out -- ./myprog @@

AFL_USE_ASAN=1 before compiling enables AddressSanitizer, per the in-depth guide. Crashes land in a crashes/ folder and hangs in hangs/ under the instance folder inside -o (out/default/ unless you name instances with -M/-S). AFL++ never stops on its own; press Ctrl-C when you're done. The guide suggests letting it run at least one full queue cycle with no new finds, which can take hours or days on a real target.

Useful AFL++ companions: afl-cmin shrinks a corpus to the files that add coverage, afl-tmin shrinks a single crash file (the AFL++ version of -minimize_crash), and -m and -t set memory and time limits.

Go: the easiest start

Go needs no extra tools. Here's the same record bug in Go. Create a module with two files:

// record.go
package record

import "errors"

var ErrNotRecord = errors.New("not a record")

// ParseName returns the name from "REC" + 1-byte length + name + payload.
func ParseName(data []byte) (string, error) {
	if len(data) < 4 || string(data[:3]) != "REC" {
		return "", ErrNotRecord
	}
	n := int(data[3])
	return string(data[4 : 4+n]), nil // bug: panics if fewer than n bytes follow
}
// record_test.go
package record

import "testing"

func FuzzParseName(f *testing.F) {
	f.Add([]byte("REC\x05helloPAYLOAD")) // seed corpus
	f.Add([]byte("REC\x00"))
	f.Fuzz(func(t *testing.T, data []byte) {
		name, err := ParseName(data)
		if err != nil {
			return // invalid input is fine, just not interesting
		}
		if len(name) != int(data[3]) {
			t.Errorf("name length %d, header says %d", len(name), data[3])
		}
	})
}
  1. Run go mod init example.com/record once, then go test -fuzz=FuzzParseName -fuzztime=60s.
  2. Go first runs the seeds as normal tests, then starts fuzzing. A slice bounds panic shows up almost immediately. The fuzzer minimizes the input and prints Failing input written to testdata/fuzz/FuzzParseName/<hash> plus a go test -run=FuzzParseName/<hash> command to replay it (Go fuzzing docs).
  3. Fix it with if len(data)-4 < n { return "", ErrNotRecord } before slicing, and rerun.
  4. Commit the file in testdata/fuzz/FuzzParseName/. Plain go test now replays it on every run, so the bug can't come back.

Go wasn't installed on the machine I used, so I didn't run this one; the code follows the Go fuzzing tutorial and the cmd/go flag docs. Two rules from those docs trip people up: -fuzz must match exactly one fuzz test in exactly one package, and -fuzztime defaults to forever. -fuzztime also accepts a count such as 10000x.

Replace the length check with a property of your own code: "decode(encode(x)) == x", "this never panics", "output is always valid JSON".

Rust with cargo-fuzz

cargo install cargo-fuzz
cargo fuzz init          # creates fuzz/ with a first target
cargo +nightly fuzz run fuzz_target_1

The generated target looks like this; put your call inside:

#![no_main]
use libfuzzer_sys::fuzz_target;

fuzz_target!(|data: &[u8]| {
    let _ = my_crate::parse(data);
});

Crashes go to fuzz/artifacts/fuzz_target_1/, and libFuzzer flags work after -- (for example cargo +nightly fuzz run fuzz_target_1 -- -max_total_time=300).

Python with Atheris

import sys
import atheris

with atheris.instrument_imports():
    import json

def TestOneInput(data: bytes):
    try:
        json.loads(data)
    except (ValueError, UnicodeDecodeError):
        pass  # expected for invalid input

atheris.Setup(sys.argv, TestOneInput)
atheris.Fuzz()

Install with pip install atheris (version 3.1.0 on PyPI as of November 2026) and run python fuzz_json.py corpus/. Any other exception is reported as a crash, with a saved crash-<sha1> file, because Atheris uses libFuzzer underneath. Catch only the exceptions your function documents; catching Exception hides the bugs you came for.

APIs with Schemathesis

uvx schemathesis run https://your-api.example.com/openapi.json \
  --header "Authorization: Bearer $TOKEN"

Or test a local server against a schema file: uvx schemathesis run ./openapi.yaml --url http://localhost:8000. Schemathesis generates requests from the schema and reports server errors and responses that don't match the documented schema. Each failure names the check (for example ST101 Server error), shows the response and gives a curl command to reproduce it (quick start). Point it at a staging environment, never at production data.

Corpus and dictionary basics

The corpus and dictionary decide how fast a fuzzer gets past the first few bytes of your format.

Seed corpus. A handful of small, valid inputs that each exercise a different feature beats thousands of near-identical large files. Keep each file small (a few KB at most), because libFuzzer's default -max_len is guessed from the corpus and otherwise caps at 4096 bytes (docs). OSS-Fuzz's new project guide calls a good seed corpus "one of the best ways" to improve coverage, and warns that seed files can end up in public bug reports, so don't seed with customer data.

Corpus growth and merging. The corpus folder you pass to libFuzzer fills up with every input that found new coverage. Shrink it now and then, keeping only files that add coverage:

mkdir corpus_min
./fuzz_parse -merge=1 corpus_min corpus

The AFL++ equivalent is afl-cmin -i out/default/queue -o corpus_min -- ./prog @@. Commit the minimized corpus, or store it as a CI artifact, so the next run starts where the last one stopped.

Dictionaries. For text formats and formats with magic values, a dictionary hands the fuzzer the keywords it would otherwise need to guess byte by byte. libFuzzer and AFL++ share the format (libFuzzer dictionary docs):

# rec.dict
magic="REC"
kw_name="name="
nul="\x00"

Pass it with -dict=rec.dict (libFuzzer) or -x rec.dict (AFL++). AFL++ ships 89 ready-made dictionaries for formats such as JSON, XML, SQL, PNG and HTTP in its dictionaries folder, and afl-clang-lto builds one automatically from string comparisons in your code. In OSS-Fuzz and ClusterFuzzLite, a file named <fuzz_target>.dict next to the binary is picked up automatically.

Run fuzzers continuously: OSS-Fuzz and ClusterFuzzLite

A five-minute run finds shallow bugs. Deep bugs show up after hours or days, and new code brings new bugs, so the real value of fuzzing comes from continuous fuzzing.

  1. 2016Google launches OSS-Fuzz, prompted by Heartbleed, a buffer overflow in OpenSSL that fuzzing could have found (OSS-Fuzz docs).
  2. Go 1.18Native fuzzing lands in the Go toolchain (Go docs).
  3. May 2025OSS-Fuzz reports over 13,000 vulnerabilities and 50,000 bugs fixed across 1,000 projects (README).
  4. Nov 2026The OSS-Fuzz projects/ folder holds 1,403 entries; engines supported are libFuzzer, AFL++, Honggfuzz and Centipede.

OSS-Fuzz is Google's free service for open source projects. It builds your fuzzers with sanitizers, runs them around the clock on Google's ClusterFuzz infrastructure, files private bug reports and verifies fixes. It supports C/C++, Rust, Go, Python, Java/JVM, JavaScript and Lua, plus Swift through a separate integration guide. To join, a project "must have a significant user base and/or be critical to the global IT infrastructure" (acceptance criteria). You open a pull request adding projects/<name>/project.yaml (homepage, main repo, language, a maintainer's contact address tied to a Google account), plus a Dockerfile and build.sh that build your fuzz targets with $CC, $CXX, $CFLAGS and $LIB_FUZZING_ENGINE. Test locally first with python3 infra/helper.py build_fuzzers and check_build.

If you're asking which projects include fuzzing harnesses or libFuzzer tests for input-parsing security, the OSS-Fuzz projects/ folder is the best public list: each folder links to a project whose parsers are fuzzed, and its build.sh shows where the harnesses live. Reading a few of them is the fastest way to learn how real projects write fuzz targets. If you want to contribute fuzzers to an existing project, our list of open source projects to contribute to is a starting point.

ClusterFuzzLite is the continuous fuzz testing solution for everyone else, including private repos. It runs the same OSS-Fuzz-style fuzzers inside your CI (GitHub Actions, GitLab, Google Cloud Build and Prow) with libFuzzer and ASan, MSan and UBSan. It supports C, C++, Java/JVM, Go, Python, Rust and Swift. Setup has two parts.

Step 1: add a .clusterfuzzlite/ folder to your repo with project.yaml (just language: c++), a Dockerfile based on gcr.io/oss-fuzz-base/base-builder:v1, and a build.sh that builds your harnesses into $OUT (build integration). For the example above, build.sh is three lines:

#!/bin/bash -eu
$CC $CFLAGS -c parse.c -o parse.o
$CXX $CXXFLAGS fuzz_parse.c parse.o -o $OUT/fuzz_parse $LIB_FUZZING_ENGINE

Step 2: add a workflow that fuzzes every pull request. This is the official GitHub Actions example, trimmed (source):

# .github/workflows/cflite_pr.yml
name: ClusterFuzzLite PR fuzzing
on:
  pull_request:
    paths:
      - '**'
permissions: read-all
jobs:
  PR:
    runs-on: ubuntu-latest
    concurrency:
      group: ${{ github.workflow }}-${{ matrix.sanitizer }}-${{ github.ref }}
      cancel-in-progress: true
    strategy:
      fail-fast: false
      matrix:
        sanitizer:
        - address
    steps:
    - name: Build Fuzzers (${{ matrix.sanitizer }})
      id: build
      uses: google/clusterfuzzlite/actions/build_fuzzers@v1
      with:
        language: c++
        github-token: ${{ secrets.GITHUB_TOKEN }}
        sanitizer: ${{ matrix.sanitizer }}
    - name: Run Fuzzers (${{ matrix.sanitizer }})
      id: run
      uses: google/clusterfuzzlite/actions/run_fuzzers@v1
      with:
        github-token: ${{ secrets.GITHUB_TOKEN }}
        fuzz-seconds: 600
        mode: 'code-change'
        sanitizer: ${{ matrix.sanitizer }}
        output-sarif: true

mode: 'code-change' fuzzes for fuzz-seconds on each pull request and fails the check with a downloadable crashing input. The docs also give workflows for batch mode (longer scheduled runs, for example every 6 hours with fuzz-seconds: 3600), prune (daily corpus cleanup, required if you run batch fuzzing) and coverage reports. For persistent corpora between runs, point storage-repo at a separate git repo.

If you don't want the Docker setup, the simplest CI option for memory-safe languages is a scheduled job that runs the native fuzzer for a fixed time, for example go test -fuzz=FuzzParseName -fuzztime=10m, and uploads testdata/fuzz/ as an artifact when it fails.

Troubleshooting your first fuzzer

Symptom Cause Fix
ld: library '.../libclang_rt.fuzzer_osx.a' not found Apple clang has no libFuzzer runtime Use upstream LLVM clang, or build in a Linux container
libFuzzer crashes instantly on its own seeds The seed corpus already triggers a bug, or the harness leaks memory Run the seed file alone, fix it; for leaks see the LeakSanitizer report
Go refuses to start fuzzing when you pass a pattern or several packages -fuzz must match exactly one test in one package Anchor the regex: -fuzz='^FuzzParseName$' and run in that package's folder
Coverage stops growing after a minute The fuzzer can't get past a magic value or checksum Add seeds and a dictionary; skip checksum checks under #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
Very slow executions per second The harness does I/O, logging or heavy setup per call Move setup into LLVMFuzzerInitialize or a global; remove I/O
UBSan prints errors but the fuzzer keeps going UBSan recovers by default Add -fno-sanitize-recover=undefined
Out-of-memory reports (libFuzzer's -rss_limit_mb defaults to 2048 MB) An input makes the code allocate a huge buffer from a length field Usually a real bug: cap sizes against the input length
AFL++ "could not connect to the forkserver" Memory limit too low for the target Raise -m, as the AFL++ guide explains

FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION is the build macro the libFuzzer docs propose for fuzzing-only builds. Define it in your fuzz build (-DFUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) so checksum checks and randomness are bypassed only there. For stepping through a crash once you have the input, any debugger works; see our guide to online GDB debuggers if you don't have one set up.

Honest limits

  • Fuzzers find crashes and violated assertions. They won't spot a wrong answer unless you write a check for it, so add properties and assertions to your targets.
  • Coverage-guided fuzzing needs a fast, deterministic target. Network calls, sleeps and global state make it slow and flaky.
  • Coverage is not correctness. A fuzzer that reached 90% of your parser has not proven it bug-free; measure coverage (OSS-Fuzz's helper.py coverage does this) to see what it never reached.
  • Web fuzzing with ffuf or wfuzz sends heavy traffic. Only run it against systems you own or have written permission to test.
  • Code behind checksums or magic values is hard to reach. Use dictionaries (-x in AFL++, -dict= in libFuzzer) and good seed files.
  • Memory-safe languages get fewer dramatic findings. In Go, Rust, Python or Java, fuzzing mostly finds panics, uncaught exceptions, hangs and logic bugs your assertions catch, which are still worth fixing.

Fuzzing complements the rest of your test suite rather than replacing it. Our explainer on automated test case generation covers the neighboring techniques. For more testing and security tooling, browse DevHunt's testing tools, security tools and open source tools. If you also harden container images, see our STIG container hardening guide.

How this guide was checked: on November 10, 2026 I read the LLVM libFuzzer and UBSan docs, the Go fuzzing docs and cmd/go reference, the AFL++, Honggfuzz, Atheris, Jazzer, Jazzer.js, RESTler, FuzzTest and OSS-Fuzz READMEs, the OSS-Fuzz and ClusterFuzzLite documentation, the cargo-fuzz book and template source, and the Schemathesis quick start; versions and stars come from the GitHub API, PyPI and npm on that date. The C example was compiled and run locally with Apple clang 17.0.0 (ASan and UBSan; libFuzzer itself was not available on that toolchain). The Go, Rust, Python, AFL++ and CI examples were not run.

FAQ

What is the best fuzzing tool for beginners?

If you write Go, the built-in go test -fuzz, because it needs nothing extra. For C and C++, start with libFuzzer (it's built into Clang, though not into Apple's clang), then run the same harness under AFL++. For Python use Atheris, for Java Jazzer, and for JavaScript Jazzer.js.

What are the best fuzzing tools for C++?

libFuzzer, AFL++ and Honggfuzz are the main engines, and all three run the same LLVMFuzzerTestOneInput harness. FuzzTest is a good choice if your code already uses GoogleTest. Build every C++ fuzzing target with -fsanitize=fuzzer,address,undefined so memory bugs crash.

Is libFuzzer still maintained?

Partly. The LLVM docs say its original authors moved to the Centipede engine and that libFuzzer is "still fully supported" for important bug fixes, but without major new features. It remains the default engine in OSS-Fuzz and ClusterFuzzLite, so harnesses written for it are a safe investment.

What is Google OSS-Fuzz?

OSS-Fuzz is a free Google service that continuously fuzzes important open source projects on Google's infrastructure and reports bugs privately to maintainers. As of May 2025 it had helped fix over 13,000 vulnerabilities and 50,000 bugs, per its README. Projects must be widely used or critical to infrastructure to be accepted.

What is continuous fuzzing?

Continuous fuzzing means running your fuzzers all the time, or on every code change, instead of once. OSS-Fuzz does this for accepted open source projects, and ClusterFuzzLite does it inside your own CI for any repo, with short runs on each pull request and longer scheduled batch runs.

What is the alternative to Peach Fuzzer?

For protocol fuzzing, boofuzz is the common open source choice, and GitLab's Protocol Fuzzer Community Edition is Peach's own open-sourced engine under the MIT license. When you have source code, coverage-guided tools like AFL++ or libFuzzer usually find more.

What are fuzzing tools in Kali Linux?

Kali packages web fuzzers such as ffuf and wfuzz for brute-forcing paths and parameters. For fuzzing your own code, install AFL++ or use your language's built-in fuzzer instead.

How long should I run a fuzzer?

Long enough that new coverage stops appearing. A few minutes finds shallow bugs and is right for pull request checks; AFL++'s guide suggests at least one full queue cycle with no new finds, which can take hours to a week on real targets. That's why long runs belong in scheduled CI or OSS-Fuzz, not on your laptop.

What is the alternative to fuzzing?

Property-based testing (Hypothesis, fast-check, QuickCheck) generates structured inputs against stated properties, static analysis finds bug patterns without running code, and code review catches logic errors. They complement fuzzing rather than replace it.