John the Ripper é o quebrador de senhas que silenciosamente quebra os hashes que nada mais consegue ler. Hashcat ganha em velocidade bruta de GPU, mas no momento em que você encontra um banco KeePass, uma chave SSH privada com passphrase, um keychain antigo do Mac OS X ou um formato de hash que o Hashcat não reconhece, John é a ferramenta que você usa. Este tutorial cobre como usar o John the Ripper de ponta a ponta: instalação no Linux, macOS e Windows, identificação de hashes, ataques por wordlist e regras, modos incremental e máscara, os scripts auxiliares *2john dos quais ninguém fala, e exatamente quando trocar para o Hashcat. Pratique cada técnica no curso de Password Cracking da HackerDNA, começando pelo lab Shadow Cracker enquanto lê.
Todos os comandos abaixo estão prontos para copiar e colar contra o John the Ripper 1.9.0-jumbo-1, o build jumbo mantido pela comunidade que vem com Kali Linux e Parrot OS. A versão padrão do John (sem "jumbo") suporta cerca de uma dúzia de formatos. O jumbo suporta mais de 470. Sempre instale o jumbo. Se a sua distro entrega a versão reduzida em john, substitua pela versão jumbo antes de continuar.
TL;DR: John the Ripper é um quebrador de senhas focado em CPU que detecta automaticamente mais de 470 formatos de hash e traz scripts auxiliares (zip2john, pdf2john, ssh2john, keepass2john) que extraem hashes quebráveis de arquivos criptografados. Rode um ataque por wordlist com john --wordlist=rockyou.txt hash.txt, adicione --rules para mutações, e veja os resultados com john --show. Use Hashcat para velocidade bruta de GPU, John quando flexibilidade de formato ou extração de hash importa mais.
O Que o John the Ripper Faz
John the Ripper é um quebrador de senhas open-source que recupera senhas em texto claro a partir de hashes criptográficos testando candidatos de wordlists, padrões de máscara ou sequências de caracteres geradas. Ele roda em Linux, macOS, Windows e na maioria dos BSDs, suporta mais de 470 formatos de hash e cifra no build jumbo, e é o que a comunidade de segurança tem de mais próximo de um quebrador universal.
A história importa. John é mantido pela Openwall desde 1996, o que o torna mais antigo do que a maioria dos hashes que ele quebra. Essa longevidade se traduz em cobertura de formatos. Onde o Hashcat foca nos tipos de hash que importam hoje, o John ainda quebra arquivos ID do Lotus Notes, keychains do Mac OS X 10.5 e blobs obscuros de autenticação de banco de dados que nenhuma outra ferramenta suporta. Para testes de penetração onde você encontra um arquivo estranho num backup, essa amplitude é a diferença entre um achado explorável e uma nota de rodapé.
Duas coisas tornam o John diferente do Hashcat. Primeiro, a detecção automática de formato: você aponta o John para um arquivo de hashes e ele descobre o algoritmo. Sem números de modo, sem tabelas de busca. Segundo, o ecossistema *2john: uma família de scripts que tira hashes de arquivos criptografados, arquivos compactados e material de chaves. O Hashcat exige que você extraia o hash sozinho; o John empacota a extração e a quebra num único fluxo. Para uma comparação mais ampla de onde cada ferramenta se sai melhor, nosso guia de ferramentas de pentest cobre o papel de cada uma numa missão real.
Uma observação afiada: ignore todo artigo "John vs Hashcat: qual é melhor" que escolhe um vencedor. Pentesters de verdade instalam os dois e usam o que cabe no trabalho. O enquadramento está errado. A pergunta certa é "qual hash tenho à frente, e qual ferramenta o gerencia melhor".
Instalando o John the Ripper
A instalação depende da plataforma, mas o resultado deve ser sempre o build jumbo. Verifique com john --list=build-info após a instalação. Se a saída mencionar "jumbo", você está pronto.
Linux (Kali, Debian, Ubuntu, Parrot)
Kali e Parrot entregam o build jumbo em john por padrão:
sudo apt install john
john --list=build-info | head -3No Debian ou Ubuntu padrão, o pacote também se chama john, mas confira a versão. Se --list=build-info não disser jumbo, compile a partir do código-fonte:
git clone https://github.com/openwall/john.git
cd john/src
./configure && make -j$(nproc)
ln -s ~/john/run/john /usr/local/bin/johnmacOS
O Homebrew instala o jumbo diretamente: brew install john-jumbo. Após a instalação, rode john --test para fazer benchmark do build no seu CPU e verificar se tudo está corretamente vinculado.
Windows
Baixe o binário pré-compilado de openwall.com/john e extraia em qualquer lugar. Rode a partir do diretório run/ extraído. WSL também funciona e tende a ser mais natural se você veio do Linux.
Após instalar, rode um teste automático para confirmar que o build funciona no seu hardware:
john --test=10
Will run 8 OpenMP threads
Benchmarking: descrypt, traditional crypt(3) [DES 256/256 AVX2-16]... DONE
Speed for cost 1 (iteration count) of 25
Raw: 8521K c/s real, 1066K c/s virtualOs números variam conforme o CPU. O objetivo do --test não é comparar com outros; é confirmar que o build inicializou corretamente e dar uma base para detectar futuras execuções anormalmente lentas.
Identificando Tipos de Hash Antes de Quebrar
O John detecta a maioria dos formatos automaticamente, mas detecção automática não é mágica. Quando o formato é ambíguo (32 caracteres hex puros podem ser MD5, NTLM, LM ou vários outros), o John escolhe um e roda. Se você errar, perde horas. Identificar o hash de antemão salva a execução.
Para hashes com marcadores de formato, a identificação é trivial:
$1$- MD5crypt (shadow Linux antigo)$5$- SHA-256crypt$6$- SHA-512crypt (padrão na maioria das distribuições Linux modernas)$2y$ou$2b$- bcrypt$y$- yescrypt (padrão no Debian 12, Ubuntu 24.04+)$argon2id$- Argon2 (a melhor classe, deliberadamente lento de quebrar)
Para hashes hex puros sem marcador, o contexto decide. Hashes NTLM vêm de arquivos SAM do Windows, dumps NTDS.dit ou da saída do secretsdump.py. MD5 puro normalmente vem de dumps de banco de dados de aplicações web. Se você realmente não conseguir distinguir, rode hashid para uma estimativa ranqueada e use a flag --format do John para travar o correto:
john --format=NT hash.txt
john --format=Raw-MD5 hash.txt
john --format=sha512crypt shadow.txtPegue a lista completa de formatos suportados com john --list=formats. A saída tem quase 500 entradas; passe pelo grep filtrando o que você procura:
john --list=formats | tr ',' '\n' | grep -i sshPara o contexto sobre diferenças entre algoritmos de hash e onde cada um aparece, nosso tutorial de quebra de hash cobre o lado teórico dos algoritmos. Este guia foca em comandos específicos do John.
Modo Wordlist: O Fluxo Padrão
O modo wordlist é o caso de 80%. Você tem um arquivo de hashes e uma lista de senhas candidatas. O John testa cada candidato, aplica hash com o algoritmo alvo e compara com os hashes fornecidos. A invocação básica:
john --wordlist=/usr/share/wordlists/rockyou.txt hash.txtEsse comando percorre 14 milhões de senhas no rockyou. Num CPU desktop moderno contra NTLM sem salt, a passagem completa termina em menos de um minuto. Contra bcrypt com fator de custo 12, a mesma passagem leva semanas. O algoritmo do hash decide tudo.
Enquanto o John roda, aperte qualquer tecla para ver o status: candidatos por segundo, ETA, candidato atual. Aperte q para abortar limpo. O John grava as quebras bem-sucedidas em ~/.john/john.pot automaticamente. Veja o que você quebrou a qualquer momento:
$ john --show hash.txt
admin:Summer2024!:::::::
backup:hunter2:::::::
2 password hashes cracked, 0 leftA saída do --show é amigável para shell: passe pelo cut -d: -f1,2 para extrair só os pares usuário:senha para o seu relatório. Se uma sessão for interrompida (você fechou o terminal, o notebook hibernou, o gato derrubou o cabo), retome a partir do arquivo .rec em ~/.john/:
john --restoreDuas flags vale a pena memorizar para o modo wordlist. --fork=N divide o trabalho em N núcleos de CPU; numa máquina de 8 núcleos, --fork=8 aproximadamente 8x sua taxa contra hashes rápidos. --session=nome rotula a execução, permitindo rodar múltiplas sessões em paralelo e restaurá-las pelo nome. Na prática, toda execução séria de quebra usa as duas: john --wordlist=rockyou.txt --rules --fork=8 --session=missao-q2 hash.txt.
/etc/shadow de um alvo Linux real e quebre os hashes com John. Lab no navegador, sem configuração.
Além das Wordlists: Modos Incremental e Máscara
Quando a wordlist se esgota e o hash continua intacto, você tem duas opções. O modo incremental gera candidatos a partir de uma distribuição de probabilidade aprendida. O modo máscara gera candidatos que correspondem a um padrão conhecido.
O incremental é a força bruta que as pessoas imaginam quando ouvem "quebra de senhas". O John gera senhas estatisticamente, começando pelas combinações de caracteres mais prováveis e expandindo. A invocação básica:
john --incremental=ASCII hash.txt
john --incremental=Digits hash.txt
john --incremental=Alnum hash.txtAs classes de caracteres padrão estão definidas em john.conf sob seções [Incremental:*]. Você pode editá-las, mas para quase qualquer execução real as classes padrão ASCII, Digits e Alnum cobrem o que você precisa. Incremental contra hashes rápidos funciona para senhas curtas (5-7 caracteres). Acima disso vira um problema matemático para o qual você não tem tempo.
O modo máscara é o que você usa quando há informação sobre a política de senhas. Suponha que a organização-alvo exija "8 caracteres, primeira letra maiúscula, termina em dígito-dígito-especial". Isso mapeia diretamente para uma máscara:
john --mask=?u?l?l?l?l?l?d?d?s hash.txtOs marcadores são iguais aos do Hashcat: ?l minúscula, ?u maiúscula, ?d dígito, ?s especial, ?a tudo imprimível. Uma máscara de nove caracteres como a acima gera cerca de 30 bilhões de candidatos. Contra NTLM sem salt, termina em segundos; contra bcrypt, você precisa de outro plano.
Na prática, o modo máscara é a técnica mais subutilizada por novos pentesters. O instinto é continuar moendo wordlists. O ganho é gastar dez minutos perguntando ao cliente sobre a política de senhas, e então codificar essa política como uma máscara. Quebras que wordlists falham por horas caem em minutos com uma máscara bem direcionada.
Regras: Multiplicando Sua Wordlist
As regras são a funcionalidade que transforma uma lista de 14 milhões de palavras em um ataque de 14 bilhões de candidatos. Cada regra muta cada entrada da wordlist: anexa dígitos, capitaliza, faz substituição leet-speak, inverte a string. Uma wordlist vira centenas de variantes por palavra.
Os conjuntos de regras embutidos mais úteis:
--rules=Single- regras padrão do John, ajustadas para velocidade. Rápidas, cobertura decente, sua escolha padrão.--rules=Wordlist- parecida com Single mas com mutações de caso mais agressivas.--rules=Jumbo- tudo junto. Todos os padrões de mutação que o John conhece. Lenta contra hashes caros.--rules=KoreLogic- regras das competições crackme da DEF CON da equipe KoreLogic. Ajustadas para padrões reais de senhas corporativas.
O comando de combate padrão para um ambiente corporativo desconhecido:
john --wordlist=rockyou.txt --rules=Jumbo --fork=8 hash.txtIsso roda todas as regras que o John tem contra todas as palavras do rockyou, paralelizado em 8 núcleos. Em NTLM sem salt, a varredura completa termina em 30-60 minutos em hardware comum. Espere taxa de quebra de 60-75% num dump corporativo típico.
Regras personalizadas vão em ~/.john/john.conf sob uma seção [List.Rules:Custom]. A sintaxe está documentada na referência oficial de regras do John the Ripper; espere uma curva de aprendizado. Para 95% das missões, as regras embutidas superam qualquer coisa que você escreveria sozinho no tempo disponível. Pule regras personalizadas até ter um motivo específico para escrevê-las, como uma empresa que exige senhas no formato "$Estação$Ano#" e as regras padrão estão perdendo o cerquilha final.
Um exemplo de cadeia de mutação. Com --rules=KoreLogic aplicado, a entrada password da wordlist gera candidatos incluindo Password1, P@ssw0rd, password!, password123, P@ssw0rd! e Password2024. Nenhum está no rockyou diretamente. Todos aparecem em dumps reais de senhas. É isso que as regras compram para você.
Quebrando Tipos de Hash do Mundo Real
Arquivos de hashes puros são território de iniciante. Missões reais entregam arquivos criptografados, material de chaves e dumps de banco de dados que precisam de pré-processamento antes que o John possa tocar neles. Os scripts auxiliares *2john lidam com esse pré-processamento.
Arquivos shadow do Linux
Os arquivos /etc/passwd e /etc/shadow precisam ser combinados num único arquivo de entrada:
unshadow /etc/passwd /etc/shadow > shadow-combined.txt
john --wordlist=rockyou.txt --rules=Single shadow-combined.txtA maioria das distribuições Linux modernas usa SHA-512crypt ($6$) ou yescrypt ($y$). Os dois são lentos de propósito. Espere cerca de 10 mil candidatos por segundo num CPU desktop. Wordlist mais regras é a estratégia realista; incremental completo não é.
Pratique o pipeline completo no lab Shadow Cracker: extraia /etc/shadow de um alvo, rode unshadow e quebre o resultado com John.
Arquivos ZIP, PDF, Office e chaves SSH
Cada tipo de arquivo tem um extrator correspondente:
zip2john secret.zip > zip.hash
pdf2john confidential.pdf > pdf.hash
office2john document.docx > office.hash
ssh2john id_rsa > ssh.hash
keepass2john credentials.kdbx > kp.hashEm seguida, quebre cada saída com o comando padrão do John. O catálogo de labs inclui Crack SHA1 Hash para prática com hashes puros e labs dedicados a quebra de ZIP e PDF na categoria password-cracking.
Hashes NTLM e do Active Directory
Dumps NTDS.dit do secretsdump.py saem num formato que o John lê diretamente. Filtre primeiro os hashes relevantes:
cut -d: -f4 ntds.dit.dump > ntlm-hashes.txt
john --format=NT --wordlist=rockyou.txt --rules=KoreLogic ntlm-hashes.txtNTLM é sem salt e rápido. Mesmo num CPU, espere milhões de candidatos por segundo. Contra um dump típico do AD, planeje 60-80% de taxa de quebra na primeira hora usando rockyou mais regras KoreLogic. Os 20-40% restantes são geralmente senhas longas aleatórias ou no estilo passphrase; mude para uma wordlist mais longa ou uma máscara direcionada se necessário.
Última verificação: abril de 2026 contra John the Ripper 1.9.0-jumbo-1 no Kali 2026.1.
John the Ripper vs Hashcat: Quando Usar Cada Um
Escolha John quando flexibilidade de formato ou extração de hash importa. Escolha Hashcat quando velocidade bruta importa. A resposta honesta é que a maioria dos pentesters usa os dois; a tabela abaixo cobre os casos onde um claramente vence.
| Cenário | John | Hashcat |
|---|---|---|
| Arquivo shadow do Linux (sha512crypt, yescrypt) | Sim | Sim |
| NTLM, hashes rápidos sem salt em GPU | Funciona, mais lento | Mais rápido |
| Extração de ZIP, PDF, Office, KeePass | Embutido | Precisa de ferramenta externa |
| Passphrase de chave SSH privada | ssh2john | Possível, desajeitado |
| Keychain do Mac OS X | Nativo | Não suportado |
| Detecção automática de formato | Sim | Flag de modo manual |
| Aceleração de GPU | Limitada | Primeira classe |
| Cobertura de 470+ formatos | Sim | 350+ mas mix diferente |
| Melhor mecanismo de regras | Bom | Melhor, mais permissivo |
O fluxo realista em missões: usar os *2john do John para extrair hashes de arquivos, identificar o formato, e então enviar hashes rápidos para o Hashcat na GPU e hashes lentos ou incomuns para o John no CPU. As duas ferramentas compartilham wordlists e (com pequenos ajustes) arquivos de regras. Mantê-las no mesmo diretório e alternar entre elas é normal.
Perguntas Frequentes
O John the Ripper é gratuito?
Sim. John the Ripper é software open-source liberado sob uma licença personalizada compatível com GPL. O build jumbo mantido pela comunidade também é gratuito. A Openwall vende uma versão Pro comercial com otimizações adicionais e wordlists incluídas, mas o build jumbo gratuito é o que 99% dos pentesters usam, e cobre todas as técnicas deste tutorial.
Quanto tempo o John the Ripper leva para quebrar uma senha?
O tempo de quebra depende quase inteiramente do algoritmo de hash e da complexidade da senha, não da ferramenta. Um hash NTLM sem salt com uma senha de 8 caracteres do rockyou quebra em segundos. Um hash bcrypt com fator de custo 12 e uma senha aleatória de 12 caracteres pode levar séculos em hardware de consumidor. A escolha do algoritmo define o orçamento de tempo; a ferramenta apenas executa a comparação.
O John the Ripper consegue quebrar senhas de WiFi?
O John consegue quebrar os formatos PMKID e handshake de 4 etapas WPA/WPA2 depois de convertê-los a partir de uma captura de pacotes usando hcxpcapngtool ou utilitário similar. Para praticar num ambiente guiado, o lab WiFi Password Cracker percorre o fluxo completo de captura à quebra. Para velocidade bruta contra hashes WPA, Hashcat em GPU é mais rápido, mas John funciona bem em CPU para quebras pontuais.
John the Ripper ou Hashcat: qual é melhor para iniciantes?
John the Ripper é mais amigável para iniciantes por causa da detecção automática e da ergonomia de linha de comando mais simples. Você aponta o John para um arquivo de hashes e ele descobre o resto. Hashcat exige consultar números de modo e é mais rígido quanto ao formato de entrada. Quando os fundamentos pegam, a maioria dos pentesters acaba usando os dois. Comece com John, adicione Hashcat quando precisar de velocidade de GPU.
Onde posso praticar John the Ripper legalmente?
Use ambientes de treinamento dedicados. O curso de Password Cracking da HackerDNA e os labs sob ele fornecem alvos vulneráveis que existem especificamente para prática ofensiva. Plataformas de CTF (labs HackerDNA, OverTheWire, picoCTF) e VMs intencionalmente vulneráveis do VulnHub também são adequadas. Nunca rode John contra sistemas, arquivos ou hashes que você não possui ou para os quais não tem autorização escrita explícita para testar.
Considerações Legais e Éticas
Aviso crítico: Quebre apenas senhas para as quais você tem autorização escrita explícita para testar. Quebra de senhas não autorizada é crime sob o CFAA (EUA), a Lei Carolina Dieckmann e o Marco Civil da Internet (Brasil), o Computer Misuse Act (Reino Unido) e legislações equivalentes em quase todas as jurisdições. A posse de credenciais quebradas sem autorização é em si um crime em muitos lugares.
Missões autorizadas de pentest, competições de CTF e seus próprios ambientes de lab dedicados são os únicos contextos seguros para o John the Ripper. Seu documento de escopo de trabalho deve incluir explicitamente quebra de senhas como atividade aprovada. Se não incluir, obtenha confirmação escrita antes de extrair o primeiro hash.
Para prática, fique em ambientes controlados. Os labs HackerDNA, VMs do VulnHub e configurações Docker locais de aplicações intencionalmente vulneráveis existem especificamente para aprendizado ofensivo e não trazem exposição legal. Dumps reais de senhas vindos de vazamentos (além de conjuntos de treino bem conhecidos como rockyou.txt) não devem ser baixados nem armazenados, mesmo para "pesquisa". A exposição legal não vale a conveniência.
Quando você quebrar senhas durante uma missão autorizada, trate a saída como alguns dos dados mais sensíveis que o cliente possui. Armazene credenciais quebradas em forma criptografada, compartilhe-as somente pelos canais combinados e apague-as quando a missão fechar. O projeto OWASP publica orientações sobre armazenamento de senhas e autenticação que ajudam quando clientes perguntam como se defender contra as técnicas que você acabou de demonstrar.
Seus Próximos Passos com o John the Ripper
John the Ripper é uma daquelas ferramentas onde a leitura te leva a 20% e o resto vem de rodar contra hashes reais. Instale o build jumbo, faça o modo wordlist rodar contra alguns hashes de prática, e então adicione regras. Depois de uma dúzia de missões, você saberá qual modo usar só pela forma da entrada.
Coloque as técnicas em prática no lab Shadow Cracker da HackerDNA, onde você extrai /etc/shadow de um alvo Linux e quebra os hashes de ponta a ponta. Para ir além, o curso de Password Cracking completo percorre todos os modos de ataque, tipos de hash e auxiliares *2john em lições guiadas com alvos reais. Comece com o plano gratuito da HackerDNA, sem cartão de crédito.
Parte da série Teste de Penetração
Artigos relacionados:
