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 : AnnoEvento ---------------- 1979Morris & Thompson: gli utenti sostituiscono i numeri di lettere per "sicuro" le loro password 1996John the Ripper 1.0: primo motore di regola pubblico, sintassi JtR (:♪ c♪ u♪ r♪ d...
2000Alec Muffett documenta che l'80% del vero cracking passa attraverso wordlist+rules, non forza bruta
2006Hashcat 0.01: migrazione su GPU, le regole vanno da 1M→1000M candidati/secondo
2009RockYou: 14.3M password chiare consentono la calibrazione empirica delle regole più efficaci
2012Gosney (Passwordscon): 8 GPU GTX 580, best64 regole, crack 90% LinkedIn in < 6 giorni
2013Löfstrand: pubblica "best64.rule", 64 regole che coprono l'85-90% delle attuali trasformazioni umane
2014Ma et al. (IEEE S&P): primo studio accademico che quantifica l'efficacia del rango di regola
2016Hashcat open source: integrato best64, velocità MD5 2 TH/s su 8× GTX 1080
2019Hashcat 6.0: OneRuleToRuleAll game (regole 52k) generato da ML su corpus di password
2023NSA 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 umanaEsempioRegola ibrida correlata ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Capitalizzare la prima lettera"sunshine" → "Sunshine"c (capitalizzare prima)
Conta tutto"sunshine" → "SUNSHINE"u (in ogni caso)
Aggiungi una cifra alla fine"sunshine" → "sunshine1"$1 (appends "1")
Aggiungi anno"sunshine" → "sunshine2024"$2 $0 $2 $4
Sostituire e→3"sunshine" → "suns3ine"s e 3 (sostituito da 3)
Sostituire a→@"password" → "p@ssword"s a @
Parola inversa"sunshine" → "enihsnus"r (riverse)
Doppia parola"sun" → "sunsun"d (duplicato)
Aggiungi! finale"sunshine" → "sunshine!"$!
Combinare più"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à:
Candidats générés par l'attaquant (ordre de test) :
password (grossa, parola più comune)
Password (capitalizzare prima)
password1 ($1)
PASSWORD (in ogni caso)
password!
p@ssword (sostituto a→@)
passw0rd (sostituto o→0)
Password1 (c + $1)
P@ssword (c + s a @)
password123 ($12$3)
...
p@sssW0rd! (complesso di combinazione)
"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
Phase 1 : Sélection de la wordlist
├── Passwords fuités triés par fréquence (RockYou, HIBP, Collections)
├── Dictionnaire linguistique (fr.txt, en.txt, de.txt...)
├── Wordlists thématiques (prénoms, villes, marques, séries TV)
└── Wordlists contextuelles (domaine cible, noms d'employés, termes métier)
Fase 2: Selezione del gioco Regole
- best64.rule (riferimento equilibrato, 64 regole)
OneRuleToRuleThemAll.rule (52,000 regole, ML-generato)
D3ad0ne.rule (34,000 regole, empiriche)
- Regole JtR (generalized.rule, specific.rule, extra.rule)
- Regole personalizzate (adattate al dominio target)
Fase 3: Espansione (regole ×)
Per ogni parola w in wordlist:
Per ogni regola r nel regolamento:
ό richiedente = domanda(r, w)
Promozionale Se candidato
Promozionale codadellacandidati.push(candidate)
--Ordine: (w1, regola1), (w1, regola2)... (w2, regola1)...
o: (w1, rule1), (w2, regola1)... secondo la strategia
Fase 4: Haching e Confronto (GPU)
- - Inviare per lotto di ~10M candidati alla GPU
- Calcolo parallelo di hash (SIMD, 168 GH/s per MD5)
- Confronto con hash(es) target
Se corrisponde: FINDED — log(candidate, hash, regola)
Fase 5: Reporting
- - candidato + regola usata + rango in 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 mot + suffixemascherato.
hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
Test "sunshine0000", "sunshine0001", ..., "sunshine9999"
Modalità -a 7 (maschera + wordlist) : inverso — prefisso mascherato + parola.
hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
Test "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 - 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→@ et 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)
RankArticoloTrasformazione% password coperte (maggio 2014) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 1:Parola lorda~18% ~
2cCapitalizzare prima~11% ~
3uTutti-6%
4$1Appendice "1"~5%
5lValutare tutto~4%
6$!Appendice "!"~3%
7s a @a →~2.8%
8c $1Capitalizzare + "1"-2.5%
9$2Appendice "2"2,1 %
10rIndietro~1,9%
11$! + cCapitalizzare + "!"~1,7%
12s o 0o~1,6%
13dDuplicare~1,4%
14s e 3e→3~ 1,3 %
15.$1 $2 $3Appendice "123"- 1,2%
16c $1 $2 $3Capitalizzare + "123"1,1%
17$0Appendice "0"~1,0%
18^1Prep "1"~0,9%
19s i 1ii)~0,8%
20c $! $1Capitalizzare + "!1"~ 0,7%
Regole di cumulo 1-10 : ~55% delle password basate sulle ditte
Regole di cumulo 1-20 : ~68% delle password basate sulle ditte
Regole di cumulo 1–64 : ~ 79% delle password basate sulle ditte
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:
SostituzioneFrequenza empirica ----------------------------- a →23% di password con @ e → 331% di password con 3 I → 119% di password con 1 o → 027% di password con 0 s → $14% di password con $ l → 18% t → 76% g → 94%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:
TerzoEsempioI candidati mediani prima di trovare ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- TOP100"password1", "P@ssword"~450–500 Ditta comune (top-10k)"Sunshine1", "sunshine!"5 000-15 000 Meno comune"Paillon2024"- 50 000 - 200.000 Senza dizionario"Xk7#mP9q"N/A (ibrida inapplicabile)Queste misure sono la base diretta delle costanti Time2Crack:
const HYBRIDKEYSPACECOMMON = 500; // Ma et al. 2014 — médiane top-100
const HYBRIDKEYSPACEDICT = 8000; // Ma et al. 2014 — dittatore corrente mediana
const HYBRIDKEYSPACEFULL = 128e6; // Gosney 2012 — best64 × 2M parole esaustive
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) {
// Sélection du keyspace selon la popularité du mot de base :
// common → mot dans HIBP top-400 → position ~500 dans la liste de l'attaquant
// dictWord → mot dans la wordlist → position ~8000
// sinon (hybridVuln sans dictWord ni common) → scan exhaustif ~128M
const hybridKS = common ? HYBRIDKEYSPACECOMUNIONE
DictWord? HYBRIDKEYSPACEDICT
: HYBRIDKEYSPACEFULL;
per (const a of ALGOS) {
Voce principale:
t("aHybrid"),
hash: a.name,
tasso: a.rate,
// budgetTime: lo spazio chiave è il numero di ipotesi — nessuna divisione di 2
// (a differenza di BrutTime, qui i candidati sono ordinati per probabilità)
asciutto: debole ? deboleGuessTime(a.rate): budgetTime(hybridKS, a.rate),
t("nWeakPassword") : t("nDictMut")
gatto: "ibrido",
});
#
} altro {
// Password senza struttura dizionario → ibrido inapplicabile
Voce principale:
t("aHybrid"),
hah: "(tutti)"
tasso: 0,
asciutto: null, // N/A nella tabella
nota: t(nStructUnrecog),
gatto: "ibrido",
});
#
#
9.2 budgetTime contro bruteTime
La distinzione tra le due funzioni è fondamentale:
// bruteTime : l'attaquant ne sait pas où est le mot de passe dans l'espace.
// Il teste en moyenne la moitié avant de le trouver. → keyspace/2
function bruteTime(keyspace, rate) {
const ls = Math.log(keyspace / 2) - Math.log(rate);
return Math.exp(ls);
}
// budgetTime: l'attaccante testa i candidati in ordine descrescente di probabilità.
// Keyspace È il numero di candidati attesi prima di trovare (posizione mediana).
// Nessuna divisione di 2 — la mediana è già incorporata nelle costanti Ma 2014.
funzione di bilancioTempo (ospite, tasso) {
const ls = Math.log(guesses) - Math.log(rate);
ritorna 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 (!DICTWORDS || !DICT(WORDS.size) restituire falso;
const l = pw.normalize("NFC"). toLowerCase();
// Test diretto: la password è nel dizionario?
se (DICT)
WORDS.has(l)) return true;
// Prova leetificata: "s0le1l" → "sun" nel dico?
const dl = deLeet(pw);
se (dl!)WORDS.has(dl) ritorna vero;
// Test substring: "sunshine123" contiene "sunshine" nel dico?
per (const w di DICTWORDS) {
se (l.includes(w) & w.length >= 4) ritorna vero;
#
ritorna falso;
#
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 HYBRIDKEYSPACECOMMON = 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,25 picosecondi. Praticamente istantaneo. Esempio : "Sunshine1" → "sunshine" è in COMMON → HYBRIDKEYSPACECOMMON = 500 →budgetTime(500, 2027e9) 0.25 nanosecondi.
10.2 HYBRIDKEYSPACEDICT = 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.000 GH/s (MD5) = 4 nanosecondi. Sempre quasi istantaneo per hash veloci. Per bcrypt (69 kH/s): 8.000 / 69 000 0,12 secondi. Esempio : "Soleil2024" → "sun" in fr.txt → HYBRIDKEYSPACEDICT = 8.000 → pochi nanosecondi su MD5, 0.12s su bcrypt.10.3 HYBRIDKEYSPACEFULL = 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 : 2000000 mots × 64 règles = 128000000 candidats
Interpretazione : 128M candidati a 2000 GH/s (MD5) 64 microsecondi. Su bcrypt (69 kH/s): ~31 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":
// Mots très courants : crackés encore plus tôt que la médiane Ma 2014
// car les attaquants modernes trient word-first + règle-first simultanément.
// Réduction de 30% sur les temps déjà courts.
m = contesto.common? 0.7
: contesto.dictWord? 0.8
- 1.0;
Rompere;
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:
// Pour chaque row non-brute :
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
CriteriDizionario puroibrido --------------------------- Candidati testatiElenco corretto paroleParole + tutte le loro varianti Copertura (RockYou)~18% ~~79-85% (con best64) Keyspace (200k parole)200 000200 000 × 64 = 12.8M ApplicabilitàPassword = parola esattaPassword derivata da una parola Esempio flessibile"sunshine" (esatto)"Sunshine1!", "sunsh1ne" Esempio resistente"Sunshine1""xK9#mQ7@" (senza 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 RULEKEYSPACE = 250000000; // vs 128M per full ibrido
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.
CriteriibridoPCF ---------------------- ApproccioParola di base + regole di trasformazioneStruttura grammaticale globale ForzaLe parole esistenti mutanoStruttura tipo "parola + cifre" Esempio"sunshine" → "Sunshine1"Rileva la struttura "Caps+lower+digit" ComplementariTriggers ondictWordTrigger sulla struttura rilevata
Keyspace (Time2Crack)500 / 8k / 128MpcfgKeyspace(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 4090)
AlgoritmoTasso (H/s)COMMON (500)DICT (8k)FULL (128M) -------------------------------------------- MD52 027 GH/s0.25 ps3.9 ns63 μ SHA-1610 GH/0,80 ps13 ns210 μ SHA-256272 GH/1,84 p29 ns470 μ NT13.462 GH/s0,14 ps2.3 ns37 μ bcrypt (costo 10)69 kH/7,2 ms0,1231 min Argon2id800 H/s0.6251044 ore Lettura : per MD5 e NTLM, anche lo spazio chiave FULL (128M candidati) è incrinato in poche dozzine di microsecondi. L'algoritmo hash è quasi irrilevante per parole comuni. Argon2id è l'unico algoritmo che resiste in modo significativo anche per parole comuni: 0,625 secondi per una parola COMMON, 10 secondi per un dictWord. Questi tempi rimangono brevi in valore assoluto, ma rappresentano un rallentamento di x10^12 vs MD5 — facendo attacchi su larga scala economicamente invisibili.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:
ProfiloGPUsMultiploFULL Bcrypt ------------------------------------- Esperienza12 × RTX 4090131 min Professionista- 100 GPU♪~4 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 = true: (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 = truec $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 = trues a @ $! → "p@pillon!" in fila ~12. Posizione complessiva: ~180,000. Sempre buono in HYBRIDKEYSPACEDICT.
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 = trueCaso 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.000 GH/s (MD5), ci vogliono ~250 secondi — ma con bcrypt (69 kH/s), ~230.000 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:
StrategiaEsempioResistenza --------------------- Capitalizzare la prima letteraSoleArticoloc, fila 2
Aggiungi una cifra"sunshine1"Articolo $1, fila 4
Aggiungi il simbolo"Sunshine!"Articolo $!, fila 6
Sostituire e→3"suns3ine"Articolo s e 3, top-20
Combina tutto"Suns3ine!"Regola composita, top-100
Scegli una parola rara"Papillon123"
Doppia parola"sunsun"Articolo d♪
Indietro"enihsnus"Articolo r, top-15
Conclusioni Qualsiasi strategia basata su "prendere una parola + modificarla" è vulnerabile all'ibrido. L'eccezione è una modifica così complessa e rara che non è coperta da alcuna regola — ma se l'utente deve ricordare questa complessa trasformazione, di solito finisce per scegliere qualcosa prevedibile.
16.3. algoritmi di hash resistenti
Anche se una password è vulnerabile all'ibrido strutturale, l'algoritmo hash può rendere l'attacco economicamente inviabile:
AlgoritmoTempo per DICT (8k indovina)Attacco pratica ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- MD5 / NTLM< 1 nanosecondoistanza istantanea SHA-256~30 nanosecondiistanza istantanea costo di bcrypt 10~0.12 secondiTriviale bcrypt costo 14- 32 secondiFessura Argon2id (default)10 secondiFessura Argon2id (forte parametrate)100 secondiLenta ma possibile Argon2id con parametri elevati (t=4, m=65536) è l'unico algoritmo che rende l'ibrido davvero costoso, anche su password deboli.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.KEYSPACEFULL = 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/passwordcrackingregole — 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