Hybrid attack — Comprehensive operation
Project reference document Time2Crack
Recipients: developers, security researchers, advanced users
Contents
addHybridAttacks()1. Overview
Hybrid attack is the cracking method that combines a dictionary wordlist with a set of transformation rulesInstead of testing each word in the dictionary as it is (pure dictionary attack), it generates on the fly all plausible variants of each word — capitalizations, character substitutions, prefix/suffix additions, inversions — and systematically tests them.
Why is it so effective? Humans do not choose "password" as a password, they choose "Password1", "p@ssw0rd", "PASSWORD123" or "password!". These variants seem stronger because they are not in the raw dictionary list — yet they are among the first generated by any modern hybrid cracking tool. The attacker exploits exactly the same "secure" heuristics that the user applies.Hybrid attack is historically the responsible method for the majority of real "mean" password crackings — those that appear to be strong without being strong. According to Ma et al. (2014, IEEE S&P), the first 8 to 10 rules applied to a current word suffice to crack the median password population.
In Time2Crack, the hybrid attack modeled:
2. Historical and academic background
2.1 Origins: John the Ripper and mutation rules
The hybrid attack is formally born with John the Ripper (Solar Designer, 1996), the first public tool to combine a wordlist with a configurable rule engine. Prior to John the Ripper, dictionary attacks tested raw words; John introduced the notion that each word generates a family of candidates.
Chronology of milestones :| Year | Event |
|---|---|
| 1979 | Morris & Thompson: users substitute numbers for letters to "secure" their passwords |
| 1996 | John the Ripper 1.0: first public rule engine, JtR syntax (:, c, u, r, d...) |
| 2000 | Alec Muffett documents that 80% of real cracking goes through wordlist+rules, not brute force |
| 2006 | Hashcat 0.01: migration on GPU, rules go from 1M→1000M candidates/second |
| 2009 | RockYou: 14.3M clear passwords allow empirical calibration of the most effective rules |
| 2012 | Gosney (Passwordscon): 8 GPU GTX 580, best64 rules, crack 90% LinkedIn in < 6 days |
| 2013 | Löfstrand: publishes "best64.rule", 64 rules covering 85-90% of current human transformations |
| 2014 | Ma et al. (IEEE S&P): first academic study quantifying effectiveness by rule rank |
| 2016 | Hashcat open source: integrated best64, MD5 speed 2 TH/s on 8× GTX 1080 |
| 2019 | Hashcat 6.0: OneRuleToRuleThemAll game (52k rules) generated by ML on corpus of passwords |
| 2023 | NSA Advisory: explicitly recommends testing corporate passwords with hybrid tools |
2.2 Founding empirical studies
Klein (1990) — Analysis of 15,000 Unix passwords. Recognizes that 24.2% are crackable per pure dictionary, but that 32% additional are crackable with simple transformations (capitalization, addition of final digit). Total: 56.2% with a primitive hybrid tool. Weir et al. (2009, IEEE S&P) — Proposes the PCFG model but valid by the way that the hashcat rules cover 78% of the transformations observed in RockYou. Demonstrates that the passwords "Password1" and "P@ssw0rd" are among the first 100 candidates generated by best64 on the word "password". Ma et al. (2014, IEEE S&P) — The most cited study on the effectiveness of hybrid rules.- Rule 1 (
: → mot brut) : crack 18% of dict-based passwords
2.3 LinkedIn flight as a school case
The 2012 LinkedIn leak (6.5 million non-salted SHA-1s) perfectly illustrates the power of the hybrid. In 72 hours, the hashcat community had cracked:
Post-crack analysis revealed that "linkedin1", "Linkedin1", "l!nked!n" and "LINKEDIN" — all variants of "linkedin" — collectively represented tens of thousands of compromised accounts.
3. Conceptual Foundations: Why the Hybrid Works
3.1 The human behaviour of "secure"
When a system imposes rules of complexity (majuscule, number, symbol), users do not generate random — they apply predictable transformations to memorizable words :
| Human strategy | Example | Corresponding hybrid rule |
|---|---|---|
| Capitalize the first letter | "sunshine" → "Sunshine" | c (capitalize first) |
| Uppercase everything | "sunshine" → "SUNSHINE" | u (uppercase all) |
| Add a digit at the end | "sunshine" → "sunshine1" | $1 (append "1") |
| Add the year | "sunshine" → "sunshine2024" | $2 $0 $2 $4 |
| Replace e→3 | "sunshine" → "sunshin3" | s e 3 (substitute e by 3) |
| Replace a→@ | "password" → "p@ssword" | s a @ |
| Reverse the word | "sunshine" → "enihsnus" | r (reverse) |
| Double the word | "sun" → "sunsun" | d (duplicate) |
| Add a final ! | "sunshine" → "sunshine!" | $! |
| Combine several | "password" → "P@ssw0rd1" | c s a @ s o 0 $1 |
These transformations seem creative to the user. exactly the first ones that the attacker tries They correspond to the constraints imposed by security policies.
3.2 The concept of efficient reduced space
A 10-character password with letters+digits+symbols has a raw keyspace-force of 94^10, 5,4 × 10^19 combinations. Too large to travel in a reasonable time.
But if this password is "Password1!" — a trivial transformation of "password" — it is among the 500 first candidates The attacker does not travel 5.4 × 10^19 combinations: he travels 500.
This is the fundamental reduction of the hybrid attack: the real space of human choices is astronomically smaller than the theoretical space of possible characters.
3.3 The Law of Power of Transformation
Just as raw passwords follow a law of power (Zipf), the transformations that humans apply also follow a very concentrated distribution. Ma et al. (2014) empirically showed:
This concentration allows a set of 64 well chosen rules (best64) to reach a coverage of 79-85%, where 64 random rules would reach only 10-15%.
3.4 Interaction with the popularity of the basic word
The more common the base word, the earlier the derived password is in the attacker's priority list. The attacker orders his candidates in decreasing probability:
Candidates generated by the attacker (test order):
password (raw word, most common)
Password (capitalize first)
password1 ($1)
PASSWORD (uppercase all)
password! ($!)
p@ssword (substitute a→@)
passw0rd (substitute o→0)
Password1 (c + $1)
P@ssword (c + s a @)
password123 ($1 $2 $3)
...
p@ssW0rd! (complex combination)
"password" is the most common word → its derivatives are tested first. "papillon" is less common → its derivatives are tested much later. This prioritization is the central mechanism that explains the three distinct keyspaces in Time2Crack.
4. Architecture of a modern hybrid attack
4.1 General pipeline
Phase 1: Wordlist selection
├── Leaked passwords sorted by frequency (RockYou, HIBP, Collections)
├── Language dictionaries (fr.txt, en.txt, de.txt...)
├── Themed wordlists (first names, cities, brands, TV series)
└── Contextual wordlists (target domain, employee names, business terms)
Phase 2: Rule set selection
├── best64.rule (balanced reference, 64 rules)
├── OneRuleToRuleThemAll.rule (52,000 rules, ML-generated)
├── d3ad0ne.rule (34,000 rules, empirical)
├── JtR rules (generated.rule, specific.rule, extra.rule)
└── Custom rules (adapted to the target domain)
Phase 3: Expansion (wordlist × rules)
├── For each word w in the wordlist:
│ For each rule r in the ruleset:
│ candidate = apply(r, w)
│ If candidate ≠ w and candidate not tested yet:
│ candidate_queue.push(candidate)
└── Order: (w1, rule1), (w1, rule2)... (w2, rule1)...
or: (w1, rule1), (w2, rule1)... depending on the strategy
Phase 4: Hashing and comparison (GPU)
├── Batches of ~10M candidates sent to the GPU
├── Parallel hash computation (SIMD, 219 GH/s for MD5)
├── Comparison with the target hash(es)
└── On a match: FOUND — log(candidate, hash, rule)
Phase 5: Reporting
└── Cracked candidate + rule used + rank in the list
4.2 Hashcat modes of operation
Hashcat implements the hybrid in two distinct ways:
Mode -a 0 (wordlist + rules) : for every word of the wordlist, apply all the rules. This is the classic hybrid mode.hashcat -a 0 -m 0 hashes.txt rockyou.txt -r best64.rule
Mode -a 6 (wordlist + mask) : combines a wordlist with a positional mask. Generates all combinations word + masked_suffix.
hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
# Tries "sunshine0000", "sunshine0001", ..., "sunshine9999"
Mode -a 7 (mask + wordlist) : inverse — masked prefix + word.
hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
# Tries "00sunshine", "01sunshine", ..., "99sunshine"
Time2Crack mainly models the mode -a 0 (transfer rules), which covers the vast majority of actual hybrid attacks documented.
4.3 Order of candidates and prioritization strategy
The order in which candidates are tested is critical.
Strategy word-first (default hashcat): all rules are applied to W1 before switching to W2.(W1, R1), (W1, R2), ..., (W1, Rn), (W2, R1), (W2, R2)...
Advantage: if W1 is very likely (e.g. "password"), you quickly discover its variants.
Rule-first strategy : all wordlists are run for R1 before going to R2.
(W1, R1), (W2, R1), ..., (Wm, R1), (W1, R2), (W2, R2)...
Advantage: the most effective rule (: → mot brut) is applied first on all words. Often more effective for diverse corpus.
In practice, hashcat uses word-first by default but experienced operators choose according to the target profile.
5. Sets of mutation rules
5.1 Syntax of hashcat rules
The hashcat rules are expressed in a minimum language where each character represents an operation on the candidate string:
Case modifiers :: — Identity (gross word, no transformation)l — lowercase all ("PASSWORD" → "password")u — uppercase all ("password" → "PASSWORD")c — Capitalize first, lowercase rest ("PASSWORD" → "Password")C — Lowercase first, uppercase rest ("Password" → "pASSWORD")t — Toggle box of all characters ("Password" → "pASSWORD")TN — Toggle box from character to position Nr — Reverse ("password" → "drowssap")d — Duplicate ("password" → "passwordpassword")f — Reflect (word + reverse) ("sun" → "sunnos"){ — Rotate left ("password" → "asswordp")} — Rotate right ("password" → "dpasswor")[ — Remove first character ("password" → "assword")] — Remove last character ("password" → "passwor")$X — Append character X ("password" + $1 → "password1")^X — Prepend character X ("password" + ^1 → "1password")iNX — Insert character X at position NsXY — Replace all X by Y ("password" + s a @ → "p@ssword")SNX — Replace character at position N by X'N — Truncate at position N (password + '4 → "pass")DN — Delete character at position N<N — Apply the rule only if length < N>N — Apply the rule only if length > N=N — Apply the rule only if length = N5.2. Composite rules
Rules can be chained on a single line to create complex transformations:
c $1 → "Password1" (capitalize + append 1)
c $! $1 → "Password!1" (capitalize + append ! + 1)
s a @ s e 3 → "p@ssw3rd" (substitute a→@ and e→3)
r $1 → "1drowssap" (reverse + append 1)
u $2 $0 $2 $3 → "PASSWORD2023" (uppercase + append year)
Power is in the composition: 64 simple rules generate thousands of distinct transformations by combination.
5.3 Main Rules
best64.rule (Löfstrand, 2013) — 64 rules selected empirically on RockYou to maximize crack rate. Considered industry benchmark. OneRuleToRuleThemAll (NotSoSecure, 2019) — 52,218 rules generated by automatic learning on cracked password corpus. Crack rate greater than best64 of ~8% on modern corpus, at the cost of a calculation time ~800× longer. d3ad0ne.rule — 34,096 Community rules, focus on patterns not covered by best64 ( accents, extended characters, non-English patterns). live.rule — 99 000+ rules, the most exhaustive. Used for long-term cracking when others failed. Generalized2.rule (JtR) — Automatically generated by statistical analysis of already cracked passwords. Recalculated periodically as new leaks occur.6. Best64 rules: the reference game
Best64 is the set of 64 standard rules of reference in academic literature and industry. Here are the most important rules and their empirical justification:
6.1 The 20 most effective rules (in order of performance)
| Rank | Rule | Transformation | % of passwords covered (Ma 2014) |
|---|---|---|---|
| 1 | : | Raw word | ~18% |
| 2 | c | Capitalize first | ~11% |
| 3 | u | Uppercase all | ~6% |
| 4 | $1 | Append "1" | ~5% |
| 5 | l | Lowercase all | ~4% |
| 6 | $! | Append "!" | ~3% |
| 7 | s a @ | a→@ | ~2.8% |
| 8 | c $1 | Capitalize + "1" | ~2.5% |
| 9 | $2 | Append "2" | ~2.1% |
| 10 | r | Reverse | ~1.9% |
| 11 | $! + c | Capitalize + "!" | ~1.7% |
| 12 | s o 0 | o→0 | ~1.6% |
| 13 | d | Duplicate | ~1.4% |
| 14 | s e 3 | e→3 | ~1.3% |
| 15 | $1 $2 $3 | Append "123" | ~1.2% |
| 16 | c $1 $2 $3 | Capitalize + "123" | ~1.1% |
| 17 | $0 | Append "0" | ~1.0% |
| 18 | ^1 | Prepend "1" | ~0.9% |
| 19 | s i 1 | i→1 | ~0.8% |
| 20 | c $! $1 | Capitalize + "!1" | ~0.7% |
6.2 Why are these rules so effective?
Each top-10 rule corresponds to a common security policy constraint:
c)$1)$!)c $1 or c $1 $2 $3Password policies do not really increase security if users implement predictable transformations — they only move passwords to the second or third rule of best64.
7. Complete Taxonomy of Transformations
7.1 Category 1: Case transformations
Most common. Exploit the obligation to have a capital capital:
c changes)7.2 Category 2: Digital Suffixes and Prefixes
Exploit the obligation to have a figure:
7.3 Category 3: Leet substitutions
Systematic replacement of letters with similar numbers or symbols:
| Substitution | Empirical frequency |
|---|---|
| a → @ | 23% of passwords with @ |
| e → 3 | 31% of passwords with 3 |
| i → 1 | 19% of passwords with 1 |
| o → 0 | 27% of passwords with 0 |
| s → $ | 14% of passwords with $ |
| l → 1 | 8% |
| t → 7 | 6% |
| g → 9 | 4% |
Combined substitutions ("P@ssw0rd") appear complex but are generated in a few rules: c s a @ s o 0They are among the 500 first candidates On "password".
7.4 Category 4: Symbolic Suffixes
Exploit the obligation to have a special character:
7.5 Category 5: Structural transformations
Less frequent but useful for some profiles:
7.6 Category 6: Compound transformations (advanced level)
Complex rules combine several operations:
c $1 s a @ → "P@ssword1" (capitalize + append 1 + substitute a→@)
u $! $1 $2 $3 → "SUNSHINE!123" (uppercase + append !123)
r c $1 → "Drowssap1" (reverse + capitalize + append 1)
s e 3 s a @ c $! → "P@ssw3rd!" (multiple substitutions + capitalize + !)
These transformations seem very complex but remain detectable by a good set of rules. OneRuleToRuleThemAll contains thousands of these.
8. Frequency Priority: The Heart of Effectiveness
8.1. The frequency of the basic word determines the priority
An intelligent attacker does not apply the rules uniformly to all words. He prioritizes:
This strategy is implemented in hashcat via the sorting of the wordlist by decreasing frequency combined with the word-first strategy. It explains why "Password1" (derived from "password", the word #1) is cracked in milliseconds, while "Soleil1" (derived from "sun", word ~5000 from the French dictionary) may take a few seconds.
8.2 Median position in search space
The key measure is the median number of candidates tested before finding the target password. Ma et al. (2014) provide empirical measurements:
| Tier | Example | Median candidates before success |
|---|---|---|
| TOP100 | "password1", "P@ssword" | ~450–500 |
| Common dictionary (top-10k) | "Sunshine1", "sunshine!" | ~5,000–15,000 |
| Less common dictionary | "Papillon2024" | ~50,000–200,000 |
| Not in a dictionary | "Xk7#mP9q" | N/A (hybrid not applicable) |
These measurements are the direct basis of Time2Crack constants:
const HYBRID_KEYSPACE_COMMON = 500; // Ma et al. 2014 — median, top-100
const HYBRID_KEYSPACE_DICT = 8_000; // Ma et al. 2014 — median, common dictionary
const HYBRID_KEYSPACE_FULL = 128e6; // Gosney 2012 — best64 × 2M words, exhaustive
8.3 Conditions necessary for the hybrid to be applicable
Hybrid attack requires the password to be structurally derivable from a dictionary wordTime2Crack detects this condition via hybridVuln :
const hybridVuln = dictWord || (common && /[a-z]/i.test(pw));
dictWord = true : the password is or derives from a language wordlistcommon && lettre : the password appears in COMMON (HIBP top-400) and contains letters — so almost certainly derived from a wordIf dictWord neither hybridVuln are true — the password contains no detectable dictionary root — hybrid attack returns null (not applicable). A purely random password like "xK9#mQ7@" is not vulnerable to hybrid.
9. Implementation in Time2Crack: addHybridAttacks()
9.1 Complete annotated code
function addHybridAttacks(rows, hybridVuln, weak, common, dictWord) {
if (hybridVuln || weak) {
// Keyspace chosen from the popularity of the base word:
// common → word in HIBP top-400 → position ~500 in the attacker's list
// dictWord → word in the wordlist → position ~8000
// otherwise (hybridVuln without dictWord or common) → exhaustive scan ~128M
const hybridKS = common ? HYBRID_KEYSPACE_COMMON
: dictWord ? HYBRID_KEYSPACE_DICT
: HYBRID_KEYSPACE_FULL;
for (const a of ALGOS) {
rows.push({
atk: t("aHybrid"),
hash: a.name,
rate: a.rate,
// budgetTime: the keyspace IS the number of guesses — no division by 2
// (unlike bruteTime, candidates here are ordered by probability)
sec: weak ? weakGuessTime(a.rate) : budgetTime(hybridKS, a.rate),
note: weak ? t("nWeakPassword") : t("nDictMut"),
cat: "hybrid",
});
}
} else {
// Password with no dictionary structure → hybrid not applicable
rows.push({
atk: t("aHybrid"),
hash: "(all)",
rate: 0,
sec: null, // N/A in the table
note: t("nStructUnrecog"),
cat: "hybrid",
});
}
}
9.2 budgetTime vs bruteTime
The distinction between the two functions is fundamental:
// bruteTime: the attacker does not know where the password sits in the space.
// On average they test half of it before finding it. → keyspace/2
function bruteTime(keyspace, rate) {
const ls = Math.log(keyspace / 2) - Math.log(rate);
return Math.exp(ls);
}
// budgetTime: the attacker tests candidates in decreasing order of probability.
// The keyspace IS the expected number of candidates before a hit (median position).
// No division by 2 — the median is already built into the Ma 2014 constants.
function budgetTime(guesses, rate) {
const ls = Math.log(guesses) - Math.log(rate);
return Math.exp(ls);
}
For the hybrid, budgetTime is correct because the 500/8000/128M candidates are empirical estimates of the median position, not total space to travel.
9.3 Relationship with isDictWord()
Detection dictWord which conditions the choice of hybrid keyspace is produced by isDictWord() :
function isDictWord(pw) {
if (!DICT_WORDS || !DICT_WORDS.size) return false;
const l = pw.normalize("NFC").toLowerCase();
// Direct test: is the password in the dictionary as is?
if (DICT_WORDS.has(l)) return true;
// De-leeted test: "s0le1l" → "soleil" in the dictionary?
const dl = deLeet(pw);
if (dl !== l && DICT_WORDS.has(dl)) return true;
// Substring test: does "sunshine123" contain "sunshine" from the dictionary?
for (const w of DICT_WORDS) {
if (l.includes(w) && w.length >= 4) return true;
}
return false;
}
This detection determines not only whether the hybrid is applicable, but also which keyspace (common vs dict) is used to calculate time.
10. The three hybrid keyspaces and their justification
10.1 HYBRID_KEYSPACE_COMMON = 500
Background The password is in COMMON — the hardcoded list HIBP top-~400. These are some of the most common passwords in the world ("password", "letmein", "sunshine", "iloveyou"...).
Justification Ma et al. (2014) empirically measured that the median position of a top-1000 password in a hybrid list sorted by probability is ~450 candidates. The number 500 is a slightly conservative estimate to cover up to ~400 rank.
Interpretation : an attacker applying best64 to a wordlist sorted by frequency tests on average 500 candidates before finding the password. At 2,600 GH/s (MD5, 12× RTX 5090), 500 candidates = 0.19 ns. Practically instantaneous.
Example : "Sunshine1" → "sunshine" is in COMMON → HYBRID_KEYSPACE_COMMON = 500 → budgetTime(500, 2634e9) 0.19 ns.
10.2 HYBRID_KEYSPACE_DICT = 8,000
Background The password is derived from a word from the language wordlist, but not from COMMON. These are common vocabulary words ("sun", "mountain", "paillon"...) with transformations.
Justification Ma et al. (2014) measure a median position of 2,000 to 15,000 depending on the popularity of the word in RockYou. The empirical median is ~8,000. This keyspace reflects that the attacker tests the word and its variants after exhausting the more common candidates.
Interpretation : 8,000 candidates at 2,600 GH/s (MD5) = 3.0 ns. Always near-instantaneous for fast hashs. For bcrypt (114 kH/s): 8,000 / 114 000 0.07 seconds.
Example : "Soleil2024" → "sun" in fr.txt → HYBRID_KEYSPACE_DICT = 8,000 → a few nanoseconds on MD5, 0.07s on bcrypt.
10.3 HYBRID_KEYSPACE_FULL = 128,000,000
Background : hybridVuln is true (password has a dictionary structure) but neither common neither dictWord The attacker must browse the entire wordlist with all the rules.
Justification : Gosney (Passwordscon 2012) documents a wordlist of 3.5M words × best64 (64 rules) = 224M candidates in total. In practice, realistic wordlists make 2M words and the partial best64 runs stop at ~128M candidates before climbing towards wider rules.
Formula : 2_000_000 words × 64 rules = 128_000_000 candidates
Interpretation : 128M candidates at 2600 GH/s (MD5) 49 µs. On bcrypt (114 kH/s): ~19 minutes.
11. High fidelity calibration
11.1 Role of high fidelity mode
When high fidelity mode (HF) is activated in Time2Crack, an additional multiplier is applied to the calculated times to refine accuracy. For hybrid attack, this multiplier takes into account factors not captured by the basic keyspaces.
HF multiplicators for hybrid
In applyHighFidelityCalibration() :
case "hybrid":
// Very common words: cracked even earlier than the Ma 2014 median,
// because modern attackers sort word-first and rule-first at the same time.
// 30% reduction on times that are already short.
m *= context.common ? 0.7
: context.dictWord ? 0.8
: 1.0;
break;
Justification :
common : modern tools (hashcat with --markov-threshold) pre-set the rules by empirical effectiveness. The best candidates arrive even earlier. Reduction of 30%.dictWord : less effect because the position in the wordlist is less concentrated. Reduction of 20%.hybridVuln only (FULL keyspace): no reduction — full keyspace is already a conservative estimate.11.3 Interaction with the monotony guard
The monotony guard ensures that no specialized attack claims to be faster that the raw force on the alphabetical substring of the password:
// For each non-brute-force row:
const floorAlpha = bruteTime(Math.pow(26, alphaOnly.length), algo.rate);
if (row.sec < floorAlpha) row.sec = floorAlpha;
For short words (e.g., "cat" = 3 letters, floor = 26^3/rate
12. Relationship with derived attacks
12.1 Hybrid vs. Pure Dictionary
| Criterion | Pure dictionary | Hybrid |
|---|---|---|
| Candidates tested | Exact words from the list | Words + all their variants |
| Coverage (RockYou) | ~18% | ~79-85% (with best64) |
| Keyspace (200k words) | 200,000 | 200,000 × 64 = 12.8M |
| Applicability | Password = exact word | Password derived from a word |
| Vulnerable example | "sunshine" (exact) | "Sunshine1!", "sunsh1ne" |
| Resistant example | "Sunshine1" | "xK9#mQ7@" (no root word) |
12.2 Hybrid vs Rule-Based
The rule-based attack in Time2Crack is conceptually similar but with a much wider set of rules:
const RULE_KEYSPACE = 250_000_000; // vs 128M for full hybrid
The difference: the best64 model hybrid (64 rules, focus on common human transformations). The rule-based attack models wider games like d3ad0ne (34k rules) or OneRuleToRuleThemAll (52k rules), used when best64 fails. The rule-based is the "second line" hybrid — slower but more comprehensive.
12.3 Hybrid vs PCFG
PCFG (Probabilistic Context-Free Grammar, Weir 2009) models the grammatical structure of the password to generate candidates.
| Criterion | Hybrid | PCFG |
|---|---|---|
| Approach | Base word + transformation rules | Overall grammatical structure |
| Strength | Mutated existing words | "Word+Digits" type structures |
| Example | "sunshine" → "Sunshine1" | Detects the "Upper+lower+digit" structure |
| Complementarity | Triggers on dictWord | Triggers on a detected structure |
| Keyspace (Time2Crack) | 500 / 8k / 128M | pcfgKeyspace(pw), computed dynamically |
PCFG can attack passwords without root dictionary if their structure is common (ex: "Thelonious8" → no word of the dico but structure Capitalize+lower+digit very predictable).
12.4 Hybrid vs Morphological (morph)
The morphological attack tests linguistic variants (flexions, variations). It is a generalization of the hybrid for languages with rich morphology:
The hybrid operates on the surface of the word (character transformations), the morphological operates on the lexical structure (derivation, bending), and they are complementary.
13. Benchmarks by hash algorithm
13.1 Time for the three hybrid keyspaces (12× RTX 5090)
| Algorithm | Rate (H/s) | COMMON (500) | DICT (8k) | FULL (128M) |
|---|---|---|---|---|
| MD5 | 2,634 GH/s | 0.19 ns | 3.0 ns | 49 μs |
| SHA-1 | 837 GH/s | 0.60 ns | 9.6 ns | 153 μs |
| SHA-256 | 332 GH/s | 1.5 ns | 24 ns | 386 μs |
| NTLM | 4,081 GH/s | 0.12 ns | 2.0 ns | 31 μs |
| bcrypt (cost 10) | 114 kH/s | 4.4 ms | 0.07 s | 19 min |
| Argon2id | 1,000 H/s | 0.5 s | 8 s | 36 hours |
13.2 Impact of the attacking profile
Time2Crack offers two profiles (Experienced 12 GPU, Professional 100 GPU). For the hybrid, the profile difference is directly proportional:
| Profile | GPUs | Multiplier | FULL bcrypt |
|---|---|---|---|
| Experienced | 12× RTX 5090 | 1× | 19 min |
| Professional | ~100 GPU | ~8× | ~2 min |
For MD5, SHA-1, NTLM: the profile changes the time from microseconds to nanoseconds — without any practical impact, both are instantaneous.
14. Concrete examples of hybrid cracking
14.1 Example 1: "Password1" (COMMON)
Analysis :isCommon("Password1") → false (not in exact HIBP)isDictWord("Password1") → true ("password" in DICTWORDS in lower case)COMMON.has("password") → true → common = trueHYBRID_KEYSPACE_COMMON = 500: (gross word "password" → no), c ("Password" → no), c $1 ("Password1" → FIND, row ~8)
14.2 Example 2: "Sun2024" (DICT)
Analysis :isCommon("Soleil2024") → falseisDictWord("Soleil2024") → true ("sun" in fr.txt)COMMON.has("soleil") → false → common = false, dictWord = trueHYBRID_KEYSPACE_DICT = 8,000c $2 $0 $2 $4 ("Sun2024") in the row ~3 of its rules → overall position ~15 003.
14.3 Example 3: "p@pillon!" (DICT with substitutions)
Analysis :isDictWord("p@pillon!") : de-leetification → "paillon" → in fr.txt → dictWord = trueHYBRID_KEYSPACE_DICT = 8,000s a @ $! → "p@pillon!" in row ~12. Overall position: ~180,000. Always good in HYBRID_KEYSPACE_DICT.
14.4 Example 4: "xK9#mQ7@" (resistant)
Analysis :isDictWord("xK9#mQ7@") → false (no root dictionary)isCommon("xK9#mQ7@") → falsehybridVuln = falsesec = null → hybrid not applicableThis password cannot be cracked by hybrid attack. It has no dictionary root. The attacker must use pure brute force, PCFG or statistical attacks (Markov, Neural).
14.5 Example 5: "LinkedInB3st!"
Analysis :isDictWord("LinkedInB3st!") : "linkedin" → wordlist en.txt + deLeet("b3st") → "best" → dictWord = trueHYBRID_KEYSPACE_DICT = 8,000Interesting case: the password contains two roots ("linkedin" and "best" via de-leetification). Hybrid attack is applicable because at least one root is detected. In practice, a combinator attack (two words glued) would be even more effective here.
15. Hybrid Attack Limits
15.1 Intrinsic limits
Dependence on the quality of the wordlist : if the basic word is not in the wordlist, the hybrid cannot work. A password based on a very specialized term (neologism, obscure technical term, word of a rare language) can resist if it is absent from all common wordlists. Incomplete coverage of transformations : even OneRuleToRuleThemAll with 52k rules does not cover 100% of imaginable transformations. Some very rare transformations (base64 partial encodings, invented patterns) escape the rules. Combinatory Explosion with Long Wordlists At 2,600 GH/s (MD5), it takes ~190 seconds — but with bcrypt (114 kH/s), ~140 years. The scalability of the hybrid is constrained by the length of the wordlist and the slowness of the hash algorithm.15.2 What Time2Crack does not capture
Context Wordlists : an attacker targeting a specific company will build a wordlist with the name of the company, products, employee names, business terms. "Renault2024!" would be cracked instantly by an attacker targeting Renault — but Time2Crack does not model this context (this is the role of the "Targeted OSINT" attack). Multi-pass composite rules Some passwords resist best64 but give in to two-pass rules (apply one rule, then apply another rule on the result). Time2Crack model only one rule pass. Cache Effects and Memorization : hashcat maintains a table of candidates already tested to avoid duplicates, which accelerates runs in practice. Not modelled in Time2Crack (conservative).15.3 Cases where the hybrid is overestimated
Time2Crack can overestimate hybrid speed in two cases:
16. Effective defences
16.1 What resists hybridization
Hybrid attack fails if the password does not derive from any existing dictionary wordEffective strategies:
Random passwords "xK9#mQ7@vP2!" contains no dictionary root. No hybrid rule can generate it. Resistance: maximum. Password generators : password managers (Bitwarden, 1Password, KeePass) generate random strings. No root dictionary → hybrid inapplicable. Passphrases of really random words : "tabouret-marmot-ginger-flash" — four random words. Hybrid attack in classical mode does not generate combinations of 4 words (this is the role of the combinator). Passphrase resists the standard hybrid.16.2 What is NOT Resistance to Hybrid
The most common "strengthening" strategies do not resist:
| Strategy | Example | Resistance |
|---|---|---|
| Capitalize the first letter | "Sunshine" | ❌ Rule c, rank 2 |
| Add a digit | "sunshine1" | ❌ Rule $1, rank 4 |
| Add a symbol | "sunshine!" | ❌ Rule $!, rank 6 |
| Replace e→3 | "sunshin3" | ❌ Rule s e 3, top-20 |
| Combine everything | "Sunshin3!" | ❌ Composite rule, top-100 |
| Choose a rare word | "papillon123" | ❌ Still in wordlists |
| Double the word | "sunsun" | ❌ Rule d, top-30 |
| Reverse | "enihsnus" | ❌ Rule r, top-15 |
16.3. Resistant hash algorithms
Even if a password is vulnerable to the structural hybrid, the hash algorithm can make the attack economically inviable:
| Algorithm | Time for DICT (8k guesses) | Attack in practice |
|---|---|---|
| MD5 / NTLM | ~3 nanoseconds | Instant |
| SHA-256 | ~24 nanoseconds | Instant |
| bcrypt cost 10 | ~0.07 seconds | Trivial |
| bcrypt cost 14 | ~1 second | Feasible |
| Argon2id (default) | ~8 seconds | Feasible |
| Argon2id (strong parameters) | ~100 seconds | Slow but possible |
16.4 Practical recommendations
17. References
Academic publications
Klein, D.V. (1990) "Foiling the Cracker": A Survey of, and Improvements to, Password Security Proceedings of the USENIX Security Workshop, 1990. — First empirical study quantifying the impact of mutation rules on cracking coverage. Notes that 56% of passwords are crackable with dictionary + simple transformations. Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009) Password Tracking Using Probabilistic Context-Free Grammars IEEE Symposium on Security and Privacy (S&P), 2009. — Founded the PCFG model and valid by the way that the hashcat rules cover 78% of the human transformations observed in RockYou. Ma, J., Yang, W., Luo, M., & Li, N. (2014) A Study of Probabilistic Password Models IEEE Symposium on Security and Privacy (S&P), 2014. — Direct reference study for Time2Crack: empirical measurement of median positions (500 for top-100, 2000–15000 for current dict) in a hybrid scan ordered by probability on 10M real passwords. Durmuth, M., Chaabane, A., Perito, D., & Castelluccia, C. (2015) When Privacy meetings Security: Leveraging Personal Information for Password Tracking ESORICS 2015. — Compare rules JtR vs Hashcat vs PCFG. Concludes that best64 surpasses PCFG by 12% on RockYou. Veras, R., Collins, C., & Thorpe, J. (2014) On the Semantic Patterns of Passwords and their Security Impact NDSS 2014. — Language analysis of semantic patterns. Ur, B., Bees, J., Segreti, S. M., Bauer, L., Christin, N., & Cranor, L. F. (2015) Do Users' Perceptions of Password Security Match Reality? ACM CHI 2015. — Demonstrates that users systematically overestimate the strength of mutated passwords. "P@ssw0rd" receives a subjective score of "strong" but is cracked in < 1s. Wheeler, D.L. (2016) zxcvbn: Low-Budget Password Strength Estimate 25th USENIX Security Symposium, 2016. — Force estimation library integrating mutation rule detection. Reference for the implementation of detection heuristics.Industrial conferences and presentations
Gosney, J (2012) 8x Nvidia GTX 580 Cluster Hashcat Benchmarks / LinkedIn crack session Passwordscon 2012, Oslo. — Document the LinkedIn crack: best64 + wordlist 3.5M = 224M candidates, 90% cracked in 6 days. Basis forHYBRID_KEYSPACE_FULL = 128M.
Löfstrand, K. (2013)
best64.rule — Empirical selection of 64 hashcat rules
Internal, published on GitHub.
— Set of 64 rules selected empirically on RockYou to maximize crack rate. Industry reference standard.
Steube, J. (2016–present)
Hashcat Advanced Password Recovery
https://hashcat.net/hashcat/
— Official mode documentation -a 0, -a 6, -a 7. Syntax of rules. Official GPU benchmarks on 12× RTX 5090.
NotSoSecure (2019)
OneRuleToRuleThemAll — ML-generated hashcat rule set
https://github.com/NotSoSecure/password_cracking_rules
— 52 218 rules generated by automatic learning on corpus of cracked passwords.
Reference tools
John the Ripper (Solar Designer, 1996–present) https://www.openwall.com/john/ — Pioneer of the wordlist+rules hybrid. JtR syntax always used in parallel with Hashcat. Hashcat (Steube, 2009–present) https://hashcat.net/hashcat/ — Reference GPU implementation. Modes -a 0/6/7 for hybrid. best64 integrated. RockYou wordlist (2009) 14,3M clear passwords. Standard calibration corpora for all hybrid rule sets. SecLists (Daniel Miessler, 2012–present) https://github.com/danielmiessler/SecLists — Collection of wordlists by language, domain, theme. Main source of Time2Crack language wordlists.Web sources cited in the Time2Crack application
Chick3nman (Hashcat benchmarks/rules). https://gist.github.com/Chick3nman/32e662a5bb63bc4f51b847bb4222fd — Related sourcedescHybrid (app.js) for the order of magnitude of the mutation rules applied.
IEEE Xplore (hybrid reference).
https://ieeexplore.ieee.org/document/6956583
— Related source descHybrid (app.js) concerning the empirical effectiveness of mutated passwords.
Document generated as part of the Time2Crack project — 2026 See also: BRUTEFORCEATTACKEXPLAINED.md, MARKOVATTACKEXPLAINED.md, DICTIONARYATTACKEXPLAINED.md*