Password Strength Checker

What “strength” means here

A password is strong if an attacker who has your hashed password cannot guess it in a useful amount of time. Nobody can measure that directly, so the standard proxy is entropy: the base-2 logarithm of how many guesses an attacker needs. Doubling the number of possible passwords adds exactly one bit. Forty bits is weak, sixty is reasonable for a service that rate limits, and eighty is comfortable even if the hash leaks.

Entropy from length alone assumes every character is chosen independently at random, which is almost never true for a password a human made up. So this tool does two estimates and takes the pessimistic one: one from the character pool, and one that walks the string looking for dictionary words, keyboard runs, sequences, repeats and dates. Pattern-based passwords collapse to a handful of bits no matter how long they look.

The four guesses-per-second rates

• Online, throttled (10/s) — a login form with rate limiting and lockouts. This is the number that applies to most real attacks against a well-built service.
• Online, unthrottled (1,000/s) — an API or a form with no rate limiting. Common in practice, and the reason throttling matters more than password policy.
• Offline, slow hash (10,000/s) — bcrypt, scrypt or Argon2id with sensible parameters. This is what a correctly built password store is supposed to give you.
• Offline, fast hash (100,000,000,000/s) — MD5, SHA-1 or plain SHA-256 on a GPU rig. Tens of billions of candidates per second is routine. If a password database using a fast hash leaks, only genuinely random passwords survive.

The gap between the first and last row is ten orders of magnitude. That is the entire argument for using a memory-hard KDF rather than a fast hash — it buys more than any password policy ever will.

Length beats complexity

Requiring an uppercase letter, a digit and a symbol to reach eight characters produces Passw0rd!. Requiring sixteen characters produces something a cracker cannot touch. The arithmetic is unforgiving: adding one character to a 12-character password with a 94-character pool multiplies the search space by 94, while switching the composition around usually adds a factor of two or three.

This is why NIST's guidance dropped forced composition and periodic rotation. Both push people toward predictable mutations — a capital first letter, a digit on the end, an exclamation mark — which are exactly the patterns a cracker's rule set applies first.

What actually helps

• A long passphrase of unrelated words. Four or five random words from a large list give 50–65 bits and are far easier to remember than eight random characters.
• A password manager. Then every password can be 20 random characters, unique per site, and you remember one thing.
• Multi-factor authentication. It does not raise entropy at all — but it makes a guessed password useless on its own, which matters more.
• Never reusing a password. One breach then compromises every account, regardless of strength.

FAQ