Como Usar o Hashcat: Modos de Ataque e Exemplos (2026)

O que o Hashcat faz

Hashcat é uma ferramenta open source de recuperação de senhas que pega um hash criptográfico, gera senhas candidatas, aplica o mesmo algoritmo em cada candidata e informa quando há correspondência. Ele suporta mais de 400 tipos de hash e roda em hardware NVIDIA, AMD, Apple e Intel pelos backends CUDA, HIP, Metal e OpenCL.

O que torna o Hashcat relevante é o paralelismo. Uma CPU testa candidatas em algumas dezenas de threads; uma GPU moderna testa dezenas de milhares ao mesmo tempo. As próprias notas de versão do Hashcat medem o Argon2 (modo 34000) em 1.703 hashes por segundo numa RTX 4090 contra 92 num Ryzen 9 9900X, uma diferença de cerca de 18x em um dos algoritmos mais lentos em circulação. Em um hash rápido e sem sal como o NTLM, a diferença é ainda maior.

A versão 7.0, lançada em agosto de 2025, foi a primeira versão principal em mais de dois anos. Ela trouxe identificação automática de tipos de hash, suporte a Argon2 e a Assimilation Bridge para empurrar trabalho para CPUs, FPGAs e Python embarcado. As notas da v7.0.0 merecem uma leitura.

Uma opinião firme antes de seguir: não comece decorando a tabela de referência dos modos. Todo tutorial empurra você a memorizar que -m 1000 é NTLM e -m 1800 é sha512crypt. Você vai absorver naturalmente a dúzia de modos que realmente encontra, e o Hashcat 7 informa o resto. Invista esse esforço em regras e máscaras, porque é de lá que vêm as taxas de sucesso.

Instalar o Hashcat e conferir se a GPU responde

No Kali, Parrot e na maioria dos derivados do Debian, o pacote está nos repositórios:

sudo apt install hashcat
hashcat --version

No macOS, o Hashcat 7 usa o backend Metal, que substituiu o caminho OpenCL abandonado pela Apple. Instale com brew install hashcat. No Windows, baixe o arquivo binário em hashcat.net, extraia e rode hashcat.exe pelo terminal dentro dessa pasta. Não existe instalador, o que costuma surpreender.

Agora o passo que quase todo mundo pula. Confirme que o Hashcat enxerga sua GPU:

$ hashcat -I
Backend Device ID #1 (Alias: #2)
  Type...........: GPU
  Vendor.........: NVIDIA Corporation
  Name...........: NVIDIA GeForce RTX 4070
  Processor(s)...: 46
  Memory.Total...: 12282 MB

Se o único dispositivo listado for a CPU, o Hashcat ainda roda, e devagar o suficiente para você concluir que a ferramenta está quebrada. A causa habitual é rodar o Kali dentro do VirtualBox ou do VMware, onde o convidado nunca recebe acesso real à GPU. O passthrough de GPU é possível e raramente vale a tarde que custa.

Assim que a GPU aparecer, meça o desempenho para ter uma referência:

hashcat -b -m 1000     # apenas NTLM
hashcat -b              # todos os modos, demora

Anote o número do NTLM. Quando uma execução futura parecer lenta, essa referência diz em segundos se o problema é o driver ou apenas um algoritmo lento.

Encontrar o modo de hash certo

A flag -m diz ao Hashcat qual algoritmo gerou seu hash. Erre nela e o Hashcat ou se recusa a carregar o arquivo ou moe bilhões de candidatas que jamais poderiam corresponder. No Hashcat 7, basta omitir o -m:

$ hashcat -a 0 hash.txt rockyou.txt
The following hash-mode match the structure of your input hash:
      # | Name                     | Category
  ======+==========================+===========
   1000 | NTLM                     | Operating System
   ...

Quando apenas um modo corresponde, o Hashcat segue automaticamente. Quando vários correspondem, ele lista as opções e pede que você escolha. Também dá para pedir a lista sem iniciar a execução:

hashcat --identify hash.txt

O limite merece ser citado direto da documentação: "Auto-detect is best effort. The correct hash-mode is NOT guaranteed." A detecção funciona só pelo formato da string, então algoritmos que produzem saídas idênticas não podem ser diferenciados. Uma string hexadecimal de 32 caracteres pode ser MD5, NTLM ou LM, e só o contexto decide: NTLM vem de dumps do SAM do Windows e do secretsdump.py, MD5 puro vem de bancos de dados de aplicações web.

Estes são os modos que cobrem a esmagadora maioria dos trabalhos reais:

Uma lacuna que vale conhecer de antemão: o Hashcat não suporta yescrypt, o formato $y$ que virou padrão no Debian 12 e no Ubuntu 24.04. Existe um pedido aberto para isso, mas o yescrypt é propositalmente pesado em memória e combina mal com GPUs. Quando você puxar um arquivo shadow de um Debian atual e vir $y$, mude para o John the Ripper. Nosso tutorial do John the Ripper cobre esse lado, e o guia de hash cracking explica por que alguns algoritmos resistem a GPUs.

Como usar o Hashcat para um ataque de dicionário (o caso dos 80%)

O modo de ataque 0 é o dicionário puro: testar cada linha de uma wordlist, em ordem. É a primeira coisa a rodar em qualquer arquivo de hashes novo, e é o que quebra a maior parte das senhas.

hashcat -m 1000 -a 0 hashes.txt /usr/share/wordlists/rockyou.txt

A ordem dos argumentos é fixa e pouco intuitiva: as opções, depois o arquivo de hashes, depois a wordlist. Inverta os dois últimos e o Hashcat tenta carregar sua wordlist como hashes, o que gera um erro confuso.

Durante a execução, aperte s para o status, p para pausar, b para pular para o próximo ataque e q para sair de forma limpa. Em execuções sem supervisão, imprima o status por temporizador:

hashcat -m 1000 -a 0 hashes.txt rockyou.txt --status --status-timer=60

Os resultados quebrados vão para o potfile em ~/.local/share/hashcat/hashcat.potfile e ficam lá permanentemente. Recupere-os quando quiser:

$ hashcat -m 1000 hashes.txt --show
b4b9b02e6f09a9bd760f388b67351e2b:Password1
8846f7eaee8fb117ad06bdd830b7586c:password

O potfile também é a origem da experiência mais confusa para iniciantes. Se você quebra um hash e roda o mesmo comando de novo, o Hashcat informa "All hashes found in potfile" e encerra sem fazer nada. Esse é o comportamento correto, não uma falha. Use --show para ler os resultados, ou --potfile-disable se quiser mesmo quebrar de novo.

Mais duas flags merecem virar reflexo. --username lê arquivos no formato user:hash em vez de engasgar nos dois pontos, o que importa porque é o formato produzido por toda ferramenta de dump. --session=nome rotula a execução para você retomá-la depois com hashcat --restore --session=nome; uma varredura completa com regras costuma durar mais que a bateria do notebook.

hashcat -m 1000 -a 0 --username --session=q3-audit \
  -o cracked.txt hashes.txt rockyou.txt

Regras: transformando uma wordlist em bilhões de candidatas

Ninguém mais usa password como senha. Usam Password1!, P@ssw0rd2026 ou password123. As regras aplicam mutações a cada entrada da wordlist para que essas variantes sejam testadas sem que você precise escrevê-las.

hashcat -m 1000 -a 0 -r /usr/share/hashcat/rules/best66.rule hashes.txt rockyou.txt

Repare no nome do arquivo. O Hashcat 7 renomeou best64.rule para best66.rule, e o changelog registra a mudança de forma explícita. Todo tutorial escrito antes de agosto de 2025 ainda manda usar best64.rule, um arquivo que não existe numa instalação atual. Quando um comando falha por arquivo de regras inexistente, esse é quase sempre o motivo.

Esse comando multiplica os 14 milhões de entradas do rockyou por 66 mutações cada, dando cerca de 950 milhões de candidatas. Contra NTLM numa GPU intermediária, ainda termina em minutos. Os arquivos de regras vêm com o Hashcat em /usr/share/hashcat/rules/:

• best66.rule - 66 mutações que cobrem os padrões comuns. Rápido, com ótimo retorno por tempo gasto, e onde você deve sempre começar.
• rockyou-30000.rule - 30.000 regras derivadas do vazamento do RockYou. A segunda passada lógica quando o best66 não basta.
• d3ad0ne.rule e dive.rule - conjuntos grandes para varreduras noturnas, com cerca de 34.000 e 98.000 regras. Ambos só fazem sentido contra hashes rápidos.
• top10_2025.rule e stacking58.rule - novos na versão 7. O primeiro traz dez mutações de alto rendimento, o segundo 58 regras feitas para serem empilhadas com outro arquivo.

Você pode empilhar arquivos de regras passando -r mais de uma vez, e as mutações se multiplicam. Dois arquivos de 100 regras viram 10.000 combinações por palavra. Isso escala rápido, então confira o espaço de busca antes de comprometer a GPU:

hashcat -m 1000 -a 0 -r best66.rule -r stacking58.rule --keyspace hashes.txt rockyou.txt

Fora os arquivos que já vêm juntos, o conjunto comunitário que vale ter é o OneRuleToRuleThemAll e seu sucessor de 2023, o OneRuleToRuleThemStill, ambos no GitHub. Eles concentram uma taxa de sucesso muito alta em um único arquivo. Coloque o .rule onde quiser e aponte o -r para o caminho.

O Hashcat 7 também acrescentou operações sobre classes de caracteres na sintaxe de regras, escritas com o prefixo ~ (~s?CY, ~@?C, ~e?C). Elas atuam sobre classes em vez de caracteres literais, então regras que antes exigiam dezenas de linhas cabem em uma.

Na prática, o truque útil é descobrir quais regras se pagaram. Rode com saída de depuração e depois leia o arquivo para ver quais mutações produziram quebras naquele ambiente:

hashcat -m 1000 -a 0 -r best66.rule --debug-mode=1 \
  --debug-file=matched-rules.txt hashes.txt rockyou.txt

Quando os usuários de um cliente acrescentam todos o ano corrente e um ponto de exclamação, isso aparece no arquivo de depuração já nas primeiras cem quebras. Monte uma regra própria de cinco linhas em torno desse padrão e os hashes restantes caem muito mais rápido do que com qualquer varredura genérica.

Ataques de máscara e híbridos

Máscaras descrevem o formato de uma senha em vez do conteúdo. Quando você sabe que a política exige oito caracteres começando com maiúscula e terminando em dois dígitos, uma máscara testa exatamente esse espaço e nada além. Os curingas:

• ?l - minúsculas a-z
• ?u - maiúsculas A-Z
• ?d - dígitos 0-9
• ?s - caracteres especiais
• ?a - tudo o que está acima
• ?h / ?H - hexadecimal minúsculo e maiúsculo

O modo de ataque 3 executa uma máscara:

hashcat -m 1000 -a 3 hashes.txt ?u?l?l?l?l?l?d?d

Isso cobre oito caracteres no padrão descrito acima, cerca de 31 bilhões de candidatas, que uma placa da linha RTX percorre contra NTLM em bem menos de um minuto. Troque o hash por bcrypt e a mesma máscara vira um projeto de vários anos. A velocidade do algoritmo decide o que é alcançável, sempre.

Para comprimentos desconhecidos, acrescente --increment e vá do curto para o longo:

hashcat -m 1000 -a 3 --increment --increment-min 6 --increment-max 8 hashes.txt ?a?a?a?a?a?a?a?a

O Hashcat 7 acrescentou o -ii (--increment-inverse), que faz a máscara crescer da direita para a esquerda. Ajuda quando a parte fixa da senha fica no começo, como um prefixo da empresa seguido de um sufixo variável.

Conjuntos de caracteres personalizados estreitam ainda mais o espaço. Defina até quatro com -1 a -4:

hashcat -m 1000 -a 3 -1 ?l?d hashes.txt Summer?1?1?1?1

Os modos híbridos encaixam uma máscara em uma wordlist. O modo 6 acrescenta no fim, o modo 7 no começo:

hashcat -m 1000 -a 6 hashes.txt rockyou.txt ?d?d?d?d    # password2026
hashcat -m 1000 -a 7 hashes.txt ?d?d rockyou.txt        # 26password

O modo 6 com quatro dígitos no fim é o comando mais rentável deste artigo inteiro. Ele pega a enorme população de senhas formadas por uma palavra de dicionário mais um ano, e roda numa fração do tempo que um conjunto grande de regras exige. Quando uma passada de dicionário volta vazia, tente isso antes de recorrer ao dive.rule.

Quebrando os tipos de hash que você realmente encontra

Arquivos shadow do Linux

Distribuições modernas usam $6$ sha512crypt (modo 1800) ou $y$ yescrypt (sem suporte, use o John). Entregue as linhas do shadow direto ao Hashcat com --username:

hashcat -m 1800 -a 0 --username shadow.txt rockyou.txt -r best66.rule

O sha512crypt roda 5.000 iterações por padrão, o que coloca uma GPU de consumo na casa das centenas de milhares de candidatas por segundo, e não dos bilhões que o NTLM entrega. Wordlists com regras direcionadas são realistas aqui. Força bruta completa não é.

Windows e Active Directory

O NTLM (modo 1000) não tem sal e é extremamente rápido, por isso os hashes de um domínio inteiro costumam cair em uma varredura noturna. Extraia-os de um dump do NTDS.dit e quebre o quarto campo separado por dois pontos:

cut -d: -f4 ntds-dump.txt > ntlm.txt
hashcat -m 1000 -a 0 ntlm.txt rockyou.txt -r rockyou-30000.rule

A saída de kerberoasting entra como modo 13100 e a de AS-REP roasting como 18200. Nos dois casos são tickets cifrados com uma chave derivada da senha, então quebrar um deles devolve a senha da conta em texto claro. Pratique o lado Windows no lab Windows Password Cracker.

Capturas sem fio

O modo 22000 substituiu o antigo 2500 e cobre handshakes PMKID e EAPOL em um único formato. Converta a captura primeiro com o hcxpcapngtool, que é um pacote separado:

hcxpcapngtool -o hash.22000 capture.pcapng
hashcat -m 22000 -a 0 hash.22000 rockyou.txt

O WPA2 exige no mínimo oito caracteres, então máscaras menores que isso só desperdiçam tempo. O lab WiFi Password Cracker percorre todo o caminho, da captura à quebra, em um alvo que você tem permissão para atacar.

Arquivos criptografados

O Hashcat quebra 7-Zip (11600), KeePass (13400), MS Office (9600) e PDF (25400), mas não extrai esses hashes para você. Essa parte cabe aos scripts auxiliares do John the Ripper. O fluxo normal é office2john document.docx > office.hash, remover o campo de usuário no início e então entregar o hash ao Hashcat para o trabalho na GPU.

Última verificação: agosto de 2026 no Hashcat 7.1.2 sobre Kali 2026.2, com os números de modo confirmados via hashcat --help.

Os quatro erros que todo mundo encontra

Estes quatro explicam quase todo post de "o Hashcat está quebrado" em qualquer fórum. Nenhum deles significa que o Hashcat está quebrado.

1. Token length exception. O hash não bate com a estrutura que o modo -m espera. Nove em cada dez vezes a causa real é uma quebra de linha sobrando, um final de linha do Windows ou um prefixo user: que você esqueceu de remover. Confira com cat -A hash.txt e procure ^M no fim das linhas. Na décima vez, seu -m está errado: rode --identify.
2. No hashes loaded. Mesma causa raiz do anterior, ou o arquivo está vazio porque um redirecionamento falhou em silêncio. Se o arquivo tem conteúdo e o formato está certo, verifique se tudo ali já foi quebrado e está no potfile.
3. Separator unmatched. Seu arquivo está no formato user:hash e você não passou --username. Acrescente a flag.
4. Self-test failed. O Hashcat verifica cada kernel contra um hash conhecido na inicialização, e a falha significa que o driver da GPU produziu a resposta errada. A correção é atualizar ou reinstalar o driver. O --self-test-disable faz a mensagem sumir e deixa você quebrando com um kernel que calcula resultados incorretos, então você não vai achar nada e não vai entender por quê.

Uma falha silenciosa merece menção própria, porque não exibe erro nenhum. A flag -O ativa os kernels otimizados, bem mais rápidos, mas que limitam o comprimento das candidatas, com frequência em 32 caracteres e às vezes menos, dependendo do modo. Se a senha real passar desse limite, o Hashcat termina a execução tranquilamente e não reporta nada. Use -O pela velocidade em candidatas curtas e tire-o assim que começar a testar frases-senha.

Ajustando a carga sem cozinhar a GPU

A flag de perfil de carga -w troca a fluidez do desktop por velocidade. O perfil 1 mantém a máquina usável, o 3 é o padrão sensato para uma máquina dedicada, e o 4 costumava ser o ajuste máximo que muita gente escolhia por hábito.

Não use -w 4 no Hashcat 7. As notas de versão são explícitas: o novo gerenciamento de memória torna esse ajuste contraproducente porque esgota a memória do host, enquanto o -w 3 alcança velocidades maiores sem esse custo. É um dos poucos conselhos antigos sobre Hashcat que a versão 7 realmente inverteu.

hashcat -m 1000 -a 0 -w 3 --hwmon-temp-abort=90 hashes.txt rockyou.txt

O corte por temperatura não é conselho opcional. O Hashcat exige mais da GPU do que qualquer jogo, e varreduras longas com regras a mantêm em carga total por horas. O limite padrão é 90 graus Celsius, e deixá-lo ativo não custa nada.

Por fim, saiba a hora de parar. Se rockyou mais best66 mais uma máscara híbrida de dígitos não quebrou um hash, a senha provavelmente é longa, aleatória ou gerada por um gerenciador de senhas. Mais três horas de dive.rule não vão mudar isso. Registre como não quebrado no relatório, o que já é um achado: significa que o dono da conta está fazendo algo certo.

Considerações legais e éticas

Garanta que a quebra de senhas esteja nomeada no escopo do trabalho antes de a missão começar. "Teste de intrusão autorizado" não é a mesma coisa que "você pode exfiltrar a base de hashes do domínio e quebrá-la", e essa distinção já gerou disputas reais. Coloque no papel.

Trate credenciais quebradas como o artefato mais sensível da missão. Guarde-as criptografadas, compartilhe apenas pelo canal acordado com o cliente e destrua tudo na entrega do relatório. Baixar vazamentos para "pesquisa" traz uma exposição jurídica que não compensa a conveniência: fique nos conjuntos de treino conhecidos como o rockyou.txt e em hashes que você mesmo gerou.

Quando o cliente perguntar como se defender do que você acabou de demonstrar, a resposta está na escolha do algoritmo e no comprimento. O NIST SP 800-63B recomenda abandonar regras de composição obrigatórias e expiração periódica em favor de frases-senha mais longas e da triagem de senhas vazadas, e o OWASP Password Storage Cheat Sheet traz parâmetros concretos de Argon2id. As duas recomendações fazem mais contra o Hashcat do que qualquer política de complexidade já fez.