L'attacco a dizionario — Funzionamento dettagliato

Documento di riferimento del progetto Time2Crack
Destinatari: sviluppatori, ricercatori di sicurezza, utenti esperti

Indice

  1. Panoramica
  2. Contesto storico e accademico
  3. Perché i dizionari funzionano
  4. Architettura di un attacco a dizionario moderno
  5. I corpus di password reali
  6. La verifica HIBP (k-anonimato)
  7. Gli elenchi di parole per lingua di Time2Crack
  8. Il rango a dizionario: rankDictionary()
  9. La de-leetificazione
  10. Dal rango al tempo di violazione
  11. Confronto con gli attacchi derivati
  12. Limiti dell'attacco a dizionario
  13. Difese efficaci
  14. Riferimenti

1. Panoramica

L'attacco a dizionario è il metodo più antico per violare le password, il più semplice da capire e, statisticamente, il più efficace contro le password umane reali. Invece di enumerare tutte le combinazioni possibili come la forza bruta, prova un elenco di candidati preparato in anticipo — il «dizionario» — in ordine di probabilità decrescente.

Perché funziona così bene. Le persone non scelgono le password a caso. Decenni di fughe di dati mostrano che le password reali sono estremamente concentrate: nella fuga di RockYou, 123456 da sola era usata da 290.731 account, circa il 2% del totale. Un attacco a dizionario ben costruito prova per primi questi candidati e li trova in una frazione di secondo, dove la forza bruta richiederebbe anni.

Time2Crack usa due meccanismi indipendenti:

I due si completano: HIBP conosce le password già trapelate, gli elenchi di parole coprono le parole comuni non ancora trapelate.


2. Contesto storico e accademico

2.1 Origini

L'attacco a dizionario è più antico della sicurezza informatica moderna. I primi sistemi Unix conservavano gli hash delle password nel file /etc/passwd, leggibile da tutti: chiunque potesse leggerlo poteva provare un elenco di parole contro tutti gli account.

AnnoEvento
1979Morris e Thompson pubblicano il primo articolo accademico sulla sicurezza delle password Unix; buona parte delle password studiate erano parole o nomi comuni.
1988Il worm Morris si diffonde in parte indovinando le password con un elenco interno di 432 parole, poi con il dizionario di sistema /usr/share/dict/words.
1991Crack (Alec Muffett): il primo programma per violare password Unix di largo uso, con regole di trasformazione delle parole.
1996John the Ripper rende popolare la modalità «elenco di parole + regole».
2009Fuga di RockYou: 32 milioni di account conservati in chiaro (14,3 milioni di password distinte) rivelano come le persone scelgono davvero le password.
2013Troy Hunt lancia Have I Been Pwned. Lo stesso anno la fuga di Adobe espone 153 milioni di account con password cifrate senza sale, il che permetteva di individuare le password identiche.
2015Hashcat diventa open source; gli attacchi a dizionario su GPU diventano alla portata di tutti.
2019«Collection #1–5»: miliardi di coppie e-mail/password raccolte da fughe precedenti circolano pubblicamente.

2.2 Le fughe fondamentali

Alcune fughe hanno trasformato l'attacco a dizionario rivelando la distribuzione reale delle password umane:

2.3 Quanto è veloce un attacco a dizionario?

Un elenco di 1 milione di parole, provato alle velocità usate da Time2Crack (12× RTX 5090, il profilo predefinito «Standard»):

AlgoritmoVelocitàTempo per 1 milione di candidati
NTLM4.081 GH/s0,25 microsecondi
MD52.634 GH/s0,38 microsecondi
SHA-1837 GH/s1,2 microsecondi
SHA-256332 GH/s3,0 microsecondi
bcrypt (costo 5)3.658 kH/s0,27 secondi
Argon2id1.000 H/scirca 17 minuti

L'attacco a dizionario è quindi istantaneo contro le funzioni di hash veloci (MD5, SHA-1, NTLM) e resta rapido anche contro bcrypt.


3. Perché i dizionari funzionano

3.1 La legge di potenza delle password umane

Gli studi empirici arrivano tutti alla stessa conclusione: le password umane non sono distribuite in modo uniforme. Seguono una legge di potenza (legge di Zipf): poche password concentrano una quota sproporzionata delle scelte.

Formalmente: se si ordinano le password per frequenza decrescente, la frequenza della password di rango r è all'incirca proporzionale a r−s, dove l'esponente s dipende dal corpus (Wang et al., 2017).

Conseguenza diretta: un attaccante che prova solo le 10 password più comuni ha già circa una probabilità su 20 di riuscire contro un dato account.

3.2 I bias cognitivi nella creazione delle password

Le persone seguono abitudini prevedibili quando creano una password:

3.3 Due modi di essere «negli elenchi»

Una password può comparire in un elenco d'attacco per due ragioni diverse:

Questi due casi corrispondono ai due meccanismi di Time2Crack descritti più avanti.


4. Architettura di un attacco a dizionario moderno

4.1 Svolgimento generale

Un attacco a dizionario moderno si svolge in quattro fasi:

Fase 1: costruire l'elenco di parole
    ├── Password trapelate (HIBP, RockYou, raccolte)
    ├── Elenchi per lingua (dizionari, nomi propri, luoghi)
    ├── Elenchi tematici (sport, cultura popolare, tecnologia, religione)
    └── Elenchi mirati (dominio dell'azienda, nomi dei dipendenti)

Fase 2: preparare l'elenco
    ├── Ordinare per frequenza (le più probabili prima)
    ├── Eliminare i duplicati
    ├── Filtrare per lunghezza (lunghezza obiettivo ± 2)
    └── Normalizzare (minuscole, Unicode NFC)

Fase 3: calcolare l'hash e confrontare
    per ogni candidato w dell'elenco:
        se hash(w) == hash_obiettivo: trovata
    (miliardi di candidati al secondo su GPU con MD5)

Fase 4: resoconto
    └── Password violate, statistiche di copertura

4.2 Ottimizzazioni hardware

Gli attacchi a dizionario moderni girano in modo massicciamente parallelo sulle GPU:

Per un elenco di 1 miliardo di password trapelate su 12× RTX 5090:

Questo scarto di circa sei ordini di grandezza tra MD5 e bcrypt mostra quanto conti la scelta dell'algoritmo di hash.

4.3 L'ordine dei candidati

L'elenco non è provato in ordine alfabetico, ma per probabilità decrescente:

  1. Le password trapelate più comuni (le prime 100 di RockYou)
  2. Le password presenti in molte fughe (ordinate per frequenza in HIBP)
  3. Le parole comuni della lingua bersaglio
  4. I nomi propri (nomi di persona, città, celebrità)
  5. I termini legati al bersaglio
  6. Le varianti e le forme flesse

Con quest'ordine una password debole viene trovata nei primi millisecondi, qualunque sia la velocità dell'hash.


5. I corpus di password reali

5.1 Have I Been Pwned (HIBP)

HIBP è il riferimento mondiale perché copre quasi tutte le grandi fughe pubbliche, indica la frequenza di ogni password ed è mantenuto attivamente. Un attaccante con l'elenco completo può provare prima le password più frequenti.

5.2 RockYou (2009): il corpus fondamentale

14,3 milioni di password distinte conservate in chiaro. La cima dell'elenco:

RangoPasswordAccountQuota
1123456290.7312,03%
21234579.0780,55%
312345678976.7900,54%
4password59.4620,42%
5iloveyou49.9520,35%

Da ricordare: una manciata di candidati, provati in pochi nanosecondi contro MD5, basta a compromettere una quota misurabile degli account di un database trapelato.

5.3 Le raccolte di elenchi specializzati

Questi corpus sono scaricabili pubblicamente: la loro esistenza è un fatto acquisito della sicurezza offensiva.


6. La verifica HIBP (k-anonimato)

6.1 Il protocollo di k-anonimato

Time2Crack verifica la password su HIBP senza mai inviarla, né lei né il suo hash completo. Il protocollo funziona così:

1. Calcolare SHA-1(password)
     → es. CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Inviare solo i primi 5 caratteri all'API di HIBP
     → GET https://api.pwnedpasswords.com/range/CBFDA
3. L'API restituisce tutti i suffissi di hash che iniziano con questo prefisso
     (diverse centinaia di righe, completate da voci fittizie)
4. Cercare il resto dell'hash nella risposta, in locale
     → C6008F9CAB4083784CBD1874F76618D2A97
5. Trovato: la password è trapelata e HIBP indica quante volte
   Non trovato: la password non è in HIBP

Garanzia di riservatezza: il server di HIBP vede solo un prefisso di 5 caratteri condiviso da centinaia di password. Non può sapere quale password è stata verificata. Il confronto avviene nel browser.

6.2 L'implementazione in Time2Crack

La verifica parte mezzo secondo dopo l'ultimo tasto premuto, in parallelo con l'analisi locale:

// app.js - checkHIBP()
async function checkHIBP(password) {
  const sha1 = await sha1Hex(password);   // uppercase hex SHA-1
  const prefix = sha1.slice(0, 5);        // sent to the API
  const suffix = sha1.slice(5);           // never leaves the browser

  const res = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`, {
    headers: { "Add-Padding": "true" },   // hide the real size of the response
  });
  if (!res.ok) return null;               // API unavailable

  const text = await res.text();
  for (const line of text.split("\n")) {
    const [hashSuffix, count] = line.trim().split(":");
    if (hashSuffix === suffix) return parseInt(count, 10); // number of leaks
  }
  return 0;                               // not found
}

Il risultato appare in un badge: «trovata N volte», «non trovata» o «non disponibile» quando l'API non risponde. Non modifica i tempi di violazione, che sono calcolati in locale.

6.3 Leggere il contatore di HIBP

Il contatore è il numero di volte in cui questa password esatta è stata vista nelle fughe indicizzate:

ContatoreSignificato
Più di 1.000.000Tra le password più usate al mondo: ogni attaccante la prova per prima
Da 10.000 a 1.000.000Molto comune
Da 1.000 a 10.000Comune
Da 100 a 1.000Poco comune ma nota
Da 1 a 100Rara, ma compromessa

Anche un contatore di 1 è un avvertimento: la password è negli elenchi a disposizione degli attaccanti, e chiunque prenda di mira l'account da cui è trapelata la proverà.


7. Gli elenchi di parole per lingua di Time2Crack

7.1 Perché elenchi per lingua oltre a HIBP

HIBP copre le password già trapelate, non le parole comuni che non lo sono ancora. Un italiano che sceglie girasole forse non è in HIBP, ma la parola è nell'elenco italiano di qualsiasi attaccante che prenda di mira utenti italofoni. Gli elenchi per lingua di Time2Crack colmano questa lacuna:

LinguaFileParole
Ingleseen.txt.gz748.958
Francesefr.txt.gz550.235
Spagnoloes.txt.gz284.834
Portoghesept.txt.gz507.721
Tedescode.txt.gz2.009.880
Italianoit.txt.gz3.252.670
Olandesenl.txt.gz2.678.323
Polaccopl.txt.gz3.670.705
Turcotr.txt.gz400.442
Totale14.103.768

Le prime versioni provenivano dagli elenchi di parole di Wikipedia di SecLists e dagli elenchi di kkrypt0nn; da allora sono stati ampliati. Al caricamento, ogni riga viene ripulita dagli spazi e convertita in minuscolo, e le parole con meno di 3 caratteri vengono scartate.

7.2 Caricamento su richiesta

Gli elenchi non sono inclusi nel codice. Viene scaricato solo l'elenco della lingua scelta, la prima volta che serve, come file gzip:

// app.js - loadDictionary() (simplified: progress bar updates removed)
async function loadDictionary(lang = AppConfig.lang) {
  // Already loaded for this language
  if (AppConfig.dictWords !== null && AppConfig.dictLang === lang) return;

  // 1. Local cache (IndexedDB)
  const cached = await cacheGet(`dict_${lang}`);
  if (cached) {
    AppConfig.setDictionary(new Set(cached), lang);
    return;
  }

  // 2. Download the compressed list
  const res = await fetch(`${basePath}data/wordlists/${lang}.txt.gz`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const buffer = await res.arrayBuffer();

  // 3. Decompress in the browser (plain .txt if DecompressionStream is missing)
  let text;
  try {
    text = await new Response(
      ReadableStream.from([new Uint8Array(buffer)])
        .pipeThrough(new DecompressionStream("gzip"))
    ).text();
  } catch {
    text = await (await fetch(`${basePath}data/wordlists/${lang}.txt`)).text();
  }

  // 4. Normalise, filter, index
  const words = text.split("\n")
    .map(w => w.trim().toLowerCase())
    .filter(w => w.length >= 3);
  AppConfig.setDictionary(new Set(words), lang);

  // 5. Keep it for the next visit
  await cachePut(`dict_${lang}`, words);
}

Perché un Set? Un Set JavaScript risponde a dictWords.has(word) in tempo costante, che l'elenco contenga 285.000 parole (spagnolo) o 3,7 milioni (polacco). Con un Array, ogni ricerca potrebbe richiedere un confronto per parola.

7.3 Cache locale (IndexedDB)

L'elenco preparato viene salvato nell'IndexedDB del browser con la chiave dict_<lingua>. Alla visita successiva viene letto dalla cache invece di essere scaricato e decompresso di nuovo:

Prima visita                         Visite successive
------------                         -----------------
fetch it.txt.gz                      cacheGet("dict_it")
  └── gunzip (DecompressionStream)     └── new Set(words)
        └── trim / minuscole / ≥ 3           └── pronto
              └── new Set(words)
                    └── cachePut("dict_it")
                          └── pronto

La password non lascia mai il browser: l'elenco viene scaricato dal server di Time2Crack e il confronto avviene in locale.


8. Il rango a dizionario: rankDictionary()

8.1 Il principio: un rango, poi un tempo

Time2Crack non si chiede solo «è una parola del dizionario?», ma «dopo quanti tentativi la troverebbe un attacco a dizionario?». Questo numero di tentativi è il rango. La funzione rankDictionary() (file core/rank/dictionary.js) lo restituisce, oppure restituisce null quando l'attacco non si applica:

// core/rank/dictionary.js - rankDictionary()
export function rankDictionary(password, dictWords = null) {
  const lower = password.toLowerCase();
  const deleeted = deleet(password);
  const alpha = password.replace(/[^a-zA-Z]/g, "");
  const uCost = uppercaseCost(alpha);        // capital letters, see 8.3

  // 1. In the top passwords as is?
  const topIdx = TOP_PASSWORDS.indexOf(lower);
  if (topIdx !== -1) return { rank: (topIdx + 1) * uCost, model: "dictionary" };

  // 2. De-leeted form in the top passwords?
  const deIdx = TOP_PASSWORDS.indexOf(deleeted);
  if (deIdx !== -1) return { rank: (deIdx + 1) * 10 * uCost, model: "dictionary" };

  // 3. In the wordlist of the selected language?
  if (dictWords instanceof Set) {
    if (dictWords.has(lower) || dictWords.has(deleeted)) {
      const mid = Math.floor(dictWords.size / 2);
      if (passwordLength(password) >= 9) {
        // a long word may also be split into shorter words, see 8.4
        const compound = rankGermanCompound(password, dictWords);
        if (compound && compound.rank < mid)
          return { rank: compound.rank * uCost, model: "dictionary" };
      }
      return { rank: mid * uCost, model: "dictionary" };
    }

    // 4. Compound made of several dictionary words?
    const compound = rankGermanCompound(password, dictWords);
    if (compound) return { rank: compound.rank * uCost, model: "dictionary" };
  }

  // Not found: the dictionary attack does not apply
  return { rank: null, model: "dictionary" };
}

8.2 Quattro livelli

LivelloRegolaEsempioRango
1. Password più comuniPosizione in un elenco di 105 delle password più comuni (RockYou, HIBP)password2
2. Variante in leetspeakPosizione della forma de-leetificata × 10p@ssw0rd20
3. Elenco della linguaMetà della dimensione dell'elencosoleil (francese)275.117
4. Parola compostaVedi 8.4apfelbaumkuchen (tedesco)21.129

Perché metà dell'elenco? Gli elenchi non sono ordinati per frequenza: la posizione di una parola nel file non dice nulla su quando un attaccante la proverebbe. In media, un attaccante che scorre l'elenco trova una data parola a metà strada.

8.3 Le maiuscole

Un attaccante comincia dalle parole in minuscolo, poi prova le varianti con maiuscole. Il rango viene moltiplicato per il numero di varianti necessarie per arrivare alle maiuscole della password (funzione uppercaseCost(), stesso metodo di zxcvbn):

MaiuscoleMoltiplicatoreEsempioRango
Tutto minuscolo× 1soleil275.117
Solo la prima lettera× 2Soleil550.234
Solo l'ultima lettera× 2soleiL550.234
Tutto maiuscolo× 2PASSWORD4
Qualsiasi altro miscugliosomma di C(n, i) per i = 1 … min(maiuscole, minuscole)PaSsWoRd324

8.4 Le parole composte

Il tedesco (e l'olandese) unisce le parole tra loro: Apfelbaumkuchen = Apfel + Baum + Kuchen. Una parola del genere spesso manca nell'elenco, ma un attaccante può costruirla combinando parole più corte. Time2Crack prova a dividere la password in 2–4 parole dell'elenco, ammettendo le consuete lettere di collegamento del tedesco (-s-, -es-, -n-, -en-, -er-, -e-). Il rango è allora il rango a maschera della password moltiplicato per 0,25 (2 parole), 0,16 (3 parole) o 0,10 (4 parole), e per 0,75 quando l'ultimo pezzo è un suffisso comune (-heit, -ung, -haus…).

La divisione viene tentata anche sulle parole lunghe presenti nell'elenco (9 caratteri o più) e mantenuta se dà un rango più basso: Sonnenblume ottiene un rango di 42.680 invece di metà dell'elenco tedesco (1.004.940).


9. La de-leetificazione

9.1 Il leetspeak non protegge

Il leetspeak sostituisce le lettere con cifre o simboli simili: a → @, e → 3, i → 1, o → 0, s → $. Lo si usa per «rinforzare» una parola comune: password → p@$$w0rd.

In realtà queste sostituzioni sono tra le prime regole applicate dagli strumenti di violazione. Non rallentano un attaccante competente.

9.2 La funzione deleet()

// core/rank/dictionary.js - deleet()
function deleet(pw) {
  return pw
    .toLowerCase()
    .replace(/0/g, "o")
    .replace(/1/g, "i")
    .replace(/3/g, "e")
    .replace(/4/g, "a")
    .replace(/5/g, "s")
    .replace(/7/g, "t")
    .replace(/8/g, "b")
    .replace(/@/g, "a")
    .replace(/\$/g, "s")
    .replace(/!/g, "i");
}

La password viene cercata sia così come è stata digitata, sia nella forma de-leetificata. Tra le password più comuni, la forma de-leetificata costa 10 volte di più (l'attaccante deve provare le varianti): p@ssw0rd → 20 invece di 2. Nell'elenco della lingua costa quanto la parola semplice.

9.3 Che cosa non viene decodificato


10. Dal rango al tempo di violazione

Il rango viene convertito in secondi dividendolo per la velocità di hash dell'attaccante:

// core/time.js - rankToSeconds()
export function rankToSeconds(rank, algo, profile = "experienced") {
  const baseRate = HASH_RATES[algo];   // guesses per second, 12× RTX 5090
  if (!baseRate) throw new Error(`Unknown algorithm: ${algo}`);
  const multiplier = ATTACKER_MULTIPLIERS[profile] ?? 1;
  return rank / (baseRate * multiplier);
}

Esempio per soleil (elenco francese, rango 275.117) con il profilo predefinito:

AlgoritmoVelocità (12× RTX 5090)CalcoloTempo
NTLM4.081 GH/s275.117 / 4.081 × 10967 nanosecondi
MD52.634 GH/s275.117 / 2.634 × 109104 nanosecondi
SHA-1837 GH/s275.117 / 837 × 109329 nanosecondi
SHA-256332 GH/s275.117 / 332 × 109829 nanosecondi
bcrypt (costo 5)3.658 kH/s275.117 / 3.658.0000,08 secondi
Argon2id1.000 H/s275.117 / 1.0004 minuti 35 secondi

Anche con Argon2id, una semplice parola francese cade in meno di 5 minuti. Il profilo dell'attaccante cambia le velocità: da una sola GPU (profilo «Dilettante») a circa 10.000 GPU (profilo «Stato»). Come per tutti gli altri modelli, il rango a dizionario non può mai superare il rango a forza bruta della stessa password.


11. Confronto con gli attacchi derivati

L'attacco a dizionario «puro» è il primo di una famiglia di attacchi che partono tutti da un elenco di parole. Time2Crack calcola nove modelli (forza bruta, dizionario, ibrido, maschera, PCFG, Markov, combinatorio, sequenze di tastiera, date), ciascuno dei quali attacca la password da un'angolazione diversa.

11.1 Dizionario e ibrido

CriterioDizionarioIbrido (dizionario + regole)
CandidatiLe parole dell'elenco, così come sonoOgni parola con le sue trasformazioni (cifre, simboli, maiuscole…)
Esempi violatipassword, farfallaP@ssw0rd!, farfalla2024
VelocitàMeno candidati, quindi più rapidoCopertura molto più ampia
Si applica quandoLa parola esatta è nell'elencoLa password deriva da una parola dell'elenco

L'attacco ibrido comincia dove finisce il dizionario puro: applica regole di trasformazione sistematiche a ogni parola dell'elenco (nello spirito di best64.rule di hashcat).

11.2 Dizionario e PCFG

CriterioDizionarioPCFG
ModelloElenco fisso di candidatiGrammatica probabilistica delle strutture delle password
Punto di forzaParole esatteStrutture come parola + cifre, maiuscola + minuscole + simbolo
Esempiopassword ✓Password123 ✓ (struttura riconosciuta)

Password123 non è una parola del dizionario in quanto tale, ma PCFG ne riconosce la struttura [maiuscola][minuscole][cifre] e la viola molto in fretta.

11.3 Dizionario e Markov

CriterioDizionarioMarkov
CandidatiElenco preparato in anticipoGenerati al volo da un modello statistico
CoperturaVocabolario notoQualsiasi sequenza che «sembra umana»
VantaggioVelocissimo sulle parole esatteCopre anche parole assenti dagli elenchi

Markov copre le password che somigliano a parole umane senza comparire in alcun elenco.

11.4 Dizionario e credential stuffing

CriterioDizionarioCredential stuffing
ObiettivoViolare un hashAccedere a un account
MeccanismoCalcolo degli hash in localeTentativi di accesso a distanza
FonteElenco di parole genericoCoppie e-mail/password trapelate
DifesaAlgoritmo di hash lentoLimitazione dei tentativi, MFA, blocco degli IP

Il credential stuffing non attacca un hash: prova direttamente coppie e-mail/password trapelate sui servizi online. È un altro attacco, ma usa gli stessi dati (fughe come quelle indicizzate da HIBP). Time2Crack non lo modella.


12. Limiti dell'attacco a dizionario

12.1 Limiti intrinseci

12.2 Che cosa Time2Crack non modella


13. Difese efficaci

13.1 Che cosa protegge

Un algoritmo di hash lento (bcrypt, Argon2id). È la difesa più efficace lato server: ogni tentativo costa di più. Per soleil (rango 275.117):

Un hash lento frena l'attaccante, ma non salva una parola del dizionario: l'elenco è semplicemente troppo corto.

Un sale unico per account. Rende inutili le tabelle precalcolate (rainbow table) e costringe l'attaccante a lavorare account per account. Non impedisce un attacco con elenco di parole contro un singolo account.

Lunghezza e casualità. Una sola parola del dizionario è sempre vulnerabile. Una passphrase di 4 o 5 parole resiste all'attacco a dizionario puro, ma non all'attacco combinatorio se le parole sono prevedibili: devono essere estratte a caso.

Password generate a caso. La vera soluzione: un gestore di password che generi password lunghe e casuali (20 caratteri o più). Non sono in nessun dizionario.

Autenticazione a più fattori (MFA). Non impedisce di violare offline gli hash rubati, ma impedisce all'attaccante di accedere con una password violata.

Limitazione dei tentativi e rilevamento delle anomalie. Proteggono dai tentativi online, non dalla violazione offline di hash rubati.

13.2 Che cosa non protegge

13.3 Consigli pratici


14. Riferimenti

Fonti accademiche

Fonti del settore

Contesto


Codice sorgente: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).