liveBook · Manning

Fuzzing

Also called fuzz testing

Fuzzing is an automated testing technique that supplies varied, malformed, unexpected, or mutated inputs to software to reveal failures, vulnerabilities, or other defects.

How 8 Manning books explain it

Secure APIs

Fuzzing is software testing that supplies varied, malformed, or unexpected inputs to discover faults and vulnerabilities.

How it is used
Validates API implementations against specifications and exposes failures caused by malformed or unexpected inputs.
How deep it goes
Demonstrates specification-driven execution, authentication setup, result interpretation, and a database failure, but stops short of remediation code.
Examples
Uses Schemathesis, OpenAPI specifications, live endpoints, malformed registration data, conformance reports, and a PostgreSQL NUL-byte error.
What you can do after
Diagnose API drift, conformance failures, ignored authentication, and input-handling defects with specification-driven tests.

Read how Secure APIs explains fuzzing →

Vibe Engineering

Fuzzing is an automated testing technique that supplies large numbers of generated, malformed, or unexpected inputs to discover failures and vulnerabilities.

How it is used
Deploys adversarial input exploration to test parsers and other code handling untrusted input.
How deep it goes
Explains instrumentation, harnesses, feedback-guided mutation, costs, and limits, but stops short of a complete tool configuration.
Examples
Uses parser inputs with nested parentheses, Unicode, long regular-expression strings, overlapping markers, and unsupported link titles.
What you can do after
Diagnose/debug with it by building a harness, tracking coverage, mutating promising inputs, and investigating discovered failures.

Read how Vibe Engineering explains fuzzing →

AI for Everyday IT

Fuzz testing is a software-testing technique that supplies automatically generated, malformed, or unexpected inputs to find failures and vulnerabilities.

How it is used
Applies fuzz testing as a security check for AI-generated code, especially around authentication, data access, and user input.
How deep it goes
Defines the purpose and target areas but stops short of specifying fuzzing tools, input-generation methods, or execution procedures.
Examples
Targets AI-generated components handling authentication, data access, or user input.
What you can do after
Diagnose failures and vulnerabilities in security-sensitive code before accepting it as safe.

Read how AI for Everyday IT explains fuzzing →

Hacking Cryptography

Fuzzing tests software by automatically generating or mutating inputs, often including malformed inputs, to expose failures and vulnerabilities.

How it is used
Finds memory-safety and parsing failures in cryptographic implementations, particularly those written in memory-unsafe languages.
How deep it goes
Connects fuzzing to coverage and parser safety but does not specify a fuzzing algorithm, harness, or operational workflow.
Examples
Uses Heartbleed and malformed heartbeat requests to demonstrate out-of-bounds reads and memory disclosure.
What you can do after
Diagnose memory-safety and parsing defects by combining extensive fuzzing with maximal test coverage.

Read how Hacking Cryptography explains fuzzing →

Code Like a Pro in Rust

Fuzz testing is a software-testing technique that exercises programs with automatically generated or mutated inputs to reveal unexpected behavior, including failures caused by invalid data.

How it is used
Uses fuzzing to find unexpected failures in code exposed to potentially invalid input, especially in security-sensitive contexts.
How deep it goes
Explains the testing approach and demonstrates target setup, structured input, execution, and a crash artifact with cargo-fuzz.
Examples
Uses a public login form and an integer parser whose regex accepts values that can fail parsing.
What you can do after
Apply fuzzing via cargo-fuzz by creating and running a target that passes generated input to Rust code.

Read how Code Like a Pro in Rust explains fuzzing →

Automating API Delivery

Fuzz testing is a technique that tests software by generating and submitting random, malformed, or semi-malformed inputs to expose defects.

How it is used
Exercises implemented APIs with generated unexpected inputs to expose undocumented behavior and validate API definitions.
How deep it goes
Explains a runnable Schemathesis workflow, generated data, recorded requests, and schema failures, but does not detail fuzzing algorithms.
Examples
Uses a Product Catalog API, an example UUID, cassette.yaml, unexpected response properties, and a 101-check test summary.
What you can do after
Diagnose/debug with it by locating schema mismatches, undocumented responses, unimplemented operations, and unexpected API behavior.

Read how Automating API Delivery explains fuzzing →

Go in Action, Second Edition

Fuzzing automatically tests software with generated or mutated inputs to find failures and unexpected behavior.

How it is used
Uses generated inputs to test edge cases and proactively search for breaking bugs in input-driven Go code.
How deep it goes
Explains corpus setup, fuzz callbacks, execution commands, failure minimization, and a Unicode bug fix.
Examples
Tests a string Contains function with words, empty strings, runes, generated inputs, and minimized Unicode failures.
What you can do after
Diagnose/debug with it by discovering, minimizing, reproducing, and fixing input-dependent failures.

Read how Go in Action, Second Edition explains fuzzing →

Go in Practice, Second Edition

Fuzz testing is software testing that exercises a program with varied, automatically generated inputs to reveal unexpected behavior.

How it is used
Finds unexpected edge cases and potentially malicious-input failures by generating or modifying function inputs.
How deep it goes
Defines fuzzing and demonstrates Go seed cases plus a fuzz callback, but does not detail fuzzing internals.
Examples
Uses a rune-summing function, hand-written strings with Unicode and emojis, and a negative-result failure condition.
What you can do after
Apply it via Go's testing tools by seeding inputs and checking invariants for errors or unexpected formats.

Read how Go in Practice, Second Edition explains fuzzing →

Also covered in

What to know first

Related concepts

Questions about fuzzing

What is fuzzing?

Fuzzing is an automated testing technique that supplies varied, malformed, unexpected, or mutated inputs to software to reveal failures, vulnerabilities, or other defects.

Which Manning books explain fuzzing?

Secure APIs, Vibe Engineering, AI for Everyday IT, Hacking Cryptography, Code Like a Pro in Rust, Automating API Delivery, Go in Action, Second Edition and Go in Practice, Second Edition.

What should I know before learning fuzzing?

Manning books that teach fuzzing usually introduce software testing, language model, authentication and exception first.

What is the difference between fuzzing and property-based testing?

Fuzzing is an automated testing technique that supplies varied, malformed, unexpected, or mutated inputs to software to reveal failures, vulnerabilities, or other defects. Property-based testing is a software-testing technique that checks whether specified general properties hold across varied, often automatically generated, inputs.

What kinds of fuzzing are there?

Kinds of fuzzing include Schemathesis.

What is fuzzing part of?

Fuzzing is part of conformance testing. Conformance testing is the evaluation of an implementation, artifact, or process against specified standards, interfaces, contracts, or requirements.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.