0x6000 · Learning Path
A Binary Exploitation Learning Path Through CTFs
A staged, legal path from C and assembly to CTF pwn challenges: what to learn in which order, practice platforms built for it, lab rules, and how it leads to defensive careers.
Guides
In-depth guides on memory-safety vulnerability classes, exploit mitigations, sanitizers, fuzzing and crash triage.
0x5000 · Secure Coding
Memory-Safe Languages and a Realistic Migration Strategy
Why memory-safe languages remove whole bug classes, what Rust's ownership model guarantees, where unsafe code and FFI remain risky, and how to harden the C++ you keep.
0x3000 · Finding Bugs
Coverage-Guided Fuzzing with libFuzzer and AFL++
Write a fuzz harness, build it with sanitizers, run libFuzzer and AFL++, manage corpora and dictionaries, and run continuous fuzzing in CI with OSS-Fuzz or ClusterFuzzLite.
0x4000 · Crash Triage
Reading Crash Reports: Signals, Backtraces and Core Dumps
Triage native crashes like a defender: what SIGSEGV and SIGABRT mean, glibc abort messages, gdb and core dumps, ASan reports, WinDbg, and how to prioritise memory-safety crashes.
0x3000 · Finding Bugs
AddressSanitizer, UBSan and Friends: A Practical Guide
How ASan, UBSan, MSan, TSan and HWASan work, which flags and runtime options to use, how to read an ASan report line by line, and how to run sanitizers in CI.
0x2000 · Exploit Mitigations
Control-Flow Integrity: CFI, Intel CET and Arm PAC/BTI
How forward-edge and backward-edge control-flow integrity work, from Clang CFI and Microsoft CFG to Intel CET shadow stacks and Arm pointer authentication, and their limits.
0x2000 · Exploit Mitigations
Stack Canaries, NX, ASLR/PIE, RELRO and FORTIFY_SOURCE
What each classic exploit mitigation protects, the GCC and Clang flags that enable it, what it costs, and how to verify a binary with checksec and readelf.
0x1000 · Vulnerability Classes
Integer Overflows and Format-String Bugs, Explained
How integer overflow, truncation and signedness errors turn into memory corruption, why user-controlled format strings are dangerous, and the checks and warnings that prevent both.
0x1000 · Vulnerability Classes
Heap Overflows, Use-After-Free and Double Free
How heap memory bugs corrupt allocator metadata and object state, why use-after-free is so dangerous, and the allocator hardening, sanitizers and ownership rules that stop them.
0x1000 · Vulnerability Classes
Stack Buffer Overflows Explained for Defenders
Why writing past a stack buffer is dangerous, the C patterns that cause it, how compilers and sanitizers catch it, and the fixes and mitigations that contain it.
0x0000 · Memory Fundamentals
How a Process Lays Out Memory: Stack, Heap and ELF Segments
A defender's tour of a Linux process's address space: ELF segments, the stack and calling conventions, the heap, mmap, and why permissions and randomization matter.