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 (:♪ 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.
  • 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 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.

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

    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 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 :
  • <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 = 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→@ 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)

    PosizioneRegolaTrasformazione% di password coperte (Ma 2014)
    1:Parola invariata~18%
    2cCapitalize first~11%
    3uUppercase all~6%
    4$1Append "1"~5%
    5lLowercase all~4%
    6$!Append "!"~3%
    7s a @a→@~2,8%
    8c $1Capitalize + "1"~2,5%
    9$2Append "2"~2,1%
    10rReverse~1,9%
    11$! + cCapitalize + "!"~1,7%
    12s o 0o→0~1,6%
    13dDuplicate~1,4%
    14s e 3e→3~1,3%
    15$1 $2 $3Append "123"~1,2%
    16c $1 $2 $3Capitalize + "123"~1,1%
    17$0Append "0"~1,0%
    18^1Prepend "1"~0,9%
    19s i 1i→1~0,8%
    20c $! $1Capitalize + "!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% delle password con @
    e → 331% delle password con 3
    i → 119% delle password con 1
    o → 027% delle password con 0
    s → $14% delle 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:

    CategoriaEsempioMediana 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 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) {
        // 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 :
  • 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:

    // 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

    CriterioDizionario puroIbrido
    Candidati provatiParole esatte della listaParole + 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 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.

    CriterioIbridoPCFG
    ApproccioParola base + regole di trasformazioneStruttura grammaticale globale
    Punto di forzaParole esistenti modificateStrutture di tipo "Parola+Cifre"
    Esempio"sunshine" → "Sunshine1"Rileva la struttura "Maiusc+minusc+cifra"
    ComplementaritàSi attiva su dictWordSi attiva su una 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 5090)

    AlgoritmoVelocità (H/s)COMMON (500)DICT (8k)FULL (128M)
    MD52.634 GH/s0,19 ns3,0 ns49 μs
    SHA-1837 GH/s0,60 ns9,6 ns153 μs
    SHA-256332 GH/s1,5 ns24 ns386 μs
    NTLM4.081 GH/s0,12 ns2,0 ns31 μs
    bcrypt (costo 10)114 kH/s4,4 ms0,07 s19 min
    Argon2id1.000 H/s0,5 s8 s36 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,5 secondi per una parola COMMON, 8 secondi per un dictWord. Questi tempi rimangono brevi in valore assoluto, ma rappresentano un rallentamento di x10^9 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:

    ProfiloGPUMoltiplicatoreFULL bcrypt
    Esperto12× RTX 50901×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 = true
  • Risultato: HYBRID_KEYSPACE_COMMON = 500
  • Tempo MD5 : 500 / 2.634e12 0,19 ns (snapshot) Tempo bcrypt costo 10 : 500 / 114 000 4,4 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 = false♪ dictWord = true
  • Risultato: HYBRID_KEYSPACE_DICT = 8.000
  • Tempo MD5 : 8 000 / 2.634e12 3.0 nanosecondi Tempo bcrypt costo 10 : 8 000 / 114 000 0,07 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: HYBRID_KEYSPACE_DICT = 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 HYBRID_KEYSPACE_DICT.

    14.4 Esempio 4: "xK9#mQ7@" (resistente)

    Analisi :
  • isDictWord("xK9#mQ7@") → falso (non dizionario radice)
  • isCommon("xK9#mQ7@") → falso
  • hybridVuln = false
  • Risultati: sec = null → ibrido 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: HYBRID_KEYSPACE_DICT = 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.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:

  • 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
    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
    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 tentativi)Attacco in pratica
    MD5 / NTLM~3 nanosecondiIstantaneo
    SHA-256~24 nanosecondiIstantaneo
    bcrypt costo 10~0,07 secondiBanale
    bcrypt costo 14~1 secondoFattibile
    Argon2id (predefinito)~8 secondiFattibile
    Argon2id (parametri robusti)~100 secondiLento 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. Base di HYBRID_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 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