Ataque del Diccionario - Operación Integral

Documento de referencia del proyecto Time2Crack

Recipientes: desarrolladores, investigadores de seguridad, usuarios avanzados

Índice

1. Sinopsis

El ataque al diccionario es el método de grieta de contraseña más antiguo, el más simple conceptualmente y estadísticamente más eficaz en la mayoría de las contraseñas humanas reales. Su principio es probar, en orden descendente de probabilidad, una lista precompilada de candidatos — el "diccionario"— en lugar de enumerar exhaustivamente todas las combinaciones posibles como lo hace la fuerza prima.

En Time2Crack, el diccionario atacan dos mecanismos distintos pero complementarios:

Estas dos detecciones son independientes y complementarias: HiBP cubre las credenciales exactas de compromiso, la lista de palabras cubre las palabras comunes que aún no se han filtrado.

2. Antecedentes históricos y académicos

2.1 Origen

El ataque del diccionario precede a la era moderna de seguridad informática. Los primeros sistemas Unix almacenan contraseñas en lenguaje simple en /etc/passwd, haciendo cualquier ataque de diccionario trivial tan pronto como el archivo era accesible.

2.2 Pérdidas de fundación

Algunas filtraciones han transformado el paisaje del ataque por diccionario revelando la distribución real de contraseñas humanas:

• Contraseña #1 ("123456") representaba 290.731 cuentas (2%)

2.3 Puntos de referencia para el ataque al diccionario

Una lista de 200.000 entradas probadas a la velocidad de un RTX 4090:

Por lo tanto, el ataque del diccionario es casi instantáneo para MD5, SHA-1 y NTLM — y sigue siendo muy rápido incluso para la cripta en pequeñas listas.

3. Fundaciones conceptuales: por qué los diccionarios trabajan

3.1 The Power Law of Human Passwords

Todos los estudios empíricos convergen hacia la misma observación: la distribución de contraseñas humanas no es uniforme — sigue a derecho del poder (Zipf). Algunas contraseñas concentran una fracción desproporcionada de opciones.

Consecuencia directa: 10 contraseñas más comunes Un atacante que prueba sólo 10 candidatos ya tiene una oportunidad en 20 para tener éxito — estadísticamente, es enorme para la cantidad de ruido generado.

3.2 Bias cognitivas en la creación de contraseña

Los humanos no eligen al azar. Aplican sistemáticamente heurísticas que hacen predecibles sus contraseñas:

3.3 El concepto de "palabra ya en las listas"

Una contraseña puede estar en una lista de ataque por dos razones diferentes:

Estos dos casos corresponden a ataques de naturaleza diferente, con diferentes velocidades, y esto es precisamente lo que los modelos Time2Crack.

4. Arquitectura de un ataque de diccionario moderno

4.1 Gasoducto general

Un ataque de diccionario moderno tiene lugar en varias fases:

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: Preprocesamiento de la lista de palabras
- Ordenar por frecuencia (probablemente primero)
- Deduplicación (no el doble del mismo candidato)
- Filtración de la longitud (longitud del objetivo + ±2)
- Normalización (bajo, Unicode NFC)
Fase 3: Cálculo de Hashs Candidato
Para cada candidato w en la lista de palabras:
, hashcandidato = hahalgo(w)
Promocional si hashcandidato= hashMeta: finalizada
- Velocidad: 168 GH/s para MD5 en RTX 4090
Fase 4: Análisis de los resultados
Report of cracked passwords, coverage statistics

4.2 Optimizaciones de hardware

Los ataques de diccionario modernos son masivamente paralelos a la GPU:

Para una lista de palabras de 14 mil millones de entradas (tamaño HIP) en 12× RTX 4090:

Esta diferencia de ~9 órdenes de magnitud entre MD5 y bcrypt explica por qué la elección del algoritmo hash es crítica.

4.3 Orden de prueba de candidatos

La lista de palabras no se prueba en orden alfabético — es ordenados por la disminución de la probabilidad :

Este tipo asegura que si la contraseña es "bajo", se encontrará en los primeros milisegundos, sea cual sea la velocidad de precipitación.

5. El corpus de contraseñas reales

5.1 He estado Pwned (HIBP)

HiBP es la referencia global porque:

Un atacante con el vertedero completo HIBP puede probar los ~14 mil millones de candidatos en orden descendente de frecuencia. Para algoritmos no saltados (MD5, SHA-1), esta lista cubre en el orden de 50-70% de todas las contraseñas en línea reales.

5.2 RockYou (2009) — Funding corpus

5.3 Colecciones de listas de palabras especializadas

Estos cuerpos son descargables públicamente — su existencia es un hecho establecido de seguridad ofensiva.

6. K-Anonymity Verification HIBP: A Real-Time Attack

6.1 Protocolo k-Anonimato

Time2Crack incorpora un cheque HIBP en tiempo real que reproduce exactamente lo que un atacante haría con la base de datos HIBP, pero nunca transmite la contraseña en lenguaje llano o su hash completo.

El protocolo k-anonymity funciona como sigue:

1. Calculer SHA-1(password)      → par exemple "CBFDAC6008F9CAB4083784CBD1874F76618D2A97"
Enviar sólo los primeros 5 caracteres a la API HIBP: "CBFDA"
La API devuelve TODOS los sufijos SHA-1 comenzando con "CBFDA" (aproximadamente 400-600 hashes)
Buscar localmente si el resto del hash ("C6008F9CAB4083784CBD1874F76618D2A97") está en la lista
Si se encuentra: la contraseña se ha comprometido (HIBP también devuelve el número de fugas)

6.2 Aplicación en Time2Crack (app.js)

El cheque HIBP es asincrónico y no bloqueo. La contraseña es analizada inmediatamente por métodos locales, y el cheque HIBP completa el resultado:

// 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
const response = await fetch(
    https://api.pwnedpasswords.com/range/${prefix}
  );
const lines = await response.text();
para (línea contigua de líneas.split('\n') {
const [hashSuffix, count] = line.split(':');
si (hashSuffix.toLowerCase() = suffix.toLowerCase() {)
parseInt(count); // número de fugas
}
}
retorno 0; // no encontrado
}

6.3 Interpretación del Conde HIBP

El recuento devuelto por HiBP indica el número de veces que esta contraseña exacta apareció en las filtraciones indexadas:

Incluso un recuento de 1 (la contraseña apareció sólo una vez en una fuga) indica una vulnerabilidad: si un atacante se dirige específicamente a esta cuenta y tiene la lista de credenciales de la fuga en cuestión, lo encontrará.

7. Time2Crack Language Wordlists

7.1 ¿Por qué los wordlists de idiomas además de HIBP

HiBP cubre las credenciales de compromiso exactas, pero no las palabras comunes nunca se agotan todavía. Un usuario de habla francesa que elige "ephemeral" como una contraseña puede no estar en HiBP (la palabra es poco probable en credenciales de aglofono), pero está en la lista de palabras francesa de cualquier atacante dirigido a un sistema de habla francesa.

Las listas de palabras de Time2Crack cubren esta brecha:

7.2 Carga perezosa

Las listas de palabras no están incluidas en el código — se cargan bajo petición al cambiar el idioma, para cubrir el presupuesto de la red:

// app.js - loadDictionary()
async function loadDictionary(lang) {
  if (DICTlang " DICT "WORDS) return;  // Déjà chargé
  if (DICTLOADING) {
DICTPENDINGLANG = lang; // Archivo de espera
retorno;
}
DICTLOADING = true;
const res = await fetch(data/wordlists/${lang}.txt);
const text = await res.text();
// Convertir en Establecer referencias clave para la búsqueda O(1)
DICTWORDS = nuevo Set(
texto.split("\n")
.map(w = título w.normalize("NFC").trim().toLowerCase())
.filter(w = título w.length
);
DICTLANG = Lang;
DICTLOADING = false;
}

Carga de cola

El DICTFINLANG evita las condiciones de raza durante los cambios rápidos en el idioma:

Scénario : l'utilisateur switche rapidement EN → FR → DE
├── EN demandé : DICTLOADING = false → inicio de la fiesta EN
FR solicitada durante la captura EN : DICTLOADING = true → DICTFINLANG = "fr"
├── DE demandé pendant fetch EN : DICTLOADING = verdadero → DICTPENDINGLANG = "de" (crash "fr")
- Fin de la venta: DICTLANG = "en", puis lance loadDictionary("de")
└── Résultat : seule la dernière langue demandée est chargée

Este comportamiento es intencional: se carga el idioma más solicitado recientemente, no todos los idiomas intermedios.

8. Detección de Diccionario en Time2Crack: isDictWord()

8.1. Operación de detección

La función isDictWord(pw) determina si una contraseña es o se deriva de una palabra de diccionario actual:

// app.js - ligne 2181
function isDictWord(pw) {
  if (!DICT(WORDS) devolver falso;
// Normalización: NFC + maleta inferior
const l = pw.normalize("NFC").toLowerCase();
// Verificación directa
siWORDS.has(l) || DICTWORDS.has (deLeet(pw))) devolver verdadero;
// Variaciones morfológicas
const deleetWord = deLeet(pw);
const variaciones = getMorphVariations(deleetWord);
para (continuación de variaciones) {
siWORDS.has(variation)) return true;
  }
devolver falso;
}

8.2 Normalización Unicode (NFC)

Normalización normalize("NFC") garantiza que los caracteres acentuados sean tratados consistentemente:

Esta estandarización se aplica tanto al crear el diccionario como al revisarlo, asegurando la correspondencia correcta para los lenguajes de acento (FR, ES, DE, PT, etc.).

8.3 Impacto en la vulnerabilidad detectada

Cuando isDictWord() Vuelve. truevarios ataques se aplican:

9. De-leetificación: cómo el atacante descifra las sustituciones

9.1 Leetspeak y sus limitaciones como protección

El leetspeak (o "1337 discurso") es una práctica de reemplazar letras con números o símbolos visualmente similares: a→@, e→3, i→1 o !, o→0, s→$. Los usuarios lo usan para "fortalecer" palabras comunes.

La realidad: estas sustituciones son las primeras normas aplicadas no constituyen una defensa real contra un atacante competente.

9.2 Aplicación deLeet() en Time2Crack

// app.js - ligne 3622
const LEETBASE = {}
a: ["@", "4"],
e: ["3"],
["0"],
s: ["$", "5"],
t: ["+", "7"],
["#"],
["9"],
};
función deLeetWith(pw, oneMap) {
let r = pw.normalize("NFC").toLowerCase();
para (const [ch, reps] de 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;
}
función de Leet(pw) {
// Ambigüedad: "1" puede ser "i" o "l"
const withI = deLeetWith(pw, { i: "1!", l: "" });
const withL = deLeetCon(pw, { l: "1", i: "!" });
// Si el diccionario está cargado, prefiera la variante que coincida
siWORDS {
siWORDS.has(withL)) retorno conL;
siWORDS.has(conI) return withI;
}
// De lo contrario: prefiere la variante con los números menos restantes
const digestsI = (con I.match(/\d/g)
const digestsL = (con L.match(/\d/g)
dígito de retorno L = dígito I? withL: withI;
}

9.3 Gestión de la ambigüedad "1" → "i" o "l"

La sustitución "1" es ambiguo: "1" puede representar "i" (como en "1nfo" → "info") o "l" (como en "p1ayer" → "jugador"). Time2Crack resuelve esta ambigüedad por:

9.4 Sustituciones no cubiertas (intencionadamente)

Time2Crack no cubre sustituciones raras o ambiguas más allá de los patrones de LEETBASE. Es una opción de diseño: cubrir demasiados casos aumentaría los falsos positivos (detectar una contraseña como una "palabra corriente" mientras que no lo es).Los patrones incluidos cubren √95% de las leetificaciones reales observadas en el corpus.

10. Cálculo del tiempo de grieta: addDictionaryAttacks()

Cálculo lógico

// 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
nota const = débil ? t("nWeakPassword")
: común ? t("nInLeaks")
: dictWord ? t(nDictHit)
t(nAbsentLeaks);
rows.push({ atk: t("aDict"), hash: a.name, spleen: a.rate, sec, note, cat: "dict" });
}
}

10.2 Tres niveles de vulnerabilidad

10.3 ¿Por qué estos números (100, 10.000, 200.000)?

Estos valores se calibran a datos reales:

10.4 Ejemplo numérico completo

Para la contraseña "sun" (actual palabra francesa, detectada como dictWord)

Incluso para Argon2id, 250 segundos es menos de 5 minutos, para una simple palabra del diccionario francés.

11. Calibración de alta fidelidad: applyHighFidelityCalibration()

11.1 ¿Por qué la calibración adicional?

El cálculo bruto addDictionaryAttacks() da una estimación del "caso peor" — como si el atacante estuviera probando uniformemente toda la lista de palabras. ordenado por probabilidad : las contraseñas más comunes llegan primero.

La calibración de alta fidelidad aplica un multiplicador correctivo basado en observaciones empíricas:

// 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 = context.common? 0.15: context.dictWord ? 0.5: 1.0;
Break;

Fuentes académicas de calibración

12. probabilidad de aplicabilidad y puntaje de confianza

12.1 Sistema de cableado

Time2Crack no solo calcula un tiempo — también evalúa la probabilidad de que el ataque del diccionario sea en realidad el ataque más rápido, a través de un sistema de puntuación multifactorial:

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

12.2 Puntuación de la prueba

En paralelo con la puntuación de aplicabilidad, un marcador "prueba" registra las señales observadas:

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

Una puntuación de evidencia de 2 (palabra en HIBP y diccionario lingüístico) aumenta la confianza final de 0.08 (2 × 0.04).

12.3 Puntuación final de la confianza

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(aplicabilidad, base) + evidenciaBoost - específicoPenalty
));

Para una contraseña common con dictWord también detectado:

Confianza máxima: El ataque del diccionario es el ataque primario sin ambigüedad.

13. Bloom filter RockYou: detección local de contraseñas generalizadas

13.1 Antecedentes

Además de la verificación HIBP (que requiere una llamada de red), Time2Crack incorpora una filtro Un filtro de floración es una estructura probabilística de datos que le permite probar pertenecer a un conjunto con una probabilidad de falsos positivos (~1%), sin almacenar los mismos elementos.

13.2 Beneficios del filtro de floración

13.3 Operación de doble escoria

// app.js - ligne 1962
function bloomHas(filter, word) {
  if (!filter) return false;
  const { bitArray, m, k } = filter;
  const w = word.toLowerCase();
// Doble-hashing: h1 y h2 son dos funciones de hash independientes
const h1 = fnv1a32(w, 2166136261); // FNV1a con semilla estándar
const h2 = fnv1a32(w, 0x811c9dc5); // FNV1a con semilla alternativa
para (let i = 0; i)
const pos = (h1 + i  (h2) нелиныминых (0)) % m; // k posiciones en la matriz de bits
const byteIdx = Math.floor(pos / 8);
const bitIdx = pos % 8;
// Si un poco es 0: la palabra está ausente
si ((bitArray[byteIdx] " (1 Identificado bitIdx)) = 0) devuelve falso;
}
// Todos los bits son a 1 : la palabra es PROBABLY presente (con 1% de FP)
retorno verdadero;
}

El FNV1a doble-hashing garantiza una distribución uniforme de posiciones en la matriz de bits, minimizando las colisiones y manteniendo la tasa de falsos positivos cerca del 1%.

13.4 Carga y formato binario

El filtro de floración se almacena en data/rockyou.bloom — un archivo binario con:

La carga es activada manualmente por el usuario (botón en la interfaz de usuario), no automáticamente en la carga de la página, para preservar el rendimiento inicial.

14. Comparación con los ataques derivados

El ataque del diccionario "puro" es el primero de una familia de ataques que todos comparten una raíz común: una lista de palabras lexical. Time2Crack implementa 7 modelos de grieta offline (fuerza de grieta, diccionario, híbrido, máscara, PCFG, Markov, combinador), cada uno atacando la contraseña desde un ángulo diferente.

14.1 Diccionario vs híbrido

El ataque híbrido comienza donde el diccionario puro se detiene: toma cada palabra de la lista de palabras y aplica reglas de mutación sistemática (hashcat "best64.rule" en mente).

14.2 Diccionario vs PCFG

Una contraseña como "Password123" puede pasar desapercibida en un diccionario (la palabra exacta "Password123" no puede ser listada) pero se romperá muy rápidamente por PCFG que reconoce la estructura [Majuscule][minuscules][digits].

14.3 Diccionario vs Markov

Markov cubre casos donde la contraseña parece una palabra humana sin estar en ninguna lista.

14.4 Dictionary vs Credential Stuffing

El relleno de credencial no ataca un hash – intenta directamente conectarse/password pares en servicios remotos. Es conceptualmente diferente de la grieta, pero comparte la misma fuente de datos (HIBP/fail).

15. Limitaciones del diccionario de ataque

15.1 Límites intrínsecos

15.2 ¿Qué cálculo de Time2Crack no modela

16. Defensas eficaces

16.1 Lo que protege contra el ataque del diccionario

La diferencia de 10+ órdenes de magnitud entre MD5 y Argon2id hace que la contraseña del diccionario "sun" inmune en la práctica si está protegida por Argon2id, incluso si el atacante sabe que es una palabra francesa.

16.2 Lo que no protege

16.3 Recomendaciones prácticas

17. Referencias

Fuentes primarias (estudios académicos)