Dictionary attack — How it works in detail
Time2Crack project reference document
Audience: developers, security researchers, advanced users
Contents
- Overview
- Historical and academic background
- Why dictionaries work
- Architecture of a modern dictionary attack
- Corpora of real passwords
- The HIBP check (k-anonymity)
- Time2Crack language wordlists
- Dictionary rank:
rankDictionary() - De-leetification
- From rank to cracking time
- Comparison with derived attacks
- Limits of the dictionary attack
- Effective defences
- References
1. Overview
The dictionary attack is the oldest password cracking method, the simplest to understand, and statistically the most effective against real human passwords. Instead of enumerating every possible combination like brute force, it tests a pre-compiled list of candidates — the "dictionary" — in decreasing order of probability.
Why it works so well. People do not choose their passwords at random. Decades of data leaks show that real passwords are extremely concentrated: in the RockYou leak, 123456 alone was used by 290,731 accounts, about 2% of the total. A well-built dictionary attack tests these candidates first and finds them in a fraction of a second, where brute force would need years.
Time2Crack uses two independent mechanisms:
- The dictionary rank, computed locally: is the password one of the most common passwords, possibly disguised with leetspeak, or a word from the dictionary of the selected language? This rank gives the cracking times shown in the results table.
- The Have I Been Pwned (HIBP) check: has this exact password already appeared in a data leak? The answer is shown as a separate badge above the results.
The two are complementary: HIBP knows the passwords that have already leaked, the wordlists cover ordinary words that have not leaked yet.
2. Historical and academic background
2.1 Origins
The dictionary attack predates modern computer security. Early Unix systems stored password hashes in the world-readable file /etc/passwd: anyone who could read it could test a word list against every account.
| Year | Event |
|---|---|
| 1979 | Morris & Thompson publish the first academic paper on Unix password security; a large share of the passwords they studied were common words or names. |
| 1988 | The Morris worm spreads in part by guessing passwords with a built-in list of 432 words, then the system dictionary /usr/share/dict/words. |
| 1991 | Crack (Alec Muffett): the first widely used Unix password cracker, with word-mangling rules. |
| 1996 | John the Ripper popularises the "wordlist + rules" mode. |
| 2009 | RockYou leak: 32 million accounts stored in plain text (14.3 million distinct passwords) reveal how people really choose passwords. |
| 2013 | Troy Hunt launches Have I Been Pwned. The same year, the Adobe breach exposes 153 million accounts whose passwords were encrypted without salt, so identical passwords could be spotted. |
| 2015 | Hashcat becomes open source; GPU dictionary attacks become accessible to everyone. |
| 2019 | "Collection #1–5": billions of email/password pairs compiled from earlier leaks circulate publicly. |
2.2 Founding leaks
Some leaks changed the dictionary attack by revealing the real distribution of human passwords:
- RockYou (2009): 14.3 million distinct passwords stored in plain text. Password #1 (
123456) was used by 290,731 accounts, about 2% of the total. - LinkedIn (2012): 6.5 million unsalted SHA-1 hashes published at first, later found to cover about 117 million accounts.
- Adobe (2013): 153 million accounts; the password hints stored in clear text helped guess the most common passwords.
- Have I Been Pwned (2013 to today): a continuous aggregation of public leaks, now a reference used worldwide.
2.3 How fast is a dictionary attack?
A list of 1 million words, tested with the speeds used by Time2Crack (12× RTX 5090, the default "Standard" profile):
| Algorithm | Speed | Time for 1 million candidates |
|---|---|---|
| NTLM | 4,081 GH/s | 0.25 microseconds |
| MD5 | 2,634 GH/s | 0.38 microseconds |
| SHA-1 | 837 GH/s | 1.2 microseconds |
| SHA-256 | 332 GH/s | 3.0 microseconds |
| bcrypt (cost 5) | 3,658 kH/s | 0.27 seconds |
| Argon2id | 1,000 H/s | about 17 minutes |
The dictionary attack is therefore instantaneous against fast hashes (MD5, SHA-1, NTLM) and remains fast even against bcrypt.
3. Why dictionaries work
3.1 The power law of human passwords
Empirical studies all reach the same conclusion: human passwords are not uniformly distributed. They follow a power law (Zipf's law): a few passwords concentrate a disproportionate share of choices.
Formally: if passwords are sorted by decreasing frequency, the frequency of the password of rank r is roughly proportional to r−s, where the exponent s depends on the corpus (Wang et al., 2017).
Direct consequence: an attacker who tries only the 10 most common passwords already has about one chance in 20 of succeeding against a given account.
3.2 Cognitive biases in password creation
People apply predictable habits when creating a password:
- Memorability: easy-to-remember words (common nouns, first names, pop culture) are over-represented.
- Availability: the password reflects the immediate environment (pet's name, sports team, favourite character).
- Predictable substitutions: e → 3, a → @, o → 0. The user believes the password is stronger, but these are the first substitutions an attacker tries.
- Appending: a digit or symbol added at the end of a word (
password1,sunshine!). - Language and culture: common passwords depend on the user's language (
Soleil123in France,Sommer123in Germany).
3.3 Two ways of being "in the lists"
A password can appear in an attack list for two different reasons:
- It has already leaked. The exact password appeared in a past breach. The attacker does not need to guess: they try known passwords in order of frequency.
- It is an ordinary word. Even if it has never leaked, it is in every attack wordlist because it is an obvious candidate. A French word such as
grenouillemay be absent from HIBP, but it is in the French wordlist of any serious cracking tool.
These two cases correspond to the two mechanisms of Time2Crack described below.
4. Architecture of a modern dictionary attack
4.1 General pipeline
A modern dictionary attack runs in four phases:
Phase 1: Build the wordlist
├── Leaked passwords (HIBP, RockYou, compilations)
├── Language wordlists (dictionaries, first names, places)
├── Thematic wordlists (sport, pop culture, tech, religion)
└── Targeted wordlists (company domain, employee names)
Phase 2: Prepare the wordlist
├── Sort by frequency (most likely first)
├── Remove duplicates
├── Filter by length (target length ± 2)
└── Normalise (lowercase, Unicode NFC)
Phase 3: Hash and compare
for each candidate w in the wordlist:
if hash(w) == target_hash: found
(billions of candidates per second on GPU for MD5)
Phase 4: Report
└── Cracked passwords, coverage statistics
4.2 Hardware optimisations
Modern dictionary attacks run massively in parallel on GPUs:
- Hashcat (the reference tool) uses thousands of GPU cores to compute billions of hashes per second.
- Batching: candidates are sent to the GPU in batches of millions to keep it busy.
- Rules on the GPU: mutation rules are applied directly on the GPU, so a short wordlist produces billions of candidates without being stored.
For a list of 1 billion leaked passwords on 12× RTX 5090:
- MD5: 109 / 2,634 × 109 ≈ 0.4 milliseconds
- bcrypt (cost 5): 109 / 3,658,000 ≈ 5 minutes
This gap of about six orders of magnitude between MD5 and bcrypt shows why the choice of hash algorithm matters so much.
4.3 Order of the candidates
The wordlist is not tested in alphabetical order but by decreasing probability:
- The most common leaked passwords (RockYou top 100)
- Passwords that appear in many leaks (sorted by HIBP frequency)
- Common words of the target language
- Proper names (first names, cities, celebrities)
- Terms related to the target
- Variants and inflected forms
With this order, a weak password is found in the first milliseconds, whatever the hash speed.
5. Corpora of real passwords
5.1 Have I Been Pwned (HIBP)
- Size: more than a billion distinct passwords, from over 14 billion breached accounts
- Source: aggregation of public leaks since 2013
- Format: SHA-1 (and NTLM) hashes with the number of times each password was seen
- Access: k-anonymity API; the full list can be downloaded by defenders
HIBP is the global reference because it covers almost all major public leaks, it records how often each password appears, and it is actively maintained. An attacker with the full list can test the most frequent passwords first.
5.2 RockYou (2009): the founding corpus
14.3 million distinct passwords stored in plain text. The top of the list:
| Rank | Password | Accounts | Share |
|---|---|---|---|
| 1 | 123456 | 290,731 | 2.03% |
| 2 | 12345 | 79,078 | 0.55% |
| 3 | 123456789 | 76,790 | 0.54% |
| 4 | password | 59,462 | 0.42% |
| 5 | iloveyou | 49,952 | 0.35% |
Takeaway: a handful of candidates, tested in a few nanoseconds against MD5, are enough to compromise a measurable share of the accounts in a leaked database.
5.3 Specialised wordlist collections
- SecLists (Daniel Miessler): an open-source collection of lists for security testing — leaked passwords, passwords sorted by language, technical terms, names.
- CrackStation: about 1.5 billion entries, including every word of Wikipedia in several languages.
- Weakpass: very large compilations of real leaked passwords.
These corpora are publicly downloadable: their existence is an established fact of offensive security.
6. The HIBP check (k-anonymity)
6.1 The k-anonymity protocol
Time2Crack checks the password against HIBP without ever sending it, nor its full hash. The protocol works as follows:
1. Compute SHA-1(password)
→ e.g. CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Send only the first 5 characters to the HIBP API
→ GET https://api.pwnedpasswords.com/range/CBFDA
3. The API returns every hash suffix starting with this prefix
(several hundred lines, padded with fake entries)
4. Look for the rest of the hash in the response, locally
→ C6008F9CAB4083784CBD1874F76618D2A97
5. Found: the password has leaked, and HIBP gives how many times
Not found: the password is not in HIBP
Privacy guarantee: the HIBP server only sees a 5-character prefix shared by hundreds of passwords. It cannot know which password was checked. The comparison is done in the browser.
6.2 Implementation in Time2Crack
The check runs half a second after you stop typing, in parallel with the local analysis:
// app.js - checkHIBP()
async function checkHIBP(password) {
const sha1 = await sha1Hex(password); // uppercase hex SHA-1
const prefix = sha1.slice(0, 5); // sent to the API
const suffix = sha1.slice(5); // never leaves the browser
const res = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`, {
headers: { "Add-Padding": "true" }, // hide the real size of the response
});
if (!res.ok) return null; // API unavailable
const text = await res.text();
for (const line of text.split("\n")) {
const [hashSuffix, count] = line.trim().split(":");
if (hashSuffix === suffix) return parseInt(count, 10); // number of leaks
}
return 0; // not found
}
The result is shown as a badge: "found N times", "not found", or "unavailable" when the API cannot be reached. It does not change the cracking times, which are computed locally.
6.3 Reading the HIBP count
The count is the number of times this exact password was seen in indexed leaks:
| Count | Meaning |
|---|---|
| More than 1,000,000 | Among the most used passwords in the world: tried first by every attacker |
| 10,000 to 1,000,000 | Very common |
| 1,000 to 10,000 | Common |
| 100 to 1,000 | Uncommon but known |
| 1 to 100 | Rare, but compromised |
Even a count of 1 is a warning: the password is in the lists available to attackers, and anyone targeting the account it leaked from will try it.
7. Time2Crack language wordlists
7.1 Why language wordlists in addition to HIBP
HIBP covers passwords that have already leaked, not ordinary words that have not leaked yet. A French speaker who chooses éphémère may not be in HIBP, but the word is in the French wordlist of any attacker targeting French-speaking users. The language wordlists of Time2Crack fill this gap:
| Language | File | Words |
|---|---|---|
| English | en.txt.gz | 748,958 |
| French | fr.txt.gz | 550,235 |
| Spanish | es.txt.gz | 284,834 |
| Portuguese | pt.txt.gz | 507,721 |
| German | de.txt.gz | 2,009,880 |
| Italian | it.txt.gz | 3,252,670 |
| Dutch | nl.txt.gz | 2,678,323 |
| Polish | pl.txt.gz | 3,670,705 |
| Turkish | tr.txt.gz | 400,442 |
| Total | 14,103,768 |
The first versions came from the Wikipedia word lists of SecLists and from the kkrypt0nn wordlists; they have been enriched since. When a list is loaded, each line is trimmed and lowercased, and words shorter than 3 characters are discarded.
7.2 Lazy loading
The wordlists are not bundled with the code. Only the list of the selected language is downloaded, the first time it is needed, as a gzip file:
// app.js - loadDictionary() (simplified: progress bar updates removed)
async function loadDictionary(lang = AppConfig.lang) {
// Already loaded for this language
if (AppConfig.dictWords !== null && AppConfig.dictLang === lang) return;
// 1. Local cache (IndexedDB)
const cached = await cacheGet(`dict_${lang}`);
if (cached) {
AppConfig.setDictionary(new Set(cached), lang);
return;
}
// 2. Download the compressed list
const res = await fetch(`${basePath}data/wordlists/${lang}.txt.gz`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const buffer = await res.arrayBuffer();
// 3. Decompress in the browser (plain .txt if DecompressionStream is missing)
let text;
try {
text = await new Response(
ReadableStream.from([new Uint8Array(buffer)])
.pipeThrough(new DecompressionStream("gzip"))
).text();
} catch {
text = await (await fetch(`${basePath}data/wordlists/${lang}.txt`)).text();
}
// 4. Normalise, filter, index
const words = text.split("\n")
.map(w => w.trim().toLowerCase())
.filter(w => w.length >= 3);
AppConfig.setDictionary(new Set(words), lang);
// 5. Keep it for the next visit
await cachePut(`dict_${lang}`, words);
}
Why a Set? A JavaScript Set answers dictWords.has(word) in constant time, whether the list holds 285,000 words (Spanish) or 3.7 million (Polish). With an Array, each lookup could require one comparison per word.
7.3 Local cache (IndexedDB)
The prepared list is stored in the browser's IndexedDB under the key dict_<language>. On the next visit, it is read from the cache instead of being downloaded and decompressed again:
First visit Next visits
----------- -----------
fetch fr.txt.gz cacheGet("dict_fr")
└── gunzip (DecompressionStream) └── new Set(words)
└── trim / lowercase / ≥ 3 └── ready
└── new Set(words)
└── cachePut("dict_fr")
└── ready
The password never leaves the browser: the list is downloaded from the Time2Crack server and the comparison is done locally.
8. Dictionary rank: rankDictionary()
8.1 Principle: a rank, then a time
Time2Crack does not only ask "is this a dictionary word?", but "after how many guesses would a dictionary attack find it?". This number of guesses is the rank. The function rankDictionary() (file core/rank/dictionary.js) returns it, or null when the attack does not apply:
// core/rank/dictionary.js - rankDictionary()
export function rankDictionary(password, dictWords = null) {
const lower = password.toLowerCase();
const deleeted = deleet(password);
const alpha = password.replace(/[^a-zA-Z]/g, "");
const uCost = uppercaseCost(alpha); // capital letters, see 8.3
// 1. In the top passwords as is?
const topIdx = TOP_PASSWORDS.indexOf(lower);
if (topIdx !== -1) return { rank: (topIdx + 1) * uCost, model: "dictionary" };
// 2. De-leeted form in the top passwords?
const deIdx = TOP_PASSWORDS.indexOf(deleeted);
if (deIdx !== -1) return { rank: (deIdx + 1) * 10 * uCost, model: "dictionary" };
// 3. In the wordlist of the selected language?
if (dictWords instanceof Set) {
if (dictWords.has(lower) || dictWords.has(deleeted)) {
const mid = Math.floor(dictWords.size / 2);
if (passwordLength(password) >= 9) {
// a long word may also be split into shorter words, see 8.4
const compound = rankGermanCompound(password, dictWords);
if (compound && compound.rank < mid)
return { rank: compound.rank * uCost, model: "dictionary" };
}
return { rank: mid * uCost, model: "dictionary" };
}
// 4. Compound made of several dictionary words?
const compound = rankGermanCompound(password, dictWords);
if (compound) return { rank: compound.rank * uCost, model: "dictionary" };
}
// Not found: the dictionary attack does not apply
return { rank: null, model: "dictionary" };
}
8.2 Four levels
| Level | Rule | Example | Rank |
|---|---|---|---|
| 1. Top passwords | Position in a list of 105 of the most common passwords (RockYou, HIBP) | password | 2 |
| 2. Leetspeak variant | Position of the de-leeted form × 10 | p@ssw0rd | 20 |
| 3. Language wordlist | Half the size of the list | soleil (French) | 275,117 |
| 4. Compound word | See 8.4 | apfelbaumkuchen (German) | 21,129 |
Why half the list? The wordlists are not sorted by frequency, so the position of a word in the file says nothing about when an attacker would try it. On average, an attacker going through the list finds a given word halfway.
8.3 Capital letters
An attacker starts with lowercase words, then tries capitalised variants. The rank is multiplied by the number of variants needed to reach the capitalisation of the password (function uppercaseCost(), same method as zxcvbn):
| Capitalisation | Multiplier | Example | Rank |
|---|---|---|---|
| All lowercase | × 1 | soleil | 275,117 |
| First letter only | × 2 | Soleil | 550,234 |
| Last letter only | × 2 | soleiL | 550,234 |
| All uppercase | × 2 | PASSWORD | 4 |
| Any other mix | sum of C(n, i) for i = 1 … min(uppercase, lowercase) | PaSsWoRd | 324 |
8.4 Compound words
German (and Dutch) glue words together: Apfelbaumkuchen = Apfel + Baum + Kuchen. Such a word is often absent from the list, but an attacker can build it by combining shorter words. Time2Crack tries to split the password into 2 to 4 words of the list, allowing the usual German linking letters (-s-, -es-, -n-, -en-, -er-, -e-). The rank is then the mask rank of the password multiplied by 0.25 (2 words), 0.16 (3 words) or 0.10 (4 words), and by 0.75 when the last piece is a common suffix (-heit, -ung, -haus…).
The split is also tried on long words that are in the list (9 characters or more), and kept when it gives a lower rank: Sonnenblume gets a rank of 42,680 instead of half the German list (1,004,940).
9. De-leetification
9.1 Leetspeak is not a protection
Leetspeak replaces letters with similar-looking digits or symbols: a → @, e → 3, i → 1, o → 0, s → $. People use it to "strengthen" a common word: password → p@$$w0rd.
In reality, these substitutions are among the first rules applied by cracking tools. They do not slow down a competent attacker.
9.2 The deleet() function
// core/rank/dictionary.js - deleet()
function deleet(pw) {
return pw
.toLowerCase()
.replace(/0/g, "o")
.replace(/1/g, "i")
.replace(/3/g, "e")
.replace(/4/g, "a")
.replace(/5/g, "s")
.replace(/7/g, "t")
.replace(/8/g, "b")
.replace(/@/g, "a")
.replace(/\$/g, "s")
.replace(/!/g, "i");
}
The password is looked up both as typed and in its de-leeted form. In the top passwords, the de-leeted form costs 10 times more (the attacker has to try the variants): p@ssw0rd → 20 instead of 2. In the language wordlist, it costs the same as the plain word.
9.3 What is not decoded
- Each character has only one replacement:
1always becomesi, neverl, sop1ayeris not recognised asplayer. - Rarer substitutions (
+→ t,9→ g,#→ h) are not decoded. - A word followed by digits or symbols (
soleil2024,sunshine!) is not a dictionary match: it is handled by the hybrid attack.
10. From rank to cracking time
The rank is converted into seconds by dividing it by the hashing speed of the attacker:
// core/time.js - rankToSeconds()
export function rankToSeconds(rank, algo, profile = "experienced") {
const baseRate = HASH_RATES[algo]; // guesses per second, 12× RTX 5090
if (!baseRate) throw new Error(`Unknown algorithm: ${algo}`);
const multiplier = ATTACKER_MULTIPLIERS[profile] ?? 1;
return rank / (baseRate * multiplier);
}
Example for soleil (French wordlist, rank 275,117), with the default profile:
| Algorithm | Speed (12× RTX 5090) | Calculation | Time |
|---|---|---|---|
| NTLM | 4,081 GH/s | 275,117 / 4,081 × 109 | 67 nanoseconds |
| MD5 | 2,634 GH/s | 275,117 / 2,634 × 109 | 104 nanoseconds |
| SHA-1 | 837 GH/s | 275,117 / 837 × 109 | 329 nanoseconds |
| SHA-256 | 332 GH/s | 275,117 / 332 × 109 | 829 nanoseconds |
| bcrypt (cost 5) | 3,658 kH/s | 275,117 / 3,658,000 | 0.08 seconds |
| Argon2id | 1,000 H/s | 275,117 / 1,000 | 4 minutes 35 seconds |
Even with Argon2id, a plain French word falls in less than 5 minutes. The attacker profile changes the speeds: from a single GPU ("Amateur" profile) to about 10,000 GPUs ("Nation-state" profile). Like every other model, the dictionary rank can never exceed the brute-force rank of the same password.
11. Comparison with derived attacks
The "pure" dictionary attack is the first of a family of attacks that all start from a word list. Time2Crack computes nine models (brute force, dictionary, hybrid, mask, PCFG, Markov, combinator, keyboard patterns, dates), each attacking the password from a different angle.
11.1 Dictionary vs hybrid
| Criterion | Dictionary | Hybrid (dictionary + rules) |
|---|---|---|
| Candidates | The words of the list, as is | Each word with its mutations (digits, symbols, capitals…) |
| Cracked examples | password, soleil | P@ssw0rd!, soleil2024 |
| Speed | Fewer candidates, so faster | Much wider coverage |
| Applies when | The exact word is in the list | The password is derived from a word of the list |
The hybrid attack starts where the pure dictionary stops: it applies systematic mutation rules to every word of the list (in the spirit of hashcat's best64.rule).
11.2 Dictionary vs PCFG
| Criterion | Dictionary | PCFG |
|---|---|---|
| Model | Fixed list of candidates | Probabilistic grammar of password structures |
| Strength | Exact words | Structures such as word + digits, capital + lowercase + symbol |
| Example | password ✓ | Password123 ✓ (structure recognised) |
Password123 is not a dictionary word as such, but PCFG recognises its structure [capital][lowercase][digits] and cracks it very quickly.
11.3 Dictionary vs Markov
| Criterion | Dictionary | Markov |
|---|---|---|
| Candidates | Pre-compiled list | Generated on the fly by a statistical model |
| Coverage | Known vocabulary | Any sequence that "looks human" |
| Advantage | Very fast on exact words | Also covers words absent from the lists |
Markov covers passwords that look like human words without being in any list.
11.4 Dictionary vs credential stuffing
| Criterion | Dictionary | Credential stuffing |
|---|---|---|
| Goal | Crack a hash | Log in to an account |
| Mechanism | Local hash computation | Remote login attempts |
| Source | Generic wordlist | Leaked email/password pairs |
| Defence | Slow hash algorithm | Rate limiting, MFA, IP blocking |
Credential stuffing does not attack a hash: it tries leaked email/password pairs directly on online services. It is a different attack, but it uses the same data (leaks such as those indexed by HIBP). Time2Crack does not model it.
12. Limits of the dictionary attack
12.1 Intrinsic limits
- Known vocabulary only. An invented password that resembles no existing word and has never leaked escapes the pure dictionary attack:
Xqz7mK9pLis in no wordlist. - Language coverage. An attacker targeting French speakers without a French wordlist will miss words such as
grenouilleorbricolage. - New passwords. A password that has never leaked is not in HIBP, even if it is common.
- Long passphrases.
MaGrandeAventureSousLesEtoilesis in no wordlist, even if each word is trivial. Passphrases are handled by other attacks (combinator, PRINCE).
12.2 What Time2Crack does not model
- Targeted wordlists: an attacker targeting a sector builds specific lists (medical terms for a hospital, gaming slang for a gaming platform). Tools such as CeWL extract words from the target's website. Time2Crack uses generic lists.
- Recent leaks: between a leak and its addition to HIBP, the passwords circulate privately without being visible through the public API.
- Other hash algorithms: Time2Crack models six algorithms (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt or PBKDF2 have different profiles.
- Word frequency: every word of the language wordlist gets the same rank (half the list), whether it is very common or very rare.
13. Effective defences
13.1 What protects
A slow hash algorithm (bcrypt, Argon2id). This is the most effective server-side defence: each guess costs more. For soleil (rank 275,117):
- MD5: about 0.1 microseconds
- bcrypt cost 12 (128 times slower than cost 5): about 10 seconds
- Argon2id: about 5 minutes
A slow hash slows the attacker down, but it does not save a dictionary word: the list is simply too short.
A unique salt per account. It makes precomputed tables (rainbow tables) useless and forces the attacker to work account by account. It does not prevent a wordlist attack on a single account.
Length and randomness. A single dictionary word is always vulnerable. A passphrase of 4 or 5 words resists the pure dictionary attack, but not the combinator attack if the words are predictable: they must be drawn at random.
Randomly generated passwords. The real solution: a password manager that generates long random passwords (20 characters or more). They are in no dictionary.
Multi-factor authentication (MFA). It does not prevent offline cracking of stolen hashes, but it stops the attacker from logging in with a cracked password.
Rate limiting and anomaly detection. They protect against online attempts, not against offline cracking of stolen hashes.
13.2 What does not protect
- Leetspeak substitutions:
password→p@ssw0rd(see section 9). - A digit at the end:
password→password1, among the first rules tested. - A capital first letter:
password→Password, a standard rule (rank × 2). - Digits and symbols around a recognisable word:
sunshine!is found with the most basic rules. - Complexity without length:
P@s1wmeets the usual rules (uppercase, lowercase, digit, symbol) but is shorter and more predictable thancorrecthorsebatterystaple.
13.3 Practical recommendations
- Use a password manager (Bitwarden, 1Password, KeePass): it generates random passwords, you only remember the master password.
- Enable MFA everywhere: even if a password leaks, the attacker cannot log in.
- Check HIBP regularly to know whether your email address appears in known leaks.
- Never reuse a password: credential stuffing exploits reuse across services.
- For passwords you must remember: a passphrase of 5 words or more, drawn at random (with dice or a generator), not chosen.
14. References
Academic sources
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. First academic analysis of Unix passwords.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. About a quarter of 15,000 Unix passwords cracked with word lists and rules.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. The founding paper of PCFG, compared with dictionary attacks.
- Ur, B., et al. (2012). How does your password measure up? The effect of strength meters on password creation. 21st USENIX Security Symposium.
- Bonneau, J. (2012). The science of guessing: Analyzing an anonymized corpus of 70 million passwords. IEEE Symposium on Security and Privacy. Measures the real distribution of passwords.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Compares dictionary, Markov and PCFG models on real corpora.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Source of the capital-letter cost used in section 8.3.
- Wang, D., Cheng, H., Wang, P., Huang, X., & Jian, G. (2017). Zipf's law in passwords. IEEE Transactions on Information Forensics and Security, 12(11), 2776–2791.
- Pasquini, D., Cianfriglia, M., Ateniese, G., & Bernaschi, M. (2021). Reducing bias in modeling real-world password strength via deep learning and dynamic dictionaries. 30th USENIX Security Symposium.
Industry sources
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. The k-anonymity API used by Time2Crack.
- Hive Systems (2025). Password table. 2025 edition based on 12× RTX 5090. Time2Crack uses measured RTX 5090 hashcat benchmarks (Specops 2026, hashcat.net forum); Argon2id remains an estimate.
- Hashcat. Advanced password recovery. https://hashcat.net. Reference tool for GPU benchmarks and mutation rules (
best64.rule). - Miessler, D. SecLists. GitHub. Source of the first language wordlists of Time2Crack.
Background
- Hunt, T. (2017). Introducing 306 million freely downloadable Pwned Passwords. troyhunt.com.
- Thomas, K., et al. (2019). Protecting accounts from credential stuffing with password breach alerting. 28th USENIX Security Symposium. Shows that k-anonymity protects privacy.
Source code: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).