Password Strength Explained: Entropy, Length, and Why Symbols Matter Less Than You Think

"P@ssw0rd!" looks strong to a human and takes a modern cracking rig well under a second to break. Meanwhile "correct-horse-battery-staple" — four ordinary words — could outlast the heat death of your patience waiting for it to crack. Password strength has almost nothing to do with how weird a password looks, and everything to do with a single number: entropy.

What entropy actually measures

Entropy, measured in bits, counts how many guesses an attacker needs on average. The formula is simple: entropy = length × log₂(character pool size). Each character drawn from lowercase letters (26 possibilities) adds log₂(26) ≈ 4.7 bits. Using all 94 printable characters adds log₂(94) ≈ 6.6 bits per character. Double the length, double the entropy. Double the entropy, and the attacker's work doesn't double — it squares.

• 8 chars, all 94 symbols: 8 × 6.6 ≈ 52 bits — crackable by a determined attacker with good hardware
• 12 chars, all 94 symbols: ≈ 79 bits — safe against anything short of nation states
• 16 chars, all 94 symbols: ≈ 105 bits — effectively uncrackable by brute force, forever
• 8 chars, lowercase only: ≈ 38 bits — broken in hours
• "P@ssw0rd!": ~0 effective bits — it's in every dictionary attackers use

Why "weird" passwords are weak

The entropy formula assumes random characters. Human-chosen passwords are anything but random: we capitalize the first letter, put the number and symbol at the end, and swap a→@ and o→0 exactly like everyone else. Attackers know all these patterns. Their cracking tools try billions of dictionary mutations — "Summer2026!", "Qwerty123" — before touching true brute force. Any password a human invented by hand has drastically less entropy than the formula suggests. Random generation isn't optional for real security; it's the whole point.

How many bits do you actually need?

For an online account protected by rate-limiting (a bank that locks after five wrong attempts), even 40–50 bits is plenty — attackers never get billions of tries. The dangerous scenario is an offline attack: a database of hashed passwords gets leaked, and attackers try trillions of guesses locally. There, 80+ bits is the comfortable target. That's a random 12–13 character password using the full character set, or a 16-character one if you want margin for the future.

Passphrases: entropy you can remember

There's one place you can't paste from a password manager: the master password of the manager itself. That's where passphrases shine. Five random words from a 7,776-word list (the Diceware list) give 5 × log₂(7776) ≈ 65 bits; six words give ≈ 78 bits. "glacier-marble-trumpet-window-spoon" is dramatically stronger than most human passwords and far easier to type and remember than "X#9k$2vQ!mZ".

Generating passwords properly

Randomness quality matters. Weak generators that use Math.random() are predictable in principle; proper password generators use the operating system's cryptographic randomness source. Our Password Generator uses crypto.getRandomValues() — the same CSPRNG your browser trusts for TLS — generates everything locally on your device, and shows a live strength meter as you adjust length and character sets.

• 16+ characters with mixed sets for anything tied to money or identity
• A unique password per site — reuse converts one breach into every breach
• A 5–6 word passphrase for your master password
• Two-factor authentication everywhere it's offered — it protects you even when a password leaks

The takeaway

Stop optimizing passwords for the pattern-matching part of your brain. Strength is entropy: long, random, unique. Let a generator make them, let a manager remember them, and spend your own memory on one good passphrase. That's the entire discipline — and it's easier than the clever-password gymnastics most people still do.