O ataque de dicionário — Funcionamento detalhado
Documento de referência do projeto Time2Crack
Público: desenvolvedores, pesquisadores de segurança, usuários avançados
Índice
- Visão geral
- Contexto histórico e acadêmico
- Por que os dicionários funcionam
- Arquitetura de um ataque de dicionário moderno
- Corpora de senhas reais
- A verificação HIBP (k-anonimato)
- As listas de palavras por idioma do Time2Crack
- A posição no dicionário:
rankDictionary() - A des-leetificação
- Da posição ao tempo de quebra
- Comparação com os ataques derivados
- Limites do ataque de dicionário
- Defesas eficazes
- Referências
1. Visão geral
O ataque de dicionário é o método mais antigo de quebra de senhas, o mais simples de entender e, estatisticamente, o mais eficaz contra senhas humanas reais. Em vez de enumerar todas as combinações possíveis como a força bruta, ele testa uma lista de candidatos preparada de antemão — o «dicionário» — em ordem decrescente de probabilidade.
Por que funciona tão bem. As pessoas não escolhem suas senhas ao acaso. Décadas de vazamentos de dados mostram que as senhas reais são extremamente concentradas: no vazamento do RockYou, só 123456 era usada por 290.731 contas, cerca de 2% do total. Um ataque de dicionário bem montado testa esses candidatos primeiro e os encontra numa fração de segundo, onde a força bruta levaria anos.
O Time2Crack usa dois mecanismos independentes:
- A posição no dicionário, calculada localmente: a senha é uma das mais comuns, talvez disfarçada em leetspeak, ou uma palavra do dicionário do idioma escolhido? Essa posição dá os tempos de quebra exibidos na tabela de resultados.
- A verificação no Have I Been Pwned (HIBP): esta senha exata já apareceu em algum vazamento de dados? A resposta aparece num selo separado, acima dos resultados.
Os dois se complementam: o HIBP conhece as senhas que já vazaram, e as listas de palavras cobrem as palavras comuns que ainda não vazaram.
2. Contexto histórico e acadêmico
2.1 Origens
O ataque de dicionário é anterior à segurança informática moderna. Os primeiros sistemas Unix guardavam os hashes das senhas no arquivo /etc/passwd, legível por todos: quem pudesse lê-lo podia testar uma lista de palavras contra todas as contas.
| Ano | Acontecimento |
|---|---|
| 1979 | Morris e Thompson publicam o primeiro artigo acadêmico sobre a segurança das senhas no Unix; boa parte das senhas estudadas eram palavras ou nomes comuns. |
| 1988 | O worm Morris se propaga em parte adivinhando senhas com uma lista embutida de 432 palavras e depois com o dicionário do sistema /usr/share/dict/words. |
| 1991 | Crack (Alec Muffett): o primeiro quebrador de senhas Unix amplamente usado, com regras de transformação de palavras. |
| 1996 | O John the Ripper populariza o modo «lista de palavras + regras». |
| 2009 | Vazamento do RockYou: 32 milhões de contas armazenadas em texto puro (14,3 milhões de senhas distintas) revelam como as pessoas realmente escolhem suas senhas. |
| 2013 | Troy Hunt lança o Have I Been Pwned. No mesmo ano, o vazamento da Adobe expõe 153 milhões de contas cujas senhas estavam cifradas sem sal, o que permitia identificar as senhas idênticas. |
| 2015 | O Hashcat passa a ser código aberto; os ataques de dicionário em GPU ficam ao alcance de todos. |
| 2019 | «Collection #1–5»: bilhões de pares e-mail/senha reunidos a partir de vazamentos anteriores circulam publicamente. |
2.2 Os vazamentos fundadores
Alguns vazamentos transformaram o ataque de dicionário ao revelar a distribuição real das senhas humanas:
- RockYou (2009): 14,3 milhões de senhas distintas em texto puro. A senha n.º 1 (
123456) era usada por 290.731 contas, cerca de 2% do total. - LinkedIn (2012): de início foram publicados 6,5 milhões de hashes SHA-1 sem sal; mais tarde soube-se que o vazamento envolvia cerca de 117 milhões de contas.
- Adobe (2013): 153 milhões de contas; as dicas de senha guardadas em texto puro ajudaram a adivinhar as senhas mais comuns.
- Have I Been Pwned (de 2013 até hoje): uma compilação contínua de vazamentos públicos, hoje uma referência mundial.
2.3 Qual a velocidade de um ataque de dicionário?
Uma lista de 1 milhão de palavras, testada nas velocidades usadas pelo Time2Crack (12× RTX 5090, o perfil predefinido «Padrão»):
| Algoritmo | Velocidade | Tempo para 1 milhão de candidatos |
|---|---|---|
| NTLM | 4.081 GH/s | 0,25 microssegundo |
| MD5 | 2.634 GH/s | 0,38 microssegundo |
| SHA-1 | 837 GH/s | 1,2 microssegundo |
| SHA-256 | 332 GH/s | 3,0 microssegundos |
| bcrypt (custo 5) | 3.658 kH/s | 0,27 segundo |
| Argon2id | 1.000 H/s | cerca de 17 minutos |
O ataque de dicionário é, portanto, instantâneo contra as funções de hash rápidas (MD5, SHA-1, NTLM) e continua rápido mesmo contra o bcrypt.
3. Por que os dicionários funcionam
3.1 A lei de potência das senhas humanas
Todos os estudos empíricos chegam à mesma conclusão: as senhas humanas não se distribuem de modo uniforme. Elas seguem uma lei de potência (lei de Zipf): umas poucas senhas concentram uma parte desproporcional das escolhas.
Formalmente: se ordenarmos as senhas por frequência decrescente, a frequência da senha de posição r é aproximadamente proporcional a r−s, em que o expoente s depende do corpus (Wang et al., 2017).
Consequência direta: um atacante que testa só as 10 senhas mais comuns já tem cerca de uma chance em 20 de acertar uma conta qualquer.
3.2 Vieses cognitivos na criação de senhas
As pessoas seguem hábitos previsíveis ao criar uma senha:
- Facilidade de memorização: palavras fáceis de lembrar (substantivos comuns, nomes próprios, cultura pop) são super-representadas.
- Disponibilidade: a senha reflete o ambiente imediato (nome do animal de estimação, time de futebol, personagem favorito).
- Substituições previsíveis: e → 3, a → @, o → 0. O usuário acha que a senha ficou mais forte, mas são as primeiras substituições que um atacante testa.
- Acréscimos no fim: um algarismo ou símbolo no fim de uma palavra (
password1,borboleta!). - Idioma e cultura: as senhas comuns dependem do idioma do usuário (
Soleil123na França,Sommer123na Alemanha).
3.3 Duas maneiras de estar «nas listas»
Uma senha pode constar de uma lista de ataque por dois motivos diferentes:
- Ela já vazou. A senha exata apareceu num vazamento anterior. O atacante não precisa adivinhar: testa as senhas conhecidas por ordem de frequência.
- É uma palavra comum. Mesmo que nunca tenha vazado, está em todas as listas de ataque porque é uma candidata óbvia. Uma palavra como
borboletapode não estar no HIBP, mas está na lista portuguesa de qualquer ferramenta séria de quebra de senhas.
Esses dois casos correspondem aos dois mecanismos do Time2Crack descritos mais adiante.
4. Arquitetura de um ataque de dicionário moderno
4.1 Desenrolar geral
Um ataque de dicionário moderno se desenrola em quatro fases:
Fase 1: montar a lista de palavras
├── Senhas vazadas (HIBP, RockYou, compilações)
├── Listas por idioma (dicionários, nomes próprios, lugares)
├── Listas temáticas (esporte, cultura pop, tecnologia, religião)
└── Listas direcionadas (domínio da empresa, nomes dos funcionários)
Fase 2: preparar a lista
├── Ordenar por frequência (as mais prováveis primeiro)
├── Remover duplicatas
├── Filtrar por comprimento (comprimento-alvo ± 2)
└── Normalizar (minúsculas, Unicode NFC)
Fase 3: calcular o hash e comparar
para cada candidato w da lista:
se hash(w) == hash_alvo: encontrada
(bilhões de candidatos por segundo em GPU com MD5)
Fase 4: balanço
└── Senhas quebradas, estatísticas de cobertura
4.2 Otimizações de hardware
Os ataques de dicionário modernos rodam de forma massivamente paralela em GPUs:
- Hashcat (a ferramenta de referência) usa milhares de núcleos de GPU para calcular bilhões de hashes por segundo.
- Processamento em lotes: os candidatos são enviados à GPU em lotes de milhões para mantê-la sempre ocupada.
- Regras na GPU: as regras de transformação são aplicadas diretamente na GPU; assim, uma lista curta gera bilhões de candidatos sem precisar armazená-los.
Para uma lista de 1 bilhão de senhas vazadas em 12× RTX 5090:
- MD5: 109 / 2.634 × 109 ≈ 0,4 milissegundo
- bcrypt (custo 5): 109 / 3.658.000 ≈ 5 minutos
Essa diferença de cerca de seis ordens de grandeza entre MD5 e bcrypt mostra o quanto a escolha do algoritmo de hash importa.
4.3 A ordem dos candidatos
A lista não é testada em ordem alfabética, mas por probabilidade decrescente:
- As senhas vazadas mais comuns (as 100 primeiras do RockYou)
- As senhas presentes em muitos vazamentos (ordenadas pela frequência no HIBP)
- As palavras comuns do idioma-alvo
- Os nomes próprios (nomes de pessoas, cidades, celebridades)
- Os termos ligados ao alvo
- As variantes e formas flexionadas
Com essa ordem, uma senha fraca é encontrada nos primeiros milissegundos, seja qual for a velocidade do hash.
5. Corpora de senhas reais
5.1 Have I Been Pwned (HIBP)
- Tamanho: mais de um bilhão de senhas distintas, vindas de mais de 14 bilhões de contas comprometidas
- Fonte: compilação de vazamentos públicos desde 2013
- Formato: hashes SHA-1 (e NTLM) com o número de vezes que cada senha foi vista
- Acesso: API com k-anonimato; os defensores podem baixar a lista completa
O HIBP é a referência mundial porque cobre quase todos os grandes vazamentos públicos, indica a frequência de cada senha e é mantido ativamente. Um atacante com a lista completa pode testar primeiro as senhas mais frequentes.
5.2 RockYou (2009): o corpus fundador
14,3 milhões de senhas distintas em texto puro. O topo da lista:
| Posição | Senha | Contas | Parcela |
|---|---|---|---|
| 1 | 123456 | 290.731 | 2,03% |
| 2 | 12345 | 79.078 | 0,55% |
| 3 | 123456789 | 76.790 | 0,54% |
| 4 | password | 59.462 | 0,42% |
| 5 | iloveyou | 49.952 | 0,35% |
A reter: um punhado de candidatos, testados em poucos nanossegundos contra MD5, basta para comprometer uma parte mensurável das contas de um banco de dados vazado.
5.3 Coleções de listas especializadas
- SecLists (Daniel Miessler): uma coleção de código aberto de listas para testes de segurança — senhas vazadas, senhas por idioma, termos técnicos, nomes.
- CrackStation: cerca de 1,5 bilhão de entradas, incluindo todas as palavras da Wikipédia em vários idiomas.
- Weakpass: compilações muito grandes de senhas reais vazadas.
Esses corpora podem ser baixados publicamente: sua existência é um fato estabelecido da segurança ofensiva.
6. A verificação HIBP (k-anonimato)
6.1 O protocolo de k-anonimato
O Time2Crack verifica a senha no HIBP sem nunca enviá-la, nem ela nem o seu hash completo. O protocolo funciona assim:
1. Calcular SHA-1(senha)
→ ex.: CBFDAC6008F9CAB4083784CBD1874F76618D2A97
2. Enviar só os 5 primeiros caracteres à API do HIBP
→ GET https://api.pwnedpasswords.com/range/CBFDA
3. A API devolve todos os sufixos de hash que começam por esse prefixo
(várias centenas de linhas, completadas com entradas falsas)
4. Procurar o resto do hash na resposta, localmente
→ C6008F9CAB4083784CBD1874F76618D2A97
5. Encontrado: a senha vazou, e o HIBP diz quantas vezes
Não encontrado: a senha não está no HIBP
Garantia de privacidade: o servidor do HIBP só vê um prefixo de 5 caracteres compartilhado por centenas de senhas. Ele não pode saber qual senha foi verificada. A comparação é feita no navegador.
6.2 A implementação no Time2Crack
A verificação começa meio segundo depois da última tecla digitada, em paralelo com a análise local:
// app.js - checkHIBP()
async function checkHIBP(password) {
const sha1 = await sha1Hex(password); // uppercase hex SHA-1
const prefix = sha1.slice(0, 5); // sent to the API
const suffix = sha1.slice(5); // never leaves the browser
const res = await fetch(`https://api.pwnedpasswords.com/range/${prefix}`, {
headers: { "Add-Padding": "true" }, // hide the real size of the response
});
if (!res.ok) return null; // API unavailable
const text = await res.text();
for (const line of text.split("\n")) {
const [hashSuffix, count] = line.trim().split(":");
if (hashSuffix === suffix) return parseInt(count, 10); // number of leaks
}
return 0; // not found
}
O resultado aparece num selo: «encontrada N vezes», «não encontrada» ou «indisponível» quando a API não responde. Ele não altera os tempos de quebra, que são calculados localmente.
6.3 Como ler o contador do HIBP
O contador é o número de vezes que esta senha exata foi vista nos vazamentos indexados:
| Contador | Significado |
|---|---|
| Mais de 1.000.000 | Entre as senhas mais usadas do mundo: todo atacante a testa primeiro |
| De 10.000 a 1.000.000 | Muito comum |
| De 1.000 a 10.000 | Comum |
| De 100 a 1.000 | Pouco comum, mas conhecida |
| De 1 a 100 | Rara, mas comprometida |
Mesmo um contador de 1 é um alerta: a senha está nas listas de que os atacantes dispõem, e quem atacar a conta de onde ela vazou vai testá-la.
7. As listas de palavras por idioma do Time2Crack
7.1 Por que listas por idioma além do HIBP
O HIBP cobre as senhas que já vazaram, não as palavras comuns que ainda não vazaram. Quem escolhe girassol talvez não esteja no HIBP, mas a palavra está na lista portuguesa de qualquer atacante que mire usuários lusófonos. As listas por idioma do Time2Crack preenchem essa lacuna:
| Idioma | Arquivo | Palavras |
|---|---|---|
| Inglês | en.txt.gz | 748.958 |
| Francês | fr.txt.gz | 550.235 |
| Espanhol | es.txt.gz | 284.834 |
| Português | pt.txt.gz | 507.721 |
| Alemão | de.txt.gz | 2.009.880 |
| Italiano | it.txt.gz | 3.252.670 |
| Neerlandês | nl.txt.gz | 2.678.323 |
| Polonês | pl.txt.gz | 3.670.705 |
| Turco | tr.txt.gz | 400.442 |
| Total | 14.103.768 |
As primeiras versões vinham das listas de palavras da Wikipédia do SecLists e das listas de kkrypt0nn; desde então foram ampliadas. No carregamento, cada linha tem os espaços removidos e é passada para minúsculas, e as palavras com menos de 3 caracteres são descartadas.
7.2 Carregamento sob demanda
As listas não vêm incluídas no código. Só a lista do idioma escolhido é baixada, na primeira vez que for necessária, como arquivo gzip:
// app.js - loadDictionary() (simplified: progress bar updates removed)
async function loadDictionary(lang = AppConfig.lang) {
// Already loaded for this language
if (AppConfig.dictWords !== null && AppConfig.dictLang === lang) return;
// 1. Local cache (IndexedDB)
const cached = await cacheGet(`dict_${lang}`);
if (cached) {
AppConfig.setDictionary(new Set(cached), lang);
return;
}
// 2. Download the compressed list
const res = await fetch(`${basePath}data/wordlists/${lang}.txt.gz`);
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const buffer = await res.arrayBuffer();
// 3. Decompress in the browser (plain .txt if DecompressionStream is missing)
let text;
try {
text = await new Response(
ReadableStream.from([new Uint8Array(buffer)])
.pipeThrough(new DecompressionStream("gzip"))
).text();
} catch {
text = await (await fetch(`${basePath}data/wordlists/${lang}.txt`)).text();
}
// 4. Normalise, filter, index
const words = text.split("\n")
.map(w => w.trim().toLowerCase())
.filter(w => w.length >= 3);
AppConfig.setDictionary(new Set(words), lang);
// 5. Keep it for the next visit
await cachePut(`dict_${lang}`, words);
}
Por que um Set? Um Set do JavaScript responde a dictWords.has(word) em tempo constante, quer a lista tenha 285.000 palavras (espanhol) ou 3,7 milhões (polonês). Com um Array, cada busca poderia exigir uma comparação por palavra.
7.3 Cache local (IndexedDB)
A lista preparada é guardada no IndexedDB do navegador com a chave dict_<idioma>. Na visita seguinte, ela é lida do cache em vez de ser baixada e descompactada de novo:
Primeira visita Visitas seguintes
--------------- -----------------
fetch pt.txt.gz cacheGet("dict_pt")
└── gunzip (DecompressionStream) └── new Set(words)
└── trim / minúsculas / ≥ 3 └── pronta
└── new Set(words)
└── cachePut("dict_pt")
└── pronta
A senha nunca sai do navegador: a lista é baixada do servidor do Time2Crack e a comparação é feita localmente.
8. A posição no dicionário: rankDictionary()
8.1 O princípio: uma posição, depois um tempo
O Time2Crack não se pergunta apenas «é uma palavra do dicionário?», mas «depois de quantas tentativas um ataque de dicionário a encontraria?». Esse número de tentativas é a posição (rank). A função rankDictionary() (arquivo core/rank/dictionary.js) a devolve, ou devolve null quando o ataque não se aplica:
// core/rank/dictionary.js - rankDictionary()
export function rankDictionary(password, dictWords = null) {
const lower = password.toLowerCase();
const deleeted = deleet(password);
const alpha = password.replace(/[^a-zA-Z]/g, "");
const uCost = uppercaseCost(alpha); // capital letters, see 8.3
// 1. In the top passwords as is?
const topIdx = TOP_PASSWORDS.indexOf(lower);
if (topIdx !== -1) return { rank: (topIdx + 1) * uCost, model: "dictionary" };
// 2. De-leeted form in the top passwords?
const deIdx = TOP_PASSWORDS.indexOf(deleeted);
if (deIdx !== -1) return { rank: (deIdx + 1) * 10 * uCost, model: "dictionary" };
// 3. In the wordlist of the selected language?
if (dictWords instanceof Set) {
if (dictWords.has(lower) || dictWords.has(deleeted)) {
const mid = Math.floor(dictWords.size / 2);
if (passwordLength(password) >= 9) {
// a long word may also be split into shorter words, see 8.4
const compound = rankGermanCompound(password, dictWords);
if (compound && compound.rank < mid)
return { rank: compound.rank * uCost, model: "dictionary" };
}
return { rank: mid * uCost, model: "dictionary" };
}
// 4. Compound made of several dictionary words?
const compound = rankGermanCompound(password, dictWords);
if (compound) return { rank: compound.rank * uCost, model: "dictionary" };
}
// Not found: the dictionary attack does not apply
return { rank: null, model: "dictionary" };
}
8.2 Quatro níveis
| Nível | Regra | Exemplo | Posição |
|---|---|---|---|
| 1. Senhas mais comuns | Posição numa lista de 105 das senhas mais comuns (RockYou, HIBP) | password | 2 |
| 2. Variante em leetspeak | Posição da forma des-leetificada × 10 | p@ssw0rd | 20 |
| 3. Lista do idioma | Metade do tamanho da lista | soleil (francês) | 275.117 |
| 4. Palavra composta | Ver 8.4 | apfelbaumkuchen (alemão) | 21.129 |
Por que metade da lista? As listas não estão ordenadas por frequência: a posição de uma palavra no arquivo não diz nada sobre quando um atacante a testaria. Em média, um atacante que percorre a lista encontra uma dada palavra na metade do caminho.
8.3 As maiúsculas
Um atacante começa pelas palavras em minúsculas e depois testa as variantes com maiúsculas. A posição é multiplicada pelo número de variantes necessárias para chegar à grafia da senha (função uppercaseCost(), mesmo método do zxcvbn):
| Maiúsculas | Multiplicador | Exemplo | Posição |
|---|---|---|---|
| Tudo em minúsculas | × 1 | soleil | 275.117 |
| Só a primeira letra | × 2 | Soleil | 550.234 |
| Só a última letra | × 2 | soleiL | 550.234 |
| Tudo em maiúsculas | × 2 | PASSWORD | 4 |
| Qualquer outra mistura | soma de C(n, i) para i = 1 … mín(maiúsculas, minúsculas) | PaSsWoRd | 324 |
8.4 As palavras compostas
O alemão (e o neerlandês) junta as palavras umas às outras: Apfelbaumkuchen = Apfel + Baum + Kuchen. Uma palavra assim costuma faltar na lista, mas um atacante pode construí-la combinando palavras mais curtas. O Time2Crack tenta dividir a senha em 2 a 4 palavras da lista, admitindo as letras de ligação habituais do alemão (-s-, -es-, -n-, -en-, -er-, -e-). A posição é então a posição por máscara da senha multiplicada por 0,25 (2 palavras), 0,16 (3 palavras) ou 0,10 (4 palavras), e por 0,75 quando o último pedaço é um sufixo comum (-heit, -ung, -haus…).
A divisão também é tentada nas palavras longas que estão na lista (9 caracteres ou mais) e mantida se der uma posição mais baixa: Sonnenblume recebe a posição 42.680 em vez da metade da lista alemã (1.004.940).
9. A des-leetificação
9.1 O leetspeak não protege
O leetspeak troca letras por algarismos ou símbolos parecidos: a → @, e → 3, i → 1, o → 0, s → $. É usado para «reforçar» uma palavra comum: password → p@$$w0rd.
Na realidade, essas substituições estão entre as primeiras regras aplicadas pelas ferramentas de quebra. Elas não atrasam um atacante competente.
9.2 A função deleet()
// core/rank/dictionary.js - deleet()
function deleet(pw) {
return pw
.toLowerCase()
.replace(/0/g, "o")
.replace(/1/g, "i")
.replace(/3/g, "e")
.replace(/4/g, "a")
.replace(/5/g, "s")
.replace(/7/g, "t")
.replace(/8/g, "b")
.replace(/@/g, "a")
.replace(/\$/g, "s")
.replace(/!/g, "i");
}
A senha é procurada tal como foi digitada e na forma des-leetificada. Entre as senhas mais comuns, a forma des-leetificada custa 10 vezes mais (o atacante precisa testar as variantes): p@ssw0rd → 20 em vez de 2. Na lista do idioma, custa o mesmo que a palavra simples.
9.3 O que não é decodificado
- Cada caractere tem uma só substituição:
1vira semprei, nuncal; por issop1ayernão é reconhecida comoplayer. - As substituições mais raras (
+→ t,9→ g,#→ h) não são decodificadas. - Uma palavra seguida de algarismos ou símbolos (
borboleta2024,borboleta!) não é uma correspondência de dicionário: quem cuida dela é o ataque híbrido.
10. Da posição ao tempo de quebra
A posição é convertida em segundos dividindo-a pela velocidade de hash do atacante:
// core/time.js - rankToSeconds()
export function rankToSeconds(rank, algo, profile = "experienced") {
const baseRate = HASH_RATES[algo]; // guesses per second, 12× RTX 5090
if (!baseRate) throw new Error(`Unknown algorithm: ${algo}`);
const multiplier = ATTACKER_MULTIPLIERS[profile] ?? 1;
return rank / (baseRate * multiplier);
}
Exemplo para soleil (lista francesa, posição 275.117) com o perfil padrão:
| Algoritmo | Velocidade (12× RTX 5090) | Cálculo | Tempo |
|---|---|---|---|
| NTLM | 4.081 GH/s | 275.117 / 4.081 × 109 | 67 nanossegundos |
| MD5 | 2.634 GH/s | 275.117 / 2.634 × 109 | 104 nanossegundos |
| SHA-1 | 837 GH/s | 275.117 / 837 × 109 | 329 nanossegundos |
| SHA-256 | 332 GH/s | 275.117 / 332 × 109 | 829 nanossegundos |
| bcrypt (custo 5) | 3.658 kH/s | 275.117 / 3.658.000 | 0,08 segundo |
| Argon2id | 1.000 H/s | 275.117 / 1.000 | 4 minutos e 35 segundos |
Mesmo com Argon2id, uma simples palavra francesa cai em menos de 5 minutos. O perfil do atacante muda as velocidades: de uma única GPU (perfil «Amador») até cerca de 10.000 GPUs (perfil «Estado»). Como em todos os outros modelos, a posição no dicionário nunca pode passar da posição por força bruta da mesma senha.
11. Comparação com os ataques derivados
O ataque de dicionário «puro» é o primeiro de uma família de ataques que partem todos de uma lista de palavras. O Time2Crack calcula nove modelos (força bruta, dicionário, híbrido, máscara, PCFG, Markov, combinador, padrões de teclado, datas), cada um atacando a senha por um ângulo diferente.
11.1 Dicionário e híbrido
| Critério | Dicionário | Híbrido (dicionário + regras) |
|---|---|---|
| Candidatos | As palavras da lista, tal como estão | Cada palavra com suas transformações (algarismos, símbolos, maiúsculas…) |
| Exemplos quebrados | password, borboleta | P@ssw0rd!, borboleta2024 |
| Velocidade | Menos candidatos, portanto mais rápido | Cobertura muito mais ampla |
| Aplica-se quando | A palavra exata está na lista | A senha deriva de uma palavra da lista |
O ataque híbrido começa onde termina o dicionário puro: aplica regras de transformação sistemáticas a cada palavra da lista (no espírito do best64.rule do hashcat).
11.2 Dicionário e PCFG
| Critério | Dicionário | PCFG |
|---|---|---|
| Modelo | Lista fixa de candidatos | Gramática probabilística das estruturas de senha |
| Ponto forte | Palavras exatas | Estruturas como palavra + algarismos, maiúscula + minúsculas + símbolo |
| Exemplo | password ✓ | Password123 ✓ (estrutura reconhecida) |
Password123 não é uma palavra do dicionário como tal, mas o PCFG reconhece sua estrutura [maiúscula][minúsculas][algarismos] e a quebra muito depressa.
11.3 Dicionário e Markov
| Critério | Dicionário | Markov |
|---|---|---|
| Candidatos | Lista preparada de antemão | Gerados na hora por um modelo estatístico |
| Cobertura | Vocabulário conhecido | Qualquer sequência que «pareça humana» |
| Vantagem | Muito rápido com palavras exatas | Cobre também palavras ausentes das listas |
O Markov cobre as senhas que parecem palavras humanas sem constar de nenhuma lista.
11.4 Dicionário e credential stuffing
| Critério | Dicionário | Credential stuffing |
|---|---|---|
| Objetivo | Quebrar um hash | Entrar numa conta |
| Mecanismo | Cálculo de hashes local | Tentativas de login remotas |
| Fonte | Lista de palavras genérica | Pares e-mail/senha vazados |
| Defesa | Algoritmo de hash lento | Limitação de tentativas, MFA, bloqueio de IP |
O credential stuffing não ataca um hash: testa diretamente pares e-mail/senha vazados em serviços online. É outro ataque, mas usa os mesmos dados (vazamentos como os indexados pelo HIBP). O Time2Crack não o modela.
12. Limites do ataque de dicionário
12.1 Limites intrínsecos
- Só vocabulário conhecido. Uma senha inventada, que não se parece com nenhuma palavra existente e nunca vazou, escapa ao ataque de dicionário puro:
Xqz7mK9pLnão está em lista nenhuma. - Cobertura de idiomas. Um atacante que mira lusófonos sem uma lista portuguesa vai deixar passar palavras como
girassolousaudade. - Senhas novas. Uma senha que nunca vazou não está no HIBP, mesmo que seja comum.
- Frases-senha longas.
MinhaGrandeAventuraSobAsEstrelasnão está em lista nenhuma, ainda que cada palavra seja banal. As frases-senha são tratadas por outros ataques (combinador, PRINCE).
12.2 O que o Time2Crack não modela
- Listas direcionadas: um atacante que mira um setor monta listas específicas (termos médicos para um hospital, gíria de jogadores para uma plataforma de jogos). Ferramentas como o CeWL extraem as palavras do site do alvo. O Time2Crack usa listas genéricas.
- Vazamentos recentes: entre um vazamento e sua inclusão no HIBP, as senhas circulam em privado sem ficar visíveis pela API pública.
- Outros algoritmos de hash: o Time2Crack modela seis algoritmos (MD5, SHA-1, SHA-256, NTLM, bcrypt, Argon2id). SHA-512, scrypt ou PBKDF2 têm perfis diferentes.
- Frequência das palavras: toda palavra da lista do idioma recebe a mesma posição (metade da lista), seja ela muito comum ou muito rara.
13. Defesas eficazes
13.1 O que protege
Um algoritmo de hash lento (bcrypt, Argon2id). É a defesa mais eficaz do lado do servidor: cada tentativa custa mais. Para soleil (posição 275.117):
- MD5: cerca de 0,1 microssegundo
- bcrypt custo 12 (128 vezes mais lento que o custo 5): cerca de 10 segundos
- Argon2id: cerca de 5 minutos
Um hash lento freia o atacante, mas não salva uma palavra do dicionário: a lista é simplesmente curta demais.
Um sal único por conta. Torna inúteis as tabelas pré-calculadas (rainbow tables) e obriga o atacante a trabalhar conta por conta. Não impede um ataque com lista de palavras contra uma única conta.
Comprimento e acaso. Uma única palavra do dicionário é sempre vulnerável. Uma frase-senha de 4 ou 5 palavras resiste ao ataque de dicionário puro, mas não ao ataque combinador se as palavras forem previsíveis: elas devem ser sorteadas.
Senhas geradas aleatoriamente. A verdadeira solução: um gerenciador de senhas que gere senhas longas e aleatórias (20 caracteres ou mais). Elas não estão em nenhum dicionário.
Autenticação multifator (MFA). Não impede a quebra offline de hashes roubados, mas impede o atacante de entrar com uma senha quebrada.
Limitação de tentativas e detecção de anomalias. Protegem contra tentativas online, não contra a quebra offline de hashes roubados.
13.2 O que não protege
- As substituições em leetspeak:
password→p@ssw0rd(ver a seção 9). - Um algarismo no fim:
password→password1, entre as primeiras regras testadas. - Uma maiúscula inicial:
password→Password, uma regra padrão (posição × 2). - Algarismos e símbolos em volta de uma palavra reconhecível:
borboleta!é encontrada com as regras mais básicas. - Complexidade sem comprimento:
P@s1wcumpre as regras habituais (maiúscula, minúscula, algarismo, símbolo), mas é mais curta e mais previsível quecorrecthorsebatterystaple.
13.3 Recomendações práticas
- Use um gerenciador de senhas (Bitwarden, 1Password, KeePass): ele gera senhas aleatórias e você só precisa lembrar a senha mestra.
- Ative a MFA em todo lugar: mesmo que uma senha vaze, o atacante não consegue entrar.
- Consulte o HIBP regularmente para saber se o seu endereço de e-mail aparece em vazamentos conhecidos.
- Nunca reutilize uma senha: o credential stuffing explora a reutilização entre serviços.
- Para as senhas que você precisa memorizar: uma frase-senha de 5 palavras ou mais, sorteadas (com dados ou um gerador), não escolhidas.
14. Referências
Fontes acadêmicas
- Morris, R., & Thompson, K. (1979). Password security: A case history. Communications of the ACM, 22(11), 594–597. Primeira análise acadêmica das senhas do Unix.
- Klein, D. V. (1990). Foiling the cracker: A survey of, and improvements to, password security. Proceedings of the 2nd USENIX Security Workshop. Cerca de um quarto de 15.000 senhas Unix quebradas com listas de palavras e regras.
- Weir, M., Aggarwal, S., de Medeiros, B., & Glodek, B. (2009). Password cracking using probabilistic context-free grammars. IEEE Symposium on Security and Privacy. O artigo fundador do PCFG, comparado com os ataques de dicionário.
- Ur, B., et al. (2012). How does your password measure up? The effect of strength meters on password creation. 21st USENIX Security Symposium.
- Bonneau, J. (2012). The science of guessing: Analyzing an anonymized corpus of 70 million passwords. IEEE Symposium on Security and Privacy. Mede a distribuição real das senhas.
- Ma, J., Yang, W., Luo, M., & Li, N. (2014). A study of probabilistic password models. IEEE Symposium on Security and Privacy. Compara os modelos de dicionário, Markov e PCFG em corpora reais.
- Wheeler, D. L. (2016). zxcvbn: Low-budget password strength estimation. 25th USENIX Security Symposium, 157–173. Origem do custo das maiúsculas usado na seção 8.3.
- Wang, D., Cheng, H., Wang, P., Huang, X., & Jian, G. (2017). Zipf's law in passwords. IEEE Transactions on Information Forensics and Security, 12(11), 2776–2791.
- Pasquini, D., Cianfriglia, M., Ateniese, G., & Bernaschi, M. (2021). Reducing bias in modeling real-world password strength via deep learning and dynamic dictionaries. 30th USENIX Security Symposium.
Fontes do setor
- Have I Been Pwned. Pwned Passwords. https://haveibeenpwned.com/Passwords. A API com k-anonimato usada pelo Time2Crack.
- Hive Systems (2025). Password table. Edição 2025 baseada em 12× RTX 5090. O Time2Crack usa benchmarks do hashcat medidos na RTX 5090 (Specops 2026, fórum hashcat.net); o Argon2id continua a ser uma estimativa.
- Hashcat. Advanced password recovery. https://hashcat.net. Ferramenta de referência para medições em GPU e regras de transformação (
best64.rule). - Miessler, D. SecLists. GitHub. Origem das primeiras listas por idioma do Time2Crack.
Contexto
- Hunt, T. (2017). Introducing 306 million freely downloadable Pwned Passwords. troyhunt.com.
- Thomas, K., et al. (2019). Protecting accounts from credential stuffing with password breach alerting. 28th USENIX Security Symposium. Mostra que o k-anonimato protege a privacidade.
Código-fonte: core/rank/dictionary.js (rankDictionary, deleet), core/rank/uppercase.js (uppercaseCost), core/time.js (rankToSeconds), app.js (loadDictionary, checkHIBP).