Work · 18+
Strong Passwords and Passphrases with Crack-Time Estimates
Generate a strong random password or passphrase. Choose length, character types, and word count. See entropy in bits and an estimated crack time — updated as you adjust options.
Cryptographically random
Security check
Enter any existing password to see how strong it is — then share the result.
This tool uses the Web Crypto API's getRandomValues — a cryptographically secure pseudorandom number generator (CSPRNG) seeded by the operating system's entropy pool. This is categorically different from Math.random(), which is designed for speed, not security, and produces predictable sequences if an attacker can observe its output.
For each character position, a random index is drawn from the selected pool and that character is appended. No patterns, no weighting, no shuffling bias.
The larger the allowed character pool, the more possibilities exist per position:
| Character set | Pool size | 12-char combinations |
|---|---|---|
| Lowercase only (a–z) | 26 | 9.5 × 10¹⁶ |
| + Uppercase (A–Z) | 52 | 3.9 × 10²⁰ |
| + Numbers (0–9) | 62 | 3.2 × 10²¹ |
| + Symbols | 94 | 4.8 × 10²³ |
Adding symbols multiplies combinations by ~150× compared to alphanumeric. But increasing length from 12 to 16 characters multiplies combinations by 94⁴ — roughly 78 million times more. Length has more impact than character variety.
Entropy, in bits, expresses how many guesses a brute-force attack requires:
entropy = length × log₂(pool size)
A 16-character password from a 94-character pool: 16 × log₂(94) ≈ 104.9 bits. Each additional bit doubles the required guesses. Rules-based passwords ("must include 1 uppercase, 1 number, 1 symbol") have lower effective entropy — the pattern is predictable and modeled in modern cracking tools. A fully random password at the same length is strictly stronger.
Crack time divides total combinations by an assumed attacker speed, then halves for average case:
crack time = (pool_size^length ÷ 2) ÷ guesses_per_second
This tool uses 100 billion guesses per second — a realistic offline rate against a fast hash (MD5, NTLM) on modern consumer GPUs. Against bcrypt or Argon2, the same password takes millions of times longer. Against an online system with rate limiting, even short passwords are practically uncrackable by brute force. The estimates are worst-case for offline fast-hash attacks.
Passphrases — sequences of random words — trade character-level density for length and memorability. The xkcd #936 comic (2011) popularized the insight: "correct horse battery staple" (4 random words) is both easier to remember and harder to brute-force than "Tr0ub4dor&3."
The critical requirement: words must be randomly selected, not chosen by the user. Human word choices follow patterns attackers exploit. Passphrases work best for credentials you type regularly — device logins, password manager master passwords.
Too short. An 8-character password with all character types has ~52 bits of entropy — crackable in hours against a fast hash in an offline attack.
Predictable substitutions. "P@ssw0rd!" follows substitution patterns explicitly modeled in cracking dictionaries. These offer almost no real strength beyond the base word.
Reuse. A strong unique password becomes worthless once it appears in a breach database. Each account needs its own credential.
Complexity over length. NIST 800-63B (updated 2024) dropped most composition rules in favor of minimum length and checking against known compromised passwords.
FAQ
Short answers for readers and answer engines.
Generation uses your device's CSPRNG. The password is never sent anywhere — it exists only in your device's memory until you copy it or close the tab.
16+ characters for general accounts using all character types. 20+ characters or a 6-word passphrase for high-value accounts. 12 characters minimum for anything.
Characters like 0 (zero), O (capital O), 1 (one), l (lowercase L), and I (capital I) are visually identical in many fonts. Excluding them prevents transcription errors when typing by hand.
Random character passwords maximize entropy per character — best for short lengths. Passphrases are longer but more memorable — better for things you type regularly without a password manager.
Each character position multiplies combinations by the pool size. Adding symbols grows the pool from 62 to 94 — a 1.5× multiplier per position. Adding one character multiplies by the full pool size — always a larger increase.
Browse