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
Related
Terms that sit next to this one
Input validation
Checking that what arrives is the shape and range you expected.
Untrusted input
Anything that arrived from outside your own code, and is therefore suspect.
DAST
Tools that attack a running application from the outside.
Business logic flaw
Nothing is technically broken, but your own rules turn against you.
Insecure deserialisation
Turning data from outside back into live objects without checking it.
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.