El ataque de diccionario — Funcionamiento detallado

Documento de referencia del proyecto Time2Crack
Destinatarios: desarrolladores, investigadores de seguridad, usuarios avanzados

Índice

  1. Visión general
  2. Contexto histórico y académico
  3. Por qué funcionan los diccionarios
  4. Arquitectura de un ataque de diccionario moderno
  5. Corpus de contraseñas reales
  6. La verificación HIBP (k-anonimato)
  7. Las listas de palabras por idioma de Time2Crack
  8. El rango de diccionario: rankDictionary()
  9. La des-leetificación
  10. Del rango al tiempo de descifrado
  11. Comparación con los ataques derivados
  12. Límites del ataque de diccionario
  13. Defensas eficaces
  14. 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:

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ñoAcontecimiento
1979Morris 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.
1988El 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.
1991Crack (Alec Muffett): el primer descifrador de contraseñas Unix de uso extendido, con reglas de transformación de palabras.
1996John the Ripper populariza el modo «lista de palabras + reglas».
2009Filtració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.
2013Troy 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.
2015Hashcat 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:

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):

AlgoritmoVelocidadTiempo para 1 millón de candidatos
NTLM4.081 GH/s0,25 microsegundos
MD52.634 GH/s0,38 microsegundos
SHA-1837 GH/s1,2 microsegundos
SHA-256332 GH/s3,0 microsegundos
bcrypt (coste 5)3.658 kH/s0,27 segundos
Argon2id1.000 H/sunos 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:

3.3 Dos maneras de estar «en las listas»

Una contraseña puede figurar en una lista de ataque por dos razones distintas:

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:

Para una lista de 1.000 millones de contraseñas filtradas en 12× RTX 5090:

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:

  1. Las contraseñas filtradas más comunes (las 100 primeras de RockYou)
  2. Las contraseñas presentes en muchas filtraciones (ordenadas por frecuencia en HIBP)
  3. Las palabras corrientes del idioma objetivo
  4. Los nombres propios (nombres de pila, ciudades, famosos)
  5. Los términos relacionados con el objetivo
  6. 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)

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:

RangoContraseñaCuentasProporción
1123456290.7312,03 %
21234579.0780,55 %
312345678976.7900,54 %
4password59.4620,42 %
5iloveyou49.9520,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

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:

ContadorSignificado
Más de 1.000.000Entre las contraseñas más usadas del mundo: todos los atacantes la prueban primero
10.000 a 1.000.000Muy común
1.000 a 10.000Común
100 a 1.000Poco común pero conocida
1 a 100Rara, 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:

IdiomaArchivoPalabras
Inglésen.txt.gz748.958
Francésfr.txt.gz550.235
Españoles.txt.gz284.834
Portuguéspt.txt.gz507.721
Alemánde.txt.gz2.009.880
Italianoit.txt.gz3.252.670
Neerlandésnl.txt.gz2.678.323
Polacopl.txt.gz3.670.705
Turcotr.txt.gz400.442
Total14.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

NivelReglaEjemploRango
1. Contraseñas más comunesPosición en una lista de 105 de las contraseñas más comunes (RockYou, HIBP)password2
2. Variante en leetspeakPosición de la forma des-leetificada × 10p@ssw0rd20
3. Lista del idiomaLa mitad del tamaño de la listasoleil (francés)275.117
4. Palabra compuestaVéase 8.4apfelbaumkuchen (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úsculasMultiplicadorEjemploRango
Todo en minúsculas× 1soleil275.117
Solo la primera letra× 2Soleil550.234
Solo la última letra× 2soleiL550.234
Todo en mayúsculas× 2PASSWORD4
Cualquier otra mezclasuma de C(n, i) para i = 1 … mín(mayúsculas, minúsculas)PaSsWoRd324

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


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:

AlgoritmoVelocidad (12× RTX 5090)CálculoTiempo
NTLM4.081 GH/s275.117 / 4.081 × 10967 nanosegundos
MD52.634 GH/s275.117 / 2.634 × 109104 nanosegundos
SHA-1837 GH/s275.117 / 837 × 109329 nanosegundos
SHA-256332 GH/s275.117 / 332 × 109829 nanosegundos
bcrypt (coste 5)3.658 kH/s275.117 / 3.658.0000,08 segundos
Argon2id1.000 H/s275.117 / 1.0004 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

CriterioDiccionarioHíbrido (diccionario + reglas)
CandidatosLas palabras de la lista, tal cualCada palabra con sus transformaciones (cifras, símbolos, mayúsculas…)
Ejemplos descifradospassword, mariposaP@ssw0rd!, mariposa2024
VelocidadMenos candidatos, por tanto más rápidoCobertura mucho más amplia
Se aplica cuandoLa palabra exacta está en la listaLa 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

CriterioDiccionarioPCFG
ModeloLista fija de candidatosGramática probabilística de las estructuras de contraseña
Punto fuertePalabras exactasEstructuras como palabra + cifras, mayúscula + minúsculas + símbolo
Ejemplopassword ✓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

CriterioDiccionarioMarkov
CandidatosLista preparada de antemanoGenerados sobre la marcha por un modelo estadístico
CoberturaVocabulario conocidoCualquier secuencia que «parezca humana»
VentajaMuy rápido con palabras exactasCubre 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

CriterioDiccionarioRelleno de credenciales (credential stuffing)
ObjetivoDescifrar un hashIniciar sesión en una cuenta
MecanismoCálculo de hashes en localIntentos de inicio de sesión a distancia
FuenteLista de palabras genéricaPares correo/contraseña filtrados
DefensaAlgoritmo hash lentoLimitació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

12.2 Lo que Time2Crack no modela


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):

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

13.3 Recomendaciones prácticas


14. Referencias

Fuentes académicas

Fuentes del sector

Contexto


Código fuente: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).