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), ou pelo conversor online do projeto. 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.

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