Hashcat: o guia completo da ferramenta de quebra de senhas com GPU

Resumo: o hashcat é o quebrador de hashes mais rápido e completo do mundo: uma ferramenta de linha de comando que usa a GPU (e a CPU) para testar senhas candidatas contra hashes de dezenas de tipos — de MD5 e NTLM a bcrypt, Kerberos e o WPA/WPA2. Neste guia você aprende os quatro modos de ataque (dicionário, combinador, máscara e regras), os modos de hash mais usados em pentest, os comandos reais de cada cenário e a quebra completa de uma rede Wi-Fi com o modo 22000 — sempre com a contraparte de defesa.

O que é

Hashcat é um utilitário de recuperação de senhas (password recovery) de código aberto, mantido pela comunidade desde 2009 e distribuído sob MIT License — o repositório oficial no GitHub tem mais de 26 mil estrelas e está em desenvolvimento ativo. Ele não "decifra" hashes no sentido matemático: executa ataques de exaustão, testando milhões de senhas candidatas por segundo e comparando o hash calculado com o hash-alvo. A mágica de velocidade vem do uso de GPGPU (General-Purpose computing on Graphics Processing Units — computação de propósito geral em placas de vídeo): enquanto uma CPU testa dezenas de milhares de hashes MD5 por segundo, uma GPU moderna passa de 30 bilhões — a paralelização massiva das placas de vídeo é perfeita para esse tipo de cálculo.

A ferramenta é o padrão de facto da indústria em auditoria de senhas: pentesters a usam para validar hashes extraídos em comprometimentos, times de segurança para testar a política de senhas da própria empresa e pesquisadores para quebrar amostras de vazamentos e provar o impacto real de senhas fracas. O projeto mantém também o hashcat.net, com uma wiki detalhada (os guias de mask attack, rule-based attack e WPA/WPA2 são referência obrigatória), um conversor online de capturas Wi-Fi para o formato do hashcat e um catálogo de exemplos de hash para todos os modos suportados.

Diferente de ferramentas de ataque a serviços (como o Hydra), o hashcat é offline: ele não fala com nenhum alvo — trabalha apenas sobre o hash que você já obteve. Isso significa que a velocidade é ilimitada (não há rate limit a respeitar) e que a única barreira entre o atacante e a senha é a força dela.

Principais características

Os modos de ataque que você vai usar

Os modos de hash mais usados em pentest

Casos de uso práticos

Primeiro contato: benchmark e identificação

Antes de atacar qualquer coisa, vale medir a capacidade da sua máquina e confirmar o modo de hash. O benchmark (-b) roda o modo escolhido com hashes de teste e reporta a velocidade — o número que vai calibrar suas expectativas:

hashcat -b -m 22000
hashcat -b -m 0

O primeiro mede o modo WPA/WPA2 — o mais caro de todos, por causa do PBKDF2 com 4.096 iterações: mesmo uma GPU parruda fica na casa de centenas a poucos milhares de candidatos por segundo. O segundo mede o MD5 — aí a mesma GPU passa de dezenas de bilhões por segundo. A diferença explica por que senhas de aplicações modernas usam hashes lentos de propósito.

Se você tem um hash e não sabe o tipo, o hashcat tenta adivinhar com --identify (ou --example-hashes mostra um exemplo de cada modo):

hashcat --identify '$2y$10$N9qo8uLOickgx2ZMRZoMyeIjZAgcfl7p92ldGxad68LJZdL17lhWy'

Ataque de dicionário: o primeiro movimento

O ataque de dicionário (-a 0) testa cada linha de uma wordlist. É a base de tudo — a maioria das senhas reais já apareceu em algum vazamento, e listas como a rockyou (14 milhões de senhas reais vazadas do MySpace em 2009) resolvem uma fatia enorme dos casos:

hashcat -m 1000 hashes.txt rockyou.txt
hashcat -m 22000 wifi.hc22000 rockyou.txt

O primeiro comando ataca hashes NTLM extraídos de um Windows; o segundo, um handshake Wi-Fi capturado (o fluxo completo de captura está no nosso guia de Wi-Fi). O hashcat imprime um painel em tempo real: velocidade, candidatos testados, tempo estimado e, quando encontra, o hash e a senha em texto claro — que aparece também no arquivo hashcat.potfile para consulta posterior.

Ataque de máscara: força bruta inteligente

Quando o dicionário falha, entra a máscara (-a 3). Em vez de testar todas as combinações de todos os caracteres (impraticável), a máscara restringe as posições a classes: ?d dígitos, ?l minúsculas, ?u maiúsculas, ?s símbolos, ?a tudo. Uma senha de PIN de 8 dígitos cai em segundos:

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

Para padrões mais realistas, você define conjuntos próprios com -1 (e -2, -3, -4). Um exemplo clássico: senha com 8 caracteres, começando com maiúscula, terminando com 3 dígitos:

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

A estimativa de tempo é o primeiro reflexo do pentester: cada posição com 26 letras multiplica o espaço por 26 — e o painel do hashcat mostra na hora se a combinação vai levar segundos ou séculos.

Ataque com regras: o dicionário que pensa

O ataque com regras (-a 0 -r) é onde o hashcat mostra seu poder. Regras são transformações aplicadas a cada palavra do dicionário: adicionar "123" no final, trocar "a" por "@", capitalizar, duplicar, inverter. A regra clássica da política de senha corporativa — "senha" vira "S3nh@!123" — é exatamente o que o atacante automatiza:

hashcat -m 1000 hashes.txt rockyou.txt -r rules/best64.rule
hashcat -m 1000 hashes.txt rockyou.txt -r rules/rockyou30000.rule

O primeiro comando usa as 64 regras mais eficazes que acompanham o hashcat; o segundo, o conjunto gigante derivado do dicionário rockyou. Regras multiplicam o custo proporcionalmente (10.000 regras = 10.000 variações por palavra), mas o ganho em cobertura é enorme — é o ataque que encontra "Corinthians2026!" quando o dicionário só tem "corinthians".

Combinador e híbrido: senhas compostas

Muitas senhas são duas palavras coladas ou uma palavra com sufixo. O combinador (-a 1) concatena cada linha de duas wordlists:

hashcat -m 1000 hashes.txt nomes.txt sobrenomes.txt -a 1

E o ataque híbrido junta dicionário com máscara: -a 6 adiciona um sufixo de máscara a cada palavra (palavra123), -a 7 adiciona um prefixo (123palavra):

hashcat -m 1000 hashes.txt rockyou.txt -a 6 ?d?d?d
hashcat -m 1000 hashes.txt rockyou.txt -a 7 ?d?d?d

Quebrando WPA/WPA2: o modo 22000

O modo 22000 é a peça central do guia de descoberta de senha de Wi-Fi: ele aceita o hash do handshake EAPOL ou do PMKID — capturado com uma placa de rede (via hcxdumptool) ou com um ESP32 rodando o Biscuit, como o T-Dongle-C5 — já no formato de texto único por rede:

WPA*02*MIC*MAC_AP*MAC_CLIENTE*ESSID*NONCE_AP*EAPOL_CLIENTE*MESSAGEPAIR

A captura bruta em .cap ou pcapng vira esse formato com o conversor hcxpcapngtool (do pacote hcxtools) — o que inclui o .pcap exportado pelo Biscuit, que não sai pronto do dongle:

hcxpcapngtool -o wifi.hc22000 captura.pcap

Também existe o conversor online do projeto (hashcat.net/cap2hashcat), mas o ideal é converter localmente para não enviar capturas de auditoria para terceiros. Com o hash em mãos, a quebra é direta:

hashcat -m 22000 wifi.hc22000 wordlist.txt
hashcat -m 22000 wifi.hc22000 wordlist.txt -r rules/best64.rule
hashcat -m 22000 wifi.hc22000 -a 3 ?d?d?d?d?d?d?d?d

O primeiro comando é o dicionário puro; o segundo adiciona regras para senhas derivadas de palavras; o terceiro varre PINs numéricos de 8 dígitos — o espaço que cobre a maioria dos PINs de roteador. Lembrando o gargalo: cada candidato exige o PBKDF2 completo, então a senha da rede — e não a velocidade da GPU — é quem decide se o ataque termina em minutos ou nunca.

Preparando o hashcat: driver de GPU e backend

A primeira armadilha de quem instala o Kali agora é descobrir que o hashcat não enxerga a placa de vídeo. Isso não é bug: uma instalação limpa do Kali não vem com o driver proprietário da NVIDIA/AMD nem com o backend (OpenCL/CUDA) instalados. O hashcat depende de duas coisas para usar a GPU: o driver da placa e um backend de computação (OpenCL ou CUDA) que o sistema operacional expõe para ele. Sem um dos dois, o hashcat -I mostra "No devices found" — e qualquer quebra falha antes de começar.

Verificando se está tudo pronto. Para placa NVIDIA, o comando que lista o status do driver é o nvidia-smi (mostra o modelo da placa, a versão do driver e a memória — se o comando não existir ou der erro, o driver não está instalado). Para o backend, o próprio hashcat lista os dispositivos que ele consegue usar:

nvidia-smi          # NVIDIA: deve mostrar sua GPU (modelo, driver, memória)
hashcat -I          # deve listar a GPU como Backend Device

Se os dois comandos reconhecem sua placa, pode rodar a quebra direto. Se um dos dois falhar, é hora de instalar — o caminho depende da sua placa.

Instalando no Kali (Linux) — NVIDIA. O driver proprietário e o CUDA Toolkit (o backend da NVIDIA) vêm nos repositórios do Kali. Antes de instalar, confirme que a linha components do seu sources.list inclui contrib non-free non-free-firmware (senão os pacotes não aparecem):

grep "contrib non-free" /etc/apt/sources.list.d/kali.sources
sudo apt update
sudo apt -y full-upgrade
sudo apt install linux-headers-$(uname -r)
sudo apt install -y nvidia-driver nvidia-cuda-toolkit

O primeiro comando verifica se os componentes contrib non-free non-free-firmware estão habilitados; os seguintes atualizam o sistema e instalam o driver e o toolkit. A instalação avisa que o módulo livre nouveau está em conflito com o driver proprietário — reinicie o sistema para que o módulo NVIDIA carregue no lugar dele (sudo reboot). Depois do reboot, repita a verificação — nvidia-smi deve mostrar a placa e o hashcat -I deve listar a GPU (tanto na seção CUDA quanto na OpenCL). Só então a quebra vale a pena.

Instalando no Kali (Linux) — AMD. Para placas AMD, o caminho é o driver AMDGPU (que no Kali já vem no kernel) mais o backend ROCm com o suporte OpenCL:

sudo apt update
sudo apt install -y amdgpu-dkms rocm-opencl-runtime
sudo reboot

Depois do reboot, o hashcat -I deve listar a placa AMD como dispositivo OpenCL. A documentação oficial do ROCm recomenda instalar com o suporte --opencl=rocm justamente para o hashcat enxergar a placa — se a sua distribuição não usa os pacotes prontos do Kali, siga o guia do fabricante para a sua placa.

Sem GPU? Use a CPU (ou OpenCL genérico). Se a sua máquina não tem placa de vídeo dedicada — ou se você está em uma máquina virtual, o caso mais comum — o hashcat ainda funciona, rodando na CPU. O que ele precisa é de um backend OpenCL que exponha o processador. No Kali, os pacotes são o ocl-icd (a camada de interface OpenCL) e o PoCL (Portable Computing Language — uma implementação de OpenCL que roda em CPU):

sudo apt install -y ocl-icd-libopencl1 pocl-opencl-icd clinfo

Depois de instalar, rode hashcat -I de novo: o processador deve aparecer como dispositivo. A quebra funciona — mas na CPU o modo 22000 é dolorosamente lento (centenas de candidatos por segundo, contra milhares na GPU). Para fins de aprendizado e senhas fracas, resolve; para séries grandes, nem tente.

Dica para quem roda o Kali em máquina virtual (VirtualBox/VMware). Dentro da VM, o hashcat quase nunca enxerga a GPU do host — a VirtualBox não expõe a placa de vídeo real ao convidado por padrão (a GPU apareceria apenas como uma controladora virtual genérica, sem OpenCL/CUDA). O caminho prático é usar a CPU mesmo, com os pacotes de OpenCL acima. No VirtualBox, o pacote que funciona no Kali é o PoCL (ou, nas versões mais novas, o mesa-opencl-icd); após sudo apt install -y pocl-opencl-icd ocl-icd-libopencl1, rode hashcat -I e confirme que o processador aparece como dispositivo — aí a quebra roda, mais lenta, mas roda. Para velocidade de verdade, instale o Kali direto no hardware (dual boot) ou use o Windows com os drivers nativos, descritos abaixo.

Instalando no Windows. No Windows, o processo é mais simples porque os drivers e o backend já vêm integrados. Para placa NVIDIA: instale o driver Game Ready/Studio do site da NVIDIA e o CUDA Toolkit — o hashcat usa o backend CUDA automaticamente. Para placa AMD: instale o AMD Software: Adrenalin Edition (que inclui o OpenCL). Para Intel (iGPU): instale o driver gráfico da Intel, que inclui o runtime OpenCL. Em todos os casos, baixe o hashcat do site oficial (ou via winget/choco) e confirme com hashcat -I que a GPU aparece listada — no Windows o comando abre um prompt no diretório do executável. Com a placa reconhecida, a quebra é idêntica:

hashcat.exe -m 22000 wifi.hc22000 rockyou.txt

Uma observação sobre o caminho do dicionário: no Linux o rockyou do Kali fica em /usr/share/wordlists/rockyou.txt (e vem compactado como rockyou.txt.gz — descompacte com sudo gunzip /usr/share/wordlists/rockyou.txt.gz antes do primeiro uso). No Windows, baixe a wordlist e aponte o caminho direto.

Quando a rockyou não resolve: wordlists maiores e regras

O dicionário clássico rockyou (14 milhões de senhas) resolve uma fatia enorme dos casos, mas não é o fim da linha — e o pentester que parou nela está deixando senha na mesa. Quando a rockyou falha, a progressão natural é subir o tamanho do dicionário e depois aplicar regras em cima dele.

Wordlists maiores: o Weakpass. O Weakpass (coleção colaborativa de wordlists, classificada por taxa de quebra) é o melhor catálogo público de dicionários gigantes — listas com bilhões de senhas reais, todas rankeadas de S a F pela taxa de crack. As mais usadas na prática:

# Exemplos de listas populares do Weakpass (tamanhos variam de MB a dezenas de GB)
# hashpwn.txt — ~1,35 bilhão de senhas
# hashmob.net_2025.large.found.txt — ~57 milhões de senhas encontradas em 2025
# weakpass_4a.txt — ~8,4 bilhões de senhas (para quem tem muito tempo e disco)

Os arquivos vêm compactados (.7z, alguns .gz) — extraia com 7z x arquivo.7z (instale com sudo apt install p7zip-full no Kali) ou gunzip arquivo.gz antes de usar. Para WPA, lembre-se do gargalo do modo 22000 (PBKDF2): uma lista de bilhões de senhas pode levar dias mesmo na GPU — comece pelas listas menores rankeadas com nota alta (S/A), que concentram as senhas que realmente aparecem, e vá subindo conforme a necessidade. As listas "found" do hashmob.net (senhas que foram quebradas em 2025) são um ótimo meio-termo entre tamanho e taxa de acerto.

Outra fonte clássica é o SecLists do Daniel Miessler, que acompanha o Kali em /usr/share/seclists (senha: sudo apt install seclists) — com wordlists temáticas (brasileiras, corporativas, por ano) perfeitas para direcionar o ataque. Existem ainda geradores de dicionários personalizados (crunch, cupp, mentalist) para criar listas sob medida a partir de informações da vítima — o cupp, por exemplo, monta candidatos a partir de nome, datas e interesses de uma pessoa.

Aplicando regras: multiplicar o alcance do dicionário. Antes de baixar uma lista de bilhões de senhas, vale tentar as regras do próprio hashcat sobre a wordlist que você já tem — elas transformam cada palavra em dezenas de variações (maiúsculas, números no final, troca de letras por símbolos, duplicação, inversão). O hashcat vem com dezenas de arquivos de regras em rules/:

hashcat -m 22000 wifi.hc22000 /usr/share/wordlists/rockyou.txt -r rules/best64.rule
hashcat -m 22000 wifi.hc22000 /usr/share/wordlists/rockyou.txt -r rules/rockyou30000.rule

O primeiro usa as 64 regras mais eficazes; o segundo, o conjunto de 30 mil regras derivado do próprio rockyou (lento, mas brutal). Combinar wordlist grande + regras é o "modo sério" da quebra: cada senha do dicionário vira dezenas de candidatos, e a cobertura cresce exponencialmente — ao custo proporcional de tempo. A ordem prática de ataque é sempre a mesma: dicionário puro → dicionário + regras → wordlist maior → wordlist maior + regras → máscara/híbrido para padrões específicos (PINs, anos, sufixos numéricos).

Ataques a hashes de aplicações: o workflow do pentest

Num engajamento real, o fluxo é sempre o mesmo: extrair → converter → quebrar. Hashes NTLM saem do Windows com ferramentas como o Mimikatz ou o Impacket (conjunto de scripts Python para protocolos Windows); tickets Kerberos saem com o Rubeus; respostas NetNTLMv2, com o Responder. Todos viram arquivos de hash e caem no mesmo hashcat:

hashcat -m 5600 netntlmv2.txt rockyou.txt -r rules/best64.rule
hashcat -m 13100 tickets.txt rockyou.txt -r rules/d3ad0ne.rule
hashcat -m 1800 shadow.txt rockyou.txt -a 3 ?l?l?l?l?l?l?d?d

O primeiro ataca respostas SMB capturadas na rede; o segundo, tickets Kerberos TGS (o famoso kerberoasting); o terceiro, o /etc/shadow do Linux com sha512crypt — todos com as regras certas para o padrão de senha do alvo.

Como se defender dos riscos

A regra de ouro: a velocidade do hashcat é função da senha, não do hash. Nenhum firewall ou IDS segura um ataque offline — quem roubou o banco de hashes já tem tudo o que precisa para quebrar no ritmo da GPU. A defesa começa onde o ataque termina: na força e na imprevisibilidade das senhas. Senhas longas (12+ caracteres) e fora de dicionários, com combinações que regras comuns não geram, são a diferença entre um hash quebrado em horas e um intocado por décadas.

Use verifiers lentos de propósito. Aplicações devem armazenar senhas com algoritmos projetados para serem caros — bcrypt, Argon2id, scrypt ou PBKDF2 com iterações altas — em vez de MD5, SHA1 ou NTLM. O custo de cada verificação (dezenas de milissegundos) é irrelevante para o login legítimo e devastador para o atacante: o mesmo hash que o MD5 quebra em bilhões por segundo cai para milhares no bcrypt. O WPA/WPA2 já usa PBKDF2 — por isso o modo 22000 é naturalmente mais lento — e o WPA3 vai além, eliminando o teste offline.

Sal, sal, sal. Hashes sem salt são vulneráveis a tabelas pré-computadas (rainbow tables) e permitem quebrar um vazamento inteiro de uma vez. Cada senha deve ter um salt único — aí o atacante quebra hash por hash, multiplicando o custo total pelo número de contas.

Teste sua própria política de senhas. A melhor forma de saber se a senha dos seus usuários sobreviveria é rodar o hashcat contra hashes reais da sua empresa (em ambiente controlado) com dicionários e regras: o resultado é a evidência que convence a diretoria a adotar MFA, gerenciadores de senha e senhas longas. Auditoria de senha é o uso legítimo — e mais valioso — do hashcat.

MFA e resposta a vazamentos. Se uma senha foi quebrada, ela vale para tudo onde foi reutilizada: force troca em massa após qualquer vazamento, exija MFA onde existir e mantenha um blocklist de senhas comprometidas (as mais usadas do rockyou, por exemplo) na política de criação de senhas.

Conclusão

O hashcat é a ferramenta que transforma a pergunta "a senha é forte?" numa resposta mensurável: se a sua GPU quebra o hash em minutos com um dicionário e três regras, a senha não é forte — é uma estatística. Dominar os quatro modos de ataque — dicionário, combinador, máscara e regras — e saber escolher o modo de hash certo cobre praticamente qualquer cenário de pentest, do NTLM extraído de um Windows ao handshake Wi-Fi capturado com um ESP32 de bolso. E, como toda ferramenta de exaustão, o hashcat ensina a lição mais importante da segurança moderna: quando o atacante é offline e infinitamente rápido, a única defesa que resta é escolher senhas que nenhuma GPU vai encontrar — e garantir que os sistemas armazenem os hashes de forma que a GPU sofra para testá-los.

Fontes e leituras adicionais

• Hashcat — hashcat (repositório oficial no GitHub) — 04/09/2026
• Hashcat Wiki — Cracking WPA/WPA2 with hashcat — 04/09/2026
• Hashcat Wiki — Mask Attack — 04/09/2026
• Hashcat Wiki — Rule-Based Attack — 04/09/2026
• Hashcat — Example Hashes (todos os modos com exemplo) — 04/09/2026
• Hashcat Forum — PMKID attack: new attack against WPA/WPA2 — 04/09/2026
• Kali Linux — Install NVIDIA GPU Drivers on Kali Linux (documentação) — 05/09/2026
• Weakpass — Wordlists: maior coleção pública de dicionários — 05/09/2026
• SecLists — Repositório oficial (Daniel Miessler) — 05/09/2026