the whole year, one map
Curriculum Map
0 done · 0 available · 239 total
done
available
locked
click a node to trace its path
next
70%
I
The Machine & Its Tongue
II
Mathematics
III
Code & Algorithms
IV
Artificial Intelligence
V
Offensive Security
Bits & the Idea of Meaning
Hex & Two's Complement
The CPU & Its Registers
Memory & Addresses
Your First Assembly Program
mov & Addressing Modes
Bridge: Your First C, Disassembled
Arithmetic & the FLAGS Register
cmp, Conditional Jumps & if
Loops at the Instruction Level
The Stack, push, pop, rsp
Functions: call & ret
The System V Calling Convention
Stack Frames & Local Variables
C Types Are Just Sizes
Pointers, Truly
Arrays & Pointer Arithmetic
Structs, Padding & Alignment
C Functions → Assembly
Function Pointers & Callbacks
Mini-Capstone: A Dynamic Array in C
The Heap & malloc/free
Strings: Bytes with a Zero
Bitwise Mastery
Talking to the Kernel: syscalls
The Compile Pipeline & Linker
Seeing It Run: gdb
Undefined Behavior & Memory Bugs
Capstone: A Tiny Stack Machine
Capstone Review & Reading Any Assembly
What a Proof Actually Is
Propositional Logic
Predicates & Quantifiers
Direct Proof & Contrapositive
Proof by Contradiction
Sets
Relations & Functions
Cardinality & Infinity
Mathematical Induction
Strong Induction & Recursion
Divisibility & the Euclidean Algorithm
Modular Arithmetic
Primes & Unique Factorization
Permutations & Combinations
Pigeonhole & the Binomial Theorem
Vectors
Vector Operations & the Dot Product
Length, Angle & Projection
Linear Independence & Span
Basis & Dimension
A Matrix Is a Function
Matrix Multiplication
Identity, Inverse & Solving Ax=b
The Determinant
Gaussian Elimination
Eigenvectors & Eigenvalues
Diagonalization
Orthogonality & the Transpose
Singular Value Decomposition
Linear Algebra in Code
The Limit
The Derivative
Rules of Differentiation
The Chain Rule, Deeply
Derivatives in Code
Multivariable Functions & Partials
The Gradient
Gradient Descent
The Jacobian & Hessian
Integration & the Fundamental Theorem
Sample Spaces & Events
Conditional Probability & Bayes
Random Variables & Distributions
Expectation & Variance
The Normal Distribution & CLT
Sampling & Estimation
Maximum Likelihood
Hypothesis Testing & p-values
Covariance, Correlation & Regression
Capstone: Regression from Probability
What 'Fluency' Means & How to Practice
Big-O, Derived
Time vs Space & the Cost Model
Arrays & Amortized Analysis
Two Pointers & Sliding Window
The Linked List
Doubly Linked Lists
Stacks
Queues & Ring Buffers
A Generic Container in C
Recursion, Truly
Backtracking
Divide & Conquer
Merge Sort
Quick Sort & Pivots
Binary Search & Its Traps
The Sorting Landscape
Hashing
Building a Hash Table
Sets & Maps
Binary Trees & Traversals
Binary Search Trees
Balanced Trees
Heaps & Priority Queues
Tries
Graphs & How to Store One
Breadth-First Search
Depth-First Search
Topological Sort
Connected Components & Union-Find
Dijkstra's Algorithm
Minimum Spanning Trees
Greedy Algorithms
Interval Problems
When Greedy Fails
Dynamic Programming
1-D Dynamic Programming
2-D Dynamic Programming
Knapsack & Subset Problems
DP on Sequences & Strings
Bit Manipulation for Algorithms
Number-Theoretic Algorithms
String Algorithms
Randomized Algorithms
P, NP & What 'Hard' Means
A Repeatable Problem-Solving Method
Reading & Refactoring
Testing Your Own Code
Timed Practice
Capstone: Design & Build a Real Program
What 'Learning from Data' Means
The Loss Landscape
Gradient Descent, Applied
Linear Regression from Scratch
Overfitting & Generalization
Logistic Regression
Sigmoid, Cross-Entropy & Why
Regularization
k-Nearest Neighbors
Evaluation
Decision Trees
Ensembles & Random Forests
Gradient Boosting
Support Vector Machines
Naive Bayes
k-Means Clustering
PCA
The Curse of Dimensionality
Anomaly Detection & Density
Feature Engineering & Representation
The Neuron
A Layer & the Forward Pass
Activation Functions
Backpropagation, Derived
Build a 2-Layer Net from Scratch
Computational Graphs
Reverse-Mode Autodiff
Build an Autograd Engine
Training Loops, Batches & SGD
Optimizers
Initialization & Normalization
Regularization for Nets
Convolutional Networks
Build a Small ConvNet
Sequence Models & RNNs
Embeddings
Attention
The Transformer
Build a Tiny Language Model
Training at Scale
How LLMs Are Actually Trained
Generative Models
Evaluation, Alignment & Failure Modes
Where the Field Is Going
Capstone: Train a Model End-to-End
The Hacker's Mindset, Ethics & Lab
Building a Professional Lab
Linux Deep Dive I
Linux Deep Dive II
Bash Scripting for Hackers
Python for Offensive Tooling
Networking Deep I
Networking Deep II
Crafting Packets from Scratch
Interception & Man-in-the-Middle
Attacking the Protocols
Traffic Analysis & Extraction
Pivoting & Tunneling
Reverse Engineering I: Static
Reverse Engineering II: Dynamic
Anti-Debugging & Deobfuscation
Assembly Through an Attacker's Eyes
Memory Corruption: The Big Idea
Anatomy of a Stack Buffer Overflow
Writing Shellcode
Bad Characters & Encoders
Modern Mitigations
Bypassing NX: ret2libc
Return-Oriented Programming
Format String Exploits
Heap Exploitation I: The Allocator
Heap Exploitation II: UAF & tcache
Pwn Capstone: Remote Exploit
Windows Exploit Dev I: SEH & Egghunters
Windows Exploit Dev II: DEP & ASLR Bypass
Browser Exploitation
Advanced Use-After-Free
Exploit Development Methodology
Kernel Internals for Attackers
Linux Kernel Exploitation
Windows Kernel Exploitation
Sandbox Escapes
The Vulnerability Researcher's Method
Auditing Source Code for Bugs
Fuzzing Fundamentals
Coverage-Guided & Structure-Aware Fuzzing
Triage: From Crash to Root Cause
From Bug to CVE to Exploit
Payload Crafting with msfvenom
Weaponized Documents & Evil PDFs
Evil Images & Polyglots
Steganography
Modern Initial Access
BadUSB & HID Attacks
QR, Clipboard & Sneaky Vectors
Writing Your First Implant
Process Injection Techniques
Persistence on Windows & Linux
In-Memory & Fileless Execution
C2 Frameworks In Depth
Resilient C2 Infrastructure
Malware OPSEC & Anti-Analysis
How EDR & AV Actually Work
Bypassing AMSI & ETW
Unhooking & Direct Syscalls
Obfuscation, Packing & Signatures
Living off the Land (LOLBins)
Building & Testing Evasive Payloads
Capstone: A Full Low-Level Chain