How Strong Is My Password? Entropy, Crack Times and What Strength Meters Miss

Every sign-up form has a strength meter, and they rarely agree. One turns green for Summer2024!, another calls it weak, and a third wants a symbol you already typed. The disagreement is not random. Each meter is a small model of how an attacker guesses, and each model has blind spots.

This guide explains how password strength is estimated, with the entropy formula worked through on real passwords, what crack-time figures assume, which patterns a checker can detect and which it cannot, and what current guidance from NIST recommends instead of symbol rules. The examples use the Password Strength Checker, and every number below is what that tool reports for the password shown.

TL;DR: Password strength is the number of guesses an attacker needs, usually expressed as entropy in bits: length × log2(size of the character pool). Each extra bit doubles the work. The Password Strength Checker computes that figure, cuts it for common passwords, repeated patterns, sequences and keyboard runs, and rates the result from Very weak (under 28 bits) to Very strong (128 bits and up), with crack-time estimates at 10 billion guesses per second offline and 1,000 per second online. Entropy formulas cannot see dictionary words with substitutions, so P@ssw0rd1 still scores Fair. Length and randomness are what help. The check runs client-side, free, no signup, and the password is never uploaded.

What does password strength mean?

Password strength is a measure of how many guesses an attacker would need, on average, to find a password. It is not a measure of how complicated the password looks. A password is strong when it is unpredictable, and it is unpredictable when it was chosen from a very large set of equally likely options.

That is why strength is usually quoted in bits. A password with 40 bits of entropy is as hard to guess as picking one item out of 2^40, about 1.1 trillion, equally likely choices. Each additional bit doubles the search.

How is password entropy calculated?

The standard estimate multiplies the password's length by the number of bits each character contributes, which depends on how many possible characters it was drawn from:

entropy (bits) = length × log2(pool size)

The checker builds the pool from the character types present in the password:

Character type	Added to the pool	Bits per character if used alone
Lowercase a to z	26	4.70
Uppercase A to Z	26	4.70
Digits 0 to 9	10	3.32
ASCII symbols and space	33	5.04
Anything outside ASCII (accents, emoji)	100	6.64

A password using all four ASCII types has a pool of 26 + 26 + 10 + 33 = 95, and log2(95) = 6.57 bits per character.

Worked example: a random 16-character password

1. Pool: all four types, 95 characters.
2. Bits per character: log2(95) = 6.5699.
3. Entropy: 16 × 6.5699 = 105.1 bits.

The checker rates that Strong. A 20-character random password from the same pool gives 20 × 6.5699 = 131.4 bits, which crosses the 128-bit line into Very strong.

The formula is only honest when the password really was generated randomly from that pool. A human-chosen password uses a tiny, predictable slice of the space, and that is where pattern checks come in.

What score bands does the checker use?

After adjusting for patterns, the checker converts the entropy into one of five labels.

Adjusted entropy	Label	What it means in practice
Under 28 bits	Very weak	Found almost immediately by any attack
28 to under 36 bits	Weak	Fast offline; limited protection online
36 to under 60 bits	Fair	Survives online guessing; vulnerable offline to a fast hash
60 to under 128 bits	Strong	Out of reach for brute force at current speeds
128 bits and up	Very strong	Beyond any foreseeable brute force

Which patterns lower the score?

Raw entropy treats aaaaaaaaaaaa as a 12-character lowercase password worth 56 bits. Nobody would call it strong. The checker applies four adjustments before scoring:

1. Common passwords. The password, lowercased, is compared with a built-in list of 53 of the most leaked passwords, including 123456, password, qwerty, letmein and p@ssw0rd. A match caps entropy at 8 bits.
2. Whole-password repetition. If the entire password is one short unit repeated, such as abcabc or aaaaaa, entropy collapses to roughly the entropy of one unit plus a few bits.
3. Runs of the same character. Three or more identical characters in a row, such as zzz, multiply entropy by 0.75.
4. Sequences. Any three-character run from the alphabet, the digits, or the keyboard rows qwertyuiop, asdfghjkl and zxcvbnm, forwards or backwards, multiplies entropy by 0.75.

It also warns, without changing the number, when a password is shorter than 8 characters, uses only one type of character, or is digits only.

What does the checker say about real passwords?

Here is what the tool reports for a set of passwords people commonly use or are advised to use. Crack times use the checker's two attacker models.

Password	Length	Adjusted entropy	Rating	Offline crack time	Online crack time	Warnings raised
password	8	8.0 bits	Very weak	instantly	instantly	Common password; one character type
qwerty123	9	6.0 bits	Very weak	instantly	instantly	Common password; sequence
aaaaaaaaaaaa	12	8.3 bits	Very weak	instantly	instantly	Repeated pattern; one character type
4829	4	13.3 bits	Very weak	instantly	5 seconds	Too short; digits only; one type
P@ssw0rd1	9	59.1 bits	Fair	12 months	centuries	None
Summer2024!	11	72.3 bits	Strong	centuries	centuries	None
Tr0ub4dor&3	11	72.3 bits	Strong	centuries	centuries	None
correct horse battery staple	28	164.7 bits	Very strong	centuries	centuries	None

Some of these can be checked by hand. qwerty123 matches the common list, capping it at 8 bits, and contains both a keyboard run and a digit sequence, so 8 × 0.75 = 6.0. For 4829, the pool is 10 digits, so 4 × 3.32 = 13.3 bits. The average number of guesses is half the space: 2^13.3 / 2 = 5,000. At 1,000 guesses a second that is 5 seconds online.

P@ssw0rd1 is the interesting row. It uses all four character types, so 9 × 6.57 = 59.1 bits, and it is not on the common list because the list contains p@ssw0rd without the trailing digit. The checker has no way to know that it is the word "password" with the most predictable substitutions a cracking tool tries first.

What do the crack-time estimates assume?

The two figures model two very different attackers, and both start from the same number: the average guesses needed, which is half of 2 raised to the entropy.

Model	Guesses per second	Represents
Offline (fast)	10,000,000,000	A stolen database of fast, unsalted hashes attacked on GPU hardware
Online (throttled)	1,000	Guessing against a live login form

The offline figure is the pessimistic case, and it is the right one to plan for, because once a site's password database leaks the attacker is no longer rate-limited. How realistic 10 billion a second is depends entirely on how the site stored passwords. A deliberately slow hash such as bcrypt reduces an attacker's rate by many orders of magnitude, which the bcrypt generator guide explains in detail, while a fast hash like unsalted MD5 or SHA-1 allows rates in this range. The hash generator guide covers the difference between those algorithms.

Two limits of the display are worth knowing:

• At 60 bits or more, the checker stops computing and shows "centuries". By its own offline assumption, 60 bits would average 2^59 / 10^10 = about 58 million seconds, roughly 1.8 years, and the figure does not reach a century until about 66 bits. Treat "centuries" on a password in the low 60s as "years, not centuries".
• Estimates say nothing about breaches. A password that appeared in a leak is guessed from the leak list first, whatever its entropy.

Why is my long password still rated weak?

Because length only helps when the characters are unpredictable. The checker lowers the score for the patterns attackers try first: a repeated block, a run like 1111, a sequence like abcd or 9876, or a keyboard walk like asdfgh. abcabcabcabc is 12 characters long, but it is one three-letter unit repeated and contains an alphabet sequence, so the checker scores it 13.3 bits: less than a random 3-character password from the full 95-character pool, which is worth 19.7 bits.

The reverse also happens, and it matters more. Some passwords score well and are weak, because a character-pool formula cannot recognize:

• dictionary words, names and places with letters swapped for look-alike digits or symbols, such as Tr0ub4dor&3;
• a season or month plus a year plus one symbol, such as Summer2024!;
• personal information like a pet's name and birth year;
• passphrases built from a famous quote or a well-known example, including correct horse battery staple, which comes from xkcd comic 936 and now appears in cracking wordlists.

The honest entropy of a passphrase depends on how the words were chosen, not on its characters. Four words picked at random from a 2,048-word list give 4 × log2(2048) = 4 × 11 = 44 bits. Six such words give 66 bits. That is lower than the character formula reports, but it is real, and it is why passphrase generators pick words with a random process rather than letting people choose.

What does NIST recommend for passwords?

The US National Institute of Standards and Technology sets out password guidance in NIST Special Publication 800-63B, Digital Identity Guidelines. Its recommendations for services that check passwords run against several habits older strength meters encouraged:

• Do not impose composition rules such as "must contain a symbol and an uppercase letter". They push people toward predictable substitutions.
• Compare new passwords against lists of values known to be compromised, common or expected, and reject matches.
• Do not force periodic password changes without evidence of compromise.
• Allow long passwords, including spaces and all printable characters, so passphrases work.

The current revision, SP 800-63B-4, keeps those principles and raises the minimum length for passwords used as the only authentication factor.

The practical reading for a person choosing a password: length and randomness do the work, a password manager makes random passwords usable, and a breach check matters as much as a strength meter. Have I Been Pwned's Pwned Passwords service lets you check whether a password has appeared in a known breach using a k-anonymity range query, which sends only the first five characters of the password's SHA-1 hash rather than the password itself.

How to check a password's strength, step by step

1. Open the free password strength checker and type or paste the password into the field. Use the eye button to show or hide it.
2. Read the rating, the adjusted entropy in bits and the length.
3. Compare the two crack times, remembering that "centuries" starts at 60 bits.
4. Look at the composition counts for lowercase, uppercase, digits and symbols. Non-ASCII characters are counted with symbols in this row.
5. Read the warnings, which name specific problems such as a sequence or a common password.
6. Follow the suggestions and watch the figures update as you type. When a password scores Strong or better with no warnings, the suggestion changes to a reminder to use it in one place only and store it in a password manager.

One small quirk: the length counts UTF-16 code units, the way JavaScript measures strings, so most emoji count as two characters.

Is it safe to type a real password into a strength checker?

With this checker, the analysis happens entirely in your browser in plain JavaScript. The password is not sent over the network, logged or stored, and the page keeps working with the network disconnected. The tool records only that a check happened, not what was checked.

The general habit is still sound: do not type real passwords into sites you do not trust, because you cannot see what a page's code does with them. If you want to test the shape of a password without exposing the real one, test a password of the same structure instead: same length, same kinds of characters, same kind of words.

How do you make a password strong?

The approaches that raise real strength, in order of impact:

Approach	Example entropy	Notes
Random password from a manager, 20 characters, all types	131 bits	Unique per site; nothing to remember
Random passphrase, 6 words from a 7,776-word list	6 × 12.9 = 77.5 bits	Easy to type; good for a master password
Random password, 12 characters, all types	78.8 bits	Hard to memorize
Human-chosen word + substitutions + year	Far lower than its score	Appears in cracking rules

The 7,776-word list is the size of a standard diceware list, where five dice rolls choose each word, and log2(7776) = 12.9 bits per word.

To create random passwords, the password generator draws characters with the browser's Web Crypto random number source, and the password generator guide covers length and character set choices. The security tools hub lists related tools, including the bcrypt generator for developers storing passwords.

Alternatives to this strength checker

• zxcvbn, the open-source estimator published by Dropbox on GitHub, matches passwords against dictionaries, names, dates and common substitutions, and is better at catching P@ssw0rd-style passwords. It is a library for developers rather than a page.
• Password manager audits check saved passwords for reuse, weakness and known breaches across all your accounts at once.
• Breach checks such as Pwned Passwords answer a different question: not how guessable a password is in theory, but whether attackers already have it.

This checker's strengths are transparency and privacy: it shows the entropy, the attacker model and the exact warnings, and the password never leaves your device.