Quebra de Senhas no Kali com John

Introdução

Neste laboratório, você aprenderá os fundamentos da quebra de senhas usando o Kali Linux, focando na poderosa ferramenta John the Ripper. O objetivo principal é entender como quebrar hashes de senhas do Linux, que são representações criptografadas de senhas normalmente armazenadas no arquivo /etc/shadow. Esta habilidade é essencial em testes de invasão (pentest) para identificar senhas fracas e melhorar a segurança do sistema.

Ao abrir o terminal, você será colocado automaticamente em um shell de container do Kali Linux. Todos os comandos neste laboratório devem ser executados dentro deste ambiente. Através de instruções guiadas passo a passo, você trabalhará com arquivos de hash de exemplo, criará e usará listas de palavras (wordlists) personalizadas, comparará ferramentas de quebra como o John the Ripper e o Hashcat, e salvará seus resultados para análise. Este laboratório foi projetado para iniciantes e oferece uma experiência de aprendizado clara e prática em um ambiente controlado.

Configurando o Ambiente e Instalando Ferramentas

Nesta primeira etapa, vamos preparar o ambiente Kali Linux instalando as ferramentas necessárias para a quebra de senhas. Como mencionado, sua sessão de terminal já está rodando dentro de um container Kali Linux.

Usaremos duas ferramentas principais: o John the Ripper, um quebrador de senhas versátil e amplamente utilizado, e o Hashcat, outra ferramenta poderosa conhecida por sua velocidade e flexibilidade. Ambas são essenciais para o kit de ferramentas de qualquer testador de invasão.

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 e o Hashcat usando o comando abaixo. A flag -y confirma automaticamente a instalação.

apt install -y john hashcat

O processo de instalação pode levar alguns minutos. Assim que terminar, 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 checando 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 está agora preparado para os exercícios de quebra de senha nas etapas seguintes.

Criando um Arquivo de Hash de Exemplo

Agora que as ferramentas estão instaladas, precisamos de dados para trabalhar. Nesta etapa, você criará um arquivo contendo hashes de senhas reais do Linux que o John the Ripper pode processar. Esses hashes são formatados para imitar os encontrados no arquivo /etc/shadow, que armazena com segurança as informações de senha dos usuários em sistemas Linux. Isso permite que você pratique a quebra de forma segura e controlada.

Todas as operações serão realizadas no diretório /root do container 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 criptográfico SHA-512, um padrão comum para sistemas Linux modernos. O formato segue a estrutura do arquivo shadow: usuario:senha_hasheada:ultima_alteracao:idade_min:idade_max:aviso:inativo:expira:reservado.

Para confirmar que 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:::

Notas Importantes:

• Estes são hashes SHA-512 reais e devidamente formatados que o John the Ripper pode processar.
• As senhas são password e 123456 - senhas muito simples e comuns que certamente estão na wordlist padrão do John.
• Isso garante uma quebra rápida para fins de demonstração, geralmente em poucos 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 pronto, é hora de começar a quebra 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 no 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 o progresso. Como criamos hashes reais com senhas muito simples e comuns (password e 123456), o John deve ser capaz de quebrá-las rapidamente usando seu modo de wordlist 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 quaisquer senhas que tenham sido quebradas, use a opção --show.

john --show /root/sample_hashes.txt

Se as senhas forem quebradas com sucesso, a saída deverá ser assim:

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 wordlist padrão do John, esses hashes devem ser quebrados muito rapidamente - muitas vezes em segundos. O sucesso demonstra que o John the Ripper está funcionando corretamente com nosso arquivo de hash real e mostra quão rapidamente 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 Wordlist Personalizada com o John the Ripper

Confiar apenas nas configurações padrão muitas vezes não é suficiente. Um ataque direcionado usando uma lista de palavras (wordlist) personalizada pode ser muito mais eficaz. Uma wordlist é simplesmente um arquivo de texto contendo uma senha potencial por linha. Nesta etapa, você criará uma pequena wordlist 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 wordlist.

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 wordlist 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 wordlist contém as senhas reais (password e 123456) que correspondem aos hashes em nosso arquivo, o John deve quebrá-las muito rapidamente.

Após o término do processo, verifique os resultados novamente.

john --show /root/sample_hashes.txt

Como nossa wordlist 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 dos ataques de wordlist direcionados. Ao incluir as senhas reais em nossa wordlist personalizada, conseguimos quebrar os hashes muito mais rápido do que dependendo apenas da wordlist padrão do John. Esta técnica é fundamental para ataques de senha direcionados. Em seguida, veremos como realizar um ataque semelhante com o Hashcat.

Quebrando Hashes com Hashcat para Comparação

Embora o John the Ripper seja uma ferramenta excelente, é uma boa prática estar familiarizado com alternativas como o Hashcat. O Hashcat é renomado 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

O Hashcat iniciará a sessão de quebra. Como nossa wordlist contém as senhas corretas (password e 123456), o Hashcat deve quebrar esses hashes muito rapidamente. Depois que terminar, visualize as senhas quebradas executando o mesmo comando com a flag --show.

hashcat -m 1800 -a 0 /root/clean_hashes.txt /root/custom_wordlist.txt --show

Se o ataque for bem-sucedido, o Hashcat exibirá o 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ê adquiriu 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 o John the Ripper e o Hashcat. Em seguida, aprendeu a preparar os dados alvo criando um arquivo de hash de exemplo que imita o formato /etc/shadow do Linux.

Você praticou o uso do John the Ripper tanto com suas configurações padrão quanto com uma wordlist personalizada, e explorou o Hashcat como uma alternativa poderosa. Por fim, aprendeu a etapa crítica de salvar suas descobertas para documentação e relatórios. Essas habilidades formam uma base sólida para testes de invasão e destacam a importância de implementar políticas de senhas fortes para se defender contra tais ataques.