Attacco dizionario — Operazione completa

Documento di riferimento del progetto Time2Crack

Recipienti: sviluppatori, ricercatori di sicurezza, utenti avanzati

Contenuto

1. Panoramica

L'attacco del dizionario è il più antico metodo di cracking delle password, il più semplice concettualmente, e statisticamente più efficace sulla maggior parte delle password umane reali. Il suo principio è quello di testare, in ordine descrescente di probabilità, una lista pre-compilata di candidati — il "dizionario" — piuttosto che esaustivamente enumerate tutte le combinazioni possibili come la forza cruda fa.

In Time2Crack, il dizionario attacca due meccanismi distinti ma complementari:

Queste due rilevazioni sono indipendenti e complementari: HiBP copre le credenziali di compromesso esatte, la lista dei testi copre le parole comuni non ancora trapelate.

2. Sfondo storico e accademico

2.1 Origini

L'attacco del dizionario precede l'era moderna della sicurezza informatica. I primi sistemi Unix memorizzavano password in lingua normale in /etc/passwd, rendendo qualsiasi dizionario attacco banale non appena il file era accessibile.

2.2 Fughe di fondazione

Alcune perdite hanno trasformato il paesaggio dell'attacco da dizionario rivelando la distribuzione effettiva delle password umane:

• Password #1 ("123456") ha rappresentato 290.731 account (2%)

2.3 Benchmark di riferimento per l'attacco del dizionario

Una lista di 200.000 voci testate alla velocità di una RTX 4090:

L'attacco del dizionario è quindi quasi istantaneo per MD5, SHA-1 e NTLM — e rimane molto veloce anche per bcrypt su piccole liste.

3. Fondazioni concettuali: perché i dizionari lavorano

3.1 La legge di potere delle password umane

Tutti gli studi empirici convergono verso la stessa osservazione: la distribuzione delle password umane non è uniforme — ne segue una legge del potere Alcune password concentrano una frazione sproporzionata di scelte.

Di conseguenza diretta: 10 password più comuni Un aggressore che prova solo 10 candidati ha già una possibilità in 20 per avere successo - statisticamente, è enorme per la quantità di rumore generato.

3.2 Bias cognitivo nella creazione di password

Gli esseri umani non scelgono a caso, applicano sistematicamente euristiche che rendono prevedibili le loro password:

3.3 Il concetto di "password già nelle liste"

Una password può essere in un elenco di attacchi per due diversi motivi:

Questi due casi corrispondono ad attacchi di natura diversa, con velocità diverse — e questo è esattamente ciò che modelli Time2Crack.

4. Architettura di un attacco dizionario moderno

4.1 Condotto generale

Un moderno attacco di dizionario avviene in diverse fasi:

Phase 1 : Constitution de la wordlist
    ├── Mots de passe fuités (HIBP, RockYou, Collections)
    ├── Wordlists linguistiques (dictionnaires, prénoms, lieux)
    ├── Wordlists thématiques (sport, pop culture, tech, religion)
    └── Wordlists contextuelles (domaine de l'entreprise cible, noms d'employés)
Fase 2: Wordlist Preprocessing
- Ordina per frequenza (molto probabilmente prima)
- Deduplicazione (non due volte lo stesso candidato)
- - Filtrazione di lunghezza (lunghezza di punta + ±2)
- Standardizzazione (caso inferiore, Unicode NFC)
Fase 3: Calcolo delle ceneri dei candidati
Per ogni candidato w nella lista delle parole:
Normalmentecandidato = hashalgo(w)
Promozionalecandidato= hashObiettivo : FIND
- Velocità: 168 GH/s per MD5 su RTX 4090
Fase 4: Analisi dei risultati
Rapporto delle password incrinate, statistiche di copertura

ottimizzazione hardware 4.2

Gli attacchi di dizionario moderni sono massicciamente paralleli alla GPU:

Per una lista di 14 miliardi di voci (dimensione HIP) su 12× RTX 4090:

Questa differenza di ~9 ordini di grandezza tra MD5 e bcrypt spiega perché la scelta dell'algoritmo hash è critica.

4.3 Ordine di prova dei candidati

La lista delle parole non è testata in ordine alfabetico — è ordinato per diminuire la probabilità :

Questo tipo assicura che se la password è "bassa", si troverà nei primi millisecondi — qualunque sia la velocità hash.

5. Il corpus delle password reali

5.1 Sono stato pestato (HIBP)

HiBP è il riferimento globale perché:

Per gli algoritmi non salati (MD5, SHA-1), questa lista copre nell'ordine del 50-70% di tutte le password online reali.

5.2 RockYou (2009) — Corpus fondatore

5.3 Collezioni di wordlist specializzati

Questi corpi sono scaricabili pubblicamente — la loro esistenza è un fatto consolidato di sicurezza offensiva.

6. K-anonimato verifica HIBP: un attacco in tempo reale

6.1 Protocollo k- anonimato

Time2Crack incorpora un controllo HIBP in tempo reale che riproduce esattamente ciò che un aggressore farebbe con il database HIBP — ma non trasmettere mai la password in lingua normale o il suo hash completo.

Il protocollo k-anonymity funziona come segue:

1. Calculer SHA-1(password)      → par exemple "CBFDAC6008F9CAB4083784CBD1874F76618D2A97"
Invia solo i primi 5 caratteri all'API HIBP: "CBFDA"
L'API restituisce tutti i suffissi SHA-1 a partire da "CBFDA" (circa 400-600 hashes)
Cerca localmente se il resto dell'hash ("C6008F9CAB4083784CBD1874F76618D2A97") è nell'elenco
Se trovato: la password è stata compromessa (HIBP restituisce anche il numero di perdite)

6.2 Attuazione in Time2Crack (app.js)

Il controllo HIBP è asincrono e non-bloccante. La password viene immediatamente analizzata dai metodi locali e il controllo HIBP completa il risultato:

// Pseudo-code simplifié
async function checkHIBP(password) {
  const sha1 = await sha1Hash(password);
  const prefix = sha1.substring(0, 5);   // 5 premiers chars
  const suffix = sha1.substring(5);       // reste du hash
risposta const = attendere fetch(
    https://api.pwnedpasswords.com/range/${prefix}
  );
const lines = attendere risposta.text();
per (const line.split('\n') {
const [hashSuffix, count] = line.split(':');
se (hashSuffix.toLowerCase() = suffisso.toLowerCase()) {
ritorno parseInt(conto); // numero di perdite
#
#
ritorno 0; // non trovato
#

6.3 Interpretazione del conte HIBP

Il conteggio restituito da HiBP indica il numero di volte che questa password esatta è apparso in perdite indicizzate:

Anche un conteggio di 1 (la password è apparsa solo una volta in una perdita) indica una vulnerabilità: se un aggressore punta specificamente questo account e ha l'elenco delle credenziali della perdita in questione, lo troverà.

7. Time2Crack Language Wordlists

7.1 Perché le liste linguistiche in aggiunta a HIBP

HiBP copre le credenziali di compromesso esatte — ma non le parole comuni non sono mai scappate ancora. Un utente francofono che sceglie "effimero" come password non può essere in HiBP (la parola è improbabile nelle credenziali anglofono), ma è nella lista francese di qualsiasi attaccante che si rivolge a un sistema francofono.

Le liste di parole di Time2Crack coprono questo divario:

7.2 Carico pigro

Le liste di parole non sono incluse nel codice — sono caricate su richiesta durante la modifica del linguaggio, per soddisfare il budget della rete:

// app.js - loadDictionary()
async function loadDictionary(lang) {
  if (DICTlang & DICTWORDS) return;  // Déjà chargé
  if (DICTLOADING:
DICTPENDINGLANG = lang; // file di attesa
ritorno;
#
DICTLOADING = true;
const res = aspetta fetch(data/wordlists/${lang}.txt);
const text = attendere res.text();
// Convertire in Impostare l'abbronzatura > per la ricerca O(1)
DICTWORDS = nuovo set(
text.split("\n")
.map(w => w.normalize("NFC").trim().toLowerCase()
.filter(w => w.length >= 4)
);
DICTLANG = Lang;
DICTLOADING = falso;
#

Caricamento della coda

The DICTFINELANG evita le condizioni di gara durante i rapidi cambiamenti linguistici:

Scénario : l'utilisateur switche rapidement EN → FR → DE
├── EN demandé : DICTLOADING = falso → inizio della fetch EN
FR richiesto durante la fessura EN : DICTLOADING = true → DICTFINELANG = "fr"
├── DE demandé pendant fetch EN : DICTLOADING = vero → DICTPENDINGLANG = "de" (crash "fr")
- Taglie di chiusura: DICTLANG = "en", puis lance loadDictionary("de")
└── Résultat : seule la dernière langue demandée est chargée

Questo comportamento è intenzionale: la lingua più recente richiesta è caricata, non tutte le lingue intermedie.

8. Rilevazione del dizionario in Time2Crack: isDictWord()

8.1. Funzionamento di rilevamento

La funzione isDictWord(pw) determina se una password è o deriva da una parola del dizionario corrente:

// app.js - ligne 2181
function isDictWord(pw) {
  if (!DICT(WORDS) restituisci falso;
// Standardizzazione: NFC + minuscolo
const l = pw.normalize("NFC"). toLowerCase();
// Verifica diretta
se (DICT)WORDS.has(l) || DICTWORDS.has(deLeet(pw)) ritorna vero;
// Variazioni morfologiche
const deleetWord = deLeet(pw);
const variazioni = ottenereMorphVariations(deleetWord);
per (variazione delle variazioni) {
se (DICT)WORDS.has(variation)) return true;
  }
ritorna falso;
#

8.2 Standardizzazione Unicode (NFC)

Standardizzazione normalize("NFC") assicura che i caratteri accentati siano trattati in modo coerente:

Questa standardizzazione viene applicata sia durante la creazione del dizionario che durante il controllo — assicurando la corretta corrispondenza per le lingue di accento (FR, ES, DE, PT, ecc.).

8.3 Impatto sulla vulnerabilità rilevata

Quando isDictWord() Torna indietro truediversi attacchi diventano applicabili:

9. De-leetificazione: come l'attaccante decodifica sostituzioni

9.1 Leetspeak e i suoi limiti come protezione

Il leetspeak (o "1337 discorso") è una pratica di sostituzione di lettere con numeri o simboli visivamente simili: a→@♪ e→3♪ i→1 o !♪ o→0♪ s→$. Gli utenti lo usano per "strengthen" parole comuni.

La realtà: queste sostituzioni sono le prime regole applicate non costituiscono una vera difesa contro un aggressore competente.

9.2 Attuazione deLeet() in Time2Crack

// app.js - ligne 3622
const LEETBASE = {
a: ["@", "4"],
e: ["3"]
["0"]
["$", "5"],
["+", "7"],
#
g: ["9"]
}
funzione diLeetWith(pw, oneMap) {
let r = pw.normalize("NFC"). toLowerCase();
per (const [ch, reps] di Object.entries(LEET)BASE))
    for (const c of reps) r = r.split(c).join(ch);
  // Appliquer la résolution ambiguë (i ou l) en dernier
  for (const [ch, reps] of Object.entries(oneMap))
    for (const c of reps) r = r.split(c).join(ch);
  return r;
}
funzione diLeet(pw) {
// Ambiguità: "1" può essere "i" o "l"
const withI = deLeetWith(pw, { i: "1!", l: "" });
const withL = deLeetWith(pw, { l: "1", i: "!" });
// Se il dizionario è caricato, preferire la variante che corrisponde
se (DICT)WORDS)
se (DICT)WORDS.has(withL) ritorno conL;
se (DICT)WORDS.has(conio) ritorno conI;
#
// Altrimenti: preferire la variante con i numeri meno rimanenti
const digestsI = (con I.match(/\d/g)
const digestsL = (con L.match(/\d/g)
cifra di ritorno L <= cifre I? conL: withI;
#

9.3 Gestione dell'ambiguità "1" → "i" o "l"

La sostituzione "1" è ambigua: "1" può rappresentare "i" (come in "1nfo" → "info") o "l" (come in "p1ayer" → "player").

9.4 Sostituzioni non coperte (intenzionalmente)

Time2Crack non copre sostituzioni rare o ambigue oltre i modelli LEETBASE. È una scelta di progettazione: coprire troppi casi aumenterebbe i falsi positivi (rilevando una password come "parola corrente" mentre non lo è).

10. Calcolo del tempo di cracking: addDictionaryAttacks()

Logica di calcolo

// app.js - ligne 3848
function addDictionaryAttacks(rows, common, weak, dictWord) {
  for (const a of ALGOS) {
    let sec;
    if (weak)     sec = 100 / a.rate;     // Top ~100 entrées
    else if (common) sec = 10000 / a.rate; // HIBP priority list ~10k
    else if (dictWord) sec = 200000 / a.rate; // Scan wordlist complète ~200k mots
    else sec = null;                        // Non applicable
const note = debole ? t("nWeakPassword")
: comune ?
: dictWord? t(nDictHit)
: t(nAbsentLeaks);
righe.push({ atk: t("aDict"), hash: a.name, milza: a.rate, sec, note, cat: "dict" });
#
#

10.2 Tre livelli di vulnerabilità

10.3 Perché questi numeri (100, 10.000, 200.000)?

Questi valori vengono calibrati ai dati effettivi:

10.4 Esempio numerico completo

Per la password "sun" (attuale parola francese, rilevata come dictWord)

Anche per Argon2id, 250 secondi è meno di 5 minuti — per una parola semplice dal dizionario francese.

11. Alta taratura di fedeltà: applyHighFidelityCalibration()

11.1 Perché la calibrazione aggiuntiva?

Il calcolo lordo addDictionaryAttacks() dà una stima del "caso peggiore" — come se l'attaccante stava testando l'intera lista di parole in modo uniforme. ordinato per probabilità : le password più comuni arrivano prima.

La taratura di alta fedeltà applica un moltiplicatore correttivo basato su osservazioni empiriche:

// app.js - ligne 4442
case "dict":
  // Ur et al. 2012 : mots communs trouvés dans les 100-10k premiers essais
  // Weir 2009 : mots dict trouvés dans les 200k premiers essais (scan ordonné)
  m = contesto.common ? 0.15: context.dictWord? 0.5: 1.0;
Rompere;

11.2 Fonti accademiche di calibrazione

12. probabilità di applicabilità e punteggio di fiducia

12.1 Sistema di punteggio

Time2Crack non solo calcola un tempo — valuta anche la probabilità che l'attacco del dizionario sia effettivamente l'attacco più veloce, tramite un sistema di punteggio multifattore:

// Score d'applicabilité (0-1)
case "dict":
  return context.common ? 0.99 : context.dictWord ? 0.85 : 0;

12.2 Punteggio delle prove

Parallelamente al punteggio di applicabilità, un punteggio "evidence" registra i segnali osservati:

case "dict":
  return Number(!!context.common) + Number(!!context.dictWord);
  // 0 : aucun signal
  // 1 : un signal (common OU dictWord)
  // 2 : deux signaux (common ET dictWord)

Un punteggio di prova di 2 (parola sia in HIBP che nel dizionario linguistico) aumenta la fiducia finale di 0.08 (2 × 0.04).

12.3 Final Confidence Score

const base = confidenceBase["dict"] || 0.6;  // confiance de base
const evidenceBoost = Math.min(0.12, row.evidenceScore  0.04);
const speculativePenalty = speculativeCats.has("dict") ? 0.08 : 0;  // dict n'est pas spéculatif
Row.confidence = Math.max(0, Math.min(1,
Math.max (applicabilità, base) + evidenzaBoost - specificPenalty
)

Per una password common con dictWord anche rilevato:

Massima fiducia: L'attacco del dizionario è l'attacco primario senza ambiguità.

13. Filtro Bloom RockYou: rilevamento locale di password diffuse

13.1 Sfondo

Oltre alla verifica HIBP (che richiede una chiamata di rete), Time2Crack incorpora una filtro della fioritura Un filtro di fioritura è una struttura dati probabilistica che consente di testare l'appartenenza a un insieme con una probabilità di falsi positivi (~1%), senza memorizzare gli elementi stessi.

13.2 Vantaggi del filtro della fioritura

13.3 Funzionamento della doppia copertura

// app.js - ligne 1962
function bloomHas(filter, word) {
  if (!filter) return false;
  const { bitArray, m, k } = filter;
  const w = word.toLowerCase();
// Doppio taglio: h1 e h2 sono due funzioni di hash indipendenti
const h1 = fnv1a32(w, 2166136261); // FNV1a con seme standard
const h2 = fnv1a32(w, 0x811c9dc5); // FNV1a con seme alternativo
per (let i = 0; i < k; i++) {
const pos = (h1 +)  (h2) > (0)) % m; // k posizioni nella matrice bit
const byteIdx = Math.floor(pos / 8);
const bitIdx = pos % 8;
// Se un po' è 0: la parola è DEFINITLY assente
se ((bitArray[byteIdx] & (1 <± bitIdx) = 0) restituisci falso;
#
// Tutti i bit sono a 1 : la parola è PROBABLY presente (con 1% di FP)
ritorno vero;
#

Il double-hashing FNV1a garantisce una distribuzione uniforme delle posizioni nell'array bit, minimizzando le collisioni e mantenendo il tasso di falsi positivi vicino all'1%.

13.4 Carico e format binario

Il filtro della fioritura è memorizzato in data/rockyou.bloom — un file binario con:

Il carico viene attivato manualmente dall'utente (pulsante nell'interfaccia utente), non automaticamente al caricamento della pagina, per preservare le prestazioni iniziali.

14. Confronto con attacchi derivati

Time2Crack implementa 7 modelli di cracking offline (forza di crescita, dizionario, ibrido, maschera, PCFG, Markov, combinatore), ogni attacco della password da un angolo diverso.

14.1 Dizionario vs ibrido

L'attacco ibrido inizia dove il puro dizionario si ferma: prende ogni parola dalla lista delle parole e applica regole di mutazione sistematiche (hashcat "best64.rule" in mente).

Dizionario 14.2 vs PCFG

Una password come "Password123" può andare inosservata in un dizionario (la parola esatta "Password123" non può essere elencato) ma sarà cracked molto rapidamente da PCFG che riconosce la struttura [Majuscule][minuscules][digits].

14.3 dizionario vs Markov

Markov copre casi in cui la password sembra una parola umana senza essere in alcuna lista.

14.4 dizionario vs Credential Stuffing

L'imbottitura Credenziale non attacca un hash — prova direttamente coppie di login/password su servizi remoti. È concettualmente diverso da cracking, ma condivide la stessa fonte di dati (HIBP/fail).

15. Limitazioni del dizionario di attacco

15.1 Limiti intrinseci

15.2 Che Calcolo di Time2Crack non Modello

16. Efficace difesa

16.1 Che cosa protegge contro l'attacco del dizionario

La differenza di 10+ ordini di grandezza tra MD5 e Argon2id rende la password del dizionario "sun" immune in pratica se protetta da Argon2id - anche se l'aggressore sa che è una parola francese.

16.2 Che cosa non protegge

16.3 Raccomandazioni pratiche

17. Riferimenti

Fonti primarie (studi accademici)