Cracking Time by Length and Character Set
The table below assumes an offline attack against a leaked password database at 100 billion guesses per second - a well-funded attacker with GPU or ASIC hardware and a fast hash like unsalted MD5. This is close to the worst realistic case. A slow hash (bcrypt/Argon2) makes every one of these numbers dramatically larger.
| Password | Length | Character set | Combinations | Time to exhaust @ 100B/sec |
|---|---|---|---|---|
password | 8 | lowercase word | in a wordlist | Instant (dictionary) |
k7m2q9x1 | 8 | lowercase + digits | 36^8 ≈ 2.8 x 10^12 | ~28 seconds |
K7m2Q9x1 | 8 | mixed + digits | 62^8 ≈ 2.2 x 10^14 | ~36 minutes |
K7m2!Q9x | 8 | all four types | 90^8 ≈ 4.3 x 10^15 | ~12 hours |
k7m2q9x1p4vb | 12 | lowercase + digits | 36^12 ≈ 4.7 x 10^18 | ~1.5 years |
K7m2!Q9x#pL4 | 12 | all four types | 90^12 ≈ 2.8 x 10^23 | ~89,000 years |
K7m2!Q9x#pL4vZ8b | 16 | all four types | 90^16 ≈ 1.85 x 10^30 | ~586 million years |
K7m2!Q9x#pL4vZ8b$Rn3 | 20 | all four types | 90^20 ≈ 1.2 x 10^38 | ~10^19 years |
| Which should I use? | 16+ | all four types | generated, unique per site | Cracking is not the threat |
Two things jump out. First, at 8 characters even full complexity buys you only about half a day of protection against a serious offline attacker - short passwords are not safe regardless of symbols. Second, each additional character multiplies the time by ~90x, so moving from 12 to 16 characters turns 89,000 years into 586 million years. Length is the lever that matters most.
Password Cracking Methods: The Attacker's Toolkit
Attackers use several primary methods to crack passwords, each with different effectiveness against generated passwords versus human-chosen passwords.
Password Cracking Methods: The Attacker's Toolkit
Attackers use several primary methods to crack passwords, each with different effectiveness against generated passwords versus human-chosen passwords.
Dictionary Attacks use lists of common words, phrases, and known passwords. They work because humans predictably choose passwords based on meaningful language and patterns they can remember. A dictionary containing the 1 billion most common passwords will crack most human-chosen passwords in seconds. However, dictionary attacks are completely useless against randomly generated passwords because random character sequences are virtually impossible to include in practical dictionaries.
Brute Force Attacks systematically try every possible character combination until finding the correct password. A brute force attack against a 12-character password using only lowercase letters would need to try up to 26^12 combinations (about 95 trillion attempts). A modern GPU can perform about 1 billion password attempts per second, which means this 12-character lowercase password would require approximately 95 million seconds to crack—about 3 years of continuous attacking.
However, modern generated passwords aren't 12 characters of only lowercase. They're typically 16+ characters using uppercase, lowercase, digits, and special characters. The number of possibilities jumps to 90^16, which is approximately 1.85 × 10^30 possible combinations. At 1 billion attempts per second, this would require 1.85 × 10^21 seconds to try all possibilities—approximately 58 billion years of continuous attacking.
Rainbow Tables are precomputed databases of password hashes. If an attacker obtains a hashed password file, they can look up hashes to find matching passwords without needing to compute anything. Rainbow tables work for common passwords but become impractical for random passwords. Creating rainbow tables for all possible 16-character passwords would require more storage capacity than exists on Earth, making this approach impossible for truly random passwords.
GPU and ASIC Acceleration provides faster cracking speeds. Specialized hardware can perform password attempts much faster than standard computers. A fully optimized ASIC-based password cracking system might reach 100 billion attempts per second instead of 1 billion. Even with this 100x speedup, cracking a 16-character random password would require 580 million years—still far longer than realistic attack timeframes.
Hybrid Attacks combine dictionary attacks with rule-based modifications. They might take common words and apply rules like capitalizing the first letter, adding a number at the end, etc. These attacks work against passwords humans create by combining simple elements but don't apply to random passwords because there's no pattern to exploit.
Hash Algorithms and Computational Difficulty
Modern systems don't store passwords in plain text; they store password hashes. A hash function converts a password into a seemingly random string. The same password always produces the same hash, but the hash can't be reversed to find the original password. This means attackers don't crack passwords directly—they crack password hashes.
The security of this approach depends on the hashing algorithm. Weak algorithms like MD5 or SHA1 are fast, allowing trillions of guesses per second. Strong algorithms specifically designed for password hashing, like bcrypt, scrypt, or Argon2, are intentionally slow. Bcrypt, for instance, is deliberately designed to slow down by a configurable factor, making password cracking computationally expensive even with optimal hardware.
A modern bcrypt configuration might require 0.5 seconds to hash and verify a single password attempt. If only 2 attempts per second are possible instead of billions, cracking becomes essentially impossible even for weak passwords, because the timeframe stretches beyond practical attack windows.
The security of your password depends partly on how the service hashes it. A website using bcrypt with strong settings can make password cracking impractical even for somewhat shorter passwords. A website using unsalted MD5 (a deprecated approach some older systems still unfortunately use) remains vulnerable even to long passwords.
This is why password managers and 2FA are so important: they protect you even if a service uses weak hashing by ensuring that breaches don't directly compromise your account.
The Role of Password Length vs. Character Diversity
Password strength is determined by both length and character set diversity. A 16-character password using only lowercase letters is more secure than a 12-character password with uppercase, digits, and special characters, because length has exponential impact on difficulty.
However, the ideal approach uses both: long passwords with maximum character diversity. A 16-character password using all four character types (90+ possible characters per position) creates exponentially more possibilities than a 20-character lowercase-only password.
Generated passwords that use all available characters provide maximum strength for their length. A 16-character generated password with all character types is more secure than a 20-character password from a password manager that restricts special characters (if such a manager existed).
Salting and Modern Password Security
When systems store passwords, they use a process called salting. A salt is random data added to the password before hashing. The same password produces completely different hashes when salted with different values, making rainbow tables useless.
This is important because it means that even if an attacker obtains a copy of your hashed password, they can't use precomputed rainbow tables. They must compute each hash independently, respecting the salt value. Modern systems using salted, properly hashed passwords provide substantial protection for generated passwords.
The diagram below traces what happens after a database is stolen. The same leaked hash leads to two completely different outcomes depending only on how the password was constructed and stored.
Time Complexity and Practical Attack Windows
From an attacker's perspective, the practical question isn't "can this password be cracked eventually" but rather "can it be cracked before it becomes useless?" Passwords are often changed periodically. By the time an attacker finishes cracking a password that took 5 years to break, the account owner has already changed the password multiple times.
Additionally, many accounts have failed login attempt limits. After 5-10 failed attempts, the account locks temporarily or permanently. This prevents brute force attacks on the actual live system. Attackers can only conduct large-scale cracking attempts on copies of password databases obtained through breaches, where they don't face attempt limits—but in those scenarios, the victim knows a breach occurred and should have already changed the password.
Quantum Computing and Future Password Security
A frequently asked question is whether quantum computers could crack passwords. Quantum computers using Shor's algorithm could theoretically break certain types of cryptography (specifically public key cryptography). However, password cracking isn't based on the same mathematical problems. Quantum computers don't provide any meaningful speedup for brute force password cracking against properly hashed passwords.
For passwords, the relevant quantum algorithm would be Grover's algorithm, which provides a square root speedup. This means a 256-bit password would become approximately as hard to crack as a 128-bit password. This is why cryptographic experts recommend longer passwords—quadrupling password length (from 128 to 256 bits) completely compensates for the threat of future quantum computers.
A generated password of 16 characters with full character diversity uses 90+ possibilities per character, which is approximately 6-7 bits of entropy per character, yielding about 96-112 bits of entropy total. Extending to 20-24 characters provides quantum resistance even against theoretical future quantum computers.
Rainbow Tables and Modern Defenses
Rainbow tables remain a theoretical concern, but modern systems mitigate them through salting. Additionally, even the largest possible rainbow tables for 16-character passwords would require more storage than exists globally. A rainbow table for all 90^16 possibilities would be approximately 1.85 × 10^30 terabytes—about 10 billion times larger than all digital storage on Earth.
The Role of Your Threat Model
Whether a generated password can be cracked depends on your threat model—the specific attacker you're trying to defend against. The random person trying to access your account will fail almost immediately because they can't efficiently guess, and account lockouts prevent brute force. An attacker with a copy of a breached password database and specialized hardware might crack weak passwords but will fail against strong generated ones.
Even the most sophisticated attackers—nation states or well-funded criminal organizations—cannot efficiently crack modern generated passwords of adequate length. The computational cost becomes astronomical even for well-resourced attackers.
Best Practices for Maximum Confidence
To ensure your generated passwords remain secure against all practical attacks:
Use 16+ character passwords. This provides security against current and reasonably foreseeable attack capabilities.
Include all character types (uppercase, lowercase, digits, special characters). This maximizes the character set and compounds the difficulty of brute force attacks.
Use a password manager for secure storage. This eliminates password reuse and ensures you can update passwords if a service is breached.
Enable two-factor authentication. This protects you even if a password is somehow compromised.
Use password managers with generated passwords rather than human-chosen passwords. Generated passwords are statistically far stronger than anything humans choose.
The Verdict: Generated Passwords Remain Secure
Generated passwords with adequate length and character diversity cannot be cracked through any practical attack method available today or in the reasonably foreseeable future. The timeframes required for brute force attacks stretch into billions or trillions of years. Rainbow tables are impossible to compute for random character combinations. Dictionary attacks don't apply because there's no pattern to exploit. Modern hashing with salting makes attacks computationally expensive even with specialized hardware.
Your generated password is not being individually targeted by attackers. The risk isn't that someone will crack your specific password—it's that you'll reuse a password across services, making breaches at one service compromise others. By using generated passwords with password managers, you eliminate that primary risk entirely. The mathematics of modern password security means your randomly generated password is exponentially more secure than any password you could choose yourself.