When a CTF binary says "all mitigations enabled", it helps to know what each one removes from the attacker's toolbox and what it leaves alone. Conceptual view, for the defender and the player who wants to understand a challenge's design:
| Mitigation | What it changes | What it does not cover |
|---|---|---|
| NX / DEP | Stack and heap memory is not executable, so injected bytes cannot run as code | Reusing code that is already in the program |
| ASLR / PIE | Addresses of stack, heap and libraries (and the binary itself, with PIE) differ every run | Information leaks that reveal an address, or bugs that need no address |
| Stack canary | A secret value before the return address; a linear overflow that damages it is detected at function exit | Overwrites that skip the canary, data-only corruption, and leaks of the canary |
| RELRO (full) | The GOT is read-only after startup | Everything that is not the GOT |
| CFI | Indirect calls and returns may only go to valid targets | Bugs that change data without changing control flow |
| Shadow stack | A protected copy of return addresses is compared on return | Corruption of function pointers or data |
The pattern is that each mitigation closes one technique, not one bug. The memory bug stays; what changes is what you can build on top of it. That is why layered defence works, and also why the real fix is still removing the bug: bounds checks, memory-safe languages, sanitizers in testing, fuzzing.
If you are learning, the most instructive exercise is the reverse one: write a small program with a bug, turn the mitigations on one by one, and observe in the debugger how the crash changes. You will remember a crash you saw better than a table you read.