Password Strength & Entropy Checker
Calculate password entropy bits, brute-force GPU crack time estimates across 4 threat models, and detect dictionary vulnerabilities.
0 bits
0 chars
0 set
Estimated Crack Time Across Threat Scenarios
--
Standard protected web login forms with fail2ban.
--
Direct unrate-limited API endpoints.
--
Leaked database using MD5 / SHA-256 without salt.
--
Modern password hashing algorithms.
Technical Deep-Dive: Password Entropy and Crack-Time Math
📌 On this page
1. The entropy formula, explained
Entropy in bits is calculated as E = L × log2(N), where L is password length and N is the size of the character pool actually used (26 for lowercase, +26 for uppercase, +10 for digits, +33 for symbols in this tool's implementation). Each additional bit of entropy doubles the number of possible combinations an attacker must search through in the worst case — this is why entropy, not raw character count alone, is the standard measure of password strength: a 20-character password using only lowercase letters can have less entropy than a 12-character password mixing all four character classes.
2. Why length matters more than complexity
Because entropy scales linearly with length but only logarithmically with pool size, adding characters is a far more efficient way to increase entropy than adding complexity rules. Going from a 26-character pool (lowercase only) to a 95-character pool (all four classes) only multiplies entropy per character by about 2.14x (log2(95)/log2(26)), but doubling the length of a password doubles its entropy outright. This is the mathematical basis for the modern security guidance favoring long passphrases over short, complex, hard-to-remember passwords.
3. Four threat models, four very different outcomes
The same password can be "safe enough" against one attack and trivially broken against another, which is why this tool models four separate scenarios rather than a single crack time. A rate-limited login form (100 guesses/hour, typical of a form with fail2ban or similar brute-force protection) is a dramatically weaker threat than an unthrottled API endpoint (10/second) exposed by a misconfigured integration, and both are dwarfed by an offline attack against a leaked password database — where the attacker has unlimited local compute and only the hash algorithm's cost stands between them and your plaintext password.
4. Why bcrypt and Argon2 exist
Fast general-purpose hash functions like MD5 and SHA-256 were designed for speed and integrity-checking, not password storage — a modern GPU cluster can compute billions of them per second, making brute-force attacks against leaked hash databases extremely fast. Password-specific hashing functions like bcrypt and Argon2 are deliberately slow and memory-hard, with a tunable "cost factor" that can be increased over time as hardware improves, keeping the attacker's guess rate down to a few thousand per second even on specialized cracking hardware — a difference of six or more orders of magnitude that translates directly into years versus seconds of real-world crack time.
5. What entropy math cannot catch
Pure entropy calculation assumes uniform random character selection, but real human-chosen passwords are never truly random — they cluster around dictionary words, keyboard patterns (qwerty, 123456), predictable substitutions (@ for a, 0 for o), and personal information. This is why this tool layers a simple dictionary-pattern check on top of the entropy score: a password can score reasonably on pure math while still being one of the first hundred guesses in a real wordlist attack. True password strength assessment (as used by tools like zxcvbn) combines entropy with pattern-matching against known breach corpora, keyboard-walk detection, and substitution-aware dictionary matching — considerably more sophisticated than length/pool-size math alone.
6. Practical password policy for WordPress admins
For WordPress specifically: enforce a minimum length (14+ characters) rather than arbitrary complexity rules, enable two-factor authentication on all admin/editor accounts (a strong password alone cannot stop a credential-stuffing attack using passwords leaked from other breached sites), rate-limit or lock out repeated failed login attempts via a security plugin or server-level rule, and rename or disable the default /wp-login.php admin username enumeration surface. A password manager generating and storing unique, high-entropy passwords per site — like the "Generate Strong Password" button above — removes the human memorability constraint entirely and is the single most effective practical improvement most people can make.
Frequently Asked Questions
What is password entropy and how is it calculated?
Password entropy measures the unpredictable randomness of a password in bits. The formula is E = Length × log2(Pool Size). A password with 60+ bits of entropy is computationally infeasible to crack with brute-force attacks.
Is my password safe when typed into this tool?
Yes, 100%. This tool operates entirely in local client-side browser JavaScript. Your password never leaves your device and is never sent over any network or server connection.
Why are passphrases (e.g. 4 random words) more secure than complex short passwords?
A passphrase like "correct-horse-battery-staple" is 28 characters long and yields ~75 bits of entropy while remaining easy for humans to remember. Length contributes exponentially more resistance to brute-force cracking than character complexity.
What is the difference between fast hash (MD5/SHA) and slow hash (bcrypt/Argon2) crack times?
Fast legacy hashes (MD5, SHA-256) allow specialized GPU clusters to guess billions of passwords per second. Modern password hashing functions (bcrypt, Argon2id) include configurable computational cost factors that throttle cracking attempts down to a few thousand per second.
Are the crack-time estimates on this page exact, real-world numbers?
They are order-of-magnitude estimates built on stated, published assumptions (100 guesses/hour for a throttled login form, 10/second unthrottled, 10 billion/second for fast-hash offline GPU cracking, 10,000/second for bcrypt/Argon2) — not a live simulation against any specific attacker or hardware. Real-world numbers vary with actual GPU cluster size, hash algorithm and cost-factor configuration, and whether the attacker has any additional information (like a leaked partial password or personal details) that narrows the search space. Treat the figures as directionally accurate for understanding relative password strength, not as precise forecasts.
Why does this tool flag "password123" as weak even though it technically has decent length and character variety?
Pure entropy math (length × log2(pool size)) assumes every character position is chosen uniformly at random from the available pool — but real attackers do not brute-force randomly, they try dictionary words and common patterns first. "password123" scores reasonably on raw entropy math but gets flagged separately by the dictionary-pattern check (line matching common words like "password," "admin," "123456") because wordlist and rule-based attacks (which try dictionary words plus common substitutions like "p4ssw0rd") crack it almost instantly regardless of its theoretical entropy score.