Module 09 — Password & Credential Attacks¶
Type 2 · Misconception Reveal — crack real hashes hands-on to reveal that encryption isn't hashing and security is cost-per-guess (fast vs slow KDF), and that reuse, not cracking, is the real vector. (Secondary: Tool-Build — the cracking/attack-mode workflow you keep.) Go to the hands-on lab →
Last reviewed: 2026-06
Offensive Security — credentials are the keys; cracking and capturing them is how access spreads.
In 60 seconds
"Most breaches don't hack in — they log in." A hash is a one-way fingerprint, so cracking is just guess → hash the guess → compare — and the entire security of a stolen hash database comes down to how expensive each guess is. Fast hashes (MD5, NTLM) fall at billions/sec on a GPU; slow KDFs (bcrypt, argon2) make each guess thousands of times costlier. But the dominant real-world vector isn't cracking at all — it's reuse: credentials from one breach sprayed everywhere else.
Why this matters¶
Most breaches don't "hack in" — they log in. Once you have a foothold, dumped password hashes, reused credentials, and weak passwords turn access into more access. Understanding how hashes are cracked — and how fast — is also the only way to argue convincingly for the defenses (strong hashing, length, MFA) that stop it.
Objective¶
Crack real password hashes, understand hash types and attack modes, and explain credential attacks like spraying and reuse — plus the defenses that defeat them.
The core idea¶
"Most breaches don't hack in — they log in." Credentials are the universal skeleton key, and this module turns on one asymmetry: a hash is a one-way fingerprint of a password, so cracking is simply guess → hash the guess → compare. That means the entire security of a stolen hash database comes down to how expensive each guess is. Fast hashes (MD5, NTLM) fall at billions of guesses per second on a GPU — a dumped database is effectively plaintext within hours. Slow KDFs (bcrypt, argon2) are designed to make each guess thousands of times costlier, so the same dump is infeasible. That single fact is why one leaked database is a shrug and an identical one elsewhere is a catastrophe. The canonical lesson is the 2012 LinkedIn breach: ~6.5 million password hashes (with ~100 million more surfacing in 2016) stored unsalted, which let crackers reverse them en masse with off-the-shelf rainbow tables — the textbook case of why a missing salt plus a fast hash turns a leak into instant plaintext.
The mental model
The security of a stolen hash database is just cost-per-guess. Cracking is guess → hash →
compare, and the "attack modes" are progressively smarter guessing: dictionary (known passwords)
→ rules (mutate them — Password → P@ssw0rd!) → mask (known structure) → brute force (last
resort). This is the Foundations crypto lesson cashed in: hashing is not encryption — there's no
"decrypt," only guess-and-check.
The gotcha
The dominant real-world entry vector isn't cracking at all — it's reuse: credentials from one breach sprayed across everything else, because humans recycle passwords. Don't fixate on GPU horsepower when the cheaper win is a password your target already leaked somewhere else.
The defensive payoff: understanding crack speed is the only way to argue the defenses convincingly — demonstrating that a 9-character fast-hashed password dies in minutes makes the case for length + a strong KDF + MFA far better than any policy memo.
AI caveat
A model identifies a hash type and suggests modes instantly, but it also misidentifies hashes and sends you burning GPU-hours on the wrong attack. Confirm the hash type and mode yourself; cracking is expensive to get wrong.
Learn (~4 hrs)¶
Cracking - Hashcat — official wiki — hash modes, attack modes, and rules; the authoritative reference. - Hashcat Tutorial: A Beginner's Guide (video) — a hands-on first pass before the wiki.
Where it sits, and the defense - MITRE ATT&CK — Brute Force (T1110) and OS Credential Dumping (T1003) — the techniques you're performing. - OWASP — Password Storage Cheat Sheet — the defender's side: why bcrypt/argon2 + salting beats you.
Key concepts¶
- Hashing vs encryption (callback to Foundations crypto)
- Hash types (MD5, NTLM, bcrypt) and why some crack in seconds — and why unsalted fast hashes (the 2012 LinkedIn breach) fall to rainbow tables
- Attack modes: dictionary, rules, mask, brute force
- Credential spraying and reuse (the real-world entry vector)
- Defenses: strong KDFs, salting, length, MFA
AI acceleration¶
A model suggests hashcat modes and rules and identifies a hash type instantly — handy. But it also misidentifies hashes or suggests attacks that waste GPU-hours. Confirm the hash type and mode yourself; cracking is expensive to get wrong.
Check yourself
- Why does a stolen bcrypt database survive where the same passwords stored as MD5 fall in hours?
- What made the 2012 LinkedIn hashes crackable en masse, and what would have stopped it?
- Why is credential reuse a bigger real-world vector than cracking, and how does spraying exploit it?
Comments
Sign in with GitHub to comment. Choose the type: Feedback (errors or suggestions on this page) · Hints (help for fellow learners — no spoilers) · General (anything else).