Password Entropy in Bits: What the Number Actually Means

Every password strength meter you have ever seen wants to give you a colored bar: red, yellow, green. That bar hides the one number that actually predicts how a password holds up under attack. That number is entropy, measured in bits, and once you can read it you stop guessing about strength and start calculating it.

Entropy answers a single question: how many guesses would an attacker need, on average, to find this password by brute force? More bits means exponentially more guesses. The whole point of this article is to make that number concrete, show you the formula, and explain why a longer password almost always beats a more complicated one.

The formula, in one line

Here is the entire calculation:

entropy bits = length × log2(charset size)

Two inputs decide everything. Length is how many characters you typed. Charset size is the size of the pool those characters could have come from. The common pools are:

• lowercase letters: 26
• uppercase letters: 26
• digits: 10
• common ASCII symbols: about 33

You add up the pools your password draws from. A password with lowercase and digits draws from 26 + 10 = 36 possible characters. A password using all four classes draws from roughly 95. Then you multiply the length by log2 of that pool size.

The log2 part is where bits come from. log2(95) is about 6.57, which means each character from a 95-symbol pool contributes 6.57 bits. A digits-only PIN, by contrast, contributes only log2(10) ≈ 3.32 bits per character, which is why a six-digit PIN is so weak.

A worked example

Take a 12-character password drawn from the full 95-character printable ASCII set, every character chosen at random:

entropy = 12 × log2(95)
        = 12 × 6.5699
        ≈ 78.8 bits

So a random 12-character password over the full pool carries roughly 79 bits of entropy. That number alone tells an attacker the size of the problem they face: about 2^79 possible combinations, which is somewhere near 600 sextillion. You can reproduce this and try your own candidates in the password entropy calculator, which also prints the raw combination count and a crack-time estimate for four different attacker speeds.

What the bit thresholds mean

Bits map cleanly onto resistance, because each extra bit doubles the work. Here is a working scale you can keep in your head:

• under 28 bits — very weak; falls instantly to any offline attack
• 28 to 35 bits — weak; survives a throttled login, nothing more
• 36 to 59 bits — medium; resists casual cracking but not a serious offline rig
• 60 to 79 bits — strong against most offline attacks
• 80 bits and above — strong; the right target for anything that matters
• 128 bits — effectively unbreakable, matching strong cryptographic keys

The reason a small jump in bits matters so much is the doubling. Going from 50 to 60 bits does not add 20 percent of effort, it multiplies the attacker's work by 2^10 = 1024. Going from 60 to 80 bits multiplies it by over a million. This is why "add 80-plus bits" is a sane rule for important credentials and "but my password has a symbol in it" usually is not.

Crack time follows directly. An attacker is expected to find the password after searching half the keyspace, so the math is 2^bits / 2 guesses divided by guesses per second. At a fast GPU rate of 10^12 guesses per second, a 79-bit password takes on the order of 10^10 years. At the same speed, a 40-bit password is gone in under a second.

Why length beats complexity

Look at the formula again. Length is a plain multiplier, and charset size only enters through a logarithm. That asymmetry is the whole argument.

Suppose you have an 8-character password using all four classes: 8 × 6.57 ≈ 52.6 bits. Now suppose you instead use a 20-character password of nothing but lowercase letters: 20 × log2(26) = 20 × 4.70 ≈ 94 bits. The longer, simpler password carries almost twice the entropy of the shorter, complicated one. Adding one symbol to an 8-character password barely nudges the bits. Adding four more random characters can add over 25 bits.

This is the case for passphrases. A string of random words is long, easy to remember, and racks up entropy through sheer length. If you want to build one, a tool like the diceware passphrase generator selects words at random so the entropy is real rather than an illusion.

When I first ran the numbers myself

I used to be the person who stuffed an 8-character password with symbols and felt clever. The first time I actually computed entropy on a few of my real passwords, the result was deflating: my "complex" P@ss9!x clocked in around 46 bits, while a four-word phrase I almost dismissed as too simple came out near 70. I had spent years optimizing the wrong variable. Watching the bits readout climb as I added characters, and barely move as I added symbols, did more to change my habits than any security lecture ever had. The number does not flatter you, and that is exactly why it is useful.

The honest limit of the math

The formula assumes every character is chosen at random from the pool. Real passwords almost never are. If your 12-character password is a dictionary word plus a year, the formula happily reports a high bit count, but an attacker running a rule-based wordlist cracks it in seconds. Treat the entropy figure as an upper bound for a truly random string, not a promise about the specific password you picked.

That gap is why two other checks matter alongside entropy. A password strength checker catches the dictionary words and common patterns the raw formula ignores, and a password leak checker tells you whether a password has already shown up in a breach corpus, which makes its theoretical entropy irrelevant. High bits, no patterns, never breached: that is the combination worth trusting.

Read the bits, aim for 80 or more on anything important, and reach for length before you reach for symbols. The math is simple, and now it is yours.

---

Made by Toolora · Updated 2026-06-13