Password strength has a real unit of measurement: entropy, expressed in bits. Entropy measures how many equally likely possibilities an attacker must search, and each additional bit doubles that number. For a password of random characters, the formula is simple: entropy = length × log₂(alphabet size). Lowercase letters give log₂(26) ≈ 4.7 bits per character; the full keyboard of ~95 printable characters gives log₂(95) ≈ 6.6. A truly random 12-character full-keyboard password is therefore about 79 bits — a number so large that guessing becomes physically impractical.
The catch: entropy assumes random
The formula only holds for passwords chosen uniformly at random. Human-chosen passwords are nothing like random — they're words, names, dates, and predictable substitutions, and cracking software tries exactly those patterns first. P@ssw0rd! looks like it uses a 95-character alphabet, but it's a dictionary word with the four most common substitutions and the most common suffix position, and it falls almost instantly. This is why NIST's Digital Identity Guidelines (SP 800-63B) moved away from composition rules ("must contain an uppercase, a number, a symbol") and toward length, screening against known-breached passwords, and encouraging passphrases: mandatory complexity produces predictable patterns, while length produces real entropy.
How long passwords actually survive
The worst case is an offline attack: an attacker has stolen a password database and can test guesses on their own hardware. Modern GPU rigs testing a fast-hashed database can plausibly try on the order of a trillion (10¹²) guesses per second. Average time to find a random password at that speed (half the keyspace):
| Password type | Entropy | Average crack time @ 10¹²/sec |
|---|---|---|
| 8 random letters + digits (62-char set) | ≈ 48 bits | ≈ 2 minutes |
| 5 random passphrase words (EFF list) | ≈ 65 bits | ≈ 5 months |
| 6 random passphrase words (EFF list) | ≈ 78 bits | ≈ 3,500 years |
| 16 random letters + digits (62-char set) | ≈ 95 bits | ≈ 750 million years |
Two things jump out. First, the cliff between 8 and 16 characters: doubling the length doesn't double the strength, it raises it by 47 bits — a factor of about 10¹⁴. Second, one extra passphrase word multiplies the work by ~7,776. (Online attacks against a website's login form are millions of times slower because sites rate-limit attempts — the table is the stolen-database scenario, which is the one your password's strength actually has to survive.)
Why word lists work: Diceware and the EFF list
A passphrase like gravel-pony-uneven-slang-crayon is easier to remember than kX9#mQ2v and dramatically stronger — provided the words are chosen at random. The EFF's Large Wordlist contains 7,776 words (chosen so five dice rolls can pick one), so each word contributes log₂(7776) ≈ 12.9 bits even though the attacker has the entire list. That's the counterintuitive core of the method: the security lives in the random selection, not in the secrecy of the words. Picking words yourself defeats it — human word choices are as predictable as human passwords.
What to actually do
Use a password manager and let it generate long random passwords — 16+ characters — for every account, so no two sites share a password and a breach at one can't cascade. For the handful of secrets you must remember (the manager's master password, your computer login), use a randomly generated passphrase of five or six words. And turn on multi-factor authentication where offered: it protects you even on the day a password does leak.
The Password Generator builds both kinds — random character passwords and EFF-wordlist passphrases — using your browser's cryptographic random number generator, shows the entropy math for each, and never sends anything over the network.
Sources and further reading
- NIST SP 800-63B — Authentication and Authenticator Management
- Electronic Frontier Foundation — Dice-generated passphrases
Reviewed September 2026.