Most people know their passwords are bad. They've been told for years to use "strong passwords" — and yet the most common password in data breaches is still "123456", followed closely by "password" and "qwerty". The advice is clear. The behaviour hasn't changed. And the reason isn't laziness — it's that nobody explains what strong actually means, why the rules matter, or how to make security practical.
This guide breaks down the actual math, explains what the password generator's four tools do and when to use each, and cuts through the noise about password complexity versus length versus passphrases. By the end, you'll know exactly what makes a password hard to crack — and have a free tool to generate ones that are.
The Math of Password Security — Entropy
Password strength is measured in bits of entropy. The formula is simple:
Entropy = length × log₂(charset size)
Charset size is the number of possible characters at each position. Using only lowercase letters gives a charset of 26. Adding uppercase doubles it to 52. Adding numbers takes it to 62. Adding symbols brings it to roughly 94. The entropy calculation assumes the password is truly random — not a word with substitutions, not a pattern.
| Length | Lowercase only (26) | + Numbers (62) | All chars (94) | Crack time (10B/sec) |
|---|---|---|---|---|
| 8 chars | 37.6 bits | 47.6 bits | 52.4 bits | hours to days |
| 12 chars | 56.4 bits | 71.4 bits | 78.6 bits | centuries to millions of years |
| 16 chars | 75.2 bits | 95.2 bits | 104.8 bits | practically forever |
| 20 chars | 94 bits | 119 bits | 131 bits | practically forever |
The crack time column assumes 10 billion guesses per second — the speed of a fast GPU running offline against a weak hash like MD5. Against modern password hashing algorithms (bcrypt, Argon2, scrypt), the effective rate drops to thousands per second, making even weaker passwords much harder to crack in practice. But you should design your passwords assuming the worst-case attacker, not the average one.
The key insight from this table: length matters more than complexity. A 16-character lowercase-only random password (75 bits) is far stronger than an 8-character password using all character types (52 bits). Adding symbols helps, but adding more characters helps more. This is why the generator defaults to 16 characters.
Why crypto.getRandomValues Matters
Not all "random" is equal. JavaScript's Math.random() is a pseudorandom number generator — it produces numbers that look random but are generated from a deterministic algorithm seeded by a predictable value. Given enough observations of Math.random() output, the internal state can often be reconstructed, and future values predicted.
The Web Crypto API's crypto.getRandomValues() uses the operating system's cryptographically secure entropy source — hardware noise, interrupt timing, and other physical unpredictability. Even if an attacker observes millions of outputs, they cannot predict the next value. This is the same source used by password managers, key generation tools, and cryptographic libraries.
The password generator uses crypto.getRandomValues() for every character selection, with a rejection sampling technique to eliminate modulo bias — the subtle statistical skew that occurs when you take a large random number modulo a smaller charset size. The result is genuinely uniform randomness across the entire character pool.
Tab 1 — Password Generator: All Settings Explained
Length (4–128 characters)
The default is 16 characters — the minimum recommended for important accounts in 2026. Use the slider or type directly. For bank accounts, email, and any account you can't lose, use 20+ characters. For low-stakes accounts where you're using a password manager anyway, 16 is fine. The 128-character upper limit supports API keys and token fields that accept very long inputs.
Character Sets
Four toggles control which character types appear in the password: uppercase (A-Z, 26 chars), lowercase (a-z, 26 chars), numbers (0-9, 10 chars), symbols (customizable, default 30 chars: !@#$%^&*()_+-=[]{}|;:,<>?). Enabling all four gives a charset of 92 characters — the standard for maximum entropy per character.
The symbol set is fully customizable. Some services don't accept all symbols, or they accept only specific ones. Edit the symbol set to match what the service allows — for example, removing <> for systems that reject angle brackets, or restricting to !@#$ only for stricter policies.
Exclude Ambiguous Characters
Removes 0, O, l, 1, and I from the charset. These characters look nearly identical in many fonts, terminal outputs, and printed pages. The entropy reduction is minimal (5 characters from a 92-character pool) but the usability benefit is significant if you're ever typing the password manually or reading it off a screen.
No Duplicate Characters
Ensures each character appears at most once in the password. This slightly reduces entropy (as each picked character reduces the pool for the next) but some systems or style guides require unique characters. Note: if the password length exceeds the charset size (e.g., 100 characters from a 92-char pool), duplicates are allowed automatically as a fallback.
Generate Multiple Passwords
Generate 1, 2, 3, 5, or 10 passwords at once. When generating multiple, a "Download All" button saves them as a plain text file (passwords.txt). Useful for generating a batch of passwords for multiple accounts in one session, or for creating a set of options to choose from.
Tab 2 — Passphrase Generator: Why Random Words Beat Symbols
The famous XKCD comic "correct horse battery staple" made the point clearly: four random common words are easier to remember than a short complex password and can be just as strong. The math backs this up.
The passphrase generator uses a pool of 300 curated English words. Each word adds approximately 8.2 bits of entropy (log₂(300) ≈ 8.2). A 4-word passphrase gives about 33 bits — weaker than a 12-character complex password. But a 6-word passphrase gives 49 bits, and an 8-word passphrase gives 66 bits — comparable to a strong 10-character random password, and far more memorable.
Options available:
- Word count: 3 to 8 words. Use 5+ for any security-critical passphrase.
- Separator: Space, hyphen, underscore, dot, random digit between words, or no separator.
- Capitalize: First letter of each word uppercase — easier to read, doesn't reduce security.
- Add number: Appends a 2-digit random number. Adds about 6.6 bits of extra entropy and satisfies "must contain a number" requirements.
A good passphrase setup: 5 words, hyphen separator, capitalize, add number. Example output: Frost-Lamp-Crane-Vault-Tide-73. That's 47 bits of entropy, memorable, and passes every complexity requirement.
The P@ssw0rd Myth — Why Substitutions Don't Help
"Password" is weak. "P@ssw0rd" is also weak. Attackers are not running through every random combination — they run dictionary attacks first. And leet-speak substitutions (@ for a, 0 for o, 3 for e) are fully included in modern dictionary attack wordlists. The word "password" with every possible substitution of a, s, and o is a tiny list that gets tested in the first few milliseconds.
The same applies to adding numbers at the end: "password1" and "password123" are both in common breach lists. Adding a capital at the start: "Password1!" is also in there. The idea that you can take a weak word and make it strong by adding a number or symbol is a 2005-era security myth that attackers have long accounted for.
True strength comes from randomness. A randomly generated password has no pattern for an attacker to exploit — no word structure, no predictable substitution, no keyboard walk. That's what the generator provides.
Tab 3 — Strength Checker: 8-Point Analysis
Paste any existing password into the strength checker to see a detailed analysis. It evaluates eight criteria:
- Contains uppercase (A–Z)
- Contains lowercase (a–z)
- Contains number (0–9)
- Contains symbol (!@#...)
- At least 12 characters long
- Not a commonly used password — checked against a list of 35 frequently breached passwords including all the obvious ones.
- No sequential patterns — detects keyboard walks (qwerty, asdf), alphabetical sequences (abc, xyz), and numeric runs (123, 987).
- No repeated characters — detects three or more identical characters in a row (aaa, 111, !!!), which reduce effective entropy significantly.
The entropy calculation applies automatic penalties for detected weaknesses: common password status caps entropy at 15 bits (effectively "very weak" regardless of apparent complexity), sequential patterns reduce entropy by 10 bits, and repeated characters reduce it by 8 bits. This means "Password123!" — which looks like it passes most complexity requirements — correctly scores as weak because it matches common password patterns.
Important: The strength checker runs entirely in your browser. The password you type is never sent to any server. You can verify this by opening your browser's DevTools Network panel — no requests are made as you type.
How Crack Time Is Calculated
The crack time shown assumes an offline brute-force attack at 10 billion guesses per second — the approximate speed of a high-end GPU cluster attacking a weakly hashed database (MD5 or SHA-1 without salting). This is the worst-case scenario for password cracking, representing a compromised database with weak storage.
The formula: Crack Time = 2^entropy ÷ 2 ÷ guesses_per_second. The division by 2 gives the average case (you find the password halfway through all possible combinations).
Reality is often better than this worst case: properly hashed passwords (bcrypt cost 12, Argon2id, scrypt) reduce GPU attack speed to thousands per second rather than billions. Online attack scenarios (where the attacker must go through a web form) are typically rate-limited to a few hundred attempts per second. But designing for worst-case gives you a safety margin, which is the right approach for anything important.
Tab 4 — PIN Generator
Generate PINs of 4, 6, 8, 10, or 12 digits using cryptographically secure randomness. An optional "No Repeating Digits" mode ensures each digit appears at most once (only possible for PINs up to 10 digits since there are only 10 distinct digits 0–9).
| PIN Length | Combinations | Entropy | Use Case |
|---|---|---|---|
| 4 digits | 10,000 | 13.3 bits | Bank card (network requirement) |
| 6 digits | 1,000,000 | 19.9 bits | Phone unlock, ATM PIN |
| 8 digits | 100,000,000 | 26.6 bits | Phone unlock (recommended) |
| 10 digits | 10,000,000,000 | 33.2 bits | High-security app PIN |
PINs are inherently weaker than passwords because the charset is only 10 digits. Their security depends almost entirely on lockout mechanisms (the device locks after 3–10 wrong attempts) rather than brute-force resistance. A 4-digit PIN with 3 attempts allowed is statistically equivalent to a 1-in-3,333 chance of guessing correctly — which is why phone theft combined with shoulder surfing is a real attack vector.
The Real Answer — Use a Password Manager
All of this guidance assumes you're trying to remember passwords. The honest recommendation for 2026 is to stop trying. A password manager lets you memorize exactly one strong passphrase (your master password) while generating and storing a unique random password for every account you have.
Free and open-source options include Bitwarden (cross-platform, excellent for most users) and KeePassXC (local storage only, no cloud). Paid options like 1Password and Dashlane offer polished apps with additional features. With any of these, you never need to type a generated password — the manager fills it in automatically.
The use case for a standalone password generator: generating a strong master password for your password manager itself, creating a password when you need one quickly on a shared computer without your manager installed, and checking the strength of passwords you're considering using. That covers the cases where a browser-based tool with no account or installation makes sense.
Final Thoughts
Password security doesn't have to be complicated once you understand the underlying principles. Entropy measures unpredictability. Length drives entropy more than complexity. Randomness means crypto.getRandomValues, not Math.random. Passphrases trade slightly lower entropy for much higher memorability. And for anything you care about keeping secure, a password manager removes the human memory bottleneck entirely.
The free Password Generator handles the generation side: four tools (random password, passphrase, strength checker, PIN) all running in your browser with cryptographic randomness and no server contact. Use the generator to create strong passwords, use the checker to evaluate existing ones, and use the passphrase tool when you need something memorable for a master password or account you access frequently.