An interactive walkthrough

How passwords get cracked

A hands-on tour of the maths and the shortcuts. By the end you will know what entropy really measures, why a dictionary attack shreds "P@ssw0rd1" in seconds, and why a boring four-word phrase beats a clever short one. Click, type, and try things; it takes about ten minutes.

Built for cybersecurity students. Every guess-rate figure here is an illustrative ballpark from public benchmarks; sources are listed on the final beat.

Module 01

The attack you're not imagining

Myth we'll unpick: "cracking a password means typing guesses into a login box"

Before we count anything, fix the mental picture. The dangerous attack does not happen at your login screen at all.

Online versus offline

A site should never store your password. It stores a hash: a scrambled fingerprint. When a database leaks, the attacker walks away with millions of these hashes and cracks them on their own hardware, offline. No login box, no lockout, no rate limit; just their machines guessing as fast as they can.

Guessing at the live login screen (an "online" attack) is slow and easily throttled or locked. The offline attack against a stolen hash database is the one that sets the standard your password has to survive.

How fast is "as fast as they can"?

~100 / secOnline, against a live login that throttles you. Slow, noisy, easy to block.

~10 thousand / secOffline against a deliberately slow hash such as bcrypt, which is built to be expensive to compute.

~100 billion / secOffline against a fast hash such as unsalted MD5, on a single high-end GPU rig. A rented cluster goes far higher.

The gap between the top and bottom rows is roughly a billion-fold. Same password, wildly different fate.

So how many guesses in a single day?

A rig chewing through 100 billion guesses per second, running for 24 hours. Do the arithmetic in your head first, then reveal it.

About 8.6 quadrillion guesses in one day (8,640,000,000,000,000).That is why "it would take ages to guess" is the wrong intuition. The only question that matters is: how many possibilities does your password have to hide among? That number has a name.

Module 02

Entropy: measuring the haystack

Entropy is just a count of possibilities, written in bits. Each bit doubles the number of guesses an attacker must make. It is the single number that decides how long the offline attack takes.

The formula, in one line

Entropy in bits = length × log₂(pool size). The pool is how many different characters you drew from: 26 for lowercase, 62 once you add uppercase and digits, about 95 with symbols. Every extra character multiplies the possibilities; taking the log just turns that multiplication into a running total of bits.

Thirty bits means roughly a billion possibilities; forty bits, a trillion; sixty bits, a quintillion. Add ten bits and you have multiplied the attacker's work by about a thousand.

Type a password and watch the haystack grow

Length

0

Character pool

0

Entropy

0 bits

Verdict

—

Online, throttled login~100 guesses / second

—

Offline, slow hash (bcrypt)~10 thousand guesses / second

—

Offline, fast hash on a GPU rig~100 billion guesses / second

—

Times are the average to find it by brute force: total possibilities, halved, divided by the guess rate. One warning: this assumes every character is chosen at random. Real passwords almost never are, and that loophole is the whole of module 03.

The lesson hiding in the numbers

Try it: type eight random symbols, then delete them and type a sixteen-letter lowercase phrase. The plain phrase usually wins. Length is inside the multiplier that gets multiplied; pool size is inside the log that gets flattened. That is the mathematical reason length beats complexity.

But brute force is the attacker's last resort. First they try the cheap trick.

Module 03

Dictionary attacks: the shortcut

Myth we'll unpick: "P@ssw0rd1 is strong because it has upper, lower, a number and a symbol"

The entropy calculator assumed randomness. Attackers bet, correctly, that you were not random. So they never start from "aaaa"; they start from what people actually pick.

They start with the answers

123456Year after year, the most common password in breach datasets.

passwordThe word itself, plus "qwerty", "111111" and "iloveyou", all near the top.

rockyou.txtA wordlist of ~14 million real passwords from the 2009 RockYou breach. It ships with cracking tools and is tried first, in seconds.

If your password is on the list, its entropy is irrelevant; it falls immediately. But most passwords are not on the list verbatim. So attackers bend the words.

Watch a dictionary word become "strong"

Click each stage. These are real, one-line transformation rules that a cracker applies automatically to every word in its list.

Now you judge: which survive?

Seven lowercase letters, a real word people love to use as a "clever" password.

hunter2

Cracked instantly. It sits in the common wordlist; no rules even needed.Length and character variety cannot save a password an attacker already has written down.

Nine characters, all four character classes. Passes every "complexity" checkbox on a signup form.

P@ssw0rd1

Cracked in seconds. It is just "password" plus three standard rules you watched a moment ago.Complexity rules push people toward predictable substitutions, which is exactly what the rulesets encode.

Four ordinary words, chosen at random, with spaces. No symbols, no capitals.

correct horse battery staple

It survives. There is no single word to look up; an attacker must guess a combination of four independent words, which is astronomically many.Roughly 44 bits of entropy, and memorable. This is the xkcd 936 argument, and it holds up.

Module 04

Why length beats complexity

Everything so far points one way. Complexity fights the log and buys little; length rides the multiplier and, done as words, stays memorable. Let us put four strategies side by side.

Pick a strategy and compare

Choose a password strategy

one memorable word (~12.9 bits)one random character (~6.6 bits)

Why this matters

A short "complex" password is hostile to you and cheap for the attacker: hard to remember, easy to guess because everyone mangles words the same way. A long passphrase flips both: each extra word multiplies the attacker's work by thousands while costing you one more thing to picture. Length is the lever. Complexity is theatre.

Practical upshot for defenders: pick long passphrases, use a password manager so length is free, never reuse a password across sites, and turn on multi-factor authentication so a cracked hash alone is not enough. And if you build the login: use a slow, salted hash (bcrypt, scrypt or Argon2), never fast unsalted MD5.

Sources used: Randall Munroe, "Password Strength", xkcd 936 (xkcd.com/936). EFF, "Deep Dive: New Wordlists for Random Passphrases" (7,776-word list, ~12.9 bits per word). NIST SP 800-63B, Digital Identity Guidelines (favours length and passphrases; drops mandatory composition rules). Hashcat published GPU benchmarks (illustrative hash rates for MD5 and bcrypt). The 2009 RockYou breach wordlist (~14 million passwords). Annual most-common-password lists (NordPass; SplashData) for "123456" and "password". Guess-rate figures are rounded ballparks for teaching.