El ataque de diccionario — Funcionamiento detallado
Documento de referencia del proyecto Time2Crack
Destinatarios: desarrolladores, investigadores de seguridad, usuarios avanzados
Índice
- Visión general
- Contexto histórico y académico
- Por qué funcionan los diccionarios
- Arquitectura de un ataque de diccionario moderno
- Corpus de contraseñas reales
- La verificación HIBP (k-anonimato)
- Las listas de palabras por idioma de Time2Crack
- El rango de diccionario:
rankDictionary() - La des-leetificación
- Del rango al tiempo de descifrado
- Comparación con los ataques derivados
- Límites del ataque de diccionario
- Defensas eficaces
- Referencias
1. Visión general
El ataque de diccionario es el método de descifrado de contraseñas más antiguo, el más sencillo de entender y, estadísticamente, el más eficaz contra las contraseñas humanas reales. En lugar de enumerar todas las combinaciones posibles como la fuerza bruta, prueba una lista de candidatos preparada de antemano —el «diccionario»— en orden de probabilidad decreciente.
Por qué funciona tan bien. Las personas no eligen sus contraseñas al azar. Décadas de filtraciones de datos muestran que las contraseñas reales están extremadamente concentradas: en la filtración de RockYou, 123456 lo usaban por sí sola 290.731 cuentas, alrededor del 2 % del total. Un ataque de diccionario bien construido prueba primero estos candidatos y los encuentra en una fracción de segundo, donde la fuerza bruta necesitaría años.
Time2Crack utiliza dos mecanismos independientes:
- El rango de diccionario, calculado localmente: ¿es la contraseña una de las más comunes, quizá disfrazada con leetspeak, o una palabra del diccionario del idioma elegido? Este rango da los tiempos de descifrado que aparecen en la tabla de resultados.
- La verificación en Have I Been Pwned (HIBP): ¿ha aparecido ya esta contraseña exacta en una filtración de datos? La respuesta se muestra en una insignia aparte, encima de los resultados.
Ambos se complementan: HIBP conoce las contraseñas ya filtradas y las listas de palabras cubren las palabras corrientes que aún no se han filtrado.
2. Contexto histórico y académico
2.1 Orígenes
El ataque de diccionario es anterior a la seguridad informática moderna. Los primeros sistemas Unix guardaban los hashes de las contraseñas en el archivo /etc/passwd, legible por todos: quien pudiera leerlo podía probar una lista de palabras contra todas las cuentas.
| Año | Acontecimiento |
|---|---|
| 1979 | Morris y Thompson publican el primer artículo académico sobre la seguridad de las contraseñas en Unix; gran parte de las contraseñas estudiadas eran palabras o nombres comunes. |
| 1988 | El gusano Morris se propaga en parte adivinando contraseñas con una lista integrada de 432 palabras y después con el diccionario del sistema /usr/share/dict/words. |
| 1991 | Crack (Alec Muffett): el primer descifrador de contraseñas Unix de uso extendido, con reglas de transformación de palabras. |
| 1996 | John the Ripper populariza el modo «lista de palabras + reglas». |
| 2009 | Filtración de RockYou: 32 millones de cuentas almacenadas en texto claro (14,3 millones de contraseñas distintas) revelan cómo eligen realmente las personas sus contraseñas. |
| 2013 | Troy Hunt lanza Have I Been Pwned. Ese mismo año, la filtración de Adobe expone 153 millones de cuentas cuyas contraseñas estaban cifradas sin sal, lo que permitía detectar las contraseñas idénticas. |
| 2015 | Hashcat pasa a ser de código abierto; los ataques de diccionario en GPU quedan al alcance de todos. |
| 2019 | «Collection #1–5»: miles de millones de pares correo/contraseña recopilados de filtraciones anteriores circulan públicamente. |
2.2 Las filtraciones fundacionales
Algunas filtraciones transformaron el ataque de diccionario al revelar la distribución real de las contraseñas humanas:
- RockYou (2009): 14,3 millones de contraseñas distintas en texto claro. La contraseña n.º 1 (
123456) la usaban 290.731 cuentas, alrededor del 2 % del total. - LinkedIn (2012): al principio se publicaron 6,5 millones de hashes SHA-1 sin sal; más tarde se supo que la filtración afectaba a unos 117 millones de cuentas.
- Adobe (2013): 153 millones de cuentas; las pistas de contraseña guardadas en texto claro ayudaron a adivinar las contraseñas más comunes.
- Have I Been Pwned (desde 2013): una recopilación continua de filtraciones públicas, hoy una referencia mundial.
2.3 ¿A qué velocidad va un ataque de diccionario?
Una lista de 1 millón de palabras, probada a las velocidades que usa Time2Crack (12× RTX 5090, el perfil «Estándar» por defecto):
| Algoritmo | Velocidad | Tiempo para 1 millón de candidatos |
|---|---|---|
| NTLM | 4.081 GH/s | 0,25 microsegundos |
| MD5 | 2.634 GH/s | 0,38 microsegundos |
| SHA-1 | 837 GH/s | 1,2 microsegundos |
| SHA-256 | 332 GH/s | 3,0 microsegundos |
| bcrypt (coste 5) | 3.658 kH/s | 0,27 segundos |
| Argon2id | 1.000 H/s | unos 17 minutos |
El ataque de diccionario es, por tanto, instantáneo contra las funciones hash rápidas (MD5, SHA-1, NTLM) y sigue siendo rápido incluso contra bcrypt.
3. Por qué funcionan los diccionarios
3.1 La ley de potencia de las contraseñas humanas
Todos los estudios empíricos llegan a la misma conclusión: las contraseñas humanas no se distribuyen de forma uniforme. Siguen una ley de potencia (ley de Zipf): unas pocas contraseñas concentran una parte desproporcionada de las elecciones.
Formalmente: si se ordenan las contraseñas por frecuencia decreciente, la frecuencia de la contraseña de rango r es aproximadamente proporcional a r−s, donde el exponente s depende del corpus (Wang et al., 2017).
Consecuencia directa: un atacante que solo prueba las 10 contraseñas más comunes ya tiene alrededor de una posibilidad entre 20 de acertar con una cuenta dada.
3.2 Sesgos cognitivos al crear contraseñas
Las personas siguen hábitos previsibles al crear una contraseña:
- Facilidad de recuerdo: las palabras fáciles de recordar (nombres comunes, nombres de pila, cultura popular) están sobrerrepresentadas.
- Disponibilidad: la contraseña refleja el entorno inmediato (nombre de la mascota, equipo deportivo, personaje favorito).
- Sustituciones previsibles: e → 3, a → @, o → 0. El usuario cree que su contraseña es más fuerte, pero son las primeras sustituciones que prueba un atacante.
- Añadidos al final: una cifra o un símbolo al final de una palabra (
password1,mariposa!). - Idioma y cultura: las contraseñas comunes dependen del idioma del usuario (
Soleil123en Francia,Sommer123en Alemania).
3.3 Dos maneras de estar «en las listas»
Una contraseña puede figurar en una lista de ataque por dos razones distintas:
- Ya se ha filtrado. La contraseña exacta apareció en una filtración anterior. El atacante no necesita adivinar: prueba las contraseñas conocidas por orden de frecuencia.
- Es una palabra corriente. Aunque nunca se haya filtrado, está en todas las listas de ataque porque es un candidato evidente. Una palabra como
mariposapuede no estar en HIBP, pero está en la lista española de cualquier herramienta de descifrado seria.
Estos dos casos corresponden a los dos mecanismos de Time2Crack que se describen más abajo.
4. Arquitectura de un ataque de diccionario moderno
4.1 Desarrollo general
Un ataque de diccionario moderno se desarrolla en cuatro fases:
Fase 1: reunir la lista de palabras
├── Contraseñas filtradas (HIBP, RockYou, recopilaciones)
├── Listas por idioma (diccionarios, nombres, lugares)
├── Listas temáticas (deporte, cultura popular, tecnología, religión)
└── Listas dirigidas (dominio de la empresa, nombres de empleados)
Fase 2: preparar la lista
├── Ordenar por frecuencia (las más probables primero)
├── Eliminar duplicados
├── Filtrar por longitud (longitud objetivo ± 2)
└── Normalizar (minúsculas, Unicode NFC)
Fase 3: calcular el hash y comparar
para cada candidato w de la lista:
si hash(w) == hash_objetivo: encontrado
(miles de millones de candidatos por segundo en GPU con MD5)
Fase 4: balance
└── Contraseñas descifradas, estadísticas de cobertura
4.2 Optimizaciones de hardware
Los ataques de diccionario modernos se ejecutan de forma masivamente paralela en GPU:
- Hashcat (la herramienta de referencia) usa miles de núcleos de GPU para calcular miles de millones de hashes por segundo.
- Procesamiento por lotes: los candidatos se envían a la GPU en lotes de millones para mantenerla siempre ocupada.
- Reglas en la GPU: las reglas de transformación se aplican directamente en la GPU; así, una lista corta produce miles de millones de candidatos sin tener que almacenarlos.
Para una lista de 1.000 millones de contraseñas filtradas en 12× RTX 5090:
- MD5: 109 / 2.634 × 109 ≈ 0,4 milisegundos
- bcrypt (coste 5): 109 / 3.658.000 ≈ 5 minutos
Esta diferencia de unos seis órdenes de magnitud entre MD5 y bcrypt muestra hasta qué punto importa la elección del algoritmo hash.
4.3 El orden de los candidatos
La lista no se prueba en orden alfabético, sino por probabilidad decreciente:
- Las contraseñas filtradas más comunes (las 100 primeras de RockYou)
- Las contraseñas presentes en muchas filtraciones (ordenadas por frecuencia en HIBP)
- Las palabras corrientes del idioma objetivo
- Los nombres propios (nombres de pila, ciudades, famosos)
- Los términos relacionados con el objetivo
- Las variantes y formas flexionadas
Con este orden, una contraseña débil se encuentra en los primeros milisegundos, sea cual sea la velocidad del hash.
5. Corpus de contraseñas reales
5.1 Have I Been Pwned (HIBP)
- Tamaño: más de mil millones de contraseñas distintas, procedentes de más de 14.000 millones de cuentas comprometidas
- Fuente: recopilación de filtraciones públicas desde 2013
- Formato: hashes SHA-1 (y NTLM) con el número de veces que se ha visto cada contraseña
- Acceso: API con k-anonimato; los defensores pueden descargar la lista completa
HIBP es la referencia mundial porque cubre casi todas las grandes filtraciones públicas, indica la frecuencia de cada contraseña y se mantiene activamente. Un atacante con la lista completa puede probar primero las contraseñas más frecuentes.
5.2 RockYou (2009): el corpus fundacional
14,3 millones de contraseñas distintas en texto claro. El principio de la lista:
| Rango | Contraseña | Cuentas | Proporción |
|---|---|---|---|
| 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 % |
Conclusión: un puñado de candidatos, probados en unos nanosegundos contra MD5, basta para comprometer una parte apreciable de las cuentas de una base de datos filtrada.
5.3 Colecciones de listas especializadas
- SecLists (Daniel Miessler): una colección de código abierto de listas para pruebas de seguridad — contraseñas filtradas, contraseñas por idioma, términos técnicos, nombres.
- CrackStation: unos 1.500 millones de entradas, entre ellas todas las palabras de Wikipedia en varios idiomas.
- Weakpass: recopilaciones muy grandes de contraseñas reales filtradas.
Estos corpus se pueden descargar públicamente: su existencia es un hecho establecido de la seguridad ofensiva.
6. La verificación HIBP (k-anonimato)
6.1 El protocolo de k-anonimato
Time2Crack comprueba la contraseña en HIBP sin enviarla nunca, ni a ella ni su hash completo. El protocolo funciona así:
1. Calcular SHA-1(contraseña)
→ p. ej. CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Enviar solo los 5 primeros caracteres a la API de HIBP
→ GET https://api.pwnedpasswords.com/range/CBFDA
3. La API devuelve todos los sufijos de hash que empiezan por ese prefijo
(varios cientos de líneas, completadas con entradas falsas)
4. Buscar el resto del hash en la respuesta, localmente
→ C6008F9CAB4083784CBD1874F76618D2A97
5. Encontrado: la contraseña se ha filtrado y HIBP indica cuántas veces
No encontrado: la contraseña no está en HIBP
Garantía de privacidad: el servidor de HIBP solo ve un prefijo de 5 caracteres que comparten cientos de contraseñas. No puede saber qué contraseña se ha comprobado. La comparación se hace en el navegador.
6.2 La implementación en Time2Crack
La comprobación empieza medio segundo después de la última pulsación, en paralelo con el análisis local:
// 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
}
El resultado aparece en una insignia: «encontrada N veces», «no encontrada» o «no disponible» cuando la API no responde. No modifica los tiempos de descifrado, que se calculan localmente.
6.3 Cómo leer el contador de HIBP
El contador es el número de veces que esta contraseña exacta se ha visto en las filtraciones indexadas:
| Contador | Significado |
|---|---|
| Más de 1.000.000 | Entre las contraseñas más usadas del mundo: todos los atacantes la prueban primero |
| 10.000 a 1.000.000 | Muy común |
| 1.000 a 10.000 | Común |
| 100 a 1.000 | Poco común pero conocida |
| 1 a 100 | Rara, pero comprometida |
Incluso un contador de 1 es una advertencia: la contraseña está en las listas de que disponen los atacantes, y quien ataque la cuenta de la que se filtró la probará.
7. Las listas de palabras por idioma de Time2Crack
7.1 Por qué listas por idioma además de HIBP
HIBP cubre las contraseñas que ya se han filtrado, no las palabras corrientes que aún no se han filtrado. Un hispanohablante que elige girasol quizá no esté en HIBP, pero la palabra está en la lista española de cualquier atacante que se dirija a usuarios hispanohablantes. Las listas por idioma de Time2Crack cubren este hueco:
| Idioma | Archivo | Palabras |
|---|---|---|
| Inglés | en.txt.gz | 748.958 |
| Francés | fr.txt.gz | 550.235 |
| Español | es.txt.gz | 284.834 |
| Portugués | pt.txt.gz | 507.721 |
| Alemán | de.txt.gz | 2.009.880 |
| Italiano | it.txt.gz | 3.252.670 |
| Neerlandés | nl.txt.gz | 2.678.323 |
| Polaco | pl.txt.gz | 3.670.705 |
| Turco | tr.txt.gz | 400.442 |
| Total | 14.103.768 |
Las primeras versiones procedían de las listas de palabras de Wikipedia de SecLists y de las listas de kkrypt0nn; desde entonces se han ampliado. Al cargarlas, a cada línea se le quitan los espacios y se pasa a minúsculas, y se descartan las palabras de menos de 3 caracteres.
7.2 Carga bajo demanda
Las listas no van incluidas en el código. Solo se descarga la lista del idioma elegido, la primera vez que hace falta, como archivo 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);
}
¿Por qué un Set? Un Set de JavaScript responde a dictWords.has(word) en tiempo constante, tanto si la lista tiene 285.000 palabras (español) como 3,7 millones (polaco). Con un Array, cada búsqueda podría requerir una comparación por palabra.
7.3 Caché local (IndexedDB)
La lista preparada se guarda en la IndexedDB del navegador con la clave dict_<idioma>. En la siguiente visita se lee de la caché en lugar de descargarla y descomprimirla de nuevo:
Primera visita Visitas siguientes
-------------- ------------------
fetch es.txt.gz cacheGet("dict_es")
└── gunzip (DecompressionStream) └── new Set(words)
└── trim / minúsculas / ≥ 3 └── lista
└── new Set(words)
└── cachePut("dict_es")
└── lista
La contraseña nunca sale del navegador: la lista se descarga del servidor de Time2Crack y la comparación se hace localmente.
8. El rango de diccionario: rankDictionary()
8.1 El principio: un rango y luego un tiempo
Time2Crack no solo se pregunta «¿es una palabra del diccionario?», sino «¿después de cuántos intentos la encontraría un ataque de diccionario?». Ese número de intentos es el rango. La función rankDictionary() (archivo core/rank/dictionary.js) lo devuelve, o devuelve null cuando el ataque no se aplica:
// 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 Cuatro niveles
| Nivel | Regla | Ejemplo | Rango |
|---|---|---|---|
| 1. Contraseñas más comunes | Posición en una lista de 105 de las contraseñas más comunes (RockYou, HIBP) | password | 2 |
| 2. Variante en leetspeak | Posición de la forma des-leetificada × 10 | p@ssw0rd | 20 |
| 3. Lista del idioma | La mitad del tamaño de la lista | soleil (francés) | 275.117 |
| 4. Palabra compuesta | Véase 8.4 | apfelbaumkuchen (alemán) | 21.129 |
¿Por qué la mitad de la lista? Las listas no están ordenadas por frecuencia: la posición de una palabra en el archivo no dice nada sobre cuándo la probaría un atacante. De media, un atacante que recorre la lista encuentra una palabra dada a mitad de camino.
8.3 Las mayúsculas
Un atacante empieza por las palabras en minúsculas y luego prueba las variantes con mayúsculas. El rango se multiplica por el número de variantes necesarias para llegar a la grafía de la contraseña (función uppercaseCost(), mismo método que zxcvbn):
| Mayúsculas | Multiplicador | Ejemplo | Rango |
|---|---|---|---|
| Todo en minúsculas | × 1 | soleil | 275.117 |
| Solo la primera letra | × 2 | Soleil | 550.234 |
| Solo la última letra | × 2 | soleiL | 550.234 |
| Todo en mayúsculas | × 2 | PASSWORD | 4 |
| Cualquier otra mezcla | suma de C(n, i) para i = 1 … mín(mayúsculas, minúsculas) | PaSsWoRd | 324 |
8.4 Las palabras compuestas
El alemán (y el neerlandés) une las palabras entre sí: Apfelbaumkuchen = Apfel + Baum + Kuchen. Una palabra así suele faltar en la lista, pero un atacante puede construirla combinando palabras más cortas. Time2Crack intenta dividir la contraseña en 2 a 4 palabras de la lista, admitiendo las letras de enlace habituales del alemán (-s-, -es-, -n-, -en-, -er-, -e-). El rango es entonces el rango por máscara de la contraseña multiplicado por 0,25 (2 palabras), 0,16 (3 palabras) o 0,10 (4 palabras), y por 0,75 cuando el último fragmento es un sufijo común (-heit, -ung, -haus…).
La división también se intenta con las palabras largas que están en la lista (9 caracteres o más) y se conserva si da un rango más bajo: Sonnenblume obtiene un rango de 42.680 en lugar de la mitad de la lista alemana (1.004.940).
9. La des-leetificación
9.1 El leetspeak no protege
El leetspeak sustituye letras por cifras o símbolos parecidos: a → @, e → 3, i → 1, o → 0, s → $. Se usa para «reforzar» una palabra corriente: password → p@$$w0rd.
En realidad, estas sustituciones están entre las primeras reglas que aplican las herramientas de descifrado. No frenan a un atacante competente.
9.2 La función 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 contraseña se busca tal como se escribió y en su forma des-leetificada. Entre las contraseñas más comunes, la forma des-leetificada cuesta 10 veces más (el atacante tiene que probar las variantes): p@ssw0rd → 20 en lugar de 2. En la lista del idioma, cuesta lo mismo que la palabra simple.
9.3 Lo que no se descodifica
- Cada carácter tiene un solo reemplazo:
1siempre pasa ai, nunca al; por esop1ayerno se reconoce comoplayer. - Las sustituciones más raras (
+→ t,9→ g,#→ h) no se descodifican. - Una palabra seguida de cifras o símbolos (
mariposa2024,mariposa!) no es una coincidencia de diccionario: la trata el ataque híbrido.
10. Del rango al tiempo de descifrado
El rango se convierte en segundos dividiéndolo por la velocidad de hash del atacante:
// 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);
}
Ejemplo para soleil (lista francesa, rango 275.117) con el perfil por defecto:
| Algoritmo | Velocidad (12× RTX 5090) | Cálculo | Tiempo |
|---|---|---|---|
| NTLM | 4.081 GH/s | 275.117 / 4.081 × 109 | 67 nanosegundos |
| MD5 | 2.634 GH/s | 275.117 / 2.634 × 109 | 104 nanosegundos |
| SHA-1 | 837 GH/s | 275.117 / 837 × 109 | 329 nanosegundos |
| SHA-256 | 332 GH/s | 275.117 / 332 × 109 | 829 nanosegundos |
| bcrypt (coste 5) | 3.658 kH/s | 275.117 / 3.658.000 | 0,08 segundos |
| Argon2id | 1.000 H/s | 275.117 / 1.000 | 4 minutos 35 segundos |
Incluso con Argon2id, una simple palabra francesa cae en menos de 5 minutos. El perfil del atacante cambia las velocidades: desde una sola GPU (perfil «Amateur») hasta unas 10.000 GPU (perfil «Estado»). Como en todos los demás modelos, el rango de diccionario nunca puede superar el rango de fuerza bruta de la misma contraseña.
11. Comparación con los ataques derivados
El ataque de diccionario «puro» es el primero de una familia de ataques que parten todos de una lista de palabras. Time2Crack calcula nueve modelos (fuerza bruta, diccionario, híbrido, máscara, PCFG, Markov, combinador, patrones de teclado, fechas), y cada uno ataca la contraseña desde un ángulo distinto.
11.1 Diccionario e híbrido
| Criterio | Diccionario | Híbrido (diccionario + reglas) |
|---|---|---|
| Candidatos | Las palabras de la lista, tal cual | Cada palabra con sus transformaciones (cifras, símbolos, mayúsculas…) |
| Ejemplos descifrados | password, mariposa | P@ssw0rd!, mariposa2024 |
| Velocidad | Menos candidatos, por tanto más rápido | Cobertura mucho más amplia |
| Se aplica cuando | La palabra exacta está en la lista | La contraseña deriva de una palabra de la lista |
El ataque híbrido empieza donde termina el diccionario puro: aplica reglas de transformación sistemáticas a cada palabra de la lista (al estilo de best64.rule de hashcat).
11.2 Diccionario y PCFG
| Criterio | Diccionario | PCFG |
|---|---|---|
| Modelo | Lista fija de candidatos | Gramática probabilística de las estructuras de contraseña |
| Punto fuerte | Palabras exactas | Estructuras como palabra + cifras, mayúscula + minúsculas + símbolo |
| Ejemplo | password ✓ | Password123 ✓ (estructura reconocida) |
Password123 no es una palabra del diccionario como tal, pero PCFG reconoce su estructura [mayúscula][minúsculas][cifras] y la descifra muy deprisa.
11.3 Diccionario y Markov
| Criterio | Diccionario | Markov |
|---|---|---|
| Candidatos | Lista preparada de antemano | Generados sobre la marcha por un modelo estadístico |
| Cobertura | Vocabulario conocido | Cualquier secuencia que «parezca humana» |
| Ventaja | Muy rápido con palabras exactas | Cubre también palabras ausentes de las listas |
Markov cubre las contraseñas que parecen palabras humanas sin figurar en ninguna lista.
11.4 Diccionario y relleno de credenciales
| Criterio | Diccionario | Relleno de credenciales (credential stuffing) |
|---|---|---|
| Objetivo | Descifrar un hash | Iniciar sesión en una cuenta |
| Mecanismo | Cálculo de hashes en local | Intentos de inicio de sesión a distancia |
| Fuente | Lista de palabras genérica | Pares correo/contraseña filtrados |
| Defensa | Algoritmo hash lento | Limitación de intentos, MFA, bloqueo de IP |
El relleno de credenciales no ataca un hash: prueba directamente pares correo/contraseña filtrados en servicios en línea. Es otro ataque, pero usa los mismos datos (filtraciones como las indexadas por HIBP). Time2Crack no lo modela.
12. Límites del ataque de diccionario
12.1 Límites intrínsecos
- Solo vocabulario conocido. Una contraseña inventada, que no se parece a ninguna palabra existente y nunca se ha filtrado, escapa al ataque de diccionario puro:
Xqz7mK9pLno está en ninguna lista. - Cobertura de idiomas. Un atacante que se dirige a hispanohablantes sin una lista española no encontrará palabras como
girasolomadrugada. - Contraseñas nuevas. Una contraseña que nunca se ha filtrado no está en HIBP, aunque sea común.
- Frases de contraseña largas.
MiGranAventuraBajoLasEstrellasno está en ninguna lista, aunque cada palabra sea trivial. Las frases de contraseña las tratan otros ataques (combinador, PRINCE).
12.2 Lo que Time2Crack no modela
- Listas dirigidas: un atacante que apunta a un sector crea listas específicas (términos médicos para un hospital, jerga de jugadores para una plataforma de juegos). Herramientas como CeWL extraen las palabras del sitio web del objetivo. Time2Crack usa listas genéricas.
- Filtraciones recientes: entre una filtración y su incorporación a HIBP, las contraseñas circulan en privado sin ser visibles a través de la API pública.
- Otros algoritmos hash: Time2Crack modela seis algoritmos (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt o PBKDF2 tienen perfiles distintos.
- Frecuencia de las palabras: todas las palabras de la lista del idioma reciben el mismo rango (la mitad de la lista), sean muy comunes o muy raras.
13. Defensas eficaces
13.1 Lo que protege
Un algoritmo hash lento (bcrypt, Argon2id). Es la defensa más eficaz del lado del servidor: cada intento cuesta más. Para soleil (rango 275.117):
- MD5: unos 0,1 microsegundos
- bcrypt coste 12 (128 veces más lento que el coste 5): unos 10 segundos
- Argon2id: unos 5 minutos
Un hash lento frena al atacante, pero no salva una palabra del diccionario: la lista es sencillamente demasiado corta.
Una sal única por cuenta. Hace inútiles las tablas precalculadas (rainbow tables) y obliga al atacante a trabajar cuenta por cuenta. No impide un ataque con lista de palabras contra una sola cuenta.
Longitud y azar. Una sola palabra del diccionario siempre es vulnerable. Una frase de contraseña de 4 o 5 palabras resiste el ataque de diccionario puro, pero no el ataque combinador si las palabras son previsibles: deben elegirse al azar.
Contraseñas generadas al azar. La verdadera solución: un gestor de contraseñas que genere contraseñas largas y aleatorias (20 caracteres o más). No figuran en ningún diccionario.
Autenticación multifactor (MFA). No impide descifrar sin conexión hashes robados, pero impide al atacante iniciar sesión con una contraseña descifrada.
Limitación de intentos y detección de anomalías. Protegen contra los intentos en línea, no contra el descifrado sin conexión de hashes robados.
13.2 Lo que no protege
- Las sustituciones en leetspeak:
password→p@ssw0rd(véase la sección 9). - Una cifra al final:
password→password1, entre las primeras reglas probadas. - Una mayúscula inicial:
password→Password, una regla estándar (rango × 2). - Cifras y símbolos alrededor de una palabra reconocible:
mariposa!se encuentra con las reglas más básicas. - Complejidad sin longitud:
P@s1wcumple las reglas habituales (mayúscula, minúscula, cifra, símbolo), pero es más corta y más previsible quecorrecthorsebatterystaple.
13.3 Recomendaciones prácticas
- Use un gestor de contraseñas (Bitwarden, 1Password, KeePass): genera contraseñas aleatorias y usted solo recuerda la contraseña maestra.
- Active la MFA en todas partes: aunque se filtre una contraseña, el atacante no podrá iniciar sesión.
- Consulte HIBP con regularidad para saber si su dirección de correo aparece en filtraciones conocidas.
- No reutilice nunca una contraseña: el relleno de credenciales aprovecha la reutilización entre servicios.
- Para las contraseñas que deba recordar: una frase de contraseña de 5 palabras o más, elegidas al azar (con dados o un generador), no escogidas por usted.
14. Referencias
Fuentes académicas
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. Primer análisis académico de las contraseñas de Unix.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. Alrededor de una cuarta parte de 15.000 contraseñas Unix descifradas con listas de palabras y reglas.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. El artículo fundacional de PCFG, comparado con los ataques de diccionario.
- 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. Mide la distribución real de las contraseñas.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Compara los modelos de diccionario, Markov y PCFG con corpus reales.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Origen del coste de las mayúsculas usado en la sección 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.
Fuentes del sector
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. La API con k-anonimato que usa Time2Crack.
- Hive Systems (2025). Password table. Edición 2025 basada en 12× RTX 5090. Time2Crack usa benchmarks de hashcat medidos en la RTX 5090 (Specops 2026, foro de hashcat.net); Argon2id sigue siendo una estimación.
- Hashcat. Advanced password recovery. https://hashcat.net. Herramienta de referencia para las mediciones en GPU y las reglas de transformación (
best64.rule). - Miessler, D. SecLists. GitHub. Origen de las primeras listas por idioma de Time2Crack.
Contexto
- 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. Muestra que el k-anonimato protege la privacidad.
Código fuente: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).