Password Strength Analyzer: Shannon Entropy Versus Real Attackers

Entropy: how many guesses, not how it looks

A password's real strength is not how complicated it looks to a human but how large the search space an attacker has to try is. If a password is drawn uniformly at random from an alphabet of N possible characters and is L characters long, its Shannon entropy in bits is:

H = L * log2(N)

lowercase only (N=26), L=8   ->  H ≈ 37.6 bits
+ digits + symbols (N≈94)    ->  H ≈ 52.4 bits  (same length!)
4 random dictionary words    ->  H ≈ log2(7776^4) ≈ 51.7 bits  (diceware)

Entropy only measures the size of the space an attacker who knows your method must search — it says nothing about whether your particular password sits in an obvious corner of that space, which is exactly what real attacks exploit.

Two very different attackers

A brute-force attacker assumes nothing and tries every string in increasing length, or every string in the full alphabet — this is the only attack Shannon entropy directly bounds, and against it, entropy and crack time are directly related: doubling the alphabet or adding characters multiplies the search space geometrically. A dictionary/pattern attacker instead tries real passwords first: leaked password lists, common words, names, dates, and every popular character substitution (a to @, o to 0, s to $) applied to them. This attacker doesn't search the whole space — it searches the tiny, densely populated region humans actually use, and it usually wins first.

Guess rates: what 'fast' actually means

Crack time is entropy divided by log2(guess rate), and guess rate depends entirely on what the attacker is attacking. Online login forms with lockouts might allow a handful of guesses a second. Offline attacks against a stolen database of fast hashes (unsalted MD5 or SHA-1) can exceed tens of billions of guesses per second on consumer GPUs. Databases protected by a deliberately slow, memory-hard hash — bcrypt or Argon2 — push that down to hundreds or thousands of guesses per second per GPU, because the hash itself is engineered to cost real time and memory to compute, which is a fixed multiplier no password length can buy back on its own.

crack_time ≈ (2^H / 2) / guesses_per_second

online, rate-limited login       ~10 guesses/sec
offline, fast unsalted hash      ~10^10 guesses/sec (GPU cluster)
offline, bcrypt/Argon2           ~10^2-10^3 guesses/sec

Why 'P@ssw0rd!' is weaker than it looks

Character substitution feels like it multiplies the search space, but a dictionary attacker doesn't brute-force the alphabet — it takes the word 'password', applies the dozen or so substitutions everyone uses, and checks those variants near the very top of its guess list. The visual complexity is real against a naive brute-force attacker and almost worthless against the attacker who actually wins in practice. A long passphrase built from several unrelated random words beats a short, substituted word not because it looks more complex, but because it doesn't live inside any attacker's dictionary at all.

Frequently asked questions

Try it live

Everything above runs in your browser — open Password Strength Analyzer and change the parameters while it is running. Nothing is installed, nothing is uploaded, the whole model lives in one tab.