Password Strength, Explained

After reading this you will be able to estimate how many guesses a password can survive, tell entropy from a guessable pattern, and read the crack-time numbers this tool reports without fooling yourself.

What password strength actually measures

Strength is the number of guesses an attacker must make before finding your password. Nothing more. It is not about how "complex" the password looks to you. A password that looks messy can still be weak if it follows a rule an attacker already knows.

Consider P@ssw0rd. It has 8 characters, an uppercase letter, a symbol and a digit, so many websites accept it as "strong". An attacker who tries the word password with common substitutions (a to @, o to 0) reaches it in fewer than a few thousand guesses. Meanwhile correct horse battery staple, four random common words, survives billions of billions of guesses. The messy-looking one is far weaker.

The single quantity that captures survival is entropy, measured in bits. Each added bit doubles the number of guesses required. This tool estimates that number and then converts it into a time at realistic attacker speeds.

When to use this checker, and when not to

Use it to compare styles of password before you commit to one. Type a throwaway example that has the same shape as your candidate: same length, same mix, same use of a dictionary word. Watch how the entropy and crack time change as you lengthen it or drop the predictable parts.

Do not type a real password you rely on into any checker, including this one. Even though the analysis runs locally and nothing is sent anywhere, building the habit of pasting live secrets into web forms is the risk you want to avoid. Compare styles, not your actual credentials.

Do not use it to "certify" a password you invented yourself. Human-chosen passwords carry patterns the estimator cannot always see. The safe path is to let a generator make random bits for you, then let this tool confirm the count.

The entropy formula and why bits double

For a password drawn at random from an alphabet, entropy is the base-2 logarithm of the number of possible passwords.

H = L \cdot \log_2(N)

Here H is entropy in bits, L is the length in characters, and N is the size of the alphabet each character is drawn from. A lowercase-only password uses N = 26. Adding uppercase makes it 52, adding digits makes it 62, adding common symbols pushes it near 95.

The logarithm matters. \log_2(26) \approx 4.70, so each random lowercase character adds about 4.7 bits. An 8-character random lowercase password holds 8 \times 4.70 = 37.6 bits. That is 2^{37.6} \approx 2.1 \times 10^{11} possibilities, roughly 210 billion.

Because the exponent grows, one extra character multiplies the work. Going from 8 to 9 lowercase characters adds 4.7 bits, which multiplies the guess count by 2^{4.70} = 26. Length beats variety: adding characters raises L, while adding a symbol type only nudges N.

Entropy is length times log2 of the alphabet size. A 12-character password from a 26-letter alphabet has 12 * 4.70 = 56.4 bits. Switching to a 95-symbol alphabet raises the per-character value to log2(95) = 6.57 bits, giving 78.8 bits for the same length. Adding four more characters at 26 letters gives 16 * 4.70 = 75.2 bits, close to the same result, showing that length and alphabet trade off.

From bits to crack time

To turn bits into time, pick a guessing speed. Offline attacks against a stolen hash can be fast. A modern GPU rig can try on the order of 10^{10} guesses per second against a weak hash. Slow hashes like bcrypt cut that to thousands per second, but assume the fast case to stay safe.

t = \frac{2^H}{2 \cdot R}

Here t is the expected time to find the password, 2^H is the search space, and R is guesses per second. The division by 2 reflects that the average hit comes halfway through the space, not at the end.

At R = 10^{10}, a 37.6-bit password falls in 2.1 \times 10^{11} / (2 \times 10^{10}) \approx 10.5 seconds. A 60-bit password takes 2^{60}/(2 \times 10^{10}) \approx 5.8 \times 10^7 seconds, about 1.8 years. An 80-bit password takes roughly 1.9 million years at the same speed.

A worked example with the demo password

Analyzing P@ssw0rd

The demo loads P@ssw0rd. Read it two ways.

  1. Naive character count: 8 characters, using uppercase, lowercase, a digit and a symbol, so N \approx 72. That gives H = 8 \times \log_2(72) = 8 \times 6.17 = 49.4 bits, which would take about 2 weeks to crack at 10^{10} guesses per second.
  2. Pattern-aware count: the checker recognizes the dictionary word password and the standard leet substitutions. The real search is "common word plus known substitution rules". A cracking list covers that in well under 10^5 attempts.
  3. At 10^{10} guesses per second, 10^5 guesses finish in 10 microseconds. Effective entropy is about \log_2(10^5) \approx 17 bits, not 49.

The gap between 49 and 17 bits is the whole lesson. The naive formula assumes each character is independent and random. This password is neither.

The naive count claims 49 bits. Once the dictionary word and substitutions are recognized, only about 17 bits remain.

Reading and interpreting the results

The tool reports four things: an entropy estimate in bits, the character variety it detected, any patterns it matched, and a crack time. Read the entropy first, then check whether the warnings undercut it.

Rough entropy tiers at 10^10 guesses per second
BitsGuesses (2^H)Crack timeVerdict
282.7 x 10^80.01 sTrivial
401.1 x 10^1255 sWeak
601.2 x 10^181.8 yrFair
801.2 x 10^241.9 M yrStrong
1001.3 x 10^302 x 10^12 yrOverkill

Aim for at least 70 bits for anything that matters, and above 80 bits for accounts you cannot afford to lose. If the tool flags a keyboard walk (qwerty), a repeat (aaaa), a year (1998) or a sequence (12345), treat the reported entropy as an upper bound the attacker will not have to reach.

A crack time of "centuries" against a fast offline attack is the number you want. Times measured in seconds, hours or days mean the password is already inside the reach of a single machine.

Common mistakes that inflate a score

These habits produce a high naive number and a low real one.

Leet substitution
Replacing a with @ or e with 3 adds almost nothing. Attackers apply these rules automatically. P@ssw0rd is not measurably stronger than password.
Appending a digit or year
Adding 2024 or ! to a word adds under 14 bits, and often far less, because the year and the trailing bang are the two most common additions.
Capitalizing the first letter
Almost everyone capitalizes position one. That habit removes most of the bit the uppercase set seems to add.
Reusing a base word
Once one site leaks Fluffy2019, variants like Fluffy2020 are the first guesses everywhere else.

The reliable fix is randomness you did not choose. Random selection is the only source that makes the naive entropy formula honest, because then every character really is independent.

Related tools

To get a password whose measured entropy matches its length, use the Password generator, which shows the bits directly as it builds a random string. If you prefer something you can type and remember, the Passphrase generator draws random words from the EFF diceware list, where five words give about 64 bits and six give about 77.

Frequently asked questions

How many bits of entropy is enough?

Aim for 70 or more for ordinary accounts and 80 or more for critical ones. At 10^{10} guesses per second, 70 bits survives about 1900 years and 80 bits about 1.9 million years.

Does adding symbols make a password strong?

Only if the whole password is random. Adding one symbol to a dictionary word raises the alphabet size on paper but leaves the guessable structure intact. Adding random characters, of any type, is what helps.

Why does the tool sometimes report a lower entropy than my own count?

Because it detected a pattern: a word, a date, a keyboard walk or a repeat. It then estimates the smaller space an attacker would actually search, which is the honest number.

Is a long passphrase really safer than a short complex password?

Usually yes. Four random common words hold roughly 51 bits and six hold about 77 bits, while a random 10-character mixed password holds about 60 bits. Length from random words is easy to remember and hard to guess.

Can an attacker really try billions of guesses per second?

Against a stolen database that used a fast or unsalted hash, yes. Well-designed slow hashes cut the rate to thousands per second, but you cannot control which hash a given site chose, so plan for the fast case.