Ataque híbrido — Operação global

Documento de referência do projeto Time2Crack
Destinatários: desenvolvedores, pesquisadores de segurança, usuários avançados

Índice

  • Visão geral
  • Formação histórica e académica
  • Fundações conceituais: Por que os trabalhos híbridos
  • Arquitetura de um ataque híbrido moderno
  • O jogo das regras de mutação
  • Regras de melhor64: o jogo de referência
  • Taxonomia Completa de Transformações
  • Prioridade de frequência: o coração da eficiência
  • Implementação no Time2Crack: addHybridAttacks()
  • Os três espaços-chave híbridos e a sua justificação
  • Calibração de alta fidelidade
  • Relação com ataques derivados
  • Benchmarks por algoritmo de hash
  • Exemplos concretos de fissuração híbrida
  • Limites de ataque híbrido
  • Defesas eficazes
  • Referências

  • Resumo

    Ataque híbrido é o método de cracking que combina uma lista de palavras do dicionário com um conjunto de regras de transformaçãoEm vez de testar cada palavra no dicionário como é (ataque puro do dicionário), gera na mosca todas as variantes plausíveis de cada palavra — capitalizações, substituições de caracteres, adições de prefixo/sufixo, inversões — e testa-as sistematicamente.

    Por que é tão eficaz? Os humanos não escolhem a palavra-passe como uma senha, escolhem a palavra-passe "Password1", "p@ssw0rd", "PASSWORD123" ou "password!". Estas variantes parecem mais fortes porque não estão na lista de dicionários em bruto — mas estão entre as primeiras geradas por qualquer ferramenta de craqueamento híbrido moderna. O atacante explora exactamente as mesmas heurísticas "seguras" que o utilizador aplica.

    O ataque híbrido é historicamente o método responsável pela maioria das quebras de senha "média" reais — aquelas que parecem ser fortes sem ser fortes. De acordo com Ma et al. (2014, IEEE S&P), as primeiras 8 a 10 regras aplicadas a uma palavra atual bastam para quebrar a senha mediana população.

    No Time2Crack, o ataque híbrido modelou:

  • A detecção de que a senha é ou é derivada de uma palavra do dicionário
  • Estimativa do número de candidatos que um atacante deve testar antes de encontrar a variante exata
  • Cálculo do tempo correspondente de acordo com o algoritmo de hash-alvo

  • 2. Antecedentes históricos e acadêmicos

    2.1 Origens: John the Ripper e regras de mutação

    O ataque híbrido nasce formalmente com João, o Estripador (Solar Designer, 1996), a primeira ferramenta pública para combinar uma lista de palavras com um mecanismo de regras configurável. Antes de John the Ripper, ataques de dicionário testaram palavras brutas; John introduziu a noção de que cada palavra gera uma família de candidatos.

    Cronologia dos marcos :
    AnoAcontecimento
    1979Morris & Thompson: usuários substituem números por letras para "segurar" suas senhas
    1996John the Ripper 1.0: primeiro motor de regra pública, sintaxe JtR (:, c, u, r, d...)
    2000Alec Muffett documenta que 80% das fissuras reais passam por wordlist+regras, não força bruta
    2006Hashcat 0.01: migração na GPU, as regras vão de 1M→1000M candidatos/segundo
    2009RockYou: 14,3M senhas claras permitem calibração empírica das regras mais eficazes
    2012Gosney (Passwordscon): 8 GPU GTX 580, melhores regras64, crack 90% LinkedIn em < 6 dias
    2013Löfstrand: publica "melhor64.rule", 64 regras que abrangem 85-90% das transformações humanas atuais
    2014Ma et al. (IEEE S&P): primeiro estudo académico que quantifica a eficácia por nível de regras
    2016Hashcat código aberto: melhor integrado64, velocidade MD5 2 TH/s em 8× GTX 1080
    2019Hashcat 6.0: OneRuleToRuleThemAll game (52k rules) gerado por ML no corpus de senhas
    2023NSA Advisory: recomenda explicitamente testar senhas corporativas com ferramentas híbridas

    2.2 Estudos empíricos fundadores

    Klein (1990) — Análise de 15,000 senhas Unix. Reconhece que 24,2% são crackable por dicionário puro, mas que 32% adicionais são crackable com transformações simples (capitalização, adição do dígito final). Total: 56,2% com uma ferramenta híbrida primitiva. Weir et al. (2009, IEEE S&P) — Propõe o modelo PCFG, mas válido pela forma como as regras do hashcat cobrem 78% das transformações observadas no RockYou. Demonstra que as senhas "Password1" e "P@ssw0rd" estão entre os primeiros 100 candidatos gerados pelo best64 na palavra "password". Ma et al. (2014, IEEE S&P) — o estudo mais citado sobre a eficácia das regras híbridas.
  • Regras 1-10: crack 51%
  • Regras 1–64 (melhor completo64): crack 79%
  • Regras 1–500: crack 88%
  • Conclusão-chave As primeiras 10 regras fazem a maioria do trabalho.
  • Durmuth et al. (2015, ESORICS) — Avalia as regras JtR vs Hashcat vs PCFG. Conclui que as regras Hashcat best64 são empiricamente as mais eficazes para senhas claras observadas, superando o PCFG em 12% na cobertura RockYou.

    2.3 Voo do LinkedIn como caso escolar

    O vazamento do LinkedIn de 2012 (6,5 milhões de SHA-1s não salgados) ilustra perfeitamente o poder do híbrido. Em 72 horas, a comunidade hashcat tinha rachado:

  • 100% senhas em top-10M wordlists (dicionário puro)
  • 90% mais via melhor64 + Combineatoratack
  • Senhas resistentes: apenas aquelas sem estrutura de dicionários
  • A análise pós-crack revelou que "linkin1", "Linkedin1", "l!nked!n" e "LINKEDIN" — todas as variantes de "linkin" — representavam coletivamente dezenas de milhares de contas comprometidas.


    3. Fundações conceituais: Por que os trabalhos híbridos

    3.1 Comportamento humano "seguro"

    Quando um sistema impõe regras de complexidade (majuscule, number, symbol), os usuários não geram aleatórios — eles aplicar transformações previsíveis a palavras memorizáveis :

    Estratégia humanaExemploRegra híbrida correspondente
    Maiúscula na primeira letra"sunshine" → "Sunshine"c (capitalize first)
    Tudo em maiúsculas"sunshine" → "SUNSHINE"u (uppercase all)
    Adicionar um dígito no final"sunshine" → "sunshine1"$1 (append "1")
    Adicionar o ano"sunshine" → "sunshine2024"$2 $0 $2 $4
    Substituir e→3"sunshine" → "sunshin3"s e 3 (substitute e by 3)
    Substituir a→@"password" → "p@ssword"s a @
    Inverter a palavra"sunshine" → "enihsnus"r (reverse)
    Duplicar a palavra"sun" → "sunsun"d (duplicate)
    Adicionar um ! final"sunshine" → "sunshine!"$!
    Combinar várias"password" → "P@ssw0rd1"c s a @ s o 0 $1

    Estas transformações parecem criativos ao utilizador. exatamente os primeiros que o atacante tenta Correspondem às restrições impostas pelas políticas de segurança.

    3.2 O conceito de espaço reduzido eficiente

    Uma senha de 10 caracteres com letras + dígitos + símbolos tem uma força de espaço de chave bruta de 94^10, 5,4 × 10^19 combinações. Muito grande para viajar em um tempo razoável.

    Mas se esta senha é "Password1!" — uma transformação trivial de "password" — está entre os 500 primeiros candidatos O atacante não viaja 5.4 × 10^19 combinações: ele viaja 500.

    Esta é a redução fundamental do ataque híbrido: o espaço real das escolhas humanas é astronomicamente menor que o espaço teórico de possíveis personagens..

    3.3 A Lei do Poder da Transformação

    Assim como as senhas cruas seguem uma lei de poder (Zipf), as transformações que os seres humanos aplicam também seguem uma distribuição muito concentrada. Ma et al. (2014) mostraram empiricamente:

  • ~5% das transformações ("adicionar 1 no final", "capitalizar a primeira letra") cobrem ~50% dos casos reais
  • ~20% das transformações cobrem ~85% dos casos
  • Os restantes 80% das transformações cobrem apenas 15% dos casos
  • Esta concentração permite que um conjunto de 64 regras bem escolhidas (melhor64) atinja uma cobertura de 79-85%, onde 64 regras aleatórias atingiriam apenas 10-15%.

    3.4 Interação com a popularidade da palavra básica

    Quanto mais comum a palavra base, mais cedo a senha derivada está na lista de prioridades do atacante. O atacante ordena aos seus candidatos uma probabilidade decrescente:

    Candidatos gerados pelo atacante (ordem de teste):
      password        (palavra sem alteração, a mais comum)
      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!       (combinação complexa)

    "password" é a palavra mais comum → seus derivados são testados primeiro. "papillon" é menos comum → seus derivados são testados muito mais tarde. Esta priorização é o mecanismo central que explica os três espaços de chave distintos no Time2Crack.


    4. Arquitetura de um ataque híbrido moderno

    4.1 Oleoduto geral

    Fase 1: Seleção da wordlist
        ├── Senhas vazadas ordenadas por frequência (RockYou, HIBP, Collections)
        ├── Dicionários linguísticos (fr.txt, en.txt, de.txt...)
        ├── Wordlists temáticas (nomes próprios, cidades, marcas, séries de TV)
        └── Wordlists contextuais (domínio-alvo, nomes de funcionários, termos do setor)
    
    Fase 2: Seleção do conjunto de regras
        ├── best64.rule (referência equilibrada, 64 regras)
        ├── OneRuleToRuleThemAll.rule (52.000 regras, geradas por ML)
        ├── d3ad0ne.rule (34.000 regras, empíricas)
        ├── Regras JtR (generated.rule, specific.rule, extra.rule)
        └── Regras próprias (adaptadas ao domínio-alvo)
    
    Fase 3: Expansão (wordlist × regras)
        ├── Para cada palavra w da wordlist:
        │     Para cada regra r do conjunto:
        │       candidato = apply(r, w)
        │       Se candidato ≠ w e candidato ainda não testado:
        │         fila_de_candidatos.push(candidato)
        └── Ordem: (w1, regra1), (w1, regra2)... (w2, regra1)...
            ou: (w1, regra1), (w2, regra1)... conforme a estratégia
    
    Fase 4: Hash e comparação (GPU)
        ├── Envio de lotes de ~10M candidatos à GPU
        ├── Cálculo paralelo dos hashes (SIMD, 219 GH/s para MD5)
        ├── Comparação com o(s) hash(es) alvo
        └── Se houver correspondência: ENCONTRADO — log(candidato, hash, regra)
    
    Fase 5: Relatório
        └── Candidato quebrado + regra usada + posição na lista

    4.2 Hashcat modos de operação

    Hashcat implementa o híbrido de duas maneiras distintas:

    Modo -a 0 (lista de palavras + regras) : para cada palavra da lista de palavras, aplicar todas as regras. Este é o modo híbrido clássico.
    hashcat -a 0 -m 0 hashes.txt rockyou.txt -r best64.rule
    Modo -a 6 (lista de palavras + máscara) : combina uma lista de palavras com uma máscara posicional. Gera todas as combinações word + masked_suffix.
    hashcat -a 6 -m 0 hashes.txt wordlist.txt ?d?d?d?d
    # Tries "sunshine0000", "sunshine0001", ..., "sunshine9999"
    Modo - a 7 (máscara + lista de palavras) : inverso — prefixo mascarado + palavra.
    hashcat -a 7 -m 0 hashes.txt ?d?d wordlist.txt
    # Tries "00sunshine", "01sunshine", ..., "99sunshine"

    Time2Crack modela principalmente o modo -a 0 (regras de transferência), que abrange a grande maioria dos ataques híbridos documentados.

    4.3 Ordem dos candidatos e estratégia de priorização

    A ordem em que os candidatos são testados é crítica.

    Estratégia palavra-primeiro (hashcat padrão): todas as regras são aplicadas ao W1 antes de mudar para W2.
    (W1, R1), (W1, R2), ..., (W1, Rn), (W2, R1), (W2, R2)...
    Vantagem: se W1 é muito provável (por exemplo, "senha"), você rapidamente descobre suas variantes. Estratégia de princípio : todas as listas de palavras são executadas para R1 antes de ir para R2.
    (W1, R1), (W2, R1), ..., (Wm, R1), (W1, R2), (W2, R2)...
    Vantagem: a regra mais eficaz (: → mot brut) é aplicado em primeiro lugar em todas as palavras. Muitas vezes mais eficaz para corpus diversos.

    Na prática, hashcat usa palavra-primeiro por padrão, mas operadores experientes escolher de acordo com o perfil alvo.


    5. Conjuntos de regras de mutação

    5.1 Sintaxe das regras do hashcat

    As regras do hashcat são expressas em uma linguagem mínima onde cada caractere representa uma operação na string candidata:

    Modificadores de maiúsculas :
  • : — Identidade (palavra bruta, sem transformação)
  • l — todos os minúsculas ("PASSWORD" → "senha")
  • u — todas as maiúsculas ("senha" → "PASSWORD")
  • c — Capitalizar primeiro, descanso minúsculo ("PASSWORD" → "Senha")
  • C — Primeiro em minúsculas, resto em maiúsculas ("Password" → "PASSWORD")
  • t — Alternar caixa de todos os caracteres ("Senha" → "PASSWORD")
  • TN — Alternar a caixa de caracteres da posição N
  • Mudanças e reversão :
  • r — Inverter ("senha" → "drowssap")
  • d — Duplicar ("palavra-passe" → "palavra-passe")
  • f — Refletir (palavra + verso) ("sol" → "sunnos")
  • { — Rodar à esquerda ("senha" → "asswordp")
  • } — Rodar à direita ("senha" → "dpasswor")
  • [ — Remover o primeiro caractere ("senha" → "assword")
  • ] — Remover o último caracter ("senha" → "passwor")
  • Adições de caracteres :
  • $X — Adicionar caracteres X ("senha" + $1 → "senha1")
  • ^X — Caráter prévio X (senha-passe) + ^1 → "1senha")
  • iNX — Inserir caracteres X na posição N
  • Substituições :
  • sXY — Substituir todos os X por Y ("senha" + s a @ → "p@ssword")
  • SNX — Substituir o carácter na posição N por X
  • Truncamentos :
  • 'N — Truncar na posição N (senha + '4 → "passar")
  • DN — Apagar o carácter na posição N
  • Condicional :
  • <N — Aplicar a regra apenas se o comprimento < N
  • >N — Aplicar a regra apenas se o comprimento > N
  • =N — Aplicar a regra apenas se o comprimento = N
  • 5.2. Regras compósitas

    Regras podem ser encadeadas em uma única linha para criar transformações complexas:

    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)

    Poder está na composição: 64 regras simples geram milhares de transformações distintas por combinação.

    5.3 Regras principais

    best64.regra (Löfstrand, 2013) — 64 regras selecionadas empiricamente no RockYou para maximizar a taxa de crack. Uma regra para todos eles (NotSoSecure, 2019) — 52.218 regras geradas pela aprendizagem automática no corpus de senha rachado. Taxa de crack maior do que o melhor64 de ~8% no corpus moderno, ao custo de um tempo de cálculo ~800× mais. d3ad0ne. rule — 34.096 Regras comunitárias, centradas nos padrões não abrangidos pelo melhor64 (acentos, caracteres alargados, padrões não ingleses). live.rule — 99 000 mais regras, as mais exaustivas, utilizadas para rachar a longo prazo quando outras não foram bem sucedidas. Generalizado2.rule (JtR) — Automaticamente gerados pela análise estatística de senhas já rachadas.

    6. Regras Best64: o jogo de referência

    O Best64 é o conjunto de 64 normas de referência na literatura acadêmica e na indústria. Aqui estão as regras mais importantes e sua justificativa empírica:

    6.1 As 20 regras mais eficazes (por ordem de desempenho)

    PosiçãoRegraTransformação% de senhas cobertas (Ma 2014)
    1:Palavra sem alteração~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%
    Regras de acumulação 1–10 : ~55% das senhas baseadas em dict Regras de acumulação 1–20 : ~68% das senhas baseadas em dict Regras de acumulação 1–64 : ~79% das senhas baseadas em dict

    6.2 Por que estas regras são tão eficazes?

    Cada regra do top-10 corresponde a uma restrição da política de segurança comum:

  • "Vai ter um capital" → usuários capitalizar a primeira letra (c)
  • "deve ter um número" → os usuários adicionam "1" no final ($1)
  • "Deve ter um símbolo" → usuários adicionar "!" ($!)
  • "deve ter letras E números" → c $1 ou c $1 $2 $3
  • Políticas de senha realmente não aumentam a segurança se os usuários implementarem transformações previsíveis — eles apenas movem senhas para a segunda ou terceira regra do melhor64.


    7. Taxonomia Completa das Transformações

    7.1 Categoria 1: Transformações de casos

    Explora a obrigação de ter um capital:

  • Capitalizar primeira letra : "Sunshine" → "Sunshine" (regra mais comum após a palavra cru)
  • Todos maiúsculas : "Sunshine" → "SUNSHINE"
  • Alternativa : "sunshine" → "sunshinE"
  • Última letra maiúscula : "sunshine" → "sunshine"
  • CamelCaso: "sunshinE" (aproximado por c alterações)
  • Prevalência : Klein (1990) observa que 41% das "senhas com maiúsculas" consistem simplesmente da palavra com a primeira letra em maiúsculas.

    7.2 Categoria 2: Sufixos e prefixos digitais

    Explorar a obrigação de ter um valor:

  • Adicionar único dígito : palavra+"0" à palavra+"9"
  • Adicionar dois algarismos : palavra+"00" para palavra+"99" (100 combinações)
  • Ano seguinte : word+"1990" to word+"2024" (35 combinações frequentes)
  • Adicionar "123" ou "1234" (muito comum)
  • Prepend single dígito : "1"+mot à "9"+mot
  • Ano anterior : "2024"+palavra
  • Prevalência Veras et al. (2014) descobrem que ~73% das senhas "obrigatórias" adicionam a figura no sufixo. Apenas ~12% prefixam-na.

    7,3 Categoria 3: Substituições de Leet

    Substituição sistemática de letras por números ou símbolos semelhantes:

    SubstituiçãoFrequência empírica
    a → @23% das senhas com @
    e → 331% das senhas com 3
    i → 119% das senhas com 1
    o → 027% das senhas com 0
    s → $14% das senhas com $
    l → 18%
    t → 76%
    g → 94%

    As substituições combinadas ("P@ssw0rd") parecem complexas, mas são geradas em algumas regras: c s a @ s o 0Eles estão entre os 500 primeiros candidatos Na palavra-passe.

    7.4 Categoria 4: Sufixos simbólicos

    Explorar a obrigação de ter um carácter especial:

  • Adicionar "!": o símbolo mais frequentemente adicionado (~35% das adições simbólicas)
  • Adicionar "?": ~ 8%
  • Adicionar "#" : ~6%
  • Adicionar "@": ~5%
  • Adicionar ".": ~4%
  • Adicionar "!!": ~3%
  • Prepends "!": menos frequente (~10% dos casos vs 35% para sufixo)
  • Kombinaison : palavra + "1!" é tão comum que é sistematicamente gerado pelo melhor64. "sunshine1!" está entre os primeiros 200 candidatos gerados no "sunshine".

    7.5 Categoria 5: Transformações estruturais

    Menos frequente, mas útil para alguns perfis:

  • Inversão: "sol" → "nu" (atual para certos grupos)
  • Duplicação: "sol" → "sol" (palavras-passe para sistemas que limitam a 8 tanques resolvidos a 16)
  • Rotação : "senha" → "asswordp"
  • Trinca + adição : "passw" + "1"
  • 7.6 Categoria 6: Transformações compostas (nível avançado)

    Regras complexas combinam várias operações:

    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 transformações parecem muito complexas, mas permanecem detectáveis por um bom conjunto de regras.UmaRegraToRuleThemall contém milhares delas.


    8. Prioridade de Frequência: O Coração de Eficácia

    8.1. A frequência da palavra básica determina a prioridade

    Um atacante inteligente não aplica as regras uniformemente a todas as palavras. Ele prioriza:

  • Palavras mais comuns (top-100 RockYou/HIBP) × todas as regras
  • Palavras moderadamente comuns (top-10k) × regras mais eficazes
  • Palavras menos frequentes (todos os dicionários) × primeiras regras
  • Esta estratégia é implementada no hashcat através da ordenação da lista de palavras, diminuindo a frequência combinada com a estratégia palavra- primeiro. Ela explica porque "Password1" (derivado de "password", a palavra #1) é rachada em milissegundos, enquanto "Soleil1" (derivado de "sol", palavra ~5000 do dicionário francês) pode levar alguns segundos.

    8.2 Posição mediana no espaço de busca

    A medida-chave é o número mediano de candidatos testados antes de encontrar a senha-alvo. Ma et al. (2014) fornecem medidas empíricas:

    CategoriaExemploMediana de candidatos até o acerto
    TOP100"password1", "P@ssword"~450–500
    Dicionário comum (top-10k)"Sunshine1", "sunshine!"~5.000–15.000
    Dicionário menos frequente"Papillon2024"~50.000–200.000
    Fora do dicionário"Xk7#mP9q"N/A (híbrido não aplicável)

    Estas medições são a base direta das 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 Condições necessárias para que o híbrido seja aplicável

    Ataque híbrido requer a senha para ser estruturalmente derivable a partir de uma palavra do dicionárioTime2Crack detecta esta condição via hybridVuln :

    const hybridVuln = dictWord || (common && /[a-z]/i.test(pw));
  • dictWord = true : a senha é ou deriva de uma lista de palavras do idioma
  • common && lettre : a senha aparece no COMMON (HIBP top-400) e contém letras — portanto, quase certamente derivada de uma palavra
  • Se dictWord nenhum dos dois hybridVuln são verdadeiros — a senha não contém nenhuma raiz de dicionário detectável — retorna ataque híbrido null (não aplicável). Uma senha puramente aleatória como "xK9# mQ7@" não é vulnerável ao híbrido.


    9. Implementação no 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

    A distinção entre as duas funçõ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 o híbrido, budgetTime é correto porque os 500/8000/128M candidatos são estimativas empíricas do posição mediana, não espaço total para viajar.

    9.3 Relação com isDictWord()

    Detecção dictWord que condiciona a escolha do espaço-chave híbrido 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 detecção determina não só se o híbrido é aplicável, mas também qual espaço de chave (common vs dict) é usado para calcular o tempo.


    10. Os três espaços-chave híbridos e a sua justificação

    10, 1 HYBRID_KEYSPACE_COMMON = 500

    Contexto A senha está em COMMON — a lista de códigos rígidos HIBP top-~400. Estas são algumas das senhas mais comuns do mundo ("senha", "letmein", "sunshine", "iloveyou"...). Justificação Ma et al. (2014) mediram empiricamente que a posição mediana de uma senha top-1000 em uma lista híbrida ordenada por probabilidade é ~450 candidatos. O número 500 é uma estimativa ligeiramente conservadora para cobrir até ~400 rank. Interpretação : um atacante aplicando best64 a uma lista de palavras ordenada por testes de frequência em média 500 candidatos antes de encontrar a senha. 0,19 ns. Praticamente instantâneo. Exemplo : "Sunshine1" → "sunshine" está em COMMON → HYBRID_KEYSPACE_COMMON = 500 → budgetTime(500, 2634e9) 0,19 ns.

    10,2 HYBRID_KEYSPACE_DICT = 8.000

    Contexto A senha é derivada de uma palavra da lista de palavras da linguagem, mas não da COMMON. Estas são palavras de vocabulário comuns ("sol", "montanha", "paillon"...) com transformações. Justificação Ma et al. (2014) medem uma posição mediana de 2.000 a 15.000 dependendo da popularidade da palavra em RockYou. A mediana empírica é de ~8.000. Este espaço-chave reflete que o atacante testa a palavra e suas variantes depois de esgotar os candidatos mais comuns. Interpretação : 8.000 candidatos a 2.600 GH/s (MD5) = 3,0 ns. Sempre quase instantânea para hashs rápidos. Para bcrypt (114 kH/s): 8.000 / 114 000 0,07 segundos. Exemplo : "Soleil2024" → "sol" em fr.txt → HYBRID_KEYSPACE_DICT = 8.000 → alguns nanossegundos no MD5, 0,07s no bcrypt.

    10,3 HYBRID_KEYSPACE_FULL = 128.000.000

    Contexto : hybridVuln é verdadeiro (senha tem uma estrutura de dicionário) mas nenhum common nenhum dos dois dictWord O atacante deve procurar toda a lista de palavras com todas as regras. Justificação : Gosney (Passwordscon 2012) documenta uma lista de palavras de 3.5M palavras × best64 (64 regras) = 224M candidatos no total. Na prática, realistas wordlists fazer 2M palavras eo melhor parcial64 corridas parar em ~128M candidatos antes de subir para regras mais amplas. Fórmula : 2_000_000 palavras × 64 regras = 128_000_000 candidatos Interpretação : 128M candidatos a 2600 GH/s (MD5) 49 µs. No bcrypt (114 kH/s): ~19 minutos.

    11. Calibração de alta fidelidade

    11.1 Papel do modo de alta fidelidade

    Quando o modo de alta fidelidade (HF) é ativado no Time2Crack, um multiplicador adicional é aplicado aos tempos calculados para refinar a precisão. Para o ataque híbrido, este multiplicador leva em conta fatores não capturados pelos espaços de chave 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;
    Justificação :
  • Para common : ferramentas modernas (hashcat com --markov-threshold) predefinir as regras por eficácia empírica.
  • Para dictWord : menos efeito porque a posição na lista de palavras está menos concentrada. Redução de 20%.
  • Para hybridVuln Apenas (espaço de chave completo): nenhuma redução — espaço de chave completo já é uma estimativa conservadora.
  • 11.3 Interacção com a monotonia

    A guarda monotonia garante que nenhum ataque especializado afirma ser mais rápido que a força bruta na subtexto alfabética da senha:

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

    Para palavras curtas (por exemplo, "gato" = 3 letras, piso = 26^3/rate


    12. Relação com ataques derivados

    12.1 Híbrido vs. Dicionário Puro

    CritérioDicionário puroHíbrido
    Candidatos testadosPalavras exatas da listaPalavras + todas as suas variantes
    Cobertura (RockYou)~18%~79-85% (com best64)
    Keyspace (200k palavras)200.000200.000 × 64 = 12,8M
    AplicabilidadeSenha = palavra exataSenha derivada de uma palavra
    Exemplo vulnerável"sunshine" (exata)"Sunshine1!", "sunsh1ne"
    Exemplo resistente"Sunshine1""xK9#mQ7@" (sem palavra base)

    12.2 Híbrido vs Baseado em Regras

    O ataque baseado em regras no Time2Crack é conceitualmente semelhante, mas com um conjunto muito mais amplo de regras:

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

    A diferença: o melhor híbrido modelo64 (64 regras, foco em transformações humanas comuns). Os modelos de ataque baseados em regras mais amplos jogos como d3ad0ne (regras 34k) ou OneRuleToRuleThemAll (regras 52k), usados quando o melhor64 falha. O híbrido baseado em regras é o híbrido "segunda linha" — mais lento mas mais abrangente.

    12. 3 Híbrido vs PCFG

    PCFG (Probabilistic Context-Free Grammar, Weir 2009) modela a estrutura gramatical da senha para gerar candidatos.

    CritérioHíbridoPCFG
    AbordagemPalavra base + regras de transformaçãoEstrutura gramatical global
    Ponto fortePalavras existentes modificadasEstruturas do tipo "Palavra+Dígitos"
    Exemplo"sunshine" → "Sunshine1"Detecta a estrutura "Maiúsc+minúsc+dígito"
    ComplementaridadeÉ acionado por dictWordÉ acionado por uma estrutura detectada
    Keyspace (Time2Crack)500 / 8k / 128MpcfgKeyspace(pw), calculado dinamicamente

    PCFG pode atacar senhas sem dicionário root se estrutura é comum (ex: "Thelonious8" → nenhuma palavra do dico mas estrutura Capitalizar + menor + dígitos muito previsível).

    12, 4 Híbrido vs Morfológico (morfo)

    O ataque morfológico testa variantes linguísticas (flexões, variações). É uma generalização do híbrido para linguagens com morfologia rica:

  • Híbrido : "sun" → "Sun1", "s0leil", "sun!"
  • Morfológico : "sol" → "sol", "sol", "solar", "sol"
  • O híbrido opera na superfície da palavra (transformações de caráter), a morfologia opera na estrutura lexical (derivação, flexão), e eles são complementares.


    13. Benchmarks pelo algoritmo de hash

    13.1 Tempo para os três espaços de chaves híbridos (12× RTX 5090)

    AlgoritmoVelocidade (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 (custo 10)114 kH/s4,4 ms0,07 s19 min
    Argon2id1.000 H/s0,5 s8 s36 horas
    Leitura : para MD5 e NTLM, mesmo o espaço de chaves FULL (128M candidatos) é rachado em algumas dezenas de microssegundos. O algoritmo de hash é quase irrelevante para palavras comuns. Argon2id é o único algoritmo que resiste significativamente mesmo para palavras comuns: 0.5 segundos para uma palavra COMMON, 8 segundos para um dictWord. Estes tempos permanecem curtos em valor absoluto, mas representam uma desaceleração de x10^9 vs MD5 — tornando ataques de grande escala economicamente inviáveis.

    13.2 Impacto do perfil de ataque

    Time2Crack oferece dois perfis (Experienced 12 GPU, Professional 100 GPU). Para o híbrido, a diferença de perfil é diretamente proporcional:

    PerfilGPUsMultiplicadorFULL bcrypt
    Experiente12× RTX 50901×19 min
    Profissional~100 GPU~8×~2 min

    Para MD5, SHA-1, NTLM: o perfil muda o tempo de microsegundos para nanossegundos — sem qualquer impacto prático, ambos são instantâneos.


    14. Exemplos concretos de fissuração híbrida

    14.1 Exemplo 1: "Senha 1" (COMMON)

    Análise :
  • isCommon("Password1") → false (não em HIBP exato)
  • isDictWord("Password1") → true ("senha" em DICTWORDS em minúsculas)
  • COMMON.has("password") → verdade → common = true
  • Resultado: HYBRID_KEYSPACE_COMMON = 500
  • Tempo MD5 : 500 / 2,634e12 0,19 ns (Snapshot) Tempo bcrypt custo 10 : 500 / 114 000 4,4 milissegundos Regras testadas antes de serem encontradas : : (palavra bruta "senha" → no), c ("Password" → no), c $1 ("Password1" → CONCLUSÕES, linha ~8)

    14.2 Exemplo 2: "Sun2024" (DICT)

    Análise :
  • isCommon("Soleil2024") → falso
  • isDictWord("Soleil2024") → true ("sol" em fr.txt)
  • COMMON.has("soleil") → false → common = false, dictWord = true
  • Resultado: HYBRID_KEYSPACE_DICT = 8.000
  • Tempo MD5 : 8 000 / 2.634e12 3,0 nanossegundos Tempo bcrypt custo 10 : 8 000 / 114 000 0,07 segundos Regras de ensaio : o atacante chega a "sol" em ~5000 na lista de palavras fr ordenado por frequência, em seguida, aplica-se c $2 $0 $2 $4 ("Sun2024") na linha ~3 de suas regras → posição geral ~15 003.

    14.3 Exemplo 3: "p@ pillon!" (DICT com substituições)

    Análise :
  • isDictWord("p@pillon!") : de-leetificação → "paillon" → em fr.txt → dictWord = true
  • Resultado: HYBRID_KEYSPACE_DICT = 8.000
  • Regras de ensaio : "paillon" em ~15.000 do dicionário fr. Rule s a @ $! → "p@ pillon!" na linha ~ 12. Posição geral: ~ 180.000. Sempre bom em HYBRID_KEYSPACE_DICT.

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

    Análise :
  • isDictWord("xK9#mQ7@") → false (sem dicionário raiz)
  • isCommon("xK9#mQ7@") → falso
  • hybridVuln = false
  • Resultado: sec = null → híbrido não aplicável
  • Esta senha não pode ser quebrada por ataque híbrido. Ela não tem raiz de dicionário. O atacante deve usar força bruta pura, PCFG ou ataques estatísticos (Markov, Neural).

    14.5 Exemplo 5: "LinkedInB3st!"

    Análise :
  • isDictWord("LinkedInB3st!") : "linkedin" → wordlist en.txt + deLeet("b3st") → "melhor" → dictWord = true
  • Resultado: HYBRID_KEYSPACE_DICT = 8.000
  • Caso interessante: a senha contém duas raízes ("linkedin" e "best" via des-leetificação). Ataque híbrido é aplicável porque pelo menos uma raiz é detectada. Na prática, um ataque combinador (duas palavras coladas) seria ainda mais eficaz aqui.


    15. Limites de ataque híbrido

    15.1 Limites intrínsecos

    Dependência da qualidade da lista de palavras : se a palavra básica não está na lista de palavras, o híbrido não pode funcionar. Uma senha baseada em um termo muito especializado (neologismo, termo técnico obscuro, palavra de uma língua rara) pode resistir se estiver ausente de todas as listas de palavras comuns. Cobertura incompleta das transformações : mesmo OneRuleToRuleThemAll com 52k regras não cobre 100% das transformações imagináveis. Algumas transformações muito raras (base64 codificações parciais, padrões inventados) escapam às regras. Explosão combinatória com Listas de Palavras Longas Com 2.600 GH/s (MD5), leva ~190 segundos — mas com bcrypt (114 kH/s), ~140 anos. A escalabilidade do híbrido é limitada pelo comprimento da lista de palavras e pela lentidão do algoritmo de hash.

    15.2 O que Time2Crack não captura

    Lista de Palavras de Contexto : um atacante atacando uma empresa específica irá construir uma lista de palavras com o nome da empresa, produtos, nomes de funcionários, termos de negócios. "Renault2024!" seria rachado instantaneamente por um atacante atacando Renault — mas Time2Crack não modela este contexto (este é o papel do ataque "SINT Targeted"). Regras compostas multipasse Algumas senhas resistem ao melhor64, mas cedem às regras de duas passagens (aplique uma regra e depois aplique outra regra sobre o resultado). Time2Crack model only one rule pass. Efeitos de cache e memorização : hashcat mantém uma tabela de candidatos já testados para evitar duplicatas, que acelera as corridas na prática.

    15.3 Casos em que o híbrido é superestimado

    Time2Crack pode superestimar a velocidade híbrida em dois casos:

  • Senhas longas Uma senha de 20 caracteres baseada num dicionário de palavras ("incompreensibilidades1!") é detectada como um dicionário, mas as ferramentas híbridas normalmente filtram os candidatos por muito tempo. O espaço de chaves real é talvez 10× maior.
  • Línguas com morfologia rica Turco, finlandês, húngaro têm listas de palavras mais complexas. "Güneş2024" pode passar sob radares se o wordlist turco não inclui todas as formas morfológicas.

  • 16. Defesas eficazes

    16.1 O que resiste à hibridização

    Ataque híbrido falhou se a senha não deriva de nenhuma palavra de dicionário existenteEstratégias eficazes:

    Senhas aleatórias "xK9# mQ7@ vP2!" não contém nenhuma raiz de dicionário. Nenhuma regra híbrida pode gerá- la. Resistência: máxima. Geradores de senhas : gerenciadores de senhas (Bitwarden, 1Password, KeePass) geram strings aleatórias. Nenhum dicionário root → híbrido inaplicável. Frases-passe de palavras realmente aleatórias : "tabouret-marmot-ginger-flash" — quatro palavras aleatórias. Ataque híbrido no modo clássico não gera combinações de 4 palavras (este é o papel do combinador).

    16.2 O que não é resistência à híbrida

    As estratégias mais comuns de "reforço" não resistem:

    EstratégiaExemploResistência
    Maiúscula na primeira letra"Sunshine"❌ Regra c, posição 2
    Adicionar um dígito"sunshine1"❌ Regra $1, posição 4
    Adicionar um símbolo"sunshine!"❌ Regra $!, posição 6
    Substituir e→3"sunshin3"❌ Regra s e 3, top-20
    Combinar tudo"Sunshin3!"❌ Regra composta, top-100
    Escolher uma palavra rara"papillon123"❌ Continua nas wordlists
    Duplicar a palavra"sunsun"❌ Regra d, top-30
    Inverter"enihsnus"❌ Regra r, top-15
    Conclusão Qualquer estratégia baseada em "tomar uma palavra + modificá-la" é vulnerável ao híbrido. A exceção é uma modificação tão complexa e rara que não é coberta por nenhuma regra – mas se o usuário tem que lembrar dessa transformação complexa, ele geralmente acaba escolhendo algo previsível.

    16.3. Algoritmos de hash resistentes

    Mesmo que uma senha seja vulnerável ao híbrido estrutural, o algoritmo de hash pode tornar o ataque economicamente inviável:

    AlgoritmoTempo para DICT (8k tentativas)Ataque na prática
    MD5 / NTLM~3 nanossegundosInstantâneo
    SHA-256~24 nanossegundosInstantâneo
    bcrypt custo 10~0,07 segundosTrivial
    bcrypt custo 14~1 segundoViável
    Argon2id (padrão)~8 segundosViável
    Argon2id (parâmetros fortes)~100 segundosLento, mas possível
    Argon2id com parâmetros elevados (t=4, m=65536) é o único algoritmo que torna o híbrido realmente caro, mesmo em senhas fracas.

    16.4 Recomendações práticas

  • Usar um gerenciador de senhas : gera puro aleatório, híbrido inaplicável
  • Se necessário : 4+ palavras realmente frase-passe aleatória (de EFF)
  • Nunca "seguro" uma palavra por substituição : o híbrido gera-os automaticamente
  • Requer custo de bcrypt ≥ 12 ou Argon2id lado do servidor: o único real mais lento
  • Activar o MFA : torna off-line cracking teórico sem impacto operacional

  • 17. Referências

    Publicações académicas

    Klein, D.V. (1990) "Folhando o Cracker": Uma pesquisa e melhorias para, Segurança de senha Procedimentos da Oficina de Segurança USENIX, 1990. — Primeiro estudo empírico que quantifica o impacto das regras de mutação na cobertura de fissuras. Observa que 56% das senhas são questionáveis com dicionário + transformações simples. Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009) Rastreamento de senhas usando Gramática Probabilística Livre de Contexto Simpósio IEEE sobre Segurança e Privacidade (S&P), 2009. — Fundado o modelo PCFG e válido pela forma como as regras do hashcat cobrem 78% das transformações humanas observadas no RockYou. Ma, J., Yang, W., Luo, M., & Li, N. (2014) Um estudo de modelos de senha probabilísticos Simpósio da IEEE sobre Segurança e Privacidade (S&P), 2014. — Estudo de referência directo para Time2Crack: medição empírica de posições medianas (500 para top-100, 2000-15000 para dict atual) em uma varredura híbrida ordenada por probabilidade em senhas reais de 10M. Durmuth, M., Chaabane, A., Perito, D., & Castelluccia, C. (2015) Quando reuniões de privacidade Segurança: Aproveitando informações pessoais para rastreamento de senha ESORICS 2015. — Compare regras JtR vs Hashcat vs PCFG. Conclui que o melhor64 supera o PCFG em 12% no RockYou. Veras, R., Collins, C., & Thorpe, J. (2014) Sobre os padrões semânticos de senhas e seu impacto de segurança NDSS 2014. — Análise linguística dos padrões semânticos. Ur, B., Bees, J., Segreti, S. M., Bauer, L., Christin, N., & Cranor, L. F. (2015) As Percepções de Segurança de Senha dos Usuários combinam com a Realidade? ACM CHI 2015. — Demonstra que os usuários superestimam sistematicamente a força das senhas mutadas. "P@ssw0rd" recebe uma pontuação subjetiva de "forte" mas é rachada em < 1s. Wheeler, D.L. (2016) zxcvbn: Estimativa de Força de Senha de Baixo Orçamento 25o Simpósio de Segurança USENIX, 2016. — Biblioteca de estimativa de força que integra a detecção de regras de mutação. Referência para a implementação de heurísticas de detecção.

    Conferências e apresentações industriais

    Gosney, J (2012)
    8x Nvidia GTX 580 Cluster Hashcat Benchmarks / LinkedIn crack session Senhascon 2012, Oslo. — Documentar o crack LinkedIn: best64 + wordlist 3.5M = 224M candidatos, 90% rachado em 6 dias. Base de HYBRID_KEYSPACE_FULL = 128M. Löfstrand, K. (2013) best64.rule — Seleção empírica de 64 regras de hashcat Interna, publicada no GitHub. — Conjunto de 64 regras selecionadas empiricamente no RockYou para maximizar a taxa de crack. Padrão de referência da indústria. Steube, J. (2016–presente) Recuperação de senha avançada Hashcat https://hashcat.net/hashcat/ — Documentação oficial do modo -a 0, -a 6, -a 7. Sintaxe das regras. NotSoSecure (2019) UmaRegraToRuleThemAll — ML-gerado hashcat regra https://github.com/NotSoSecure/password_cracking_rules — 52 218 regras geradas pela aprendizagem automática sobre o corpus de senhas rachadas.

    Ferramentas de referência

    João, o Estripador (Solar Designer, 1996–presente) https://www.openwall.com/john/ — Pioneer do híbrido wordlist+rules. A sintaxe JtR sempre foi usada em paralelo com Hashcat. Hashcat (Steube, 2009–presente) https://hashcat.net/hashcat/ — Implementação de GPU de referência. Lista de palavras RockYou (2009) 14,3M senhas claras. Corpora de calibração padrão para todos os conjuntos de regras híbridas. SecListas (Daniel Miessler, 2012–presente) https://github.com/danielmiessler/SecLists — Coleção de listas de palavras por idioma, domínio, tema. Fonte principal de listas de palavras de idioma Time2Crack.

    Fontes da Web citadas no aplicativo Time2Crack

    Chick3nman (benchmarks/regras do Hashcat). https://gist.github.com/Chick3nman/32e662a5bb63bc4f51b847bb4222fd — Fonte coligada descHybrid (app.js) para a ordem de magnitude das regras de mutação aplicadas. IEEE Xplore (referência híbrida). https://ieexplore.ieee.org/document/6956583 — Fonte coligada descHybrid (app.js) sobre a eficácia empírica das senhas alteradas.
    Documento gerado como parte do projeto Time2Crack — 2026 Ver também: BRUTEFORCEATAQUEEXPLICADO.md, MARKOVATAQUEEXPLICADO.md, DICIONÁRIOATAQUEEXPLICADO.md