Password Crack Time Calculator

Password Crack Time Calculator

Popular AI Skill PRO

Enter Calculation

Formula

T=NLGwhere{L=LengthG=Guesses/secN=26[a-z]+26[A-Z]+10[0-9]+32[symbols]\begin{gathered} T = \frac{N^{L}}{G} \\[1.5em] \text{where}\quad \left\{ \begin{aligned} L &= \text{Length} \\ G &= \text{Guesses/sec} \\ N &= 26\,{{[\text{a-z}]}} + 26\,{{[\text{A-Z}]}} + 10\,{{[\text{0-9}]}} + 32\,{{[\text{symbols}]}} \end{aligned} \right. \end{gathered}
Usage stats

Advertisement

Results

Estimated Time to Crack (brute force)
208.83
seconds
Character set size 26
Total combinations 208,827,064,576
In hours 0.06
In days 0
In years 0

Report an error on this page

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.

Exponential curve showing crack time rising steeply as password length increases
Each extra character multiplies the number of combinations, so crack time rises exponentially with length.

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\).

Advertisement

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.

Diagram relating character set size N, password length L, and guess speed G to crack time
Crack time grows as the character set size raised to the password length, divided by the attacker's guess speed.

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.

Advertisement

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.

Last updated:

Most popular in Digital Life

View all Digital Life calculators