Skip to main content
Be Bitwise

The Exploit Development Process

Exploit Development & Real-World Impact · Exploit Development track

3 min read

In this module

From Bug to Exploit

Over the past several modules you've studied individual vulnerability classes — buffer overflows, use-after-free, integer overflows, format strings — and the mitigations designed to stop them. Now it's time to see how these pieces fit together in the exploit development process: the path from discovering a bug to having a working exploit in your hands.

The four steps below read as a line, but in practice it's a loop. Most of the time goes on the backward arrows:

Step 1: Finding the Bug

Vulnerabilities do not announce themselves. Researchers discover them through several techniques:

  • Fuzzing - feeding a program millions of randomly generated or mutated inputs and watching for crashes. Tools like AFL and libFuzzer automate this process and can find bugs in minutes that manual review might miss for years.
  • Code auditing - reading source code line by line, looking for unsafe patterns: unchecked memcpy, signed/unsigned comparisons (Integer Overflows & Type Confusion), missing bounds checks.
  • Reverse engineering - when source code is unavailable, disassembling the binary and analysing its logic to find flaws. This requires the assembly knowledge you built in Assembly Language.
The Bug is Not the Exploit

Finding a bug is only the beginning. A crash proves that something is wrong, but it does not mean the bug is exploitable. Many crashes are "just" denial of service - the program dies, but the attacker gains no further control. The next steps determine whether a bug can become a weapon.

Step 2: Analysing the Vulnerability

Once a crash is found, the researcher needs to answer a few uncomfortable questions: what memory is being corrupted? What values does the attacker actually control? Which mitigations are in play? How much is the input constrained — size limits, character restrictions, timing?

Those answers determine whether the bug is exploitable and how much work it'll take. Full return-address control from a stack overflow is relatively clean. A heap corruption that writes two bytes under tight constraints needs genuine creativity.

Step 3: Developing the Exploit

With the vulnerability analysed, the researcher crafts an input that transforms the crash into controlled behaviour. This might involve:

  • Calculating the exact offset to overwrite the return address (as we will see in the next lesson)
  • Building a ROP chain to bypass DEP (Return-Oriented Programming)
  • Leaking an address to defeat ASLR (Exploit Mitigations)
  • Bypassing the stack canary with an information leak

Each mitigation adds another problem the exploit must solve.

Step 4: Testing Reliability

A proof-of-concept that fires once in a debugger is not a reliable exploit. Real-world use means ASLR randomisation, varying system configurations, race conditions. Professional exploit developers test across OS versions and configurations until the thing works consistently — not just sometimes.

Defensive Thinking

Understanding this process changes how defenders prioritise. An easy-to-find, easy-to-exploit bug needs an urgent patch. A bug buried in a rare code path behind multiple mitigations can wait for the next release cycle. Thinking through the attacker's work is how you make those calls accurately.