L'attacco a dizionario — Funzionamento dettagliato
Documento di riferimento del progetto Time2Crack
Destinatari: sviluppatori, ricercatori di sicurezza, utenti esperti
Indice
- Panoramica
- Contesto storico e accademico
- Perché i dizionari funzionano
- Architettura di un attacco a dizionario moderno
- I corpus di password reali
- La verifica HIBP (k-anonimato)
- Gli elenchi di parole per lingua di Time2Crack
- Il rango a dizionario:
rankDictionary() - La de-leetificazione
- Dal rango al tempo di violazione
- Confronto con gli attacchi derivati
- Limiti dell'attacco a dizionario
- Difese efficaci
- 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:
- Il rango a dizionario, calcolato localmente: la password è una delle più comuni, magari camuffata in leetspeak, o una parola del dizionario della lingua scelta? Da questo rango derivano i tempi di violazione mostrati nella tabella dei risultati.
- La verifica su Have I Been Pwned (HIBP): questa password esatta è già comparsa in una fuga di dati? La risposta appare in un badge separato, sopra i risultati.
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.
| Anno | Evento |
|---|---|
| 1979 | Morris e Thompson pubblicano il primo articolo accademico sulla sicurezza delle password Unix; buona parte delle password studiate erano parole o nomi comuni. |
| 1988 | Il 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. |
| 1991 | Crack (Alec Muffett): il primo programma per violare password Unix di largo uso, con regole di trasformazione delle parole. |
| 1996 | John the Ripper rende popolare la modalità «elenco di parole + regole». |
| 2009 | Fuga di RockYou: 32 milioni di account conservati in chiaro (14,3 milioni di password distinte) rivelano come le persone scelgono davvero le password. |
| 2013 | Troy 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. |
| 2015 | Hashcat 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:
- RockYou (2009): 14,3 milioni di password distinte conservate in chiaro. La password n. 1 (
123456) era usata da 290.731 account, circa il 2% del totale. - LinkedIn (2012): inizialmente furono pubblicati 6,5 milioni di hash SHA-1 senza sale; in seguito si scoprì che la fuga riguardava circa 117 milioni di account.
- Adobe (2013): 153 milioni di account; i suggerimenti per la password conservati in chiaro hanno aiutato a indovinare le password più comuni.
- Have I Been Pwned (dal 2013 a oggi): una raccolta continua delle fughe pubbliche, oggi un riferimento mondiale.
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»):
| Algoritmo | Velocità | Tempo per 1 milione di candidati |
|---|---|---|
| NTLM | 4.081 GH/s | 0,25 microsecondi |
| MD5 | 2.634 GH/s | 0,38 microsecondi |
| SHA-1 | 837 GH/s | 1,2 microsecondi |
| SHA-256 | 332 GH/s | 3,0 microsecondi |
| bcrypt (costo 5) | 3.658 kH/s | 0,27 secondi |
| Argon2id | 1.000 H/s | circa 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:
- Memorabilità: le parole facili da ricordare (nomi comuni, nomi propri, cultura popolare) sono sovrarappresentate.
- Disponibilità: la password riflette l'ambiente immediato (nome dell'animale, squadra sportiva, personaggio preferito).
- Sostituzioni prevedibili: e → 3, a → @, o → 0. L'utente crede che la password sia più robusta, ma sono le prime sostituzioni che un attaccante prova.
- Aggiunte in fondo: una cifra o un simbolo alla fine di una parola (
password1,farfalla!). - Lingua e cultura: le password comuni dipendono dalla lingua dell'utente (
Soleil123in Francia,Sommer123in Germania).
3.3 Due modi di essere «negli elenchi»
Una password può comparire in un elenco d'attacco per due ragioni diverse:
- È già trapelata. La password esatta è comparsa in una fuga passata. L'attaccante non deve indovinare: prova le password note in ordine di frequenza.
- È una parola comune. Anche se non è mai trapelata, è in tutti gli elenchi d'attacco perché è un candidato ovvio. Una parola come
farfallapuò mancare in HIBP, ma è nell'elenco italiano di qualsiasi strumento serio.
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:
- Hashcat (lo strumento di riferimento) usa migliaia di core GPU per calcolare miliardi di hash al secondo.
- Elaborazione a blocchi: i candidati vengono inviati alla GPU in blocchi di milioni per tenerla sempre occupata.
- Regole sulla GPU: le regole di trasformazione sono applicate direttamente sulla GPU; così un elenco breve produce miliardi di candidati senza doverli memorizzare.
Per un elenco di 1 miliardo di password trapelate su 12× RTX 5090:
- MD5: 109 / 2.634 × 109 ≈ 0,4 millisecondi
- bcrypt (costo 5): 109 / 3.658.000 ≈ 5 minuti
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:
- Le password trapelate più comuni (le prime 100 di RockYou)
- Le password presenti in molte fughe (ordinate per frequenza in HIBP)
- Le parole comuni della lingua bersaglio
- I nomi propri (nomi di persona, città, celebrità)
- I termini legati al bersaglio
- 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)
- Dimensione: oltre un miliardo di password distinte, provenienti da più di 14 miliardi di account compromessi
- Fonte: raccolta delle fughe pubbliche dal 2013
- Formato: hash SHA-1 (e NTLM) con il numero di volte in cui ogni password è stata vista
- Accesso: API con k-anonimato; i difensori possono scaricare l'elenco completo
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:
| Rango | Password | Account | Quota |
|---|---|---|---|
| 1 | 123456 | 290.731 | 2,03% |
| 2 | 12345 | 79.078 | 0,55% |
| 3 | 123456789 | 76.790 | 0,54% |
| 4 | password | 59.462 | 0,42% |
| 5 | iloveyou | 49.952 | 0,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
- SecLists (Daniel Miessler): una raccolta open source di elenchi per i test di sicurezza — password trapelate, password per lingua, termini tecnici, nomi.
- CrackStation: circa 1,5 miliardi di voci, tra cui tutte le parole di Wikipedia in diverse lingue.
- Weakpass: raccolte molto grandi di vere password trapelate.
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:
| Contatore | Significato |
|---|---|
| Più di 1.000.000 | Tra le password più usate al mondo: ogni attaccante la prova per prima |
| Da 10.000 a 1.000.000 | Molto comune |
| Da 1.000 a 10.000 | Comune |
| Da 100 a 1.000 | Poco comune ma nota |
| Da 1 a 100 | Rara, 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:
| Lingua | File | Parole |
|---|---|---|
| Inglese | en.txt.gz | 748.958 |
| Francese | fr.txt.gz | 550.235 |
| Spagnolo | es.txt.gz | 284.834 |
| Portoghese | pt.txt.gz | 507.721 |
| Tedesco | de.txt.gz | 2.009.880 |
| Italiano | it.txt.gz | 3.252.670 |
| Olandese | nl.txt.gz | 2.678.323 |
| Polacco | pl.txt.gz | 3.670.705 |
| Turco | tr.txt.gz | 400.442 |
| Totale | 14.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
| Livello | Regola | Esempio | Rango |
|---|---|---|---|
| 1. Password più comuni | Posizione in un elenco di 105 delle password più comuni (RockYou, HIBP) | password | 2 |
| 2. Variante in leetspeak | Posizione della forma de-leetificata × 10 | p@ssw0rd | 20 |
| 3. Elenco della lingua | Metà della dimensione dell'elenco | soleil (francese) | 275.117 |
| 4. Parola composta | Vedi 8.4 | apfelbaumkuchen (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):
| Maiuscole | Moltiplicatore | Esempio | Rango |
|---|---|---|---|
| Tutto minuscolo | × 1 | soleil | 275.117 |
| Solo la prima lettera | × 2 | Soleil | 550.234 |
| Solo l'ultima lettera | × 2 | soleiL | 550.234 |
| Tutto maiuscolo | × 2 | PASSWORD | 4 |
| Qualsiasi altro miscuglio | somma di C(n, i) per i = 1 … min(maiuscole, minuscole) | PaSsWoRd | 324 |
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
- Ogni carattere ha una sola sostituzione:
1diventa semprei, mail; perciòp1ayernon viene riconosciuta comeplayer. - Le sostituzioni più rare (
+→ t,9→ g,#→ h) non vengono decodificate. - Una parola seguita da cifre o simboli (
farfalla2024,farfalla!) non è una corrispondenza di dizionario: se ne occupa l'attacco ibrido.
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:
| Algoritmo | Velocità (12× RTX 5090) | Calcolo | Tempo |
|---|---|---|---|
| NTLM | 4.081 GH/s | 275.117 / 4.081 × 109 | 67 nanosecondi |
| MD5 | 2.634 GH/s | 275.117 / 2.634 × 109 | 104 nanosecondi |
| SHA-1 | 837 GH/s | 275.117 / 837 × 109 | 329 nanosecondi |
| SHA-256 | 332 GH/s | 275.117 / 332 × 109 | 829 nanosecondi |
| bcrypt (costo 5) | 3.658 kH/s | 275.117 / 3.658.000 | 0,08 secondi |
| Argon2id | 1.000 H/s | 275.117 / 1.000 | 4 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
| Criterio | Dizionario | Ibrido (dizionario + regole) |
|---|---|---|
| Candidati | Le parole dell'elenco, così come sono | Ogni parola con le sue trasformazioni (cifre, simboli, maiuscole…) |
| Esempi violati | password, farfalla | P@ssw0rd!, farfalla2024 |
| Velocità | Meno candidati, quindi più rapido | Copertura molto più ampia |
| Si applica quando | La parola esatta è nell'elenco | La 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
| Criterio | Dizionario | PCFG |
|---|---|---|
| Modello | Elenco fisso di candidati | Grammatica probabilistica delle strutture delle password |
| Punto di forza | Parole esatte | Strutture come parola + cifre, maiuscola + minuscole + simbolo |
| Esempio | password ✓ | 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
| Criterio | Dizionario | Markov |
|---|---|---|
| Candidati | Elenco preparato in anticipo | Generati al volo da un modello statistico |
| Copertura | Vocabolario noto | Qualsiasi sequenza che «sembra umana» |
| Vantaggio | Velocissimo sulle parole esatte | Copre 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
| Criterio | Dizionario | Credential stuffing |
|---|---|---|
| Obiettivo | Violare un hash | Accedere a un account |
| Meccanismo | Calcolo degli hash in locale | Tentativi di accesso a distanza |
| Fonte | Elenco di parole generico | Coppie e-mail/password trapelate |
| Difesa | Algoritmo di hash lento | Limitazione 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
- Solo vocabolario noto. Una password inventata, che non somiglia ad alcuna parola esistente e non è mai trapelata, sfugge all'attacco a dizionario puro:
Xqz7mK9pLnon è in nessun elenco. - Copertura linguistica. Un attaccante che prende di mira utenti italiani senza un elenco italiano si perderà parole come
girasoleopomeriggio. - Password nuove. Una password mai trapelata non è in HIBP, anche se è comune.
- Frasi lunghe.
LaMiaGrandeAvventuraSottoLeStellenon è in nessun elenco, anche se ogni parola è banale. Le passphrase sono gestite da altri attacchi (combinatorio, PRINCE).
12.2 Che cosa Time2Crack non modella
- Elenchi mirati: un attaccante che prende di mira un settore costruisce elenchi specifici (termini medici per un ospedale, gergo dei giocatori per una piattaforma di gioco). Strumenti come CeWL estraggono le parole dal sito web del bersaglio. Time2Crack usa elenchi generici.
- Fughe recenti: tra una fuga e la sua aggiunta a HIBP, le password circolano in privato senza essere visibili tramite l'API pubblica.
- Altri algoritmi di hash: Time2Crack modella sei algoritmi (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt o PBKDF2 hanno profili diversi.
- Frequenza delle parole: ogni parola dell'elenco della lingua riceve lo stesso rango (metà dell'elenco), che sia comunissima o rarissima.
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):
- MD5: circa 0,1 microsecondi
- bcrypt costo 12 (128 volte più lento del costo 5): circa 10 secondi
- Argon2id: circa 5 minuti
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
- Le sostituzioni in leetspeak:
password→p@ssw0rd(vedi la sezione 9). - Una cifra in fondo:
password→password1, tra le prime regole provate. - Un'iniziale maiuscola:
password→Password, una regola standard (rango × 2). - Cifre e simboli attorno a una parola riconoscibile:
farfalla!si trova con le regole più semplici. - Complessità senza lunghezza:
P@s1wrispetta le regole abituali (maiuscola, minuscola, cifra, simbolo) ma è più corta e più prevedibile dicorrecthorsebatterystaple.
13.3 Consigli pratici
- Usate un gestore di password (Bitwarden, 1Password, KeePass): genera password casuali, voi ricordate solo la password principale.
- Attivate la MFA ovunque: anche se una password trapela, l'attaccante non può accedere.
- Consultate HIBP regolarmente per sapere se il vostro indirizzo e-mail compare in fughe note.
- Non riutilizzate mai una password: il credential stuffing sfrutta il riutilizzo tra servizi diversi.
- Per le password da ricordare: una passphrase di 5 parole o più, estratte a caso (con i dadi o un generatore), non scelte.
14. Riferimenti
Fonti accademiche
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. Prima analisi accademica delle password Unix.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. Circa un quarto di 15.000 password Unix violate con elenchi di parole e regole.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. L'articolo fondativo di PCFG, confrontato con gli attacchi a dizionario.
- Ur, B., et al. (2012). How does your password measure up? The effect of strength meters on password creation. 21st USENIX Security Symposium.
- Bonneau, J. (2012). The science of guessing: Analyzing an anonymized corpus of 70 million passwords. IEEE Symposium on Security and Privacy. Misura la distribuzione reale delle password.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Confronta i modelli a dizionario, Markov e PCFG su corpus reali.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Fonte del costo delle maiuscole usato nella sezione 8.3.
- Wang, D., Cheng, H., Wang, P., Huang, X., & Jian, G. (2017). Zipf's law in passwords. IEEE Transactions on Information Forensics and Security, 12(11), 2776–2791.
- Pasquini, D., Cianfriglia, M., Ateniese, G., & Bernaschi, M. (2021). Reducing bias in modeling real-world password strength via deep learning and dynamic dictionaries. 30th USENIX Security Symposium.
Fonti del settore
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. L'API con k-anonimato usata da Time2Crack.
- Hive Systems (2025). Password table. Edizione 2025 basata su 12× RTX 5090. Time2Crack usa benchmark hashcat misurati sulla RTX 5090 (Specops 2026, forum hashcat.net); Argon2id resta una stima.
- Hashcat. Advanced password recovery. https://hashcat.net. Strumento di riferimento per le misure su GPU e le regole di trasformazione (
best64.rule). - Miessler, D. SecLists. GitHub. Fonte dei primi elenchi per lingua di Time2Crack.
Contesto
- Hunt, T. (2017). Introducing 306 million freely downloadable Pwned Passwords. troyhunt.com.
- Thomas, K., et al. (2019). Protecting accounts from credential stuffing with password breach alerting. 28th USENIX Security Symposium. Mostra che il k-anonimato protegge la riservatezza.
Codice sorgente: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).