The Science of Strong Passwords: Entropy Explained

By PasswordForge · August 10, 2026 · 7 min read

When a website tells you your password is "strong," what does that actually mean? The honest answer is a single number: entropy, measured in bits. Entropy quantifies how unpredictable your password is to an attacker who knows nothing about it except the rules used to generate it. More entropy means more possible passwords the attacker must try, which means more time to crack.

This article explains how entropy is calculated, how character sets and length contribute to it, and why the password you think is clever is almost always weaker than a randomly generated one.

What Is Password Entropy?

Password entropy is a measure of unpredictability. It is expressed in bits because it answers a binary question: how many guesses, on average, does an attacker need to find your password? Each additional bit of entropy doubles the search space. A password with 40 bits of entropy has roughly one trillion (2^40) possible values; a password with 50 bits has about one quadrillion (2^50).

Entropy only holds when the password is selected uniformly at random from the full character space. A password chosen by a human — even one that looks complex — usually has far less entropy than its character set and length would suggest, because humans are predictable. This is why password strength meters that count character types are misleading: they measure what the password looks like, not how it was chosen.

The Entropy Formula

The entropy of a randomly generated password is calculated with a simple logarithmic formula:

entropy = log2(charset_size ^ length) = length × log2(charset_size)

Here, charset_size is the number of distinct characters the password could draw from, and length is the number of characters in the password. The result is in bits. The formula shows two things immediately: entropy scales linearly with length but only logarithmically with charset size. Doubling the character set adds just one bit per character; doubling the length doubles the total entropy.

Character Set Size Impact

The size of the character pool has a real but bounded effect on entropy. The three pools most generators use:

• Lowercase letters only (a–z): 26 characters → log2(26) ≈ 4.7 bits per character.
• Mixed case (a–z, A–Z): 52 characters → log2(52) ≈ 5.7 bits per character.
• All printable ASCII (letters, digits, symbols): 95 characters → log2(95) ≈ 6.6 bits per character.

So adding uppercase to a lowercase-only password buys roughly one extra bit per character, and adding digits and symbols buys about another bit on top of that. These gains add up, but they are modest compared to what length can achieve.

Length vs Complexity: Why Length Matters More

Because entropy scales linearly with length but only logarithmically with charset size, length dominates. An 8-character password using all 95 printable ASCII characters has about 52.7 bits of entropy. A 16-character password using only lowercase letters has about 75.2 bits. The longer lowercase password is more than 65,000 times harder to brute force, despite looking "simpler."

This is why modern guidance from NIST SP 800-63B and similar standards emphasizes length over complexity. A long password of random words can exceed the entropy of a short password full of symbols — and it is easier to remember. For a deeper comparison, see our article on passphrases versus passwords.

Entropy Benchmarks

Entropy translates directly into brute force time. The benchmarks below assume an attacker trying one billion guesses per second — a conservative estimate for a single GPU rig in 2026. Specialized hardware and distributed attacks can be orders of magnitude faster.

• 40 bits (weak): ~15 minutes to crack. Equivalent to an 8-character lowercase password.
• 60 bits (moderate): ~35 years to crack. Equivalent to a 10-character mixed-ASCII password.
• 80+ bits (strong): ~38 million years at 1 billion guesses/second. Equivalent to a 12-character full-ASCII password or a four-word passphrase.
• 128 bits (very strong): Effectively uncrackable by brute force with any current or foreseeable classical hardware.

Password strength analysis from grahammiranda.com demonstrates that an 8-character password using only lowercase letters offers just 37.6 bits of entropy — crackable in minutes on modern hardware. This is why any password shorter than 12 characters, or drawn from a limited character set, should be considered unsafe regardless of how "random" it looks.

Why "Pa$$w0rd" Is Weaker Than "correct-horse-battery-staple"

Consider two passwords that both look "complex" at a glance:

Pa$$w0rd uses mixed case, symbols, and a digit, suggesting a charset of 95. But it is a dictionary word with predictable leet substitutions (a→@, a→$, o→0). Attackers run dictionary attacks that try these substitutions automatically. Its effective entropy is closer to 10–15 bits, not the 52.7 bits its length and apparent charset would suggest.

correct-horse-battery-staple uses only lowercase letters and hyphens, a charset of 27, over 25 characters. Even if an attacker knows the words came from a 7,776-word list (the EFF short list), its entropy is about log2(7776^4) ≈ 51.7 bits. In practice it is far harder to crack than Pa$$w0rd because it was generated randomly from a large word list, not by a human applying predictable substitutions.

The lesson: a password's strength depends on how it was generated, not what it looks like. Random selection from a large pool — whether characters or words — is what creates real entropy.

Calculating Brute Force Time from Entropy

To estimate how long a brute force attack would take, divide the search space by the attacker's guess rate. The search space is 2^entropy, and the time is that divided by guesses per second:

time = 2^entropy / guesses_per_second

For a 60-bit password and a 1-billion-guesses-per-second attacker: 2^60 ≈ 1.15 × 10^18 guesses, divided by 10^9, gives about 1.15 × 10^9 seconds — roughly 36 years. Double the entropy to 70 bits and the time jumps to about 37,000 years. Each extra bit doubles the work.

For practical advice on defending against the full range of attacks — not just brute force but dictionary, credential stuffing, and phishing — see our guide on common password attacks and defenses.

Summary

Password entropy is the honest measure of strength. It is calculated as length × log2(charset_size), and it scales linearly with length but only logarithmically with character set size. This is why length matters more than sprinkling in symbols: an 8-character "complex" password has roughly 52 bits of entropy, while a 16-character lowercase password has over 75. Human-chosen passwords, even ones that look complex, typically have far less entropy than their length suggests because they rely on predictable patterns. Generate passwords randomly, favor length, and aim for at least 80 bits of entropy — the point at which brute force becomes infeasible for any current hardware.