ToolSite

Password Entropy Explained: How Strong Is Strong?

Understand password entropy in bits: what it measures, how many bits you need, and how to check strength with our free password generator and hash calculator.

By ToolSite5 min readguides

What Entropy Measures

Entropy measures unpredictability. In password terms, it answers: how many guesses would an attacker need, on average, to find this password by brute force?

The formula:

entropy (bits) = log2(character_set_size ^ length)
               = length × log2(character_set_size)

Every additional bit of entropy doubles the number of possible passwords and doubles the time required to crack it. A password with 40 bits of entropy is 2^40 (roughly 1 trillion) times harder to crack than one with 0 bits.

Entropy is a worst-case metric. It assumes the attacker knows exactly how you generated the password: the character set, the length, and the method. A password that feels random to you (P@ssw0rd) has very low entropy because the attacker's dictionary of common substitutions includes it.

How Many Bits Do You Actually Need?

| Entropy (bits) | Cracking Difficulty | Recommendation | |---|---|---| | 0-28 | Very weak | Cracked in under 1 second | | 29-35 | Weak | Cracked in minutes to hours | | 36-59 | Reasonable | Cracked in months (with offline attack) | | 60-80 | Strong | Infeasible with current hardware | | 80+ | Very strong | Beyond foreseeable brute-force |

A password like Tr0ub4dor&3 has roughly 28 bits of entropy despite looking complex. A passphrase like correct-horse-battery-staple has roughly 119 bits. The length, not the symbols, provides the security.

This is the core insight from the famous xkcd comic "Password Strength": four random common words beat one short complex password every time.

Character Set Size Is a Multiplier

Adding a number to your password set increases possible characters from 52 (upper + lower) to 62. That's a multiplier of log2(62/52) which is about 0.25 bits per character. Adding a symbol increases it further to 95 characters, adding another roughly 0.6 bits per character.

Adding an extra character to your password adds log2(set_size) bits. That's about 4.7 bits for lowercase only, 6.6 bits for full mixed. The extra character always wins over the wider character set.

This is why NIST SP 800-63B (the U.S. government's digital identity guidelines) dropped the requirement for character composition rules (one uppercase, one number, one symbol). A 16-character all-lowercase password has more entropy than an 8-character password with all character sets, and the all-lowercase password is easier to remember and type.

Examples

An 8-character password using uppercase, lowercase, digits, and symbols:

8 × log2(95) ≈ 8 × 6.57 ≈ 52.5 bits

A 12-character password using only lowercase letters:

12 × log2(26) ≈ 12 × 4.70 ≈ 56.4 bits

The all-lowercase password with 12 characters is stronger than the complex 8-character password. This is why NIST stopped recommending forced character composition rules.

A 20-character all-lowercase password:

20 × log2(26) ≈ 20 × 4.70 ≈ 94 bits

That's in the "very strong" range. And it could be a sentence like theoldbrowndogranfast, which is far easier to remember than xK9#mP2$vL7. The entropy math doesn't care about memorability. The user does.

How Attackers Crack Passwords

Modern cracking tools don't try aaaaaaa, aaaaaab, aaaaaac. They use:

  1. Dictionary attacks: common passwords, leaked password lists, and word combinations drawn from real breaches. The RockYou list has millions of real passwords. If your password is on it, entropy doesn't matter.
  2. Rule-based mutations: password becomes P@ssw0rd (common substitutions). Tools like Hashcat apply thousands of mutation rules: capitalize the first letter, append 1 or !, replace a with @, etc.
  3. Brute force: only after the above methods fail. This is where entropy math applies directly. The attacker tries every possible combination within the character set and length range.

A password that looks random but is short may survive a dictionary attack but fall to brute force quickly. A long passphrase made of common words survives both. The dictionary of four-word combinations from a 7,776-word list is 7,776^4 (roughly 3.66 × 10^15), which is about 51 bits per word for four words. That's roughly 204 bits, well beyond brute-force range.

Entropy vs Password Managers

A password manager generates truly random strings at the character level: xK9#mP2$vL7qW5%nR3&. The entropy is purely length × log2(charset_size), with no dictionary shortcuts.

For a 20-character password from a 95-character set:

20 × log2(95) ≈ 20 × 6.57 ≈ 131 bits

This is why the standard advice is: use a password manager for every account. Generate 20+ character random passwords. Memorize one strong master password for the manager itself.

Generate and Measure

Use the Password Generator to produce passwords with controlled length and character sets. The generator lets you mix uppercase, lowercase, digits, and symbols, and excludes ambiguous characters (0/O, 1/l/I).

To verify a password's entropy after generation:

  1. Count the characters in the set you actually used (was it 26? 62? 95?).
  2. Multiply by log2(set_size).
  3. Compare against the table above.

Keep in mind: this formula gives the entropy of a truly random password from that character set. If you chose the password yourself (not a generator), the real entropy is lower because humans are bad at randomness. The only way to get the entropy the formula promises is to use a random generator.

Try it yourself: open the Password Generator. Generate a 16-character password with all character sets enabled. Then generate an 8-character password with the same settings. The 16-character password has roughly 105 bits of entropy. The 8-character password has about 52 bits. The security difference is a factor of 2^53, which is about 9 quadrillion.

Related Reading