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
addHybridAttacks()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:
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 :| Ano | Acontecimento |
|---|---|
| 1979 | Morris & Thompson: usuários substituem números por letras para "segurar" suas senhas |
| 1996 | John the Ripper 1.0: primeiro motor de regra pública, sintaxe JtR (:, c, u, r, d...) |
| 2000 | Alec Muffett documenta que 80% das fissuras reais passam por wordlist+regras, não força bruta |
| 2006 | Hashcat 0.01: migração na GPU, as regras vão de 1M→1000M candidatos/segundo |
| 2009 | RockYou: 14,3M senhas claras permitem calibração empírica das regras mais eficazes |
| 2012 | Gosney (Passwordscon): 8 GPU GTX 580, melhores regras64, crack 90% LinkedIn em < 6 dias |
| 2013 | Löfstrand: publica "melhor64.rule", 64 regras que abrangem 85-90% das transformações humanas atuais |
| 2014 | Ma et al. (IEEE S&P): primeiro estudo académico que quantifica a eficácia por nível de regras |
| 2016 | Hashcat código aberto: melhor integrado64, velocidade MD5 2 TH/s em 8× GTX 1080 |
| 2019 | Hashcat 6.0: OneRuleToRuleThemAll game (52k rules) gerado por ML no corpus de senhas |
| 2023 | NSA 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.- Artigo 1.o (
: → mot brut) : crack 18% das senhas baseadas em dict
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:
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 humana | Exemplo | Regra 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:
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 Nr — 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")$X — Adicionar caracteres X ("senha" + $1 → "senha1")^X — Caráter prévio X (senha-passe) + ^1 → "1senha")iNX — Inserir caracteres X na posição NsXY — Substituir todos os X por Y ("senha" + s a @ → "p@ssword")SNX — Substituir o carácter na posição N por X'N — Truncar na posição N (senha + '4 → "passar")DN — Apagar o carácter na posição N<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 = N5.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ção | Regra | Transformação | % de senhas cobertas (Ma 2014) |
|---|---|---|---|
| 1 | : | Palavra sem alteração | ~18% |
| 2 | c | Capitalize first | ~11% |
| 3 | u | Uppercase all | ~6% |
| 4 | $1 | Append "1" | ~5% |
| 5 | l | Lowercase all | ~4% |
| 6 | $! | Append "!" | ~3% |
| 7 | s a @ | a→@ | ~2,8% |
| 8 | c $1 | Capitalize + "1" | ~2,5% |
| 9 | $2 | Append "2" | ~2,1% |
| 10 | r | Reverse | ~1,9% |
| 11 | $! + c | Capitalize + "!" | ~1,7% |
| 12 | s o 0 | o→0 | ~1,6% |
| 13 | d | Duplicate | ~1,4% |
| 14 | s e 3 | e→3 | ~1,3% |
| 15 | $1 $2 $3 | Append "123" | ~1,2% |
| 16 | c $1 $2 $3 | Capitalize + "123" | ~1,1% |
| 17 | $0 | Append "0" | ~1,0% |
| 18 | ^1 | Prepend "1" | ~0,9% |
| 19 | s i 1 | i→1 | ~0,8% |
| 20 | c $! $1 | Capitalize + "!1" | ~0,7% |
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:
c)$1)$!)c $1 ou c $1 $2 $3Polí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:
c alterações)7.2 Categoria 2: Sufixos e prefixos digitais
Explorar a obrigação de ter um valor:
7,3 Categoria 3: Substituições de Leet
Substituição sistemática de letras por números ou símbolos semelhantes:
| Substituição | Frequência empírica |
|---|---|
| a → @ | 23% das senhas com @ |
| e → 3 | 31% das senhas com 3 |
| i → 1 | 19% das senhas com 1 |
| o → 0 | 27% das senhas com 0 |
| s → $ | 14% das senhas com $ |
| l → 1 | 8% |
| t → 7 | 6% |
| g → 9 | 4% |
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:
7.5 Categoria 5: Transformações estruturais
Menos frequente, mas útil para alguns perfis:
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:
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:
| Categoria | Exemplo | Mediana 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 idiomacommon && lettre : a senha aparece no COMMON (HIBP top-400) e contém letras — portanto, quase certamente derivada de uma palavraSe 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 :
common : ferramentas modernas (hashcat com --markov-threshold) predefinir as regras por eficácia empírica.dictWord : menos efeito porque a posição na lista de palavras está menos concentrada. Redução de 20%.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ério | Dicionário puro | Híbrido |
|---|---|---|
| Candidatos testados | Palavras exatas da lista | Palavras + todas as suas variantes |
| Cobertura (RockYou) | ~18% | ~79-85% (com best64) |
| Keyspace (200k palavras) | 200.000 | 200.000 × 64 = 12,8M |
| Aplicabilidade | Senha = palavra exata | Senha 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ério | Híbrido | PCFG |
|---|---|---|
| Abordagem | Palavra base + regras de transformação | Estrutura gramatical global |
| Ponto forte | Palavras existentes modificadas | Estruturas 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 / 128M | pcfgKeyspace(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:
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)
| Algoritmo | Velocidade (H/s) | COMMON (500) | DICT (8k) | FULL (128M) |
|---|---|---|---|---|
| MD5 | 2.634 GH/s | 0,19 ns | 3,0 ns | 49 μs |
| SHA-1 | 837 GH/s | 0,60 ns | 9,6 ns | 153 μs |
| SHA-256 | 332 GH/s | 1,5 ns | 24 ns | 386 μs |
| NTLM | 4.081 GH/s | 0,12 ns | 2,0 ns | 31 μs |
| bcrypt (custo 10) | 114 kH/s | 4,4 ms | 0,07 s | 19 min |
| Argon2id | 1.000 H/s | 0,5 s | 8 s | 36 horas |
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:
| Perfil | GPUs | Multiplicador | FULL bcrypt |
|---|---|---|---|
| Experiente | 12× RTX 5090 | 1× | 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 = trueHYBRID_KEYSPACE_COMMON = 500: (palavra bruta "senha" → no), c ("Password" → no), c $1 ("Password1" → CONCLUSÕES, linha ~8)
14.2 Exemplo 2: "Sun2024" (DICT)
Análise :isCommon("Soleil2024") → falsoisDictWord("Soleil2024") → true ("sol" em fr.txt)COMMON.has("soleil") → false → common = false, dictWord = trueHYBRID_KEYSPACE_DICT = 8.000c $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 = trueHYBRID_KEYSPACE_DICT = 8.000s 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@") → falsohybridVuln = falsesec = null → híbrido não aplicávelEsta 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 = trueHYBRID_KEYSPACE_DICT = 8.000Caso 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:
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égia | Exemplo | Resistê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 |
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:
| Algoritmo | Tempo para DICT (8k tentativas) | Ataque na prática |
|---|---|---|
| MD5 / NTLM | ~3 nanossegundos | Instantâneo |
| SHA-256 | ~24 nanossegundos | Instantâneo |
| bcrypt custo 10 | ~0,07 segundos | Trivial |
| bcrypt custo 14 | ~1 segundo | Viável |
| Argon2id (padrão) | ~8 segundos | Viável |
| Argon2id (parâmetros fortes) | ~100 segundos | Lento, mas possível |
16.4 Recomendações práticas
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 deHYBRID_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 coligadadescHybrid (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