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 e salvará seus resultados para revisão posterior. Este laboratório foi projetado para iniciantes e mantém o fluxo de trabalho focado no John the Ripper, que funciona de forma confiável no ambiente de contêiner fornecido.
Configurando o Ambiente e Instalando Ferramentas
Nesta primeira etapa, prepararemos o ambiente Kali Linux instalando a ferramenta principal para este laboratório. Como mencionado, sua sessão de terminal já está sendo executada dentro de um contêiner Kali Linux.
Usaremos o John the Ripper, um quebrador de senhas versátil e amplamente utilizado que funciona de forma confiável no contêiner do LabEx fornecido.
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 usando o seguinte comando. A flag -y confirma automaticamente a instalação.
apt install -y john
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]
...
Com o John the Ripper instalado e verificado, 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 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 formatados corretamente que o John the Ripper pode processar.
- As senhas são
passworde123456- senhas muito simples e comuns que certamente 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 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 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 deve 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 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 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á-las 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 contando apenas com a lista de palavras padrão do John. Essa técnica é fundamental para ataques de senha direcionados. Na etapa final, você salvará as credenciais quebradas em um arquivo de relatório para revisão posterior.
Salvando as Senhas Quebradas
Nesta etapa, você salvará as credenciais quebradas da sua sessão do John the Ripper em um arquivo de relatório. Este é um hábito prático durante o trabalho de auditoria de senhas, pois permite que você revise as contas recuperadas posteriormente sem precisar executar o processo de quebra novamente.
Use john --show para exibir as senhas recuperadas e, em seguida, redirecione essa saída para /root/cracked_passwords.txt.
john --show /root/sample_hashes.txt > /root/cracked_passwords.txt
Exiba o relatório salvo para confirmar que ele contém as credenciais quebradas.
cat /root/cracked_passwords.txt
A saída deve ser semelhante a esta:
user1:password:18234:0:99999:7:::
user2:123456:18234:0:99999:7:::
2 password hashes cracked, 0 left
Se o arquivo ainda não contiver nenhuma senha quebrada, execute novamente o comando john --wordlist=/root/custom_wordlist.txt /root/sample_hashes.txt da etapa anterior e salve os resultados novamente.
Ao salvar as senhas quebradas em um arquivo, você completa o fluxo de trabalho desde a preparação do hash até os resultados documentados. Isso lhe dá um registro reutilizável que você pode inspecionar ou compartilhar durante uma revisão de segurança controlada.
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 e instalando o John the Ripper. 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 depois salvou as credenciais recuperadas em um arquivo de relatório para revisão posterior. 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.
