Attacco ibrido — Funzionamento completo
Documento di riferimento del progetto Time2Crack
Recipienti: sviluppatori, ricercatori di sicurezza, utenti avanzati
Contenuto
addHybridAttacks()1. Panoramica
Attacco ibrido è il metodo di cracking che combina un dizionario con un insieme di regole di trasformazioneInvece di testare ogni parola nel dizionario in quanto è (attacco del dizionario puro), genera sulla mosca tutte le varianti plausibili di ogni parola — capitalizzazioni, sostituzioni dei caratteri, aggiunte prefisso/suffix, inversioni — e li testa sistematicamente.
Perché è così efficace? Gli esseri umani non scelgono "password" come password, scelgono "Password1", "p@ssw0rd", "PASSWORD123" o "password!". Queste varianti sembrano più forti perché non sono nella lista del dizionario grezzo - ma sono tra i primi generati da qualsiasi strumento di cracking ibrido moderno. L'attaccante sfrutta esattamente la stessa euristica "segreta" che l'utente applica.L'attacco ibrido è storicamente il metodo responsabile per la maggior parte dei veri "mean" cracking password - quelli che sembrano essere forti senza essere forti. le prime regole da 8 a 10 applicate a una parola corrente sufficiente per rompere la password mediana popolazione.
In Time2Crack, l'attacco ibrido modellato:
2. Sfondo storico e accademico
2.1 Origini: regole John the Ripper and mutation
L'attacco ibrido è nato formalmente con Giovanni lo Squartatore (Solar Designer, 1996), il primo strumento pubblico per combinare una lista di parole con un motore di regola configurabile. Prima di John the Ripper, il dizionario attacca parole crude testate; John ha introdotto la nozione che ogni parola genera una famiglia di candidati.
Cronologia delle pietre miliari :| Anno | Evento |
|---|---|
| 1979 | Morris & Thompson: gli utenti sostituiscono i numeri di lettere per "sicuro" le loro password |
| 1996 | John the Ripper 1.0: primo motore di regola pubblico, sintassi JtR (:♪ c♪ u♪ r♪ d... |
| 2000 | Alec Muffett documenta che l'80% del vero cracking passa attraverso wordlist+rules, non forza bruta |
| 2006 | Hashcat 0.01: migrazione su GPU, le regole vanno da 1M→1000M candidati/secondo |
| 2009 | RockYou: 14.3M password chiare consentono la calibrazione empirica delle regole più efficaci |
| 2012 | Gosney (Passwordscon): 8 GPU GTX 580, best64 regole, crack 90% LinkedIn in < 6 giorni |
| 2013 | Löfstrand: pubblica "best64.rule", 64 regole che coprono l'85-90% delle attuali trasformazioni umane |
| 2014 | Ma et al. (IEEE S&P): primo studio accademico che quantifica l'efficacia del rango di regola |
| 2016 | Hashcat open source: integrato best64, velocità MD5 2 TH/s su 8× GTX 1080 |
| 2019 | Hashcat 6.0: OneRuleToRuleAll game (regole 52k) generato da ML su corpus di password |
| 2023 | NSA Advisory: consiglia esplicitamente di testare password aziendali con strumenti ibridi |
2.2 Studi empirici fondati
Klein (1990) — Analisi di 15.000 password Unix. Riconosce che il 24,2% sono crackabili per puro dizionario, ma che il 32% in più sono crackabili con semplici trasformazioni (capitalizzazione, aggiunta di cifra finale). Weir et al. (2009, IEEE S&P) — Propone il modello PCFG ma valido per il modo in cui le regole hashcat coprono il 78% delle trasformazioni osservate in RockYou. Dimostra che le password "Password1" e "P@ssw0rd" sono tra i primi 100 candidati generati da best64 sulla parola "password". Ma et al. (2014, IEEE S&P) — Lo studio più citato sull'efficacia delle regole ibride.- Articolo 1 (
: → mot brut) : crack 18% delle password basate sulle ditte
2.3 LinkedIn volo come caso scolastico
La perdita LinkedIn 2012 (6,5 milioni di SHA-1 non salsi) illustra perfettamente la potenza dell'ibrido.
L'analisi post-crack ha rivelato che "linkedin1", "Linkedin1", "l!nked!n" e "LINKEDIN" — tutte le varianti di "linkedin" — rappresentavano collettivamente decine di migliaia di account compromessi.
3. Fondazioni concettuali: Perché i lavori ibridi
3.1 Il comportamento umano della "sicurezza"
Quando un sistema impone regole di complessità (majuscule, numero, simbolo), gli utenti non generano casuali — essi applicare le trasformazioni prevedibili alle parole memorizzabili :
| Strategia umana | Esempio | Regola ibrida corrispondente |
|---|---|---|
| Maiuscola alla prima lettera | "sunshine" → "Sunshine" | c (capitalize first) |
| Tutto maiuscolo | "sunshine" → "SUNSHINE" | u (uppercase all) |
| Aggiungere una cifra alla fine | "sunshine" → "sunshine1" | $1 (append "1") |
| Aggiungere l'anno | "sunshine" → "sunshine2024" | $2 $0 $2 $4 |
| Sostituire e→3 | "sunshine" → "sunshin3" | s e 3 (substitute e by 3) |
| Sostituire a→@ | "password" → "p@ssword" | s a @ |
| Invertire la parola | "sunshine" → "enihsnus" | r (reverse) |
| Raddoppiare la parola | "sun" → "sunsun" | d (duplicate) |
| Aggiungere un ! finale | "sunshine" → "sunshine!" | $! |
| Combinarne diverse | "password" → "P@ssw0rd1" | c s a @ s o 0 $1 |
Queste trasformazioni sembra creativo all'utente. esattamente i primi che l'attaccante prova Esse corrispondono ai vincoli imposti dalle politiche di sicurezza.
3.2 Il concetto di spazio ridotto efficiente
Una password di 10 caratteri con lettere+digits+symbols ha una forza chiave raw di 94^10, 5,4 × 10^19 combinazioni. Troppo grande per viaggiare in un tempo ragionevole.
Ma se questa password è "Password1!" — una trasformazione banale di "password" — è tra i 500 primi candidati L'attaccante non viaggia 5,4 × 10^19 combinazioni: viaggia 500.
Questa è la riduzione fondamentale dell'attacco ibrido: lo spazio reale delle scelte umane è astronomicamente più piccolo dello spazio teorico dei possibili personaggi.
3.3 La legge del potere della trasformazione
Proprio come le password crude seguono una legge di potere (Zipf), le trasformazioni che gli esseri umani applicano seguono anche una distribuzione molto concentrata.
Questa concentrazione consente ad un insieme di 64 regole ben scelte (best64) di raggiungere una copertura del 79-85%, dove 64 regole casuali raggiungerebbero solo il 10-15%.
3.4 Interazione con la popolarità della parola di base
Più comune è la parola di base, prima la parola d'ordine derivata è nell'elenco prioritario dell'attaccante. L'attaccante ordina ai suoi candidati di diminuire la probabilità:
Candidati generati dall'attaccante (ordine di test):
password (parola grezza, la più comune)
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! (combinazione complessa)
"password" è la parola più comune → i suoi derivati sono testati prima. "papillon" è meno comune → i suoi derivati sono testati molto più tardi. Questa priorità è il meccanismo centrale che spiega i tre distinti keyspace di Time2Crack.
4. Architettura di un moderno attacco ibrido
4.1 Condotto generale
Fase 1: Selezione della wordlist
├── Password trapelate ordinate per frequenza (RockYou, HIBP, Collections)
├── Dizionari linguistici (fr.txt, en.txt, de.txt...)
├── Wordlist tematiche (nomi propri, città, marchi, serie TV)
└── Wordlist contestuali (dominio bersaglio, nomi dei dipendenti, termini di settore)
Fase 2: Selezione del set di regole
├── best64.rule (riferimento equilibrato, 64 regole)
├── OneRuleToRuleThemAll.rule (52.000 regole, generate con ML)
├── d3ad0ne.rule (34.000 regole, empiriche)
├── Regole JtR (generated.rule, specific.rule, extra.rule)
└── Regole personalizzate (adattate al dominio bersaglio)
Fase 3: Espansione (wordlist × regole)
├── Per ogni parola w della wordlist:
│ Per ogni regola r del set:
│ candidato = apply(r, w)
│ Se candidato ≠ w e candidato non ancora provato:
│ coda_candidati.push(candidato)
└── Ordine: (w1, regola1), (w1, regola2)... (w2, regola1)...
oppure: (w1, regola1), (w2, regola1)... secondo la strategia
Fase 4: Hashing e confronto (GPU)
├── Invio di lotti di ~10M candidati alla GPU
├── Calcolo parallelo degli hash (SIMD, 219 GH/s per MD5)
├── Confronto con l'hash o gli hash bersaglio
└── In caso di corrispondenza: TROVATO — log(candidato, hash, regola)
Fase 5: Report
└── Candidato craccato + regola usata + posizione nella lista
4.2 Modalità di funzionamento Hashcat
Hashcat implementa l'ibrido in due modi distinti:
Modalità -a 0 (elenco delle parole + regole) : per ogni parola della lista delle parole, applicare tutte le regole, questa è la modalità ibrida classica.hashcat -a 0 -m 0 hashes.txt rockyou.txt -r best64.rule
Modalità -a 6 (parola + maschera) : combina una wordlist con una maschera posizionale. Genera tutte le combinazioni word + masked_suffix.
hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
# Tries "sunshine0000", "sunshine0001", ..., "sunshine9999"
Modalità -a 7 (maschera + wordlist) : inverso — prefisso mascherato + parola.
hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
# Tries "00sunshine", "01sunshine", ..., "99sunshine"
Time2Crack modella principalmente la modalità -a 0 (regole di trasferimento), che copre la maggior parte degli attacchi ibridi reali documentati.
4.3 Ordine dei candidati e strategia di priorità
L'ordine in cui i candidati sono testati è fondamentale.
Principio di strategia (hashcat di default): tutte le regole vengono applicate a W1 prima di passare a W2.(W1, R1), (W1, R2), ..., (W1, Rn), (W2, R1), (W2, R2)...
Vantaggio: se W1 è molto probabile (ad esempio "password"), si scopre rapidamente le sue varianti.
La prima strategia : tutte le liste di parole vengono eseguite per R1 prima di andare a R2.
(W1, R1), (W2, R1), ..., (Wm, R1), (W1, R2), (W2, R2)...
Vantaggio: la regola più efficace (: → mot brut) viene applicato prima su tutte le parole. Spesso più efficace per vari corpus.
In pratica, hashcat utilizza word-first per impostazione predefinita, ma gli operatori esperti scelgono secondo il profilo di destinazione.
5. Set di regole di mutazione
5.1 Sintassi delle regole di hashcat
Le regole hashcat sono espresse in una lingua minima in cui ogni personaggio rappresenta un'operazione sulla stringa del candidato:
Modifica dei casi :: — Identità (parola grezza, nessuna trasformazione)l — minuscolo tutto ("PASSWORD" → "password")u — maiuscolo tutto ("password" → "PASSWORD")c — Capitalizzare in primo luogo, il riposo minuscolo ("PASSWORD" → "Password")C — In primo luogo, il resto maiuscolo ("Password" → "pASSWORD")t — Toggle box di tutti i caratteri ("Password" → "pASSWORD")TN — Toggle box dal carattere alla posizione Nr — Inverso ("password" → "drowssap")d — Duplicare ("password" → "passwordpassword")f — Riflettere (parola + inverso) ("sun" → "sunnos"){ — Ruotare a sinistra ("password" → "asswordp")} — Ruota destra ("password" → "dpasswor")[ — Rimuovere il primo carattere ("password" → "assword")] — Rimuovere l'ultimo carattere ("password" → "passwor")$X — Appendice carattere X ("password" + $1 → "password1"^X — Prepend carattere X ("password" + ^1 → "1password")iNX — Inserisci il carattere X nella posizione NsXY — Sostituire tutto X per Y ("password" + s a @ → "p@ssword")SNX — Sostituire il carattere nella posizione N di X'N — Truncate nella posizione N (password + '4 → "passo")DN — Eliminare il carattere nella posizione N<N — Applicare la regola solo se la lunghezza < N>N — Applicare la regola solo se la lunghezza > N=N — Applicare la regola solo se la lunghezza = N5.2. Regole compositi
Le regole possono essere incatenate su una singola linea per creare trasformazioni complesse:
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)
Il potere è nella composizione: 64 regole semplici generano migliaia di trasformazioni distinte per combinazione.
5.3 Regole principali
best64.rule (Löfstrand, 2013) — 64 regole selezionate empiricamente su RockYou per massimizzare il tasso di crepa. OneRuleToRuleThemAll (NotSoSecure, 2019) — 52.218 regole generate da apprendimento automatico su corpus di password cracked. Tasso di cravatta maggiore del ~8% sul corpus moderno, al costo di un tempo di calcolo ~800× più lungo. d3ad0ne.rule — 34.096 norme comunitarie, si concentrano su modelli non coperti da best64 (accento, caratteri estesi, modelli non inglesi). live.rule — 99 000+ regole, la più esaustiva, utilizzata per la fessura a lungo termine quando altri fallirono. Generalized2.rule (JtR) — Automaticamente generato dall'analisi statistica delle password già incrinate. Ricalcolato periodicamente come si verificano nuove perdite.6. Best64 regole: il gioco di riferimento
Best64 è l'insieme di 64 regole standard di riferimento nella letteratura e nell'industria accademica.
6.1 Le 20 regole più efficaci (in ordine di prestazioni)
| Posizione | Regola | Trasformazione | % di password coperte (Ma 2014) |
|---|---|---|---|
| 1 | : | Parola invariata | ~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 Perché queste regole sono così efficaci?
Ogni regola top-10 corrisponde ad un vincolo di politica di sicurezza comune:
c)$1)$!)c $1 o c $1 $2 $3Le politiche di password non aumentano realmente la sicurezza se gli utenti implementano trasformazioni prevedibili — spostano solo le password alla seconda o terza regola del best64.
7. Totale tassonomia delle trasformazioni
7.1 Categoria 1: Trasformazioni dei casi
Sfrutta l'obbligo di avere un capitale:
c modifiche)7.2 Categoria 2: Suffissi e prefissi digitali
Sfrutta l'obbligo di avere una cifra:
7.3 Categoria 3: Sostituzioni delle perdite
Sostituzione sistematica di lettere con numeri o simboli simili:
| Sostituzione | Frequenza empirica |
|---|---|
| a → @ | 23% delle password con @ |
| e → 3 | 31% delle password con 3 |
| i → 1 | 19% delle password con 1 |
| o → 0 | 27% delle password con 0 |
| s → $ | 14% delle password con $ |
| l → 1 | 8% |
| t → 7 | 6% |
| g → 9 | 4% |
Le sostituzioni combinate ("P@ssw0rd") appaiono complesse ma sono generate in poche regole: c s a @ s o 0Sono tra i 500 primi candidati Su "password".
7.4 Categoria 4: Suffissi simbolici
Sfrutta l'obbligo di avere un carattere speciale:
7.5 Categoria 5: Trasformazioni strutturali
Meno frequente ma utile per alcuni profili:
7.6 Categoria 6: Trasformazioni composte (livello avanzato)
Le regole complesse combinano diverse operazioni:
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 + !)
Queste trasformazioni sembrano molto complesse ma rimangono rilevabili da un buon insieme di regole. OneRuleToRuleThemAll contiene migliaia di queste.
8. Priorità di frequenza: Il Cuore di efficacia
8.1. La frequenza della parola di base determina la priorità
Un aggressore intelligente non applica le regole uniformemente a tutte le parole.
Questa strategia viene implementata in hashcat attraverso la selezione della lista delle parole diminuendo la frequenza combinata con la prima strategia di parola. Si spiega perché "Password1" (derivato da "password", la parola #1) è incrinato in millisecondi, mentre "Soleil1" (derivato da "sun", parola ~5000 dal dizionario francese) può richiedere alcuni secondi.
8.2 Posizione mediana nello spazio di ricerca
La misura chiave è il numero mediano di candidati testati prima di trovare la password di destinazione. Ma et al. (2014) forniscono misurazioni empiriche:
| Categoria | Esempio | Mediana dei candidati prima del successo |
|---|---|---|
| TOP100 | "password1", "P@ssword" | ~450–500 |
| Dizionario comune (top-10k) | "Sunshine1", "sunshine!" | ~5.000–15.000 |
| Dizionario meno frequente | "Papillon2024" | ~50.000–200.000 |
| Fuori dizionario | "Xk7#mP9q" | N/A (ibrido non applicabile) |
Queste misure sono la base diretta delle costanti Time2Crack:
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 Condizioni necessarie per l'ibrido da applicare
Attacco ibrido richiede la password per essere strutturalmente derivabile da una parola dizionarioTime2Crack rileva questa condizione tramite hybridVuln :
const hybridVuln = dictWord || (common && /[a-z]/i.test(pw));
dictWord = true : la password è o deriva da una lista linguisticacommon && lettre : la password appare in COMMON (HIBP top-400) e contiene lettere — così quasi certamente derivate da una parolaSe dictWord # hybridVuln sono veri — la password non contiene radice del dizionario rilevabile — ibrido attacco restituisce null Una password puramente casuale come "xK9#mQ7@" non è vulnerabile all'ibrido.
9. Attuazione in Time2Crack: addHybridAttacks()
9.1 Codice annotato completo
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 contro bruteTime
La distinzione tra le due funzioni è fondamentale:
// 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);
}
Per l'ibrido, budgetTime è corretto perché i candidati 500/8000/128M sono stime empiriche delle posizione mediana, non totale spazio per viaggiare.
9.3 Rapporto con isDictWord()
Rilevazione dictWord che condiziona la scelta del keyspace ibrido è prodotta da 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;
}
Questa rilevazione determina non solo se l'ibrido è applicabile, ma anche quale spazio chiave (comune vs dict) viene utilizzato per calcolare il tempo.
10. I tre settori chiave ibridi e la loro giustificazione
10.1 HYBRID_KEYSPACE_COMMON = 500
Contesto La password è in COMMON — la lista codificata HIBP top-~400. Queste sono alcune delle password più comuni del mondo ("password", "letmein", "sunshine", "iloveyou"...).
Giustificazione Ma et al. (2014) empiricamente misurato che la posizione mediana di una password top-1000 in un elenco ibrido ordinato per probabilità è ~450 candidati. Il numero 500 è una stima leggermente conservatrice per coprire fino a ~400 rango.
Interpretazione : un aggressore che applica il best64 ad una lista di parole ordinata da test di frequenza in media 500 candidati prima di trovare la password. 0,19 ns. Praticamente istantaneo.
Esempio : "Sunshine1" → "sunshine" è in COMMON → HYBRID_KEYSPACE_COMMON = 500 → budgetTime(500, 2634e9) 0.19 ns.
10.2 HYBRID_KEYSPACE_DICT = 8.000
Contesto La parola d'ordine deriva da una parola del wordlist di lingua, ma non da COMMON. Queste sono parole comuni del vocabolario ("sun", "mountain", "paillon"...) con trasformazioni.
Giustificazione Ma et al. (2014) misurano una posizione mediana da 2.000 a 15.000 a seconda della popolarità della parola in RockYou. La mediana empirica è ~8,000. Questo spazio chiave riflette che l'attaccante testa la parola e le sue varianti dopo esaurimento dei candidati più comuni.
Interpretazione : 8.000 candidati a 2.600 GH/s (MD5) = 3,0 ns. Sempre quasi istantaneo per hash veloci. Per bcrypt (114 kH/s): 8.000 / 114 000 0,07 secondi.
Esempio : "Soleil2024" → "sun" in fr.txt → HYBRID_KEYSPACE_DICT = 8.000 → pochi nanosecondi su MD5, 0.07s su bcrypt.
10.3 HYBRID_KEYSPACE_FULL = 128.000
Contesto : hybridVuln è vero (password ha una struttura del dizionario) ma né common # dictWord L'aggressore deve sfogliare l'intera lista delle parole con tutte le regole.
Giustificazione : Gosney (Passwordscon 2012) documenta una lista di parole di 3.5M × best64 (64 regole) = 224M candidati in totale. In pratica, i wordlist realistici fanno 2M parole e i migliori64 parziali si fermano a ~128M candidati prima di salire verso regole più ampie.
Formula : 2_000_000 parole × 64 regole = 128_000_000 candidati
Interpretazione : 128M candidati a 2600 GH/s (MD5) 49 µs. Su bcrypt (114 kH/s): ~19 minuti.
11. Taratura ad alta fedeltà
11.1 Ruolo di alta fedeltà
Quando la modalità di alta fedeltà (HF) viene attivata in Time2Crack, un moltiplicatore aggiuntivo viene applicato ai tempi calcolati per affinare la precisione.
moltiplicatori HF per ibridi
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;
Giustificazione :
common : strumenti moderni (hashcat con --markov-threshold) preimpostare le regole per efficacia empirica; i migliori candidati arrivano ancora prima. Riduzione del 30%.dictWord : meno effetto perché la posizione nella lista dei testi è meno concentrata. Riduzione del 20%.hybridVuln solo (spazio chiave COMPLETA): nessuna riduzione — lo spazio chiave completo è già una stima conservatrice.11.3 Interazione con la guardia monotona
La guardia monotona assicura che nessun attacco specializzato sostiene di essere più veloce che la forza cruda sulla sottostringa alfabetica della password:
// For each non-brute-force row:
const floorAlpha = bruteTime(Math.pow(26, alphaOnly.length), algo.rate);
if (row.sec < floorAlpha) row.sec = floorAlpha;
Per brevi parole (ad esempio, "cat" = 3 lettere, piano = 26^3/rate
12. Rapporto con attacchi derivati
12.1 Dizionario ibrido vs. Pure
| Criterio | Dizionario puro | Ibrido |
|---|---|---|
| Candidati provati | Parole esatte della lista | Parole + tutte le loro varianti |
| Copertura (RockYou) | ~18% | ~79-85% (con best64) |
| Keyspace (200k parole) | 200.000 | 200.000 × 64 = 12,8M |
| Applicabilità | Password = parola esatta | Password derivata da una parola |
| Esempio vulnerabile | "sunshine" (esatta) | "Sunshine1!", "sunsh1ne" |
| Esempio resistente | "Sunshine1" | "xK9#mQ7@" (nessuna radice) |
12.2 Hybrid vs RuleBased
L'attacco basato sulla regola in Time2Crack è concettualmente simile ma con un insieme molto più ampio di regole:
const RULE_KEYSPACE = 250_000_000; // vs 128M for full hybrid
La differenza: il modello ibrido best64 (64 regole, si concentrano sulle trasformazioni umane comuni). I modelli di attacco basati su regole più ampi giochi come d3ad0ne (regole 34k) o OneRuleToRuleThemAll (regole 52k), utilizzati quando best64 fallisce.
12.3 Hybrid vs PCFG
PCFG (Probabilistic Context-Free Grammar, Weir 2009) modella la struttura grammaticale della password per generare candidati.
| Criterio | Ibrido | PCFG |
|---|---|---|
| Approccio | Parola base + regole di trasformazione | Struttura grammaticale globale |
| Punto di forza | Parole esistenti modificate | Strutture di tipo "Parola+Cifre" |
| Esempio | "sunshine" → "Sunshine1" | Rileva la struttura "Maiusc+minusc+cifra" |
| Complementarità | Si attiva su dictWord | Si attiva su una struttura rilevata |
| Keyspace (Time2Crack) | 500 / 8k / 128M | pcfgKeyspace(pw), calcolato dinamicamente |
PCFG può attaccare le password senza root dizionario se il loro struttura è comune (ex: "Thelonious8" → nessuna parola del dico ma struttura Capitalize+lower+digit molto prevedibile).
12.4 Hybrid vs Morphological (morph)
L'attacco morfologico prova le varianti linguistiche (flessioni, variazioni) è una generalizzazione dell'ibrido per le lingue con ricca morfologia:
L'ibrido opera sulla superficie della parola (trasformazioni di caratteri), la morfologica opera sulla struttura lessicale (derivation, bending), e sono complementari.
13. Benchmarks per algoritmo di hash
13.1 Tempo per i tre settori chiave ibridi (12× RTX 5090)
| Algoritmo | Velocità (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 (costo 10) | 114 kH/s | 4,4 ms | 0,07 s | 19 min |
| Argon2id | 1.000 H/s | 0,5 s | 8 s | 36 ore |
13.2 Impatto del profilo di attacco
Time2Crack offre due profili (esperti 12 GPU, Professional 100 GPU). Per l'ibrido, la differenza del profilo è direttamente proporzionale:
| Profilo | GPU | Moltiplicatore | FULL bcrypt |
|---|---|---|---|
| Esperto | 12× RTX 5090 | 1× | 19 min |
| Professionista | ~100 GPU | ~8× | ~2 min |
Per MD5, SHA-1, NTLM: il profilo cambia il tempo da microsecondi a nanosecondi — senza alcun impatto pratico, entrambi sono istantanei.
14. Esempi concreti di cracking ibrido
14.1 Esempio 1: "Password1" (COMMON)
Analisi :isCommon("Password1") → falso (non in esatto HIBP)isDictWord("Password1") → true ("password" in DICTWORDS in caso inferiore)COMMON.has("password") → vero → common = trueHYBRID_KEYSPACE_COMMON = 500: (grossa parola "password" → no), c ("Password" → no), c $1 ("Password1" → FINO, fila ~8)
14.2 Esempio 2: "Sun2024" (DICT)
Analisi :isCommon("Soleil2024") → falsoisDictWord("Soleil2024") → true ("sun" in fr.txt)COMMON.has("soleil") → falsi → common = false♪ dictWord = trueHYBRID_KEYSPACE_DICT = 8.000c $2 $0 $2 $4 ("Sun2024") nella riga ~3 delle sue regole → posizione complessiva ~15 003.
14.3 Esempio 3: "p@pillon!" (DICT con sostituzioni)
Analisi :isDictWord("p@pillon!") : de-leetification → "paillon" → in fr.txt → dictWord = trueHYBRID_KEYSPACE_DICT = 8.000s a @ $! → "p@pillon!" in fila ~12. Posizione complessiva: ~180,000. Sempre buono in HYBRID_KEYSPACE_DICT.
14.4 Esempio 4: "xK9#mQ7@" (resistente)
Analisi :isDictWord("xK9#mQ7@") → falso (non dizionario radice)isCommon("xK9#mQ7@") → falsohybridVuln = falsesec = null → ibrido non applicabileQuesta password non può essere decifrata da attacchi ibridi. Non ha radice del dizionario. L'attaccante deve usare la forza bruta pura, PCFG o attacchi statistici (Markov, Neural).
14.5 Esempio 5: "LinkedInB3st!"
Analisi :isDictWord("LinkedInB3st!") : "linkedin" → wordlist en.txt + deLeet("b3st") → "migliore" → dictWord = trueHYBRID_KEYSPACE_DICT = 8.000Caso interessante: la password contiene due radici ("linkedin" e "best" via de-leetification). L'attacco ibrido è applicabile perché almeno una radice viene rilevata. In pratica, un attacco combinatore (due parole incollate) sarebbe ancora più efficace qui.
15. Limiti di attacco ibridi
15.1 Limiti intrinseci
Dipendenza dalla qualità della wordlist : se la parola di base non è nella wordlist, l'ibrido non può funzionare. Una password basata su un termine molto specializzato (neologismo, termine tecnico oscuro, parola di una lingua rara) può resistere se è assente da tutti i wordlist comuni. Copertura incompleta delle trasformazioni : anche OneRuleToRuleThemAll con le regole 52k non copre il 100% delle trasformazioni immaginabili. Esplosione combinata con Long Wordlist A 2.600 GH/s (MD5), ci vogliono ~190 secondi — ma con bcrypt (114 kH/s), ~140 anni. La scalabilità dell'ibrido è ostacolata dalla lunghezza della wordlist e dalla lentezza dell'algoritmo hash.15.2 Che Time2Crack non cattura
Context Wordlists : un aggressore che si rivolge a una specifica società costruirà una lista di parole con il nome della società, prodotti, nomi dei dipendenti, termini di business. "Renault2024!" verrebbe incrinato immediatamente da un aggressore che si rivolge a Renault - ma Time2Crack non modella questo contesto (questo è il ruolo dell'attacco "Targeted OSINT". Regole composte multipass Alcune password resistere best64 ma dare a due regole di passaggio (applicare una regola, quindi applicare un'altra regola sul risultato). Cache Effetti e Memorizzazione : hashcat mantiene una tabella di candidati già testati per evitare duplicati, che accelera le operazioni in pratica.15.3 Casi dove l'ibrido è sopravvalutato
Time2Crack può sovrastimare la velocità ibrida in due casi:
16. Efficace difesa
16.1 Che cosa resiste all'ibridazione
Attacco ibrido fallisce se la password non deriva da nessuna parola di dizionario esistenteStrategie efficaci:
Password casuali "xK9#mQ7@vP2!" non contiene radice del dizionario. Nessuna regola ibrida può generarla. Resistenza: massimo. Generatori di password : password manager (Bitwarden, 1Password, KeePass) generano stringhe casuali. Nessun dizionario root → ibrido inapplicabile. Passafrasi di parole davvero casuali : "tabouret-marmot-ginger-flash" — quattro parole casuali. L'attacco ibrido in modalità classica non genera combinazioni di 4 parole (questo è il ruolo del combinatore). Passphrase resiste al ibrido standard.16.2 Che cosa non è resistenza all'ibrido
Le più comuni strategie di "strengthening" non resistono:
| Strategia | Esempio | Resistenza |
|---|---|---|
| Maiuscola alla prima lettera | "Sunshine" | ❌ Regola c, posizione 2 |
| Aggiungere una cifra | "sunshine1" | ❌ Regola $1, posizione 4 |
| Aggiungere un simbolo | "sunshine!" | ❌ Regola $!, posizione 6 |
| Sostituire e→3 | "sunshin3" | ❌ Regola s e 3, top-20 |
| Combinare tutto | "Sunshin3!" | ❌ Regola composta, top-100 |
| Scegliere una parola rara | "papillon123" | ❌ Comunque nelle wordlist |
| Raddoppiare la parola | "sunsun" | ❌ Regola d, top-30 |
| Invertire | "enihsnus" | ❌ Regola r, top-15 |
16.3. algoritmi di hash resistenti
Anche se una password è vulnerabile all'ibrido strutturale, l'algoritmo hash può rendere l'attacco economicamente inviabile:
| Algoritmo | Tempo per DICT (8k tentativi) | Attacco in pratica |
|---|---|---|
| MD5 / NTLM | ~3 nanosecondi | Istantaneo |
| SHA-256 | ~24 nanosecondi | Istantaneo |
| bcrypt costo 10 | ~0,07 secondi | Banale |
| bcrypt costo 14 | ~1 secondo | Fattibile |
| Argon2id (predefinito) | ~8 secondi | Fattibile |
| Argon2id (parametri robusti) | ~100 secondi | Lento ma possibile |
16.4 Raccomandazioni pratiche
17. Riferimenti
Pubblicazioni accademiche
Klein, DV (1990) "Foiling the Cracker": un sondaggio e miglioramenti a, sicurezza delle password Atti del Laboratorio di Sicurezza USENIX, 1990. — Primo studio empirico che quantifica l'impatto delle regole di mutazione sulla copertura di cracking. Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009) Tracciamento di password Utilizzo di Grammatica Probabilistica Context-Free IEEE Symposium on Security and Privacy (S&P), 2009. — Fondato il modello PCFG e valido dal modo in cui le regole hashcat coprono il 78% delle trasformazioni umane osservate in RockYou. Ma, J., Yang, W., Luo, M., & Li, N. (2014) Uno studio di modelli di password probabilistic IEEE Symposium on Security and Privacy (S&P), 2014. — Studio di riferimento diretto per Time2Crack: misurazione empirica delle posizioni mediane (500 per top-100, 2000–15000 per la ditta corrente) in una scansione ibrida ordinata per probabilità su 10M password reali. Durmuth, M., Chaabane, A., Perito, D., & Castelluccia, C. (2015) Quando incontri sulla privacy Sicurezza: Levare i dati personali per il monitoraggio delle password ESORICS 2015. — Confronta le regole JtR vs Hashcat vs PCFG. Conclude che best64 supera PCFG del 12% su RockYou. Veras, R., Collins, C., & Thorpe, J. (2014) Sui modelli semantici delle password e il loro impatto di sicurezza NDSS 2014. — Analisi linguistica dei modelli semantici. Ur, B., Api, J., Segreti, S. M., Bauer, L., Christin, N., & Cranor, L. F. (2015) I vantaggi degli utenti di Password Security Match Reality? ACM CHI 2015. "P@ssw0rd" riceve un punteggio soggettivo di "forte" ma è incrinato in < 1s. Wheeler (2016) zxcvbn: stima della forza di password a basso costo 25th USENIX Simposio di sicurezza, 2016. — Biblioteca di stima della forza che integra il rilevamento delle regole di mutazione.Conferenze e presentazioni industriali
Gosney, J (2012) 8x Nvidia GTX 580 Cluster Hashcat Benchmarks / sessione di crack LinkedIn Passwordscon 2012, Oslo. — Documentare la crepa LinkedIn: best64 + wordlist 3.5M = 224M candidati, 90% incrinato in 6 giorni. Base diHYBRID_KEYSPACE_FULL = 128M.
Löfstrand (2013)
best64.rule — Selezione empirica di 64 regole hashcat
Interno, pubblicato su GitHub.
— Set di 64 regole selezionate empiricamente su RockYou per massimizzare il tasso di crepa.
Steube, J. (2016–presente)
Hashcat Advanced Password Recovery
https://hashcat.net/hashcat/
— Documentazione ufficiale in modalità 0, -a 6, -a 7. Sintassi delle regole.
NotSoSecure (2019)
OneRuleToRuleThemAll — set di regola di hashcat generato ML
https://github.com/NotSoSecure/password_cracking_rules
— 52 218 regole generate dall'apprendimento automatico su corpus di password screpolate.
Strumenti di riferimento
Giovanni lo Squartatore (Solar Designer, 1996-presente) https://www.openwall.com/john/ — Pioniere del wordlist+rules ibrido. JtR sintassi sempre utilizzata in parallelo con Hashcat. Hashcat (Steube, 2009–presente) https://hashcat.net/hashcat/ — implementazione GPU di riferimento. Modalità -a 0/6/7 per ibrido. best64 integrato. Condividi su Twitter (2009) 14,3M password chiare. Corpora di calibrazione standard per tutti i set di regole ibride. SecLismo (Daniel Miessler, 2012–presente) https://github.com/danielmiessler/SecLists — Raccolta di liste di parole per lingua, dominio, tema.Fonti web citate nell'applicazione Time2Crack
Chick3nman (Hashcat benchmarks/rules). https://gist.github.com/Chick3nman/32e662a5bb63bc4f51b847bb4222fd — Fonti correlatedescHybrid (app.js) per l'ordine di grandezza delle regole di mutazione applicate.
IEEE Xplore (riferimento ibrido).
https://ieeexplore.ieeee.org/document/6956583
— Fonti correlate descHybrid (app.js) riguardante l'efficacia empirica delle password mutate.
Documento generato come parte del progetto Time2Crack — 2026 Vedi anche: BRUTEFORCEATTIVITÀESPLAINED.md, MARKOVATTIVITÀESPLAINED.md, DICZIONALEATTIVITÀESPLOSIONE