Working backward from a compiled program to understand what it does — the defensive and research counterpart to binary exploitation. You reverse a malicious sample to learn its behaviour, write detection for it, and defend; you reverse a CTF binary to find the flag; you reverse closed-source software to find and report its bugs.
Every note assumes the authorization framing in rules of engagement. This is defensive, CTF, and research work: analyse only what you’re authorised to, and run live samples only in a properly isolated lab. The techniques are neutral; purpose and isolation are what make it safe and legal.
The one idea: reverse engineering rebuilds what a program does from code that discarded how it was written, by alternating two views — static (read it without running; safe and complete, but defeated by packing) and dynamic (run it and watch; cuts through packing, but only sees executed paths). Malware analysis is that skill pointed at hostile code, in a safe lab, to produce detection.
Why this exists
The vault had binary exploitation (breaking programs) but treated malware analysis and reverse engineering — understanding programs — as two passing mentions. It’s the defensive twin of exploitation, a core DFIR skill, and the natural application of compilers and assembly read in reverse — so it earns a section, completing the offensive-technical trio with 11 and 12.
Reading order
- what-reverse-engineering-is — [Intermediate] — the discipline, static vs dynamic, the file formats, the mindset, and the legal line
- static-analysis — [Intermediate] — the cheap tells (hash, strings, imports) that reveal purpose before you read code, then Ghidra’s decompiler
- dynamic-analysis — [Intermediate → Advanced] — running it safely, behavioural monitoring, debugging, and unpacking in memory (the move against packing)
- how-malware-works — [Intermediate] — the taxonomy, the one lifecycle every sample follows, and the recurring techniques (persistence, injection, living-off-the-land, C2)
- evasion-and-anti-analysis — [Advanced] — packing, polymorphism, and anti-analysis — why signature detection is losing and defence moved to behaviour
- the-malware-analysis-workflow — [Intermediate → Advanced] — the safe lab, the triage-to-deep-dive process, IOCs and YARA (the deliverable), and where to practise legally
If you only take three things
- Static and dynamic are complementary — static sees all code but is beaten by packing; dynamic cuts through packing but only sees what runs. Serious analysis loops between them (01).
- The cheap tells come first — hash reputation, strings and imports often reveal a sample’s whole purpose before you read one instruction (02).
- Isolation is a safety requirement, not a nicety — you’re running live hostile code; a disposable, network-isolated VM is non-negotiable (06).
Practice
Start where there’s no infection risk and build up:
- CTF
revchallenges (picoCTF) and crackmes.one — pure reverse-engineering skill, benign binaries - Ghidra on your own programs — see your source turned back into pseudocode
- malware-traffic-analysis.net and Practical Malware Analysis (the canonical book + labs)
- Live samples (MalwareBazaar) — only once your lab isolation is solid → cybersecurity projects
Related
- cybersecurity curriculum map · binary exploitation · active directory
- security operations — where IOCs and YARA feed detection
- compilers · assembly — what reversing undoes
- the threat taxonomy — the higher-level view
Software engineering
Infrastructure & security
Computer science
Hardware & engineering