7 min readMay 31, 2021


Hunting bugs? This is the Art

What is Fuzzing?

Fuzzing has long been recognized as an effective method for identifying software vulnerabilities. The main idea is to purposefully send faulty input to the target software and identify failure. Each erroneous input is a test case. Failure signifies the discovery of a flaw, which may subsequently be corrected to improve the target software’s resilience and security. Fuzzing is an important technique in software vulnerability management, both for organizations that create software and for organizations that utilize software. A fuzzer is a piece of software that is used to test the target software. A proper fuzzer is composed of three main parts:

1. The poet is in charge of developing the test cases. The poet is sometimes referred to as a test case generator, a test case engine, or an anomalizer.

2. The test cases are delivered to the destination by the courier. The courier may also be referred to as an injector, delivery mechanism, or test driver.

3. The oracle assesses whether or not the objective was successful. Not all fuzzers implement all three components, but in order to fully utilize the potential of automated fuzzing, all components must be present.

When utilizing fuzzers to increase robustness and security, the final aim is to solve flaws rather than find them. A good fuzzer must preserve records, provide actionable reports, and offer a seamless remediation procedure in order to recreate failures and repair them.

Fuzzing in context of Software

We refer to software as anything that is built from source code into executable code that runs on a processor, including operating systems, desktop programs, server applications, mobile apps, embedded system firmware, systems on a chip, and so on. A robustness problem occurs when a piece of software breaks by mistake as a result of unexpected or faulty input. Furthermore, a wide cast of miscreants deliberately strives to cause software to fail by providing unexpected or faulty inputs. It is a security issue when software breaks as a result of an intentional attack. The three faces of the same hobgoblin, software flaws, are robustness, security, and safety. A bug is a mistake committed by a developer; when the correct conditions are met, the bug is triggered and the program performs something it was not meant to do. Finding and resolving bugs is the key to improving robustness, security, and safety.

Positive and Negative Testing

Historically, software testing has been primarily concerned with functionality. Is the program functioning as it should? Functional testing is a type of positive testing in which test developers write code and frameworks that send legitimate inputs to the target product and verify for accurate outcomes. The software design in a traditional software development approach is a collection of requirements for the target software. The test development team’s mission is quite simple: translate the design requirements into test cases to ensure that the product performs as defined in the specification. Functional testing is unquestionably crucial. Software that has only been subjected to favorable testing, on the other hand, will fail quickly when deployed into a chaotic and hostile environment. The actual world is a shambles. It is riddled with unforeseen situations and poorly constructed inputs. Software must be able to deal with other software and humans that provide incorrect input, conduct operations in unanticipated sequence, and generally abuse the software. Negative testing is the process of delivering wrong or unexpected inputs to software to see if it fails. Keep in mind that various negative test instruments will yield various findings for the same test target. Each tool operates differently and will test several types of incorrectly generated inputs on the target software.

Software Vulnerabilities

Bugs are also known as code vulnerabilities. In the world of software, vulnerabilities come in three flavors:

1. Design vulnerabilities are problems with the design of the software itself. In general, design vulnerabilities must be hunted and killed by humans.

2. Configuration vulnerabilities occur when the setup of a piece of software has exposed a vulnerability. Much of the seek-and-destroy work must be performed by humans.

3. Code vulnerabilities are bugs. Positive and negative testing can be used to find and fix bugs related to functionality.

Additionally, vulnerabilities are known, zero-day or unknown.

Black, White and Gray box testing

The test tool in black box testing has no knowledge of the target’s internals. The tool only communicates with the target via external interfaces. A white box tool, on the other hand, searches the target’s source code for vulnerabilities. White box testing includes both static approaches such as source code scanning and dynamic testing in which the source code has been instrumented and rebuilt for improved target monitoring. Gray box tools integrate methods from the black box and the white box. These tools communicate with the target via its exterior interfaces, but they also consult the source code for extra information.

Fuzzing may be done using either black box or gray box testing. Fuzzing is an exceptionally valuable method for testing software because of its versatility, independent of the availability of source code or extensive internal knowledge. Fuzzing, as a black box approach, is valuable for anybody who wants to understand the real-world resilience and dependability of the systems they operate or want to install. This is also why fuzzing is the most popular approach used by black hat operators and hackers to discover software vulnerabilities.

Even in the absence of source code, the ability to more carefully monitor the vitals of the target software increases testing quality. Log files, process information, and resource use all give useful information that may be utilized during fuzzing to determine how unusual inputs influence the target system. If the source code is accessible, debugger tools and other instrumentation can be utilized to create a gray box methodology for fuzzing. This enhances test accuracy and enables for faster resolution of found problems.

Static and Dynamic Testing

Vulnerabilities are hunted out utilizing both static and dynamic testing methods. In order to reduce risk to the appropriate level, a mature development process should employ a range of static and dynamic strategies.

Without executing the target software, static approaches can be employed. Among them are the following:

1. Source code reviews carried out by developers to look for unknown vulnerabilities in source code.

2. Automated source code analysis tools scan the target source code and report on patterns of programming vulnerabilities.

3. Static binary analysis tools analyze compiled (executable) programs and report on libraries and known vulnerabilities.

Dynamic testing approaches, which include the following, are done on the target program while it is running:

1. Load testing sends a huge number of inputs to the target software to check if it fails due to the high volume.

2. Interoperability testing ensures that two implementations can communicate using a predefined protocol, language, or notation.

3. Conformance testing confirms that the tested system and its behavior adhere to the applicable requirements.

4. Fuzzing sends out aberrant inputs to software to test whether it fails. It is an effective method for discovering previously unknown vulnerabilities.

Role of Fuzzing in vulnerability and risk management.

A fuzzer will not solve all problems of a software/application. It must be part of an arsenal of tools and part of a process for software vulnerability management. Software vulnerability management is a subset of risk management. Software vulnerability management will be used in conjunction with other risk management strategies by a company aiming to reduce, or at least understand, its total risk. Fuzzing is a strong tool for evaluating software’s resilience and security, which is directly tied to risk.

Techniques Used in Components of Fuzzing.

1. The Poet

Since the quality of test case materials and test cases determines the profound outcome of Fuzzing, there is a standard of techniques.

1. Random

2. Template

3. Generational

4. Revolutionary

2. The Courier

The courier is in charge of delivering the poet’s test cases to the target program. Fuzzing includes a number of fields, each with its unique set of obstacles.

1. Network protocol fuzzing

2. File fuzzing

3. API Fuzzing

4. User interface fuzzing

3. The Oracle

The oracle determines whether a test case passes or fails. It checks the target to see if a failure has occurred. Knowing when a failure has occurred is crucial to the success of fuzzing

1. Types of Failures

· Crashes

· Endless Loops

· Resource Leaks or shortages

· Unexpected behavior

2. Traditional Oracles

· Eyeballs

· Valid case or Functional

· Resource Monitoring

3. Advanced Oracles

· External Tools

· Dynamic Binary

· Source Code Instrumentation

· Functional and Behavioral checks

Wrap up

Fuzzing is a good approach for identifying software flaws. The main idea is to purposefully send faulty input to the target software and identify failure. Fuzzing is more successful when it can generate test cases that are nearly accurate but are flawed in some manner. Various Oracle approaches offer differing degrees of failure detection. Fuzzing is an important tool in the management of software vulnerabilities. Fuzzing is used by builders as part of the Secure Development Life Cycle. Bugs that are fixed prior to deployment or product delivery are unimportant. In the broader context of risk management, proactively detecting and repairing problems through fuzzing protects against various sorts of damage. If a flaw in your product causes a catastrophic failure or a major data leak, reputation may suffer irreparable damage, and legal culpability may be overwhelming. Bugs in the items you use might cause human injury or environmental damage if you provide a service such as healthcare, power, communications, or another key infrastructure.

“Finding and fixing bugs saves money, protects your customers and your reputation, and in many cases, saves lives.”

“Be responsible and use your knowledge for good, together let’s make this world more secure.”

Stay Safe

Happy Hacking!

Written by Ashan Vijay — 3rd Year 1st Semester -Cyber Security Student-SLIIT




First they begin with Us..