Fuzzing
Fuzzing is an automated testing technique that supplies varied, malformed, unexpected, or mutated inputs to software to reveal failures, vulnerabilities, or other defects.
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.
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.
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.
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.
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.
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.
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.
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.
Also covered in
- Learn Go with Pocket-Sized Projects
- Write Powerful Rust Macros
- Idiomatic Rust
- The Coder CafeIn early access (MEAP)
What to know first
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- authenticationAuthentication is the process of verifying the claimed identity of a user, service, device, or other entity.
- exceptionAn exception is a runtime signal or value representing an abnormal condition that interrupts ordinary program flow and can be handled or propagated.
Related concepts
- property-based testingcontrasts with · Property-based testing is a software-testing technique that checks whether specified general properties hold across varied, often automatically generated, inputs.
- corpususes · A corpus is an organized collection of documents, texts, or other language data assembled for processing, retrieval, analysis, training, or evaluation.
- libraryused by · A software library is a reusable collection of code or components that provides functionality for other programs to incorporate or invoke.
- Schemathesisincludes · Schemathesis is an open-source tool that generates and executes property-based tests for web APIs from API schemas such as OpenAPI definitions.
- software testingproduces · Software testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- conformance testingpart of · Conformance testing is the evaluation of an implementation, artifact, or process against specified standards, interfaces, contracts, or requirements.
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.







