The Actual Threat Model
Before optimizing passwords, understand what you're defending against. There are three distinct attack scenarios, and each has different implications for password design:
- Online brute force — an attacker submits guesses directly to a login form. Most services rate-limit after 5-10 failed attempts, making this attack very slow. Even weak passwords survive online brute force if the site has basic protections.
- Offline hash cracking — the attacker obtains the site's hashed password database (via breach) and cracks it locally using GPU clusters. This is the dangerous scenario. Modern consumer GPUs can test billions of password candidates per second against common hash algorithms.
- Credential stuffing — the attacker uses previously leaked username/password pairs from other breaches to log into new sites. This is why password reuse is the single biggest vulnerability. If any site you've used has been breached, your reused password is already in attacker databases.
The primary design constraint for strong passwords is scenario 2 (offline cracking) and scenario 3 (credential stuffing). Length and uniqueness address both.
The Math: Password Entropy
Password strength is measured in bits of entropy using the formula:
Where H is entropy in bits, L is password length, and N is the number of possible characters at each position (the "character set size"). Each additional bit of entropy doubles the number of guesses required to crack the password.
NIST SP 800-63B (2024 revision) recommends a minimum of 8 characters for user-chosen passwords and suggests that passwords with 112+ bits of entropy are "very strong" by cryptographic standards. Most security practitioners recommend 80+ bits as the working minimum for sensitive accounts.
Cracking Times at Current GPU Speeds
A modern consumer GPU (RTX 4090) can test approximately 164 billion MD5 hashes per second, or about 10 billion bcrypt hashes per second (bcrypt is much slower by design). The table below uses the slower, more secure assumption of 10 billion guesses/second against a well-implemented hash.
| Length | Character set | Entropy | Crack time (10B/s) |
|---|---|---|---|
| 8 | lowercase (26) | 37.6 bits | < 1 second |
| 8 | mixed case + digits (62) | 47.6 bits | ~22 minutes |
| 12 | all printable ASCII (95) | 78.9 bits | ~2,000 years |
| 16 | all printable ASCII (95) | 105.2 bits | Effectively infinite |
| 20 | all printable ASCII (95) | 131.5 bits | Effectively infinite |
| 4 words | Diceware list (7,776) | 51.7 bits | ~14 hours |
| 6 words | Diceware list (7,776) | 77.5 bits | ~800 years |
Note: "Effectively infinite" means cracking would take longer than the estimated age of the universe given current hardware. Hardware improves over time — a password considered safe today may not be in 10 years. For long-term sensitive data, use 16+ characters.
Why "Complexity Rules" Are Mostly Wrong
The classic complexity rule — "must contain uppercase, lowercase, number, and special character" — was formalized in NIST SP 800-63 (2004) and has been misapplied for two decades. NIST explicitly reversed it in the 2017 revision and 2024 update.
Why complexity rules fail in practice:
- Users apply predictable patterns to meet requirements:
password→P@ssw0rd! - Attackers already have these substitution patterns in their dictionaries
P@ssw0rd!has only marginally more entropy thanpassword— both are dictionary attacks, not brute force- Complexity requirements encourage shorter passwords (users struggle to memorize long complex strings)
A 20-character lowercase-only random string (qmvwrfxzknlptsdchbja) has 94 bits of entropy. P@ssw0rd! has approximately 18 bits in practice because it's a dictionary entry. Length beats forced complexity every time, as long as the password is genuinely random.
Random Passwords vs Passphrases: Which to Use When
Both are valid. The choice comes down to the use case:
Random passwords
Best when stored in a password manager. Maximum entropy per character.
- Highest security per length
- Not human-memorable
- Requires a password manager
- Use for: all accounts in your manager
Passphrases
Best for the one password you must memorize. Human-friendly, still strong.
- Easy to type and remember
- 6+ words required for 80+ bits
- Use for: password manager master password, disk encryption
- Example:
maple-frost-quantum-ridge-table
Generate both with KeyForge: random passwords for password manager storage, and memorable passphrases for the master password you'll type from memory.
How KeyForge Generates Passwords (The Technical Details)
KeyForge uses the crypto.getRandomValues() Web Crypto API — the same cryptographic random number generator used by your browser for TLS connections. This is not Math.random(), which is a pseudorandom function unsuitable for security purposes. crypto.getRandomValues() uses the operating system's cryptographically secure entropy source.
All generation happens client-side. Opening your browser's network inspector (F12 → Network tab) while clicking "Generate" shows zero outbound requests. The passwords are computed locally and displayed on your screen — nothing is logged, transmitted, or stored.
To verify: KeyForge is open about its implementation. The random selection function uses rejection sampling to avoid modulo bias — a subtle but important correctness property that cheaper generators skip.
Other KeyForge Tools
- Strong Password Generator — full printable ASCII, configurable length and character sets
- Memorable Password Generator — word-based passphrases for the passwords you type from memory
- PIN Generator — cryptographically random 4-8 digit PINs
- Bulk Password Generator — generate dozens of unique passwords for batch provisioning
- Password Strength Checker — entropy calculation and crack time estimate for any password
- Hash Generator — MD5, SHA-256, SHA-512 hashes computed locally
Frequently Asked Questions
What makes a password strong?
Four properties determine password strength: length (longer is exponentially harder to crack), character set size (using uppercase, lowercase, digits, and symbols multiplies the search space), unpredictability (no dictionary words, keyboard patterns, or personal info), and uniqueness (never reused across accounts). A 20-character random string beats a 40-character dictionary phrase with predictable substitutions.
How long should a strong password be?
At minimum 16 characters for standard accounts; 20+ for high-value accounts (banking, email, password manager master password). The math: a 12-character random password from a 95-character set has 95^12 ≈ 5.4 × 10^23 possibilities. At 10 billion guesses per second (current GPU capability), that takes ~1.7 million years. A 20-character version: effectively uncrackable for any foreseeable hardware.
Is it safe to use an online password generator?
KeyForge generates passwords entirely in your browser using JavaScript's crypto.getRandomValues() API — no data is sent to any server. You can verify this by opening your browser's network inspector (F12 → Network tab) while generating: there are no outbound requests. The generated passwords never leave your device. Browser-based generators using the Web Crypto API are cryptographically secure.
What's the difference between a random password and a passphrase?
A random password is a sequence of characters with no semantic meaning — hard to remember, easy for a password manager to store. A passphrase is a sequence of random words (e.g., 'correct-horse-battery-staple') that's longer in character count and easier to type or memorize. A 4-word passphrase from a 7,776-word list (standard Diceware) has 7,776^4 ≈ 3.6 × 10^15 possibilities — comparable to a good 10-character random password but far easier to type on mobile.
Should I use a password manager or memorize passwords?
Use a password manager. Human memory cannot hold 50+ unique 20-character random strings — so people reuse passwords, which is the #1 cause of account compromises. A password manager with a single strong master password (memorize this one) generates and stores unique passwords for every site. Reputable options include Bitwarden (open-source, free tier), 1Password, and Dashlane. The master password is the only one you need to remember — make it a long passphrase.
What is password entropy and does it matter?
Entropy measures unpredictability in bits: H = L × log₂(N), where L is length and N is the character set size. A password with 80+ bits of entropy is considered strong by NIST guidelines (SP 800-63B). A 16-character password using all 95 printable ASCII characters has 16 × log₂(95) ≈ 105 bits. Entropy matters because it directly translates to the number of guesses required — doubling entropy squares the cracking time.
How often should I change my passwords?
NIST's 2024 guidelines (SP 800-63B) no longer recommend periodic forced changes — evidence shows they cause users to make predictable modifications (Password1 → Password2) that reduce security. Change passwords when: you have evidence or suspicion of compromise, a service reports a breach involving your account, or you've reused a password that appears in a breach database. Check breach databases at haveibeenpwned.com.
Generate a Strong Password Now
100% browser-side. Cryptographically secure. Nothing sent to any server.