The Arms Race
Exploit Development & Real-World Impact · Exploit Development track
4 min read
In this module
An Endless Cycle
The history of computer security is a story of escalation with no ceiling. Defenders build a wall. Attackers find a way over it. Defenders build a taller wall. Each mitigation you learned in Exploit Mitigations was invented to stop something specific — and each one reliably spawned new bypass methods.
The Escalation Timeline
Stack buffer overflows (Stack-Based Buffer Overflows) led to stack canaries (Exploit Mitigations). Attackers responded with information leaks to read the canary value, or used non-sequential writes that skip the canary entirely.
Code injection (shellcode on the stack) led to DEP/NX. Attackers responded with Return-Oriented Programming - reusing the program's own code instead of injecting new code.
ROP exploits that required known addresses led to ASLR. Attackers responded with information leaks to discover the randomized base addresses, or used partial overwrites that only modify the lower bytes of an address (which are not randomized).
Control flow hijacking led to CFI and shadow stacks. Attackers responded with data-only attacks that corrupt variables influencing program behaviour without redirecting control flow at all.
The same four rounds with the years attached. Read each row left to right: the attack, the defence it provoked, and the answer to that defence.
Some of the "answers" are older than the defences they beat. ret2libc was published in 1997, years before NX was common, and each defence took several years to get from a research patch onto ordinary desktops.
When all control-flow defences are in place, attackers can still win by corrupting data rather than code pointers. Changing an isAdmin flag from 0 to 1, modifying a filename string, or corrupting a size variable can achieve the attacker's goals without ever hijacking a function pointer or return address. These attacks bypass every mitigation designed to protect control flow.
Breaking the Cycle: Memory-Safe Languages
Every mitigation so far is a dressing on a wound that hasn't closed: C and C++ let programs corrupt their own memory. The only way to actually break the cycle is to remove that capability.
Rust eliminates buffer overflows, use-after-free, double-free, and data races at compile time via its ownership system. Go uses garbage collection and bounds checking. Java and C# run in managed environments that block direct memory access entirely. In all these languages, the vulnerability classes that drive the arms race simply can't appear in safe code.
The Linux kernel now accepts Rust modules. Android has rewritten security-critical components in Rust. Chromium is introducing Rust for new code. Each rewritten component excises entire categories of potential bugs — not by patching them, but by making them architecturally impossible.
Career Paths in Security Research
The knowledge you have built across these modules maps directly to real-world security careers:
- Vulnerability researcher - finding bugs in software through fuzzing, code auditing, and reverse engineering
- Exploit developer - turning vulnerabilities into working proofs of concept for red teams or vendors
- Malware analyst - reverse-engineering malicious software to understand and neutralise threats
- Security engineer - designing and implementing defences, from compiler mitigations to secure architectures
- Penetration tester - authorised simulated attacks to identify weaknesses before real attackers do
All of these roles benefit from the low-level understanding of memory, CPU architecture, and assembly that you have developed throughout this curriculum.
The Big Picture
You started this curriculum by learning that computers store everything as binary numbers. You built up through CPU instruction execution, memory layout, operating system management, and then the vulnerabilities that emerge when any of that is handled sloppily.
The arms race will continue as long as unsafe languages are used for system software. But the trajectory is clear enough. Memory-safe languages are winning ground fast — and understanding why they matter, at the level of bits, bytes, and memory addresses, is what separates a developer who writes secure code from one who just hopes for the best.
Try the Simulations
Full Exploit Chain
Complete exploit: overflow a buffer to overwrite the return address, redirecting execution to attacker-controlled code that stores a marker value.
Finding the Offset
Write a unique pattern of bytes to consecutive memory addresses to determine which offset overwrites the return address. The pattern value at the return address location reveals the exact offset.