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

  1. Visão geral
  2. Contexto histórico e acadêmico
  3. Por que os dicionários funcionam
  4. Arquitetura de um ataque de dicionário moderno
  5. Corpora de senhas reais
  6. A verificação HIBP (k-anonimato)
  7. As listas de palavras por idioma do Time2Crack
  8. A posição no dicionário: rankDictionary()
  9. A des-leetificação
  10. Da posição ao tempo de quebra
  11. Comparação com os ataques derivados
  12. Limites do ataque de dicionário
  13. Defesas eficazes
  14. 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:

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.

AnoAcontecimento
1979Morris 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.
1988O 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.
1991Crack (Alec Muffett): o primeiro quebrador de senhas Unix amplamente usado, com regras de transformação de palavras.
1996O John the Ripper populariza o modo «lista de palavras + regras».
2009Vazamento 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.
2013Troy 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.
2015O 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:

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

AlgoritmoVelocidadeTempo para 1 milhão de candidatos
NTLM4.081 GH/s0,25 microssegundo
MD52.634 GH/s0,38 microssegundo
SHA-1837 GH/s1,2 microssegundo
SHA-256332 GH/s3,0 microssegundos
bcrypt (custo 5)3.658 kH/s0,27 segundo
Argon2id1.000 H/scerca 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:

3.3 Duas maneiras de estar «nas listas»

Uma senha pode constar de uma lista de ataque por dois motivos diferentes:

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:

Para uma lista de 1 bilhão de senhas vazadas em 12× RTX 5090:

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:

  1. As senhas vazadas mais comuns (as 100 primeiras do RockYou)
  2. As senhas presentes em muitos vazamentos (ordenadas pela frequência no HIBP)
  3. As palavras comuns do idioma-alvo
  4. Os nomes próprios (nomes de pessoas, cidades, celebridades)
  5. Os termos ligados ao alvo
  6. 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)

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çãoSenhaContasParcela
1123456290.7312,03%
21234579.0780,55%
312345678976.7900,54%
4password59.4620,42%
5iloveyou49.9520,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

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:

ContadorSignificado
Mais de 1.000.000Entre as senhas mais usadas do mundo: todo atacante a testa primeiro
De 10.000 a 1.000.000Muito comum
De 1.000 a 10.000Comum
De 100 a 1.000Pouco comum, mas conhecida
De 1 a 100Rara, 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:

IdiomaArquivoPalavras
Inglêsen.txt.gz748.958
Francêsfr.txt.gz550.235
Espanholes.txt.gz284.834
Portuguêspt.txt.gz507.721
Alemãode.txt.gz2.009.880
Italianoit.txt.gz3.252.670
Neerlandêsnl.txt.gz2.678.323
Polonêspl.txt.gz3.670.705
Turcotr.txt.gz400.442
Total14.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ívelRegraExemploPosição
1. Senhas mais comunsPosição numa lista de 105 das senhas mais comuns (RockYou, HIBP)password2
2. Variante em leetspeakPosição da forma des-leetificada × 10p@ssw0rd20
3. Lista do idiomaMetade do tamanho da listasoleil (francês)275.117
4. Palavra compostaVer 8.4apfelbaumkuchen (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úsculasMultiplicadorExemploPosição
Tudo em minúsculas× 1soleil275.117
Só a primeira letra× 2Soleil550.234
Só a última letra× 2soleiL550.234
Tudo em maiúsculas× 2PASSWORD4
Qualquer outra misturasoma de C(n, i) para i = 1 … mín(maiúsculas, minúsculas)PaSsWoRd324

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


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:

AlgoritmoVelocidade (12× RTX 5090)CálculoTempo
NTLM4.081 GH/s275.117 / 4.081 × 10967 nanossegundos
MD52.634 GH/s275.117 / 2.634 × 109104 nanossegundos
SHA-1837 GH/s275.117 / 837 × 109329 nanossegundos
SHA-256332 GH/s275.117 / 332 × 109829 nanossegundos
bcrypt (custo 5)3.658 kH/s275.117 / 3.658.0000,08 segundo
Argon2id1.000 H/s275.117 / 1.0004 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érioDicionárioHíbrido (dicionário + regras)
CandidatosAs palavras da lista, tal como estãoCada palavra com suas transformações (algarismos, símbolos, maiúsculas…)
Exemplos quebradospassword, borboletaP@ssw0rd!, borboleta2024
VelocidadeMenos candidatos, portanto mais rápidoCobertura muito mais ampla
Aplica-se quandoA palavra exata está na listaA 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érioDicionárioPCFG
ModeloLista fixa de candidatosGramática probabilística das estruturas de senha
Ponto fortePalavras exatasEstruturas como palavra + algarismos, maiúscula + minúsculas + símbolo
Exemplopassword ✓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érioDicionárioMarkov
CandidatosLista preparada de antemãoGerados na hora por um modelo estatístico
CoberturaVocabulário conhecidoQualquer sequência que «pareça humana»
VantagemMuito rápido com palavras exatasCobre 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érioDicionárioCredential stuffing
ObjetivoQuebrar um hashEntrar numa conta
MecanismoCálculo de hashes localTentativas de login remotas
FonteLista de palavras genéricaPares e-mail/senha vazados
DefesaAlgoritmo de hash lentoLimitaçã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

12.2 O que o Time2Crack não modela


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

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

13.3 Recomendações práticas


14. Referências

Fontes acadêmicas

Fontes do setor

Contexto


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