What this calculator does
The Password Crack Time Calculator estimates how long an attacker would need to brute-force a password by trying every possible combination. It is based purely on the size of the keyspace and the attacker's guessing speed, giving you a quick sense of how much stronger a longer or more complex password really is.
How to use it
Enter the password length (number of characters), tick the character sets your password draws from, and set the attacker's guesses per second. A modern GPU rig can do roughly one billion (1,000,000,000) fast-hash guesses per second, which is a reasonable default. The result shows the worst-case time to exhaust the entire keyspace, expressed in seconds, hours, days, and years.
The formula explained
The total number of possible passwords is the character set size raised to the power of the length: \(C = N^{L}\). Dividing that by the attacker's guesses per second gives the time to try them all:
$$t = \frac{N^{L}}{G}$$The character set size N adds up: lowercase (26), uppercase (26), digits (10) and symbols (32), so a full mix gives \(N = 94\).
Worked example
Take an 8-character lowercase password (\(N = 26\), \(L = 8\)) against an attacker doing 1 billion guesses/second. Combinations = \(26^{8} = 208{,}827{,}064{,}576\). Crack time:
$$t = \frac{208{,}827{,}064{,}576}{1{,}000{,}000{,}000} \approx 208.83 \text{ seconds}$$— under four minutes. Add uppercase, digits, and symbols (\(N = 94\)) and the same length jumps to \(94^{8} \approx 6.1 \times 10^{15}\) combinations, or about 70 days.
Crack Time Across Password Lengths and Character Sets
The table shows the time to exhaust the entire keyspace, \(T = N^{L}/G\), at an attacker speed of \(G = 10^{9}\) guesses per second (1 billion/s). The average time to find a password is about half of each value. Years use 365.25 days; values are rounded.
| Length (L) | Digits only (N=10) | Lowercase (N=26) | Alphanumeric (N=62) | Full printable (N=94) |
|---|---|---|---|---|
| 6 | 0.001 s | 0.31 s | 56.8 s | 690 s (about 11.5 min) |
| 8 | 0.1 s | 209 s (about 3.5 min) | 2.5 days | 70.6 days |
| 10 | 10 s | 1.6 days | 26.6 years | about 1,700 years |
| 12 | 1,000 s (about 16.7 min) | 3.0 years | about 102,000 years | about 15 million years |
| 16 | 115.7 days | about 1.4 million years | about 1.5 trillion years | about 1.2 quadrillion years |
Example substitution: for 8 lowercase letters, \(N^{L} = 26^{8} = 208{,}827{,}064{,}576\), so \(T = 208{,}827{,}064{,}576 / 10^{9} \approx 209\) seconds.
Each extra character multiplies the time by \(N\), so adding length helps far more than widening the character set by a small amount. The 94-character set here is the 26 + 26 + 10 letters and digits plus 32 ASCII symbols.
Typical Attacker Guess Rates by Hash Type
In an offline attack, the attacker has a stolen database of password hashes and tests guesses at the speed of their hardware. The rates below are rough orders of magnitude for a single high-end consumer GPU (for example, published hashcat benchmarks for an RTX 4090-class card). They vary widely with hardware, software, and the algorithm's settings, so treat them as ballpark figures only.
| Hash algorithm | Approx. guesses/second per GPU | Notes |
|---|---|---|
| NTLM | ~1011 to 1012 | Very fast, unsalted Windows hash |
| MD5 | ~1011 | Fast, not suitable for password storage |
| SHA-1 | ~1010 to 1011 | Fast general-purpose hash |
| SHA-256 | ~1010 | Fast general-purpose hash |
| bcrypt (cost ~10 to 12) | ~103 to 105 | Deliberately slow; each +1 in cost doubles the work |
| scrypt (typical settings) | ~103 to 105 | Memory-hard; depends strongly on parameters |
| Argon2id (typical settings) | ~102 to 104 | Memory-hard; depends strongly on memory, time, and parallelism settings |
Attackers can use many GPUs in parallel, so total speed can be many times higher than a single-card figure. Slow, salted, memory-hard hashes (bcrypt, scrypt, Argon2) reduce the guesses per second by many orders of magnitude compared with fast hashes.
Online attacks (guessing through a login form or API) are far slower, often only a few to a few hundred guesses per second at most, because of network latency, rate limiting, lockouts, and CAPTCHAs. Brute-force estimates with billions of guesses per second apply to the offline scenario.
Interpreting Your Crack Time Result
The calculator reports \(T = N^{L}/G\), the worst-case time to try every possible combination. On average an attacker finds a randomly chosen password after searching about half the keyspace, so the expected time is roughly \(T/2\). This assumes each character is picked uniformly at random from the selected sets; human-chosen passwords are far less random.
| Result band | What it means for offline attack |
|---|---|
| Seconds to minutes | Trivially exhausted with modest hardware; the password offers essentially no resistance once its hash is stolen. |
| Hours to days | Practical for a motivated attacker with one or a few GPUs, especially against fast hashes. |
| Weeks to months | Feasible for an attacker willing to rent or own larger hardware, though costly. |
| Years to centuries | Out of reach for brute force at the assumed speed, though hardware improvements and parallelism can shrink it. |
Important limits of the estimate:
- Dictionary and rule-based attacks try common words, names, patterns, and substitutions first, so a predictable password can fall much faster than its keyspace suggests.
- Reused or leaked passwords bypass brute force entirely: if a password appears in a breach list, it can be tried immediately.
- Hardware gets faster over time, and the guess rate you enter is only a snapshot; a result of many years today may be shorter later.
- The calculator's character set is an assumption. If the password does not truly use all selected sets uniformly, the real keyspace is smaller.
The US NIST publication SP 800-63B (Digital Identity Guidelines: Authentication) emphasizes password length over composition rules, recommends allowing long passwords (at least 64 characters), and recommends screening new passwords against lists of known breached or commonly used values. Revision 4 raises the minimum length for passwords used as a single factor. This is general information about published guidance, not personalized security advice.
FAQ
Is this exact? No. It is the theoretical maximum for pure brute force. Real attackers use dictionaries, leaked password lists, and patterns, so a guessable password falls far faster than this estimate.
What guess rate should I use? It depends on the hash. Fast hashes (MD5, unsalted) allow billions per second; slow hashes (bcrypt, Argon2) allow only thousands. Lower G means a much longer crack time.
How do I make a strong password? Length beats complexity. Each extra character multiplies the keyspace by N, so a long passphrase is dramatically harder to crack than a short complex one.