Why Most Password Strength Meters Are Misleading
Open any signup form and you'll see a colored bar that turns from red to green as you type — "weak," "medium," "strong." These meters are almost always based on arbitrary rules: does it have a number, does it have a capital letter, is it 8 characters long. None of that actually measures how hard a password is to guess. A password can satisfy every one of those rules and still be cracked in under a second, while a genuinely random string of lowercase letters can be effectively uncrackable. The real measure of password strength is entropy, and understanding it changes how you think about every password you create.
What Entropy Actually Means
Entropy, measured in bits, tells you how many possible passwords exist given the character set and length you used. The formula is simple: entropy = length × log2(pool size), where pool size is the number of distinct characters available (26 for lowercase, 52 for upper+lowercase, 62 with digits, and more once symbols are added). Every additional bit of entropy doubles the number of guesses an attacker needs to try before finding your password on average.
A critical detail most tools get wrong: entropy should be calculated from the character classes actually present in the password, not just the classes the generator was allowed to use. A 12-character password using only lowercase letters has a pool size of 26, not 94, even if the generator that made it also supported symbols. This matters because it's the honest, defensible number — and it's exactly what a real attacker's brute-force search space would be.
Turning Entropy Into Crack Time
Once you have entropy in bits, you can estimate how long a password would survive against different kinds of attacks by dividing the total keyspace (2^entropy) by an attacker's guess rate:
- Fast offline hash cracking (~10 billion guesses/sec): This is what's possible when an attacker has stolen a database of unsalted or weakly-hashed passwords and is running cracking rigs with modern GPUs. Anything under 50 bits of entropy falls in minutes to hours here.
- Slow offline hash (~10,000 guesses/sec): Passwords hashed properly with bcrypt, scrypt, or Argon2 are deliberately slow to compute, which shrinks the attacker's guess rate by six orders of magnitude. This is why proper password hashing matters as much as password strength itself.
- Online throttled attack (~100 guesses/sec): Most login forms rate-limit failed attempts, lock accounts after repeated failures, or require CAPTCHAs. Even a modestly weak password can survive years against this kind of attack simply because the attacker can't try fast enough.
Seeing all three numbers side by side is far more useful than a single "strong/weak" label — it shows you exactly which threat model your password actually protects against.
The Weaknesses a Length-Only Check Misses
Length and character variety aren't the whole story. Three specific weaknesses defeat passwords that otherwise look strong on paper:
- Common passwords and dictionary words. "P@ssw0rd1" has decent character variety and length, but it's a trivial variation on the single most common password in every leaked database. Attackers try dictionary-based and mutation-based guesses (swapping "a" for "@", "o" for "0") before ever falling back to true brute force.
- Keyboard-walk patterns. Sequences like "qwerty," "asdfgh," or "123456" look random to a naive character-class checker but are among the very first guesses in any real attack, because they're fast to type and endlessly reused.
- Repetition. Patterns like "aaaa" or "1212" reduce the effective entropy far below what the raw length suggests, because once an attacker recognizes the pattern, the search space collapses dramatically.
Why Cryptographic Randomness Matters for Generation
Not all "random" password generators are equal. Many use Math.random(), which is a fast, non-cryptographic pseudo-random number generator — fine for shuffling a UI animation, but not designed to resist prediction. Given enough outputs, its internal state can sometimes be reconstructed, which in theory could let an attacker predict future "random" passwords. Cryptographically secure generators use window.crypto.getRandomValues(), which draws from an operating-system-level entropy source specifically designed to be unpredictable. Any password generator worth using should rely on this API, not the general-purpose Math object.
Building a Personal Password Habit
The most practical strategy combines three things: use a password manager so you never reuse or invent passwords manually, generate every password with a cryptographically random tool set to at least 16 characters with all character classes enabled, and enable two-factor authentication everywhere it's offered so a single compromised password isn't enough on its own. Entropy and crack-time numbers are useful for understanding risk, but the habit of never reusing passwords is what actually stops most real-world account takeovers.