Introdução
Neste laboratório, você aprenderá os fundamentos da quebra de senhas usando o Kali Linux, com foco na poderosa ferramenta John the Ripper. O objetivo principal é entender como quebrar hashes de senha do Linux, que são representações criptografadas de senhas normalmente armazenadas no arquivo /etc/shadow. Essa habilidade é essencial em testes de intrusão para identificar senhas fracas e melhorar a segurança do sistema.
Ao abrir o terminal, você será colocado automaticamente em um shell de contêiner do Kali Linux. Todos os comandos neste laboratório devem ser executados dentro deste ambiente. Por meio de instruções guiadas passo a passo, você trabalhará com arquivos de hash de exemplo, criará e usará listas de palavras personalizadas, comparará ferramentas de quebra como John the Ripper e Hashcat, e salvará seus resultados para análise. Este laboratório foi projetado para iniciantes e oferece uma experiência de aprendizado prática e clara em um ambiente controlado.
Configurando o Ambiente e Instalando Ferramentas
Nesta primeira etapa, prepararemos o ambiente Kali Linux instalando as ferramentas necessárias para a quebra de senhas. Como mencionado, sua sessão de terminal já está sendo executada dentro de um contêiner Kali Linux.
Usaremos duas ferramentas principais: John the Ripper, um quebrador de senhas versátil e amplamente utilizado, e Hashcat, outra ferramenta poderosa conhecida por sua velocidade e flexibilidade. O Hashcat requer um runtime OpenCL, portanto, também instalaremos um pacote CPU OpenCL neste contêiner.
Primeiro, atualize a lista de pacotes para garantir que você tenha acesso às versões mais recentes do software.
apt update
Em seguida, instale o John the Ripper, o Hashcat e o runtime CPU OpenCL usando o comando a seguir. O sinalizador -y confirma a instalação automaticamente.
apt install -y john hashcat pocl-opencl-icd
O processo de instalação pode levar alguns minutos. Assim que for concluído, você pode verificar se o John the Ripper foi instalado corretamente executando-o sem nenhuma opção.
john
Você deverá ver as informações de ajuda e versão, o que confirma que a ferramenta está pronta. A saída será semelhante a esta:
John the Ripper 1.9.0-jumbo-1+bleeding-aec1328d6c 2021-11-02 10:45:52 +0100 OMP [linux-gnu 64-bit x86_64 AVX512BW AC]
Copyright (c) 1996-2021 by Solar Designer and others
Homepage: https://www.openwall.com/john/
Usage: john [OPTIONS] [PASSWORD-FILES]
...
Em seguida, verifique a instalação do Hashcat verificando sua versão.
hashcat --version
A saída esperada exibirá o número da versão, como:
v6.2.5
Com ambas as ferramentas instaladas e verificadas, seu ambiente agora está preparado para os exercícios de quebra de senha nas etapas a seguir.
Criando um Arquivo de Hash de Exemplo
Agora que as ferramentas estão instaladas, precisamos de alguns dados para trabalhar. Nesta etapa, você criará um arquivo contendo hashes de senha reais do Linux que o John the Ripper pode processar. Esses hashes são formatados para imitar aqueles encontrados no arquivo /etc/shadow, que armazena com segurança as informações de senha do usuário em sistemas Linux. Isso permite que você pratique a quebra de senhas de maneira segura e controlada.
Todas as operações serão realizadas no diretório /root do contêiner Kali. Criaremos o arquivo de hash diretamente com hashes reais pré-gerados para senhas simples e comuns que podem ser quebradas rapidamente.
Crie o arquivo de hash de exemplo diretamente com o seguinte comando:
cd /root
echo -e "user1:\$6\$randomsalt\$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::\nuser2:\$6\$anothersalt\$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::" > sample_hashes.txt
Alternativamente, você pode criar o arquivo manualmente copiando e colando o conteúdo:
cd /root
cat > sample_hashes.txt << 'EOF'
user1:$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::
user2:$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::
EOF
O prefixo $6$ em cada linha indica que o hash é um hash SHA-512 crypt, um padrão comum para sistemas Linux modernos. O formato segue a estrutura do arquivo shadow: username:hashed_password:last_change:min_age:max_age:warning:inactive:expire:reserved.
Para confirmar se o arquivo foi criado corretamente, exiba seu conteúdo usando o comando cat:
cat /root/sample_hashes.txt
A saída deve mostrar as duas entradas de usuário com valores de hash reais:
user1:$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:18234:0:99999:7:::
user2:$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:18234:0:99999:7:::
Observações Importantes:
- Estes são hashes SHA-512 reais e formatados corretamente que o John the Ripper pode processar.
- As senhas são
passworde123456- senhas muito simples e comuns que garantidamente estão na lista de palavras padrão do John. - Isso garante uma quebra rápida para fins de demonstração, normalmente em segundos.
Com este arquivo de dados de exemplo pronto, você agora tem um alvo para sua prática de quebra de senhas. Na próxima etapa, você usará o John the Ripper para tentar quebrar esses hashes.
Quebrando Hashes com o Modo Padrão do John the Ripper
Com o arquivo de hash de exemplo no lugar, é hora de começar a quebrar com o John the Ripper. Por padrão, o John usa vários modos, incluindo um modo de "quebra única" (single crack) que usa o nome de usuário e outras informações para adivinhar senhas, seguido por um modo de lista de palavras com sua lista de senhas integrada. Este é um ótimo ponto de partida para identificar senhas fracas e comuns.
Execute o seguinte comando para iniciar o processo de quebra em seu arquivo sample_hashes.txt.
john /root/sample_hashes.txt
O John carregará os hashes e iniciará sua sessão de quebra. Você verá uma saída indicando seu progresso. Como criamos hashes reais com senhas muito simples e comuns (password e 123456), o John deve ser capaz de quebrá-los rapidamente usando seu modo de lista de palavras padrão.
Using default input encoding: UTF-8
Loaded 2 password hashes with 2 different salts (sha512crypt, crypt(3) $6$ [SHA512 512/512 AVX512BW 8x])
Cost 1 (iteration count) is 5000 for all loaded hashes
Will run 2 OpenMP threads
Proceeding with single, rules:Single
Press 'q' or Ctrl-C to abort, almost any other key for status
Almost done: Processing the remaining buffered candidate passwords, if any.
Proceeding with wordlist:/usr/share/john/password.lst
...
Você pode deixar o John rodar por um tempo para tentar a quebra, ou interromper o processo com Ctrl-C se quiser verificar os resultados antecipadamente. Para visualizar as senhas que foram quebradas, use a opção --show.
john --show /root/sample_hashes.txt
Se as senhas forem quebradas com sucesso, a saída deverá ser semelhante a esta:
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Como usamos senhas muito simples (password e 123456) que quase certamente estão na lista de palavras padrão do John, esses hashes devem ser quebrados muito rapidamente - geralmente em segundos. O sucesso demonstra que o John the Ripper está funcionando corretamente com nosso arquivo de hash real e mostra a rapidez com que senhas fracas podem ser comprometidas.
Na próxima etapa, exploraremos como fornecer ao John listas de palavras personalizadas e ajustar vários parâmetros para melhorar a eficiência da quebra.
Usando uma Lista de Palavras Personalizada com o John the Ripper
Confiar nas configurações padrão muitas vezes não é suficiente. Um ataque direcionado usando uma lista de palavras personalizada pode ser muito mais eficaz. Uma lista de palavras é simplesmente um arquivo de texto contendo uma senha potencial por linha. Nesta etapa, você criará uma pequena lista de palavras personalizada e a usará com o John the Ripper.
Crie um arquivo chamado custom_wordlist.txt no diretório /root com algumas senhas comuns, incluindo aquelas que sabemos que estão em nosso arquivo de hash.
echo -e "password\n123456\nadmin123\ntest1234\nqwerty\npassword123" > /root/custom_wordlist.txt
Verifique o conteúdo da sua nova lista de palavras.
cat /root/custom_wordlist.txt
A saída deve exibir as seis senhas que você acabou de adicionar:
password
123456
admin123
test1234
qwerty
password123
Agora, execute o John the Ripper novamente, mas desta vez, especifique sua lista de palavras personalizada usando a opção --wordlist.
john --wordlist=/root/custom_wordlist.txt /root/sample_hashes.txt
Este comando diz ao John para testar cada senha em custom_wordlist.txt contra os hashes em sample_hashes.txt. Como nossa lista de palavras contém as senhas reais (password e 123456) que correspondem aos hashes em nosso arquivo, o John deve quebrá-los muito rapidamente.
Após o término do processo, verifique os resultados novamente.
john --show /root/sample_hashes.txt
Como nossa lista de palavras contém as senhas corretas, a saída agora deve mostrar as credenciais quebradas:
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Isso demonstra a eficácia de ataques direcionados com listas de palavras. Ao incluir as senhas reais em nossa lista de palavras personalizada, conseguimos quebrar os hashes muito mais rápido do que confiando apenas na lista de palavras padrão do John. Essa técnica é fundamental para ataques de senha direcionados. A seguir, veremos como realizar um ataque semelhante com o Hashcat.
Quebrando Hashes com o Hashcat para Comparação
Embora o John the Ripper seja uma excelente ferramenta, é uma boa prática estar familiarizado com alternativas como o Hashcat. O Hashcat é conhecido por sua velocidade, especialmente em sistemas com GPUs. Aqui, realizaremos o mesmo ataque de dicionário usando o Hashcat.
O Hashcat prefere um arquivo limpo contendo apenas os valores de hash. Use o comando awk para extrair o segundo campo (o hash) de sample_hashes.txt e salvá-lo em um novo arquivo, clean_hashes.txt.
awk -F':' '{print $2}' /root/sample_hashes.txt > /root/clean_hashes.txt
Verifique o conteúdo do novo arquivo.
cat /root/clean_hashes.txt
A saída deve conter apenas as strings de hash:
$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/
Agora, execute o Hashcat. Você precisa especificar o modo de hash (-m 1800 para SHA-512 crypt) e o modo de ataque (-a 0 para um ataque de dicionário direto).
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt
Session..........: hashcat
Status...........: Cracked
Hash.Mode........: 1800 (sha512crypt $6$, SHA512 (Unix))
Hash.Target......: /root/clean_hashes.txt
Time.Started.....: Mon Sep 1 06:33:21 2025 (0 secs)
Time.Estimated...: Mon Sep 1 06:33:21 2025 (0 secs)
Kernel.Feature...: Pure Kernel
Guess.Base.......: File (/root/custom_wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........: 226 H/s (5.08ms) @ Accel:8 Loops:1024 Thr:1 Vec:8
Recovered........: 2/2 (100.00%) Digests (total), 1/2 (50.00%) Digests (new), 2/2 (100.00%) Salts
Progress.........: 6/12 (50.00%)
Rejected.........: 0/6 (0.00%)
Restore.Point....: 0/6 (0.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:4096-5000
Candidate.Engine.: Device Generator
Candidates.#1....: password -> password123
Antes de executar o ataque, confirme se o Hashcat consegue detectar um backend OpenCL:
hashcat -I
Se este comando informar que nenhuma plataforma OpenCL está disponível, instale o runtime CPU OpenCL e verifique novamente:
apt update
apt install -y pocl-opencl-icd
hashcat -I
Após o OpenCL ser detectado, execute o comando de quebra novamente. Se o Hashcat exibir um aviso neste ambiente conteinerizado, adicione --force.
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --force
Após a conclusão do ataque, visualize as senhas quebradas executando o comando com o sinalizador --show.
hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --show
Quando o ataque é bem-sucedido, o Hashcat exibe cada hash seguido pela senha quebrada, separados por dois pontos:
$6$randomsalt$WS2qjCQ1JrmZv8otdbtntIYu6lRzkk2aIVhgIMdMexOcvD9bEAoxtKcyZLXbR3wlhOOPBscJbLCPUU/fYjFhM0:password
$6$anothersalt$ZffCt8y5Hl8gLYS79/rhyT76C12kNhuOvkFR8Ll0RXcjQz2Nzuh3VUdT//e21HYfH6fP9btOp2aG22O3S7q1z/:123456
Esta etapa apresentou o Hashcat como uma alternativa poderosa para a quebra de senhas. Na etapa final, você aprenderá a documentar adequadamente suas descobertas.
Resumo
Neste laboratório, você obteve experiência prática com técnicas fundamentais de quebra de senhas em um ambiente Kali Linux. Você começou configurando seu espaço de trabalho, instalando ferramentas essenciais como John the Ripper e Hashcat. Em seguida, aprendeu a preparar dados de destino criando um arquivo de hash de exemplo que imita o formato /etc/shadow do Linux.
Você praticou o uso do John the Ripper com suas configurações padrão e com uma lista de palavras personalizada, e explorou o Hashcat como uma alternativa poderosa. Finalmente, você aprendeu a etapa crítica de salvar suas descobertas para documentação e relatório. Essas habilidades formam uma base sólida para testes de intrusão e destacam a importância de implementar políticas de senha fortes para se defender contra tais ataques.
