Attacco ibrido — Funzionamento completo

Documento di riferimento del progetto Time2Crack
Recipienti: sviluppatori, ricercatori di sicurezza, utenti avanzati

Contenuto

  • Panoramica
  • Sfondo storico e accademico
  • Fondazioni concettuali: Perché i lavori ibridi
  • Architettura di un moderno attacco ibrido
  • Il gioco delle regole di mutazione
  • Best64 regole: il gioco di riferimento
  • Totale tassonomia delle trasformazioni
  • Priorità di frequenza: il cuore dell'efficienza
  • Attuazione in Time2Crack: addHybridAttacks()
  • I tre keyspace ibridi e la loro giustificazione
  • Taratura ad alta fedeltà
  • Rapporti con attacchi derivati
  • Benchmarks per algoritmo di hash
  • Esempi concreti di cracking ibrido
  • Limiti di attacco ibridi
  • Efficace difesa
  • Referenze

  • 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:

  • Il rilevamento che la password è o deriva da una parola del dizionario
  • La stima del numero di candidati un aggressore dovrebbe verificare prima di trovare la variante esatta
  • Calcolo del tempo corrispondente secondo l'algoritmo di hash target

  • 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 (:curd... 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.
  • Regole 1-10: crack 51%
  • Regole 1–64 (full best64): crack 79%
  • Regole 1–500: crack 88%
  • Conclusione chiave Le prime 10 regole fanno la maggior parte del lavoro.
  • Durmuth et al. (2015, ESORICS) — Valuta le regole JtR vs Hashcat vs PCFG. Conclude che le regole Hashcat best64 sono empiricamente le più efficaci per le password chiare osservate, superando PCFG del 12% sulla copertura RockYou.

    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.

  • 100% password in top-10M wordlist (pure dizionario)
  • 90% di più tramite best64 + Combineatorattack
  • password resistenti: solo quelle senza alcuna struttura del dizionario
  • 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.

  • ~5% delle trasformazioni ("add 1 alla fine", "capitalizzare la prima lettera") coprire ~50% dei casi reali
  • ~20% delle trasformazioni coprono ~85% dei casi
  • Il restante 80% delle trasformazioni copre solo il 15% dei casi
  • 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 N
  • Rimozioni e inversioni :
  • r — 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")
  • Altre caratteristiche :
  • $X — Appendice carattere X ("password" + $1 → "password1"
  • ^X — Prepend carattere X ("password" + ^1 → "1password")
  • iNX — Inserisci il carattere X nella posizione N
  • Sostituzione :
  • sXY — Sostituire tutto X per Y ("password" + s a @ → "p@ssword")
  • SNX — Sostituire il carattere nella posizione N di X
  • Truncazioni :
  • 'N — Truncate nella posizione N (password + '4 → "passo")
  • DN — Eliminare il carattere nella posizione N
  • Condizione :
  • - 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 = N
  • 5.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:

  • "Shall have a capital capital capital" → utenti capitalizzare la prima lettera (c)
  • "deve avere un numero" → gli utenti aggiungono "1" alla fine ($1)
  • "Shall have a symbol" → gli utenti aggiungono "!" ($!)
  • "deve avere lettere e numeri" → c $1 o c $1 $2 $3
  • Le 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:

  • Capitalizzare la prima lettera: "sunshine" → "Sunshine" (regola più comune dopo la parola cruda)
  • Tutti i casi: "sunshine" → "SUNSHINE"
  • Toggle alterna: "sunshine" → "sUnShInE"
  • Ultima lettera maiuscola: "sunshine" → "sunshine"
  • CamelCase: "sunshinE" (approssimato da c modifiche)
  • Prevalenza : Klein (1990) nota che il 41% delle "passwords con capitali" consiste semplicemente della parola con la prima lettera in capitali.

    7.2 Categoria 2: Suffissi e prefissi digitali

    Sfrutta l'obbligo di avere una cifra:

  • Appendice cifra singola: parola+"0" a parola+"9"
  • Appendice due cifre: parola+"00" a parola+"99" (100 combinazioni)
  • Allegato anno: parola+"1990" a parola+"2024" (35 combinazioni frequenti)
  • Appendice "123" o "1234" (molto comune)
  • Numero singolo: "1"+mot à "9"+mot
  • Anno precedente: "2024"+parola
  • Prevalenza Veras et al. (2014) trovano che il ~73% delle password "obbligatorie" aggiungono la cifra in suffisso.

    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:

  • Appendice "!": il simbolo più frequentemente aggiunto (~35% di aggiunte simboliche)
  • Appendice "?": ~8%
  • Appendice "#" : ~6%
  • Appendice "@": ~5%
  • Appendice ".: ~4%
  • Appendice "!!": ~3%
  • Prepends "!": meno frequente (~10% dei casi vs 35% per il suffisso)
  • Kombinaison : word + "1!" è così comune che è generata sistematicamente dal best64. "sunshine1!" è tra i primi 200 candidati generati su "sunshine".

    7.5 Categoria 5: Trasformazioni strutturali

    Meno frequente ma utile per alcuni profili:

  • Inversione: "sun" → "naked" (corrente per alcuni gruppi)
  • Duplicazione: "sun" → "sunsun" (password per sistemi che limitano a 8 serbatoi risolti a 16)
  • Rotazione: "password" → "asswordp"
  • Truncation + aggiunta: "passw" + "1"
  • 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.

  • Parole più comuni (top-100 RockYou/HIBP) × tutte le regole
  • Parole moderatamente comuni (top-10k) × regole più efficaci
  • Parole meno frequenti (tutti i dizionario) × prime regole
  • 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 linguistica
  • common && lettre : la password appare in COMMON (HIBP top-400) e contiene lettere — così quasi certamente derivate da una parola
  • Se 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 :
  • Per common : strumenti moderni (hashcat con --markov-threshold) preimpostare le regole per efficacia empirica; i migliori candidati arrivano ancora prima. Riduzione del 30%.
  • Per dictWord : meno effetto perché la posizione nella lista dei testi è meno concentrata. Riduzione del 20%.
  • Per 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 on dictWordTrigger 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:

  • Ibrido: "sun" → "Sun1", "s0leil", "sun!"
  • Morfologico: "sun" → "sun", "sun", "solar", "sun"
  • 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
  • Risultato: HYBRIDKEYSPACECOMMON = 500
  • Tempo MD5 : 500 / 2.027e12 0,25 picosecondi (snapshot) Tempo bcrypt costo 10 : 500 / 69 000 7,2 millisecondi Regole testate prima di trovare : : (grossa parola "password" → no), c ("Password" → no), c $1 ("Password1" → FINO, fila ~8)

    14.2 Esempio 2: "Sun2024" (DICT)

    Analisi :
  • isCommon("Soleil2024") → falso
  • isDictWord("Soleil2024") → true ("sun" in fr.txt)
  • COMMON.has("soleil") → falsi → common = falsedictWord = true
  • Risultato: HYBRIDKEYSPACEDICT = 8.000
  • Tempo MD5 : 8 000 / 2.027e12 3.9 nanosecondi Tempo bcrypt costo 10 : 8 000 / 69 000 0,12 secondi Regole di prova : l'attaccante arriva a "sun" a ~5000 nella lista delle parole fr ordinati per frequenza, quindi si applica c $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 = true
  • Risultato: HYBRIDKEYSPACEDICT = 8.000
  • Regole di prova : "paillon" a ~ 15.000 del dizionario fr. Regola s 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@") → falso
  • hybridVuln = false
  • Risultati: sec = nullibrido non applicabile
  • Questa 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 = true
  • Risultato: HYBRIDKEYSPACEDICT = 8.000
  • Caso 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:

  • password lunghe Una password di 20 caratteri basata su un dizionario di parola ("incomprehensibleities1!") viene rilevata come un dizionario, ma gli strumenti ibridi di solito filtrano i candidati troppo a lungo.
  • Lingue con ricca morfologia Turco, Finlandese, Ungherese hanno parole più complesse. "Güneş2024" può passare sotto i radar se la lista di parole turca non include tutte le forme morfologiche.

  • 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 letteraSoleArticolo c, 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

  • Utilizzare un password manager : genera puro ibrido casuale, inapplicabile
  • Se necessario : 4+ parole in realtà passphrase casuale (da EFF)
  • Mai "sicurare" una parola per sostituzione : l'ibrido li genera automaticamente
  • Richiedere bcrypt cost ≥ 12 o Argon2id lato server: l'unico vero rallentatore
  • Abilita MFA : rende offline cracking teorico senza impatto operativo

  • 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 correlate descHybrid (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