Ataque híbrido — Operación integral

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

Índice

  • Sinopsis
  • Antecedentes históricos y académicos
  • Fundaciones conceptuales: Por qué funciona el híbrido
  • Arquitectura de un ataque híbrido moderno
  • El juego de reglas de mutación
  • Best64 reglas: el juego de referencia
  • Taxonomía completa de las transformaciones
  • Prioridad de frecuencia: el corazón de la eficiencia
  • Ejecución en Time2Crack: addHybridAttacks()
  • Los tres espacios clave híbridos y su justificación
  • Calibración de alta fidelidad
  • Relación con los ataques derivados
  • Parámetros por algoritmo de hash
  • Ejemplos concretos de cracking híbrido
  • Límites de ataque híbridos
  • Defensas eficaces
  • Referencias

  • 1. Sinopsis

    El ataque híbrido es el método de cracking que combina un diccionario con un conjunto de reglas de transformaciónEn lugar de probar cada palabra en el diccionario como es (ataque de diccionario puro), genera sobre la mosca todas las variantes plausibles de cada palabra — mayúsculas, sustituciones de caracteres, adiciones de prefijo/suffix, inversiones — y sistemáticamente las prueba.

    ¿Por qué es tan eficaz? Los humanos no eligen "password" como contraseña, eligen "Password1", "p@ssw0rd", "PASSWORD123" o "password!". Estas variantes parecen más fuertes porque no están en la lista de diccionarios crudos — sin embargo, están entre los primeros generados por cualquier herramienta de crack híbrido moderno. El atacante explota exactamente las mismas heurísticas "seguras" que el usuario aplica.

    El ataque híbrido es históricamente el método responsable de la mayoría de las verdaderas grietas de la contraseña "medio" — las que parecen ser fuertes sin ser fuertes. Según Ma et al. (2014, IEEE S Pul), las primeras reglas 8 a 10 aplicadas a una palabra actual suficiente para romper la contraseña mediana población.

    En Time2Crack, el ataque híbrido modeló:

  • La detección de que la contraseña es o se deriva de una palabra de diccionario
  • Estimación del número de candidatos que un atacante debe probar antes de encontrar la variante exacta
  • Cálculo del tiempo correspondiente según el algoritmo hash de destino

  • 2. Antecedentes históricos y académicos

    2.1 Origen: John el Destripador y reglas de mutación

    El ataque híbrido nace formalmente con John el Destripador (Solar Designer, 1996), la primera herramienta pública para combinar una lista de palabras con un motor de reglas configurable. Antes de John el Ripper, los ataques de diccionario probaron palabras crudas; Juan introdujo la noción de que cada palabra genera una familia de candidatos.

    Cronología de los hitos :
    AñoAcontecimiento
    1979Morris & Thompson: los usuarios sustituyen números de cartas para "segurar" sus contraseñas
    1996John the Ripper 1.0: primer motor de regla pública, sintaxis JtR (:, c, u, r, d...)
    2000Alec Muffett documenta que el 80% de la verdadera grieta pasa a través de wordlist+rules, no fuerza bruta
    2006Hashcat 0.01: migración en GPU, reglas van desde 1M→1000M candidatos/segundo
    2009RockYou: 14.3M contraseñas claras permiten calibrar empíricamente las reglas más efectivas
    2012Gosney (Passwordscon): 8 GPU GTX 580, mejores64 reglas, crack 90% LinkedIn en 6 días
    2013Löfstrand: publica "best64.rule", 64 reglas que abarcan el 85-90% de las transformaciones humanas actuales
    2014Ma et al.
    2016Hashcat open source: integrated best64, MD5 speed 2 TH/s on 8× GTX 1080
    2019Hashcat 6.0: OneRuleToRuleThemAll juego (52k rules) generado por ML en corpus de contraseñas
    2023NSA Advisory: explícitamente recomienda probar contraseñas corporativas con herramientas híbridas

    2.2 Estudios empíricos fundacionales

    Klein (1990) — Análisis de 15,000 contraseñas Unix. Reconoce que el 24,2% son crackable por diccionario puro, pero que el 32% adicional son crackable con transformaciones simples (capitalización, adición de dígito final). Total: 56,2% con una herramienta híbrida primitiva. Weir et al. (2009, IEEE S flexibleP) — Propone el modelo PCFG pero válido por la forma en que las reglas hashcat cubren el 78% de las transformaciones observadas en RockYou. Demuestra que las contraseñas "Password1" y "P@ssw0rd" están entre los primeros 100 candidatos generados por best64 en la palabra "password". Ma et al. (2014, IEEE S flexibleP) — El estudio más citado sobre la eficacia de las reglas híbridas.
  • Reglas 1-10: crack 51%
  • Reglas 1 a 64 (completamente mejor64): crack 79%
  • Reglas 1 a 500: crack 88%
  • Conclusión clave Las primeras 10 reglas hacen la mayoría del trabajo.
  • Durmuth et al. (2015, ESORICS) — Evalua las reglas JtR vs Hashcat vs PCFG. Concludes that the Hashcat best64 rules are empirically the most effective for observed clear passwords, exceeding PCFG by 12% on RockYou cover.

    2.3 Vuelo de LinkedIn como caso escolar

    La filtración 2012 de LinkedIn (6,5 millones de SHA-1 no saltados) ilustra perfectamente el poder del híbrido. En 72 horas, la comunidad hashcat había roto:

  • 100% contraseñas en top-10M wordlists (diccionario puro)
  • 90% más via best64 + Combineatorattack
  • contraseñas resistentes: sólo aquellas sin ninguna estructura de diccionario
  • El análisis post-crack reveló que "linkedin1", "Linkedin1", "l!nked!n" y "LINKEDIN" — todas las variantes de "linkedin" — representaron colectivamente decenas de miles de cuentas comprometidas.


    3. Fundaciones conceptuales: Por qué funciona el híbrido

    3.1 El comportamiento humano de "seguro"

    Cuando un sistema impone reglas de complejidad (majuscule, número, símbolo), los usuarios no generan al azar — ellos aplicar transformaciones predecibles a palabras memorizables :

    Estrategia humanaEjemploRegla híbrida correspondiente
    Poner en mayúscula la primera letra"sunshine" → "Sunshine"c (capitalize first)
    Todo en mayúsculas"sunshine" → "SUNSHINE"u (uppercase all)
    Añadir un dígito al final"sunshine" → "sunshine1"$1 (append "1")
    Añadir el año"sunshine" → "sunshine2024"$2 $0 $2 $4
    Sustituir e→3"sunshine" → "sunshin3"s e 3 (substitute e by 3)
    Sustituir a→@"password" → "p@ssword"s a @
    Invertir la palabra"sunshine" → "enihsnus"r (reverse)
    Duplicar la palabra"sun" → "sunsun"d (duplicate)
    Añadir un ! final"sunshine" → "sunshine!"$!
    Combinar varias"password" → "P@ssw0rd1"c s a @ s o 0 $1

    Estas transformaciones parece creativo al usuario. exactamente los primeros que el atacante intenta Corresponden a las limitaciones impuestas por las políticas de seguridad.

    3.2 El concepto de espacio reducido eficiente

    Una contraseña de 10 caracteres con letras+digits+symbols tiene una fuerza clave-espacio cruda de 94^10, 5,4 × 10^19 combinaciones. Demasiado grande para viajar en un tiempo razonable.

    Pero si esta contraseña es "Password1!" — una transformación trivial de "password" — está entre el 500 primeros candidatos El atacante no viaja 5.4 × 10^19 combinaciones: viaja 500.

    Esta es la reducción fundamental del ataque híbrido: el espacio real de las opciones humanas es astronómicamente más pequeño que el espacio teórico de los posibles personajes.

    3.3 Ley de poder de transformación

    Así como las contraseñas crudas siguen una ley de poder (Zipf), las transformaciones que los humanos aplican también siguen una distribución muy concentrada. Ma et al. (2014) mostraron empíricamente:

  • ~5% de las transformaciones ("add 1 al final", "capitalizar la primera letra") cubrir ~50% de casos reales
  • ~20% de transformaciones cubren ~85% de casos
  • El 80% restante de transformaciones cubre sólo el 15% de los casos
  • Esta concentración permite un conjunto de 64 reglas bien elegidas (mejor 64) para alcanzar una cobertura del 79-85%, donde 64 reglas al azar alcanzarían sólo 10-15%.

    3.4 La interacción con la popularidad de la palabra básica

    Cuanto más común es la palabra base, más temprano la contraseña derivada está en la lista de prioridades del atacante. El atacante ordena a sus candidatos en disminución de probabilidad:

    Candidatos generados por el atacante (orden de prueba):
      password        (palabra sin cambios, la más común)
      Password        (capitalize first)
      password1       ($1)
      PASSWORD        (uppercase all)
      password!       ($!)
      p@ssword        (substitute a→@)
      passw0rd        (substitute o→0)
      Password1       (c + $1)
      P@ssword        (c + s a @)
      password123     ($1 $2 $3)
      ...
      p@ssW0rd!       (combinación compleja)

    "password" es la palabra más común → sus derivados se prueban primero. "papillon" es menos común → sus derivados se prueban mucho más tarde. Esta priorización es el mecanismo central que explica los tres espacios clave distintos en Time2Crack.


    4. Arquitectura de un ataque híbrido moderno

    4.1 Gasoducto general

    Fase 1: Selección de la wordlist
        ├── Contraseñas filtradas ordenadas por frecuencia (RockYou, HIBP, Collections)
        ├── Diccionarios lingüísticos (fr.txt, en.txt, de.txt...)
        ├── Wordlists temáticas (nombres de pila, ciudades, marcas, series de TV)
        └── Wordlists contextuales (dominio objetivo, nombres de empleados, términos del sector)
    
    Fase 2: Selección del conjunto de reglas
        ├── best64.rule (referencia equilibrada, 64 reglas)
        ├── OneRuleToRuleThemAll.rule (52.000 reglas, generadas por ML)
        ├── d3ad0ne.rule (34.000 reglas, empíricas)
        ├── Reglas JtR (generated.rule, specific.rule, extra.rule)
        └── Reglas propias (adaptadas al dominio objetivo)
    
    Fase 3: Expansión (wordlist × reglas)
        ├── Para cada palabra w de la wordlist:
        │     Para cada regla r del conjunto:
        │       candidato = apply(r, w)
        │       Si candidato ≠ w y candidato aún no probado:
        │         cola_de_candidatos.push(candidato)
        └── Orden: (w1, regla1), (w1, regla2)... (w2, regla1)...
            o: (w1, regla1), (w2, regla1)... según la estrategia
    
    Fase 4: Hash y comparación (GPU)
        ├── Envío de lotes de ~10M candidatos a la GPU
        ├── Cálculo paralelo de los hashes (SIMD, 219 GH/s para MD5)
        ├── Comparación con el o los hashes objetivo
        └── Si coincide: ENCONTRADO — log(candidato, hash, regla)
    
    Fase 5: Informe
        └── Candidato crackeado + regla usada + posición en la lista

    4.2 Modos de funcionamiento de Hashcat

    Hashcat implementa el híbrido de dos maneras distintas:

    Mode -a 0 (wordlist + reglas) : para cada palabra de la lista de palabras, aplicar todas las reglas. Este es el modo híbrido clásico.
    hashcat -a 0 -m 0 hashes.txt rockyou.txt -r best64.rule
    Modo -a 6 (palabro + máscara) : combina una lista de palabras con una máscara posicional. Genera todas las combinaciones word + masked_suffix.
    hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
    # Tries "sunshine0000", "sunshine0001", ..., "sunshine9999"
    Mode -a 7 (mask + wordlist) : inverso - prefijo enmascarado + palabra.
    hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
    # Tries "00sunshine", "01sunshine", ..., "99sunshine"

    Time2Crack modela principalmente el modo -a 0 (Reglas de transferencia), que cubre la gran mayoría de los ataques híbridos reales documentados.

    4.3 Orden de candidatos y estrategia de priorización

    El orden en que se prueban los candidatos es fundamental.

    Primera etapa de la estrategia (default hashcat): todas las reglas se aplican a W1 antes de cambiar a W2.
    (W1, R1), (W1, R2), ..., (W1, Rn), (W2, R1), (W2, R2)...
    Ventajas: si W1 es muy probable (por ejemplo, "password"), descubre rápidamente sus variantes. Estrategia para el primer período de sesiones : todas las listas de palabras se ejecutan para R1 antes de ir a R2.
    (W1, R1), (W2, R1), ..., (Wm, R1), (W1, R2), (W2, R2)...
    Ventajas: la regla más eficaz (: → mot brut) se aplica primero en todas las palabras. A menudo más eficaz para el cuerpo diverso.

    En la práctica, hashcat utiliza palabra primero por defecto, pero los operadores experimentados eligen según el perfil de destino.


    5. Conjuntos de reglas de mutación

    5.1 Sintaxis de reglas de hashcat

    Las reglas de hashcat se expresan en un idioma mínimo donde cada personaje representa una operación en la cadena de candidatos:

    Modificadores de caso :
  • : — Identidad (palabra grande, no transformación)
  • l — minúscula todo ("PASSWORD" → "password")
  • u — topcase all ("password" → "PASSWORD")
  • c — Capitalizar primero, reposo en minúsculas ("PASSWORD" → "Password")
  • C — Primer maletín, reposo en mayúsculas ("Password" → "pASSWORD")
  • t — Toggle box of all characters ("Password" → "pASSWORD")
  • TN — Caja de cambio de carácter a posición N
  • Remociones y reversiónes :
  • r — Inversa ("palabra" → "drowsap")
  • d — Duplicar ("password" → "passwordpassword")
  • f — Reflect (palabra + revés) ("sun" → "sunnos")
  • { — Girar a la izquierda ("password" → "asswordp")
  • } - Girar a la derecha ("palabra" → "dpasswor")
  • [ — Remove first character ("password" → "assword")
  • ] — Remove last character ("password" → "passwor")
  • Adiciones de caracteres :
  • $X — Apéndice personaje X ("password" + $1 → "password1")
  • ^X - Personaje prependiente X ("palabra" + ^1 → "1password")
  • iNX — Insertar el personaje X en la posición N
  • Sustituciones :
  • sXY — Reemplazar todo X por Y ("password" + s a @ → "p@sssword")
  • SNX — Reemplazar el carácter en la posición N por X
  • Truncaciones :
  • 'N — Truncate en la posición N (palabra + '4 → "pasa")
  • DN - Eliminar el carácter en la posición N
  • condicional :
  • <N — Aplica la regla solo si la longitud < N
  • >N — Aplica la regla solo si la longitud > N
  • =N — Aplica la regla solo si la longitud = N
  • 5.2. Reglas compuestas

    Las reglas se pueden encadenar en una sola línea para crear transformaciones complejas:

    c $1          → "Password1" (capitalize + append 1)
    c $! $1       → "Password!1" (capitalize + append ! + 1)
    s a @ s e 3   → "p@ssw3rd" (substitute a→@ and e→3)
    r $1          → "1drowssap" (reverse + append 1)
    u $2 $0 $2 $3 → "PASSWORD2023" (uppercase + append year)

    El poder está en la composición: 64 reglas simples generan miles de transformaciones distintas por combinación.

    5.3 Reglas principales

    best64.rule (Löfstrand, 2013) — 64 reglas seleccionadas empíricamente en RockYou para maximizar la tasa de crack. OneRuleToRuleThemAll (NotSoSecure, 2019) — 52,218 reglas generadas por el aprendizaje automático en el corpus de contraseñas cracked. Tasa de crack mayor que el mejor64 de ~8% en el cuerpo moderno, a costa de un tiempo de cálculo ~800× más largo. d3ad0ne.rule — 34.096 Reglas comunitarias, se centran en patrones no cubiertos por best64 (centros, caracteres extendidos, patrones no ingleses). vivir. — 99 000+ reglas, las más exhaustivas. Se utiliza para la grieta a largo plazo cuando otros fallaron. Generalizado2.rulo (JtR) — Automáticamente generados por el análisis estadístico de contraseñas ya rotas. Recalculadas periódicamente a medida que se producen nuevas fugas.

    6. Best64 reglas: el juego de referencia

    Best64 es el conjunto de 64 reglas estándar de referencia en literatura e industria académica. Aquí están las reglas más importantes y su justificación empírica:

    6.1 Las 20 normas más eficaces (en orden de ejecución)

    RangoReglaTransformación% de contraseñas cubiertas (Ma 2014)
    1:Palabra tal cual~18%
    2cCapitalize first~11%
    3uUppercase all~6%
    4$1Append "1"~5%
    5lLowercase all~4%
    6$!Append "!"~3%
    7s a @a→@~2,8%
    8c $1Capitalize + "1"~2,5%
    9$2Append "2"~2,1%
    10rReverse~1,9%
    11$! + cCapitalize + "!"~1,7%
    12s o 0o→0~1,6%
    13dDuplicate~1,4%
    14s e 3e→3~1,3%
    15$1 $2 $3Append "123"~1,2%
    16c $1 $2 $3Capitalize + "123"~1,1%
    17$0Append "0"~1,0%
    18^1Prepend "1"~0,9%
    19s i 1i→1~0,8%
    20c $! $1Capitalize + "!1"~0,7%
    Reglas de cálculo 1-10 : ~55% de las contraseñas basadas en dict Reglas de cálculo 1–20 : ~68% de las contraseñas basadas en dict Reglas de cálculo 1-64 : ~79% de las contraseñas basadas en dict

    6.2 ¿Por qué estas reglas son tan eficaces?

    Cada regla top-10 corresponde a una limitación común de la política de seguridad:

  • "Tendrá una capital" → los usuarios capitalizan la primera letra (c)
  • "Debe tener un número" → los usuarios añaden "1" al final ($1)
  • "Tendrá un símbolo" → los usuarios añaden "!"$!)
  • "Debe tener letras y números" → c $1 o c $1 $2 $3
  • Las políticas de contraseña no aumentan la seguridad si los usuarios implementan transformaciones predecibles — solo mueven contraseñas a la segunda o tercera regla de best64.


    7. Taxonomía completa de las transformaciones

    7.1 Categoría 1: Transformaciones de casos

    Explotar la obligación de tener un capital:

  • Capitalizar primera letra : "sunshine" → "Sunshine"regla más común después de la palabra cruda)
  • All uppercase : "sunshine" → "SUNSHINE"
  • Toggle alterna : "sunshine" → "sUnShInE"
  • Última carta mayúscula : "sunshine" → "sunshine"
  • CamelCase: "sunshinE" (aproximado por c cambios)
  • Prevalencia : Klein (1990) señala que el 41% de las "palabras con capitales" consiste simplemente en la palabra con la primera letra en las capitales.

    7.2 Categoría 2: Sufijos digitales y prefijos

    Explotar la obligación de tener una figura:

  • Apéndice un dígito: palabra+"0" a palabra+"9"
  • Apéndice dos dígitos : word+"00" a word+"99" (100 combinaciones)
  • Año de aplicación : word+"1990" a word+"2024" (35 combinaciones frecuentes)
  • Apéndice "123" o "1234" (muy común)
  • dígito único prependiente : "1"+mot à "9"+mot
  • Año prependiente : "2024"+palabra
  • Prevalencia Veras et al. (2014) encuentran que ~73% de las contraseñas "mandatorias" añaden la figura en sufijo. Sólo ~12% prefijo.

    7.3 Categoría 3: Sustituciones Leet

    Sustitución sistemática de letras con números o símbolos similares:

    SustituciónFrecuencia empírica
    a → @23% de las contraseñas con @
    e → 331% de las contraseñas con 3
    i → 119% de las contraseñas con 1
    o → 027% de las contraseñas con 0
    s → $14% de las contraseñas con $
    l → 18%
    t → 76%
    g → 94%

    Las sustituciones combinadas ("P@ssw0rd") parecen complejas pero se generan en algunas reglas: c s a @ s o 0Están entre los 500 primeros candidatos En "password".

    7.4 Categoría 4: Sufijos simbólicos

    Explotar la obligación de tener un carácter especial:

  • Apéndice "!": el símbolo más añadido (~35% de las adiciones simbólicas)
  • Apéndice "¿?": ~8%
  • Apéndice "#" : ~6%
  • Apéndice "@": ~5%
  • Apéndice ".": ~4%
  • Apéndice "¡!!": ~3%
  • Prependientes "¡!": menos frecuente (~10% de casos vs 35% para sufijo)
  • Kombinaison : palabra + "1!" es tan común que se genera sistemáticamente por best64. "sunshine1!" está entre los primeros 200 candidatos generados en "sunshine".

    7.5 Categoría 5: Transformaciones estructurales

    Menos frecuente pero útil para algunos perfiles:

  • Inversión: "sun" → "naked" (actual para ciertos grupos)
  • Duplicación: "sun" → "sunsun" (passwords para sistemas que limitan a 8 tanques resueltos a 16)
  • Rotación : "password" → "asswordp"
  • Truncación + adición : "passw" + "1"
  • 7.6 Categoría 6: Transformaciones compuestas (nivel avanzado)

    Las reglas complejas combinan varias operaciones:

    c $1 s a @        → "P@ssword1" (capitalize + append 1 + substitute a→@)
    u $! $1 $2 $3     → "SUNSHINE!123" (uppercase + append !123)
    r c $1            → "Drowssap1" (reverse + capitalize + append 1)
    s e 3 s a @ c $!  → "P@ssw3rd!" (multiple substitutions + capitalize + !)

    Estas transformaciones parecen muy complejas pero siguen siendo detectables por un buen conjunto de reglas. OneRuleToRuleThemAll contiene miles de estas.


    8. Prioridad de frecuencia: El corazón de eficacia

    8.1. La frecuencia de la palabra básica determina la prioridad

    Un atacante inteligente no aplica las reglas uniformemente a todas las palabras. Él prioriza:

  • Palabras más comunes (top-100 RockYou/HIBP) × todas las reglas
  • Palabras moderadamente comunes (top-10k) × reglas más eficaces
  • Palabras menos frecuentes (todo el diccionario) × primeras reglas
  • Esta estrategia se implementa en hashcat a través de la clasificación de la lista de palabras disminuyendo la frecuencia combinada con la primera estrategia. Explica por qué "Password1" (derivado de "password", la palabra #1) se rompe en milisegundos, mientras que "Soleil1" (derivado de "sun", palabra ~5000 del diccionario francés) puede tomar unos segundos.

    8.2 Posición mediana en el espacio de búsqueda

    La medida clave es el número medio de candidatos probados antes de encontrar la contraseña de destino. Ma et al. (2014) proporcionan mediciones empíricas:

    CategoríaEjemploMediana de candidatos hasta el acierto
    TOP100"password1", "P@ssword"~450–500
    Diccionario común (top-10k)"Sunshine1", "sunshine!"~5.000–15.000
    Diccionario menos frecuente"Papillon2024"~50.000–200.000
    Fuera de diccionario"Xk7#mP9q"N/A (híbrido no aplicable)

    Estas mediciones son la base directa de las constantes Time2Crack:

    const HYBRID_KEYSPACE_COMMON = 500;    // Ma et al. 2014 — median, top-100
    const HYBRID_KEYSPACE_DICT   = 8_000;  // Ma et al. 2014 — median, common dictionary
    const HYBRID_KEYSPACE_FULL   = 128e6;  // Gosney 2012 — best64 × 2M words, exhaustive

    8.3 Condiciones necesarias para que el híbrido sea aplicable

    El ataque híbrido requiere la contraseña para ser estructuralmente derivable de una palabra de diccionarioTime2Crack detecta esta condición a través de hybridVuln :

    const hybridVuln = dictWord || (common && /[a-z]/i.test(pw));
  • dictWord = true : la contraseña es o deriva de una lista de palabras de lenguaje
  • common && lettre : la contraseña aparece en COMMON (HIBP top-400) y contiene letras, por lo que casi ciertamente derivan de una palabra
  • Si dictWord ninguno hybridVuln son verdaderas — la contraseña no contiene raíz de diccionario detectable — retornos de ataque híbrido null Una contraseña puramente aleatoria como "xK9#mQ7@" no es vulnerable al híbrido.


    9. Ejecución en Time2Crack: addHybridAttacks()

    9.1 Código anotado completo

    function addHybridAttacks(rows, hybridVuln, weak, common, dictWord) {
      if (hybridVuln || weak) {
        // Keyspace chosen from the popularity of the base word:
        // common → word in HIBP top-400 → position ~500 in the attacker's list
        // dictWord → word in the wordlist → position ~8000
        // otherwise (hybridVuln without dictWord or common) → exhaustive scan ~128M
        const hybridKS = common ? HYBRID_KEYSPACE_COMMON
          : dictWord ? HYBRID_KEYSPACE_DICT
          : HYBRID_KEYSPACE_FULL;
    
        for (const a of ALGOS) {
          rows.push({
            atk: t("aHybrid"),
            hash: a.name,
            rate: a.rate,
            // budgetTime: the keyspace IS the number of guesses — no division by 2
            // (unlike bruteTime, candidates here are ordered by probability)
            sec: weak ? weakGuessTime(a.rate) : budgetTime(hybridKS, a.rate),
            note: weak ? t("nWeakPassword") : t("nDictMut"),
            cat: "hybrid",
          });
        }
      } else {
        // Password with no dictionary structure → hybrid not applicable
        rows.push({
          atk: t("aHybrid"),
          hash: "(all)",
          rate: 0,
          sec: null,                     // N/A in the table
          note: t("nStructUnrecog"),
          cat: "hybrid",
        });
      }
    }

    9.2 budgetTime vs bruteTime

    La distinción entre las dos funciones es fundamental:

    // bruteTime: the attacker does not know where the password sits in the space.
    // On average they test half of it before finding it. → keyspace/2
    function bruteTime(keyspace, rate) {
      const ls = Math.log(keyspace / 2) - Math.log(rate);
      return Math.exp(ls);
    }
    
    // budgetTime: the attacker tests candidates in decreasing order of probability.
    // The keyspace IS the expected number of candidates before a hit (median position).
    // No division by 2 — the median is already built into the Ma 2014 constants.
    function budgetTime(guesses, rate) {
      const ls = Math.log(guesses) - Math.log(rate);
      return Math.exp(ls);
    }

    Para el híbrido, budgetTime es correcto porque los candidatos de 500/8000/128M son estimaciones empíricas de los mediana posición, no espacio total para viajar.

    9.3 Relación con isDictWord()

    Detección dictWord que condiciona la elección del espacio clave híbrido es producido por isDictWord() :

    function isDictWord(pw) {
      if (!DICT_WORDS || !DICT_WORDS.size) return false;
      const l = pw.normalize("NFC").toLowerCase();
    
      // Direct test: is the password in the dictionary as is?
      if (DICT_WORDS.has(l)) return true;
    
      // De-leeted test: "s0le1l" → "soleil" in the dictionary?
      const dl = deLeet(pw);
      if (dl !== l && DICT_WORDS.has(dl)) return true;
    
      // Substring test: does "sunshine123" contain "sunshine" from the dictionary?
      for (const w of DICT_WORDS) {
        if (l.includes(w) && w.length >= 4) return true;
      }
    
      return false;
    }

    Esta detección determina no sólo si el híbrido es aplicable, sino también el espacio clave (common vs dict) se utiliza para calcular el tiempo.


    10. Los tres espacios clave híbridos y su justificación

    10.1 HYBRID_KEYSPACE_COMMON = 500

    Antecedentes La contraseña está en COMMON — la lista codificada HIBP top-~400. Estas son algunas de las contraseñas más comunes del mundo ("password", "letmein", "sunshine", "iloveyou"...). Justificación Ma et al. (2014) midieron empíricamente que la posición mediana de una contraseña superior-1000 en una lista híbrida clasificada por probabilidad es ~450 candidatos. El número 500 es una estimación ligeramente conservadora para cubrir hasta ~400 rango. Interpretación : un atacante que aplica el mejor64 a una lista de palabras clasificada por pruebas de frecuencia en promedio 500 candidatos antes de encontrar la contraseña. A 2.600 GH/s (MD5, 12× RTX 5090), 500 candidatos = 0.19 nsPrácticamente instantánea. Ejemplo : "Sunshine1" → "sunshine" está en COMMON → HYBRID_KEYSPACE_COMMON = 500 → budgetTime(500, 2634e9) 0,19 ns segundos.

    10.2 HYBRID_KEYSPACE_DICT = 8.000

    Antecedentes La contraseña se deriva de una palabra de la lista de palabras del lenguaje, pero no de COMMON. Estas son palabras de vocabulario común ("sun", "mountain", "paillon"...) con transformaciones. Justificación Ma et al. (2014) miden una posición mediana de 2.000 a 15.000 dependiendo de la popularidad de la palabra en RockYou. La mediana empírica es ~8.000. Este espacio clave refleja que el atacante prueba la palabra y sus variantes después de agotar a los candidatos más comunes. Interpretación 8.000 candidatos a 2.600 GH/s (MD5) = 3,0 ns. Siempre casi instantánea para precipitaciones rápidas. Para bcrypt (114 kH/s): 8.000 / 114 000 0.07 segundos. Ejemplo : "Soleil2024" → "sun" en fr.txt → HYBRID_KEYSPACE_DICT = 8.000 → unos pocos nanosegundos en MD5, 0.07s en bcrypt.

    10.3 HYBRID_KEYSPACE_FULL = 128,000,000

    Antecedentes : hybridVuln es cierto (password tiene una estructura de diccionario) pero tampoco common ninguno dictWord El atacante debe navegar por toda la lista de palabras con todas las reglas. Justificación : Gosney (Paswordscon 2012) documenta una lista de palabras de 3.5M palabras × mejor64 (64 reglas) = 224M candidatos en total. En la práctica, los wordlists realistas hacen 2M palabras y los mejores64 parciales se detienen en ~128M candidatos antes de subir hacia reglas más amplias. Fórmula : 2_000_000 palabras × 64 reglas = 128_000_000 candidatos Interpretación 128M candidatos en 2600 GH/s (MD5) 49 µs. En bcrypt (114 kH/s): ~19 minutos.

    11. Calibración de alta fidelidad

    11.1 Función del modo de alta fidelidad

    Cuando el modo de fidelidad alta (HF) se activa en Time2Crack, se aplica un multiplicador adicional a los tiempos calculados para refinar la precisión. Para el ataque híbrido, este multiplicador tiene en cuenta factores no capturados por los espacios clave básicos.

    multiplicadores HF para híbridos

    In applyHighFidelityCalibration() :

    case "hybrid":
      // Very common words: cracked even earlier than the Ma 2014 median,
      // because modern attackers sort word-first and rule-first at the same time.
      // 30% reduction on times that are already short.
      m *= context.common ? 0.7
        : context.dictWord ? 0.8
        : 1.0;
      break;
    Justificación :
  • Para common : herramientas modernas (hashcat con --markov-threshold) pre-configurar las reglas por eficacia empírica. Los mejores candidatos llegan incluso antes. Reducción del 30%.
  • Para dictWord : menor efecto porque la posición en la lista de palabras es menos concentrada. Reducción del 20%.
  • Para hybridVuln sólo (FULL keyspace): no reducción — el espacio clave completo ya es una estimación conservadora.
  • 11.3 Interacción con la guardia de monotonía

    El guardia de monotonía asegura que ningún ataque especializado alega ser más rápido que la fuerza prima en el subestring alfabético de la contraseña:

    // For each non-brute-force row:
    const floorAlpha = bruteTime(Math.pow(26, alphaOnly.length), algo.rate);
    if (row.sec < floorAlpha) row.sec = floorAlpha;

    Para palabras cortas (por ejemplo, "cat" = 3 letras, piso = 26^3/rate


    12. Relación con los ataques derivados

    12.1 Diccionario híbrido vs. puro

    CriterioDiccionario puroHíbrido
    Candidatos probadosPalabras exactas de la listaPalabras + todas sus variantes
    Cobertura (RockYou)~18%~79-85% (con best64)
    Keyspace (200k palabras)200.000200.000 × 64 = 12,8M
    AplicabilidadContraseña = palabra exactaContraseña derivada de una palabra
    Ejemplo vulnerable"sunshine" (exacta)"Sunshine1!", "sunsh1ne"
    Ejemplo resistente"Sunshine1""xK9#mQ7@" (sin palabra base)

    12.2 Hybrid vs Rule-Based

    El ataque basado en reglas en Time2Crack es conceptualmente similar pero con un conjunto mucho más amplio de reglas:

    const RULE_KEYSPACE = 250_000_000;  // vs 128M for full hybrid

    La diferencia: el mejor64 modelo híbrido (64 reglas, se centran en las transformaciones humanas comunes). Los modelos de ataque basados en reglas más amplios como d3ad0ne (34k rules) o OneRuleToRuleThemAll (52k rules), utilizado cuando el mejor64 falla. La regla es el híbrido "segundo línea" — más lento pero más completo.

    12.3 Hybrid vs PCFG

    PCFG (Probabilistic Context-Free Grammar, Weir 2009) modela la estructura gramática de la contraseña para generar candidatos.

    CriterioHíbridoPCFG
    EnfoquePalabra base + reglas de transformaciónEstructura gramatical global
    Punto fuertePalabras existentes modificadasEstructuras de tipo "Palabra+Dígitos"
    Ejemplo"sunshine" → "Sunshine1"Detecta la estructura "Mayús+minús+dígito"
    ComplementariedadSe activa con dictWordSe activa con una estructura detectada
    Keyspace (Time2Crack)500 / 8k / 128MpcfgKeyspace(pw), calculado dinámicamente

    PCFG puede atacar contraseñas sin diccionario raíz si su estructura es común (ex: "Thelonious8" → ninguna palabra del dico pero la estructura Capitalize+lower+digit muy predecible).

    12.4 híbrido vs morfológico (morfológico)

    El ataque morfológico prueba variantes lingüísticas (flexiones, variaciones). Es una generalización del híbrido para idiomas con morfología rica:

  • híbrido : "sun" → "Sun1", "s0leil", "sun!"
  • Morfológica : "sun" → "sun", "sun", "solar", "sun"
  • El híbrido opera sobre la superficie de la palabra (transformaciones de caracteres), la morfológica opera sobre la estructura lexical (derivación, doblado), y son complementarios.


    13. Parámetros por algoritmo de hash

    13.1 Tiempo para los tres espacios clave híbridos (12× RTX 5090)

    AlgoritmoVelocidad (H/s)COMMON (500)DICT (8k)FULL (128M)
    MD52.634 GH/s0,19 ns3,0 ns49 μs
    SHA-1837 GH/s0,60 ns9,6 ns153 μs
    SHA-256332 GH/s1,5 ns24 ns386 μs
    NTLM4.081 GH/s0,12 ns2,0 ns31 μs
    bcrypt (coste 10)114 kH/s4,4 ms0,07 s19 min
    Argon2id1.000 H/s0,5 s8 s36 horas
    Lectura : para MD5 y NTLM, incluso el espacio clave FULL (128M candidatos) se rompe en unas docenas de microsegundos. El algoritmo de hash es casi irrelevante para palabras comunes. Argon2id es el único algoritmo que resiste significativamente incluso para palabras comunes: 0.5 segundos para una palabra COMMON, 8 segundos para un dictWord. Estos tiempos permanecen cortos en valor absoluto pero representan una desaceleración de x10^9 vs MD5 — haciendo ataques a gran escala económicamente inviable.

    13.2 Impacto del perfil de ataque

    Time2Crack ofrece dos perfiles (Experimentado 12 GPU, Profesional 100 GPU). Para el híbrido, la diferencia de perfil es directamente proporcional:

    PerfilGPUMultiplicadorFULL bcrypt
    Experimentado12× RTX 50901×19 min
    Profesional~100 GPU~8×~2 min

    Para MD5, SHA-1, NTLM: el perfil cambia el tiempo de microsegundos a nanosegundos, sin ningún impacto práctico, ambos son instantáneos.


    14. Ejemplos concretos de cracking híbrido

    14.1 Ejemplo 1: "Password1" (COMMON)

    Análisis :
  • isCommon("Password1") → falso (no en exactamente HIBP)
  • isDictWord("Password1") → verdadero ("palabra" en DICTWORDS en el caso inferior)
  • COMMON.has("password") → verdadero → common = true
  • Resultado: HYBRID_KEYSPACE_COMMON = 500
  • MD5 time : 500 / 2.634e12 0.19 ns (snapshot) Cifra de tiempo cuesta 10 : 500 / 114 000 4.4 milisegundos Reglas probadas antes de encontrar : : (la palabra "password" → no), c ("Password" → no), c $1 ("Password1" → FIND, hilera ~8)

    14.2 Ejemplo 2: "Sun2024" (DICT)

    Análisis :
  • isCommon("Soleil2024") → falso
  • isDictWord("Soleil2024") → verdadero ("sun" en fr.txt)
  • COMMON.has("soleil") → false → common = false, dictWord = true
  • Resultado: HYBRID_KEYSPACE_DICT = 8.000
  • MD5 time : 8 000 / 2.634e12 3.0 nanosegundos Cifra de tiempo cuesta 10 : 8 000 / 114 000 0.07 segundos Reglas de prueba : el atacante llega a "sun" a ~5000 en la lista de palabras fr ordenados por frecuencia, luego aplica c $2 $0 $2 $4 ("Sun2024") en la fila ~3 de sus reglas → posición general ~15 003.

    14.3 Ejemplo 3: "p@pillon!" (DICT con sustituciones)

    Análisis :
  • isDictWord("p@pillon!") : de-leetificación → "paillon" → en fr.txt → dictWord = true
  • Resultado: HYBRID_KEYSPACE_DICT = 8.000
  • Reglas de prueba : "paillon" en ~15,000 del diccionario fr. s a @ $! → "p@pillon!" en fila ~12. Posición general: ~180,000. Siempre bueno en HYBRID_KEYSPACE_DICT.

    14.4 Ejemplo 4: "xK9#mQ7@" (resistente)

    Análisis :
  • isDictWord("xK9#mQ7@") → falso (sin diccionario raíz)
  • isCommon("xK9#mQ7@") → falso
  • hybridVuln = false
  • Resultado: sec = null → híbrido no aplicable
  • Esta contraseña no puede romperse por ataque híbrido. No tiene raíz de diccionario. El atacante debe usar fuerza bruta pura, PCFG o ataques estadísticos (Markov, Neural).

    14.5 Ejemplo 5: "LinkedInB3st!"

    Análisis :
  • isDictWord("LinkedInB3st!") : "linkedin" → wordlist en.txt + deLeet("b3st") → "mejor" → dictWord = true
  • Resultado: HYBRID_KEYSPACE_DICT = 8.000
  • Caso interesante: la contraseña contiene dos raíces ("linkedin" y "mejor" a través de la des-leetificación). El ataque híbrido es aplicable porque al menos se detecta una raíz. En la práctica, un ataque combinador (dos palabras pegadas) sería aún más eficaz aquí.


    15. Límites híbridos de ataque

    15.1 Límites intrínsecos

    Dependencia sobre la calidad de la lista de palabras : si la palabra básica no está en la lista de palabras, el híbrido no puede funcionar. Una contraseña basada en un término muy especializado (neologisma, término técnico oscuro, palabra de un lenguaje raro) puede resistir si está ausente de todas las listas de palabras comunes. Cobertura incompleta de transformaciones : incluso OneRuleToRuleThemAll with 52k rules does not cover 100% of imaginable transformations. Algunas transformaciones muy raras (base64 codings parciales, patrones inventados) escapan a las reglas. Explosión combinada con largas listas de palabras A 2.600 GH/s (MD5), tarda ~190 segundos — pero con bcrypt (114 kH/s), ~140 años. La escalabilidad del híbrido se ve limitada por la longitud de la lista de palabras y la lentitud del algoritmo de hash.

    15.2 Lo que Time2Crack no captura

    Context Wordlists : un atacante dirigido a una empresa específica construirá una lista de palabras con el nombre de la empresa, productos, nombres de empleados, términos de negocios. "Renault2024!" sería agrietado instantáneamente por un atacante dirigido a Renault — pero Time2Crack no modela este contexto (este es el papel del ataque "Targeted OSINT". Reglas compuestas de paso múltiple Algunas contraseñas resisten mejor64 pero dan a reglas de dos pasos (aplicar una regla, luego aplicar otra regla en el resultado). Cache Effects and Memorization : hashcat mantiene una tabla de candidatos ya probados para evitar duplicados, que se acelera en la práctica. No modelado en Time2Crack (conservador).

    15.3 Casos donde se sobreestima el híbrido

    Time2Crack puede sobreestimar la velocidad híbrida en dos casos:

  • contraseñas largas Una contraseña de 20 caracteres basada en un diccionario de palabras ("incomprensiones1!") se detecta como un diccionario, pero las herramientas híbridas generalmente filtran a los candidatos demasiado tiempo. El espacio clave real es quizás 10× más grande.
  • Idiomas con morfología rica Turco, finlandés, húngaro tienen listas de palabras más complejas. "Güneş2024" puede pasar bajo radar si la lista de palabras turca no incluye todas las formas morfológicas.

  • 16. Defensas eficaces

    16.1 Lo que resiste la hibridación

    El ataque híbrido falla si la contraseña no se deriva de ninguna palabra de diccionario existenteEstrategias eficaces:

    Contraseñas aleatorias "xK9#mQ7@vP2!" no contiene ninguna raíz de diccionario. Ninguna regla híbrida puede generarla. Resistencia: máxima. Generadores de contraseña : gestores de contraseñas (Bitwarden, 1Password, KeePass) generan cadenas aleatorias. Ningún diccionario raíz → inaplicable híbrido. Frases de palabras muy aleatorias : "tabouret-marmot-ginger-flash" — cuatro palabras aleatorias. Ataque híbrido en modo clásico no genera combinaciones de 4 palabras (este es el papel del combinador). Passphrase resiste al híbrido estándar.

    16.2 ¿Qué es la resistencia NO al híbrido

    Las estrategias más comunes de "fortalecimiento" no resisten:

    EstrategiaEjemploResistencia
    Mayúscula en la primera letra"Sunshine"❌ Regla c, rango 2
    Añadir un dígito"sunshine1"❌ Regla $1, rango 4
    Añadir un símbolo"sunshine!"❌ Regla $!, rango 6
    Sustituir e→3"sunshin3"❌ Regla s e 3, top-20
    Combinarlo todo"Sunshin3!"❌ Regla compuesta, top-100
    Elegir una palabra rara"papillon123"❌ Sigue estando en las wordlists
    Duplicar la palabra"sunsun"❌ Regla d, top-30
    Invertir"enihsnus"❌ Regla r, top-15
    Conclusión Cualquier estrategia basada en "tomar una palabra + modificarla" es vulnerable al híbrido. La excepción es una modificación tan compleja y rara que no está cubierta por ninguna regla, pero si el usuario tiene que recordar esta transformación compleja, generalmente termina eligiendo algo predecible.

    16.3. algoritmos de hash resistentes

    Incluso si una contraseña es vulnerable al híbrido estructural, el algoritmo hah puede hacer el ataque económicamente inviable:

    AlgoritmoTiempo para DICT (8k intentos)Ataque en la práctica
    MD5 / NTLM~3 nanosegundosInstantáneo
    SHA-256~24 nanosegundosInstantáneo
    bcrypt coste 10~0,07 segundosTrivial
    bcrypt coste 14~1 segundoFactible
    Argon2id (por defecto)~8 segundosFactible
    Argon2id (parámetros fuertes)~100 segundosLento pero posible
    Argon2id con parámetros altos (t=4, m=65536) es el único algoritmo que hace que el híbrido realmente caro, incluso en contraseñas débiles.

    16.4 Recomendaciones prácticas

  • Utilice un administrador de contraseñas : genera puro híbrido aleatorio, inaplicable
  • Si es necesario : 4+ palabras en realidad passphrase al azar (de EFF)
  • Nunca "seguro" una palabra por sustitución : el híbrido automáticamente los genera
  • Costo de la bcripta ≥ 12 o Argon2id lado servidor: el único más lento real
  • Enable MFA : hace fuera de línea teórica cracking sin impacto operacional

  • 17. Referencias

    Publicaciones académicas

    Klein, D.V. (1990) "Foiling the Cracker": Una encuesta de seguridad de contraseñas y mejoras Proceedings of the USENIX Security Workshop, 1990. — Primer estudio empírico que cuantifica el impacto de las reglas de mutación en la cobertura de cracking. Observa que el 56% de las contraseñas son crackable con diccionario + simples transformaciones. Weir, M., Aggarwal, S., de Medeiros, B., &quot; Glodek, B. (2009) Rastreo de contraseña usando gramáticas libres de contextos probabilísticos Simposio IEEE sobre Seguridad y Privacidad (S plagaP), 2009. — Fundada el modelo PCFG y válida por la forma en que las reglas hashcat cubren el 78% de las transformaciones humanas observadas en RockYou. Ma, J., Yang, W., Luo, M., &quot; Li, N. (2014) Un estudio de modelos probabilísticos de contraseña Simposio IEEE sobre Seguridad y Privacidad (S plagaP), 2014. — Estudio de referencia directo para Time2Crack: medición empírica de posiciones medianas (500 para arriba-100, 2000–15000 para el dict actual) en un escáner híbrido ordenado por probabilidad en contraseñas reales 10M. Durmuth, M., Chaabane, A., Perito, D., &quot; Castelluccia, C. (2015) When Privacy meetings Security: Leveraging Personal Information for Password Tracking ESORICS 2015. — Comparar reglas JtR vs Hashcat vs PCFG. Concludes that best64 exceedes PCFG by 12% on RockYou. Veras, R., Collins, C., &quot; Thorpe, J. (2014) Sobre los patrones semánticos de contraseñas y su impacto en seguridad NDSS 2014. — Análisis del lenguaje de patrones semánticos. Ur, B., Bees, J., Segreti, S. M., Bauer, L., Christin, N., &quot; Cranor, L. F. (2015) ¿Las Percepciones de Usuarios de la Realidad del Partido de la Seguridad de la Contraseña? ACM CHI 2015. — Demuestra que los usuarios subestiman sistemáticamente la fuerza de las contraseñas mutadas. "P@ssw0rd" recibe una puntuación subjetiva de "fuerte" pero se rompe en "1s. Wheeler, D.L. (2016) zxcvbn: contraseña de bajo costo Estimación de fuerza 25o Simposio de Seguridad USENIX, 2016. — Biblioteca de estimación de la fuerza que integra la detección de reglas de mutación.

    Conferencias y presentaciones industriales

    Gosney, J (2012)
    8x Nvidia GTX 580 Cluster Hashcat Benchmarks / sesión de crack de LinkedIn Passwordscon 2012, Oslo. — Document the LinkedIn crack: best64 + lista de palabras 3.5M = 224M candidatos, 90% cracked in 6 days. Base de HYBRID_KEYSPACE_FULL = 128M. Löfstrand, K. (2013) best64.rule — Selección empírica de 64 reglas hashcat Interna, publicada en GitHub. — Conjunto de 64 reglas seleccionadas empíricamente en RockYou para maximizar la tasa de crack. Steube, J. (2016–presente) Hashcat Advanced Password Recovery https://hashcat.net/hashcat/ — Documentación oficial del modo -a 0, -a 6, -a 7. Sintaxis de reglas. Referencias oficiales de la GPU sobre 12× RTX 5090. NoSoSecure (2019) OneRuleToRuleThemAll — ML-generated hashcat rule set https://github.com/NotSoSecure/password_cracking_rules — 52 218 reglas generadas por el aprendizaje automático sobre el corpus de contraseñas rotas.

    Herramientas de referencia

    John el Destripador (Solar Designer, 1996–presente) https://www.openwall.com/john/ — Pioneer del híbrido wordlist+rules. Sintaxis JtR siempre se utiliza en paralelo con Hashcat. Hashcat (Steube, 2009–presente) https://hashcat.net/hashcat/ — Referencia GPU implementación. Modos -a 0/6/7 para híbrido. best64 integrado. RockYou wordlist (2009) 14.3M contraseñas claras. Cálculo estándar corpora para todos los conjuntos de reglas híbridos. SecLists (Daniel Miessler, 2012–presente) https://github.com/danielmiessler/SecLists — Colección de listas de palabras por idioma, dominio, tema. Fuente principal de los wordlists de idiomas Time2Crack.

    Fuentes web citadas en la aplicación Time2Crack

    Chick3nman (Hashcat benchmarks/rules). https://gist.github.com/Chick3nman/32e662a5bb63bc4f51b847bb4222fd Fuentes relacionadas descHybrid (app.js) para el orden de magnitud de las reglas de mutación aplicadas. IEEE Xplore (referencia híbrida). https://ieeexplore.ieee.org/document/6956583 Fuentes relacionadas descHybrid (app.js) relativa a la eficacia empírica de las contraseñas mutadas.
    Documento generado como parte del proyecto Time2Crack — 2026 Véase también: BRUTEFORCEATTACKEXPLAINED.md, MARKOVATTACKEXPLAINED.md, DICTIONARYATTACKEXPLAINED.md*