Password Hash Crack Time Estimator

Estimate how long a brute-force attacker would need to guess a password, based on its character-set entropy and how fast you assume the attacker can try guesses. Everything runs in your browser — the password you type is never sent anywhere or logged.

How to use it

1. Type or paste the password into Password to test. It's masked like a normal password field.
2. Pick an attacker scenario:
   • Online, rate-limited (~10 guesses/sec) — a login form that locks out or throttles after failed attempts.
   • Online, no rate limit (~1,000 guesses/sec) — a login form with no meaningful throttling.
   • Offline, slow hash (~10,000 guesses/sec) — the password database leaked, but was hashed with a deliberately slow algorithm like bcrypt, scrypt, or Argon2.
   • Offline, fast hash (~10 billion guesses/sec) — the database leaked and was hashed with a fast, unsalted algorithm like MD5 or SHA-1, cracked on GPU hardware.
3. Read the result: the detected character set, the entropy in bits, and the estimated average crack time.

The estimate updates automatically as you type.

How the estimate is calculated

Character set. The tool looks at which kinds of characters the password actually contains — lowercase letters (26 possibilities), uppercase letters (26), digits (10), and common symbols (32) — and adds up the sizes of the classes it finds. Lowercase only gives a 26-character set; add a digit and a symbol and it jumps to 68.

Entropy. Entropy in bits is password length × log2(character-set size) — the "search-space entropy," or how many yes/no questions it takes, on average, to pin down the password by brute force. It assumes the password is drawn evenly from that character set with no exploitable pattern; a dictionary word plus a digit has far less real-world entropy than this formula credits it with, because a smart attacker tries dictionary words first.

Crack time. Given the entropy and an assumed guess rate, the average time to crack is half the total keyspace divided by that rate — an attacker is expected to find the answer after searching half of all possibilities, not all of them. Results beyond roughly the age of the universe are reported as "longer than the age of the universe" rather than an unreadable string of digits or scientific notation.

Guesses-per-second isn't one fixed number — it depends on the exact hash or key-derivation function, the attacker's hardware, and any defenses (rate limiting, lockouts, MFA) in front of the login. The four scenarios use commonly-cited, round figures meant to bracket realistic cases, not measure a specific setup. Treat the result as an order-of-magnitude check, not a guarantee.

Why does the same password show different crack times?

Crack time depends entirely on the assumed attacker speed. A password that survives centuries against a rate-limited login form could fall in seconds against an offline attacker running a fast hash on GPU hardware — which is exactly why slow, salted hashing algorithms (bcrypt, scrypt, Argon2) exist: they close that gap by making every guess expensive, even offline.

Does this account for dictionary attacks or leaked-password lists?

No. This measures pure brute-force search-space entropy, not real-world guessability. A password can score high entropy here and still be one of the first things an attacker with a leaked-password list or dictionary tries. Avoid dictionary words, names, and predictable substitutions (p@ssw0rd) regardless of what the entropy number says.

Is my password sent anywhere?

No. Calculations happen locally in your browser (or, via the API, inside a single stateless request) — the password is never logged, stored, or transmitted elsewhere.