Skip to main content
Be Bitwise

What is an Exploit Chain?

Exploit Chains & Real-World Case Studies · Exploit Development track

6 min read

In this module

One Vulnerability Is Not Enough

Earlier modules walked you through individual vulnerability classes: buffer overflows, use-after-free, integer overflows, and the techniques that turn them into exploits. Real-world software almost never falls to a single bug. Sandboxes, ASLR, DEP, privilege separation, and a half-dozen other layers mean one bug usually buys you very little on its own. Full compromise demands chaining, where each exploit unlocks just enough capability to make the next one possible.

That sequence is an exploit chain: vulnerabilities triggered one after another, with the output of each step feeding the requirements of the next. The idea is straightforward; pulling it off in practice is brutally hard. Modern security architectures are built around exactly that asymmetry.

The Anatomy of an Exploit Chain

A typical exploit chain against a modern target (like a web browser or a mobile phone) follows a pattern:

  1. Initial access: The attacker triggers a vulnerability in code that processes untrusted input. In a browser, this might be a bug in the JavaScript engine or an image parser. On a phone, it might be a bug in the messaging app's media handling.

  2. Information leak: ASLR randomizes memory layout, so the attacker needs to discover actual addresses. An information leak vulnerability - reading memory that should not be accessible, leaking a pointer through a timing side channel, or exploiting a format string bug - reveals the memory layout.

  3. Code execution: Using the leaked addresses, the attacker constructs a ROP chain or other code-reuse technique to gain arbitrary code execution within the vulnerable process.

  4. Sandbox escape: If the vulnerable process is sandboxed (as browser renderers and many mobile apps are), the attacker must break out of the sandbox. This usually requires a second vulnerability - in the IPC mechanism, in a privileged service, or in the kernel.

  5. Privilege escalation: The attacker climbs from the compromised process's limited privileges to full system access, typically through a kernel vulnerability.

  6. Persistence: The attacker installs a persistent implant that survives reboots.

Tap a link to see which defence forced it into the chain. Then patch one bug and watch everything after it go dark:

A six-link chain

Initial access
Info leak
Code execution
Sandbox escape
Privilege escalation
Persistence

Hover over or tap each step to see details

Exploit Chain

An exploit chain is a sequence of vulnerabilities used together, each one handing the attacker a capability that lets the next step happen. Modern systems force chains because no single bug clears every layer of defence in one jump. More layers, longer chain, harder attack.

Why Chains Are Necessary

Chains exist because defence in depth works. Look at how each mitigation tacks on another link:

  • DEP/NX prevents running code from the stack → attacker needs code reuse (ROP), adding a step
  • ASLR randomizes addresses → attacker needs an information leak, adding a step
  • Sandboxing limits what a compromised process can do → attacker needs a sandbox escape, adding a step
  • Privilege separation means the sandboxed process runs with minimal privileges → attacker needs privilege escalation, adding a step
  • Code signing prevents loading arbitrary code → attacker must find ways to reuse existing signed code

Each mitigation is bypassable in isolation given the right bug. What they buy you is requirements. The attacker who needs five bugs instead of one is paying many times the price.

The Economics of Exploit Chains

Exploit chains are expensive to develop. Each vulnerability must be:

  • Discovered: Finding bugs in well-audited code requires significant expertise and time
  • Reliable: Each step must work consistently, not just occasionally
  • Compatible: The vulnerabilities must work together - the output of one step must provide what the next step needs
  • Current: Software updates constantly change the attack surface, and a patch to any single link breaks the entire chain

That cost is a feature, not a bug. A full chain that needs five zero-days, with each zero-day eating months of expert time, represents years of effort and millions of dollars on the meter. The pool of actors who can afford to build and burn one is short: nation-state intelligence agencies, specialised offensive vendors, and a few private brokers.

Disclosure and patching punch above their weight here. Snip any one link and the whole chain falls apart. That's why fast patching matters even when you can't patch everything — knock out a single bug in the chain and the complete compromise stops working.

The Information Leak: The Glue of Modern Chains

Information leaks deserve their own paragraph because they're the one ingredient nearly every chain wants. If you look at modern chains, you'll struggle to find one without at least one leak somewhere in the recipe.

Without a leak, the attacker is rolling dice. ASLR gives 28 to 40 bits of entropy depending on the region; on 64-bit systems that's a vast haystack. Guess wrong and the target crashes — and in a browser, that means the tab dies, which is the kind of thing users notice and remember.

A leak swaps the probabilistic attack for a deterministic one. Read one pointer, calculate every other address from there, and the rest of the chain runs first try.

Common information leak sources:

  • Out-of-bounds reads that return adjacent memory contents
  • Type confusion bugs where an object's fields are reinterpreted, leaking pointer values
  • Uninitialised memory reads where freed object data (containing pointers) is returned
  • Format string vulnerabilities that dump stack contents
  • Side channels (timing, cache) that reveal address information

Reliability and Stealth

A chain that's not reliable is barely a chain. Each step adds another way to fail:

  • A memory corruption exploit can crash the process if the heap layout shifts a few bytes
  • A race condition can lose the race, forcing retries
  • Aggressive memory mangling can crash the program later, when it tries to dereference what you broke

Serious exploit developers spend a huge fraction of their time on reliability:

  • Heap grooming: Manipulating the heap layout before the exploit to ensure objects are in predictable positions
  • Controlled corruption: Overwriting only what is necessary, preserving the rest of the object's fields to prevent crashes
  • Clean recovery: After exploitation, fixing up corrupted memory so the process continues running normally
  • Graceful failure: If a step fails, the chain should exit cleanly rather than crashing

The top-tier chains, the ones intelligence agencies pay millions for, are engineered to be invisible. The phone keeps working. Nothing crashes, nothing slows down, the user has no idea anything happened. That stealth bar adds enormous engineering load on top of the exploitation itself.

The next lessons walk through real chains from three different worlds: browsers, mobile devices, and a handful of historical operations worth knowing about.