What Makes a Strong Password? The Real Math

Two passwords. P@ssw0rd! and correct horse battery staple. Ask most people which is stronger and they'll point at the first one — it's got a capital, a number, a symbol, it looks like security. It also gets cracked in well under a second. The second one, four plain lowercase words with spaces, would take a serious attacker somewhere north of a thousand years. The gap between what looks strong and what is strong is the whole subject here.

So let's replace intuition with the actual measurement. By the end you'll be able to look at a password and estimate, roughly, how hard it is to guess — and you'll stop wasting effort on the parts that don't help.

Strength has a unit, and it isn't 'number of symbols'

The property that makes a password hard to crack is entropy, measured in bits. Ignore the physics connotation; here it just means one thing — how many guesses an attacker has to make. Each bit of entropy doubles that number.

The cleanest way to feel this is coin flips. One flip has two outcomes; an attacker calling it has a 1-in-2 shot. Ten flips have 1,024 outcomes. Thirty flips have over a billion. Every flip you add doesn't add to the difficulty, it doubles it — that's what 'exponential' means, and it's why small-looking changes to a password can swing its strength by factors of millions.

For a password, entropy comes from two multiplied ingredients: how many characters it is (length), and how many possibilities each character is drawn from (the character set), assuming each character is genuinely unpredictable. That last clause is where most passwords quietly fail, and we'll get to it. The rough formula is entropy ≈ length × log2(character-set size). Hold onto the shape of it: length is a multiplier out front.

The myth worth killing: 'special characters make it strong'

Here's the received wisdom, and here's why it's half wrong. Adding symbols grows the character set — from 26 lowercase letters to about 95 printable ASCII characters if you use everything. That roughly increases per-character entropy from about 4.7 bits to about 6.6 bits. Real, but modest: it's a bigger base.

Length, by contrast, is the exponent's friend. Steelman the symbol argument first, because it isn't nonsense — a bigger character set genuinely helps. But watch what each lever actually buys. Adding one symbol to an 8-character password adds those ~6.6 bits once. Adding four more characters adds ~6.6 bits four times over. Length compounds; character-set size doesn't. Given a choice between one more symbol and four more characters, the characters win, and it isn't close.

There's a second, nastier problem with leaning on complexity: people do it predictably. Capital letter at the front, the digit and the ! at the end, a swapped for @, o for 0. Password-cracking tools were built by people who know this. They don't guess randomly — they try dictionary words first, then those exact substitutions and placements. So P@ssw0rd! doesn't have the entropy its character set implies; against a real cracker it has almost none, because it's password wearing a costume the tool checks for on guess number three.

The worked math

Put numbers on the opening example. P@ssw0rd! is nine characters, but it's a known base word plus known substitutions — its effective entropy against a targeted attack is maybe 20-some bits, and modern hardware chews through that essentially instantly.

correct horse battery staple is four words. If each word is picked randomly from a list of, say, 7,776 common words (the standard Diceware list), each word contributes about 12.9 bits, so four words give roughly 51 bits — and you can just add a fifth word to climb higher. Fifty-one bits is over two quadrillion combinations, and every additional random word multiplies that by another ~7,776. Longer, more memorable, and dramatically harder. That's the entire case for passphrases in one comparison.

The catch, and I'll be precise about it: this only holds if the words are random. to be or not to be is six words and almost zero entropy, because it's a famous line sitting in every attacker's phrase dictionary. Randomness is the assumption the whole calculation rests on. If you don't trust yourself to pick randomly — and honestly, no one should — that's exactly what a password generator or a random string generator is for: they draw from a cryptographically secure source, so the entropy you think you have is the entropy you actually have.

The turn: strong is only half the system

Now the part that keeps me honest, because a post about password strength that stops here is misleading. Your password's entropy determines how hard it is to guess. It does nothing about how the website stores it.

If a site keeps passwords in plaintext, or runs them through a single fast hash like raw SHA-256, then a database breach hands attackers everything — and a fast hash lets them test billions of guesses per second, at which point even a decent password is at risk. The defense on the server side is a deliberately slow, salted hash. A salt makes every stored hash unique so attackers can't crack the whole database at once, and a slow algorithm like bcrypt taxes each guess so brute force stops being economical. You can see what that stored form looks like with a bcrypt generator.

So the real picture is two independent locks. Your entropy stops online guessing and credential stuffing. Their hashing stops a stolen database from becoming a stolen password. A strong password behind bad storage still leaks in a breach; a weak password behind perfect storage still falls to guessing. You control one lock, they control the other — pick services that clearly take the second one seriously.

What to actually do

Strip it to the rules that follow from the math. Favor length over cleverness — a long passphrase or a 16-plus-character random string beats a short symbol salad. Make it genuinely random, which in practice means let a tool pick it. Don't reuse it, because the strongest password on earth is worthless once it's been breached somewhere else and fed into a stuffing attack. And use a manager so length and uniqueness don't have to fit in your head.

The one-sentence version: a strong password is a long, truly random one, because entropy — not the number of symbols — is what an attacker has to defeat. Generate one properly in the password generator, then stop trying to be clever. The math already is.