Platform

Platform overview How it works Authorization testing Evidence & reports Private scanning Integrations

Solutions

Security agencies Product teams Regulated industries Partner programme

Learn

Blog Knowledge hub Compare

Resources

Pricing Documentation FAQ Security & data What we haven’t proved

Company

About Contact Careers Sign in to the platform Start a $199 pilot

Home / Knowledge hub / Fuzzing

Knowledge hub

Fuzzing

Throwing malformed input at an application to see what falls over.

What it means

Fuzzing throws large volumes of malformed or unexpected input at an application to see what falls over. Empty values, enormous values, wrong types, strange characters, structures nested far deeper than anyone planned for.

OWASP traces the technique back to 1989, and it is mechanical by design. The point is to try what nobody thought to try, which is the one job a machine does better than a person.

Why it matters

It finds crashes and parsing bugs, especially in code that handles files, documents, images or a custom format. Those crashes sometimes turn into something much worse in the hands of somebody patient. Google's OSS-Fuzz has found tens of thousands of bugs in open source projects this way.

For most businesses this is background vocabulary rather than a purchase. It matters if you write software that parses files or speaks an unusual protocol. It matters much less if you run a web application where the input is ordinary and the real risk is who may do what. Knowing which of those you are saves money.

How it shows up

Its limit is understanding. Fuzzing is poor at anything requiring knowledge of what the application is for. It will never conclude that a discount applies twice, or that this record belongs to another customer, because both are valid inputs producing valid responses.

A practical version for most teams is small. Send wrong types, missing fields, huge values and negative numbers to your own API endpoints. Then see which ones answer with an internal error and a stack trace attached. See input validation.

Questions people ask

Fuzzing, answered

Is fuzzing useful for a web application, or only for C code?

Memory-unsafe languages are where it pays best, because a crash there often means something exploitable. Web applications get less out of it.

It is still worth pointing at anything that parses: file uploads, imports, XML or document handling, and any custom protocol you invented.

Is fuzzing the same as running a scanner?

They overlap and the intent differs. A DAST scanner sends known attack payloads and checks for known signatures of a known flaw.

A fuzzer sends chaos and watches for the application misbehaving. One looks for the bugs somebody has already catalogued. The other looks for the ones nobody has.

How long do you have to run a fuzzer to get anything?

Minutes can produce results on a fresh target. Serious campaigns run continuously, which is how the large open source projects do it.

The practical answer for a small team is to run it in the background against your parsers, and to stop expecting a report at the end of an afternoon.

Do we need fuzzing if we already have good unit tests?

Unit tests check the cases you imagined. Fuzzing exists for the cases you did not, which is a different job.

If your code only ever receives input from your own front end, tests cover most of it. If strangers can post to it, the unimagined cases are the ones that matter.

Can fuzzing break our production system?

Yes, which is why nobody should run it against production. It is designed to find the input that makes things fall over.

Run it against a test environment. For the same reason, Cyberlop does not fuzz your live application or run availability tests against it.

Sources

Where this comes from

Bad input, or the wrong permission?

Random input finds crashes. We test what a perfectly valid request from the wrong account gets back, and prove it with the response. Ask what 30 days on one application covers.

Or start with a $199 pilot on one application: thirty days, success criteria agreed before day one, credited against the annual if you convert.