Introdução
Neste laboratório, você ganhará experiência prática com o John the Ripper, uma ferramenta de auditoria de segurança de senhas e recuperação de senhas de código aberto amplamente utilizada. Compreender como usar tais ferramentas é crucial para identificar vulnerabilidades em políticas de senhas e fortalecer a segurança geral do sistema. Você aprenderá os passos práticos envolvidos na coleta de hashes de senhas, no uso do John the Ripper para identificar senhas fracas, na geração de relatórios sobre senhas quebradas e na formulação de recomendações para políticas de senhas aprimoradas. Este laboratório também abordará a automação do processo de auditoria de senhas, fornecendo uma visão abrangente das melhores práticas de segurança de senhas.
Coletar Hashes de Senha para Auditoria
Nesta etapa, você aprenderá como coletar hashes de senha, que são essenciais para a auditoria de senhas. Em sistemas Linux, os hashes de senha são tipicamente armazenados no arquivo /etc/shadow. No entanto, o acesso direto a este arquivo requer privilégios de root. Para fins deste laboratório, criamos um arquivo shadow fictício chamado /etc/shadow_dummy que você utilizará.
Primeiro, vamos examinar o conteúdo do arquivo shadow fictício.
cat /etc/shadow_dummy
Você deverá ver uma saída semelhante a esta, mostrando nomes de usuário e seus hashes de senha correspondentes:
user1:5f4dcc3b5aa765d61d8327deb882cf99
user2:21232f297a57a5a743894a0e4a801fc3
user3:d41d8cd98f00b204e9800998ecf8427e
user4:e10adc3949ba59abbe56e057f20f883e
user5:a8b7c6d5e4f3g2h1i0j9k8l7m6n5o4p3
Em seguida, você copiará este arquivo shadow fictício para o seu diretório de trabalho atual (~/project) para torná-lo facilmente acessível para o John the Ripper.
cp /etc/shadow_dummy ~/project/hashes.txt
Agora, verifique se o arquivo hashes.txt foi copiado com sucesso para o seu diretório ~/project.
ls ~/project/hashes.txt
A saída deve confirmar a presença do arquivo:
/home/labex/project/hashes.txt
Executar John the Ripper para Identificação de Senhas Fracas
Nesta etapa, você usará o John the Ripper para identificar senhas fracas a partir do arquivo hashes.txt que você preparou. O John the Ripper pode usar vários modos de quebra, incluindo ataques de dicionário. Realizaremos um ataque de dicionário usando uma lista de palavras pré-definida.
Primeiro, certifique-se de estar no diretório ~/project, onde seus arquivos hashes.txt e wordlist.txt estão localizados.
cd ~/project
Agora, execute o John the Ripper usando o arquivo hashes.txt e o arquivo wordlist.txt. A opção --wordlist especifica o caminho para sua lista de palavras.
john --wordlist=wordlist.txt hashes.txt
O John the Ripper começará a processar os hashes. Se encontrar alguma correspondência, ele exibirá as senhas quebradas. A saída pode ser semelhante a esta:
Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (LM HASH, descrypt/BSDI crypt/other crypt(3) [DES/AES-NI])
Press 'q' or Ctrl-C to abort, almost any other key for status
password (user1)
123456 (user2)
test (user3)
admin (user4)
4g 0:00:00:00 DONE (2023-10-27 08:30) 400% (ETA: 08:30) 0.000c/s 0p/s 4.000w/s 4.000P/s user1, user2, user3, user4
Session completed.
Neste exemplo, o John the Ripper quebrou com sucesso as senhas de user1, user2, user3 e user4. A senha de user5 não foi quebrada porque não está em nossa lista de palavras simples.
Para ver as senhas que o John quebrou até agora, você pode usar a opção --show.
john --show hashes.txt
A saída listará as senhas quebradas:
user1:password
user2:123456
user3:test
user4:admin
4 password hashes cracked, 1 left
Este comando é útil para revisar os resultados da sua sessão de quebra.
Gerar Relatórios sobre Senhas Quebradas
Nesta etapa, você aprenderá como gerar relatórios sobre as senhas quebradas. O John the Ripper armazena as senhas quebradas em um arquivo, tipicamente ~/.john/john.pot. Você pode usar a opção --show para exibir essas senhas quebradas, o que serve como um relatório básico.
Para obter uma lista limpa de senhas quebradas, você pode redirecionar a saída de john --show para um arquivo. Esta é uma prática comum para gerar relatórios que podem ser posteriormente analisados ou compartilhados.
Primeiro, vamos garantir que estamos no diretório ~/project.
cd ~/project
Agora, redirecione a saída de john --show hashes.txt para um novo arquivo chamado cracked_passwords.txt.
john --show hashes.txt > cracked_passwords.txt
Este comando não produzirá nenhuma saída no terminal, mas criará o arquivo cracked_passwords.txt no seu diretório atual.
Em seguida, visualize o conteúdo do arquivo cracked_passwords.txt para confirmar que o relatório foi gerado corretamente.
cat cracked_passwords.txt
Você deverá ver a lista de senhas quebradas, semelhante ao seguinte:
user1:password
user2:123456
user3:test
user4:admin
4 password hashes cracked, 1 left
Este arquivo cracked_passwords.txt agora serve como seu relatório, detalhando as contas de usuário com senhas fracas e quebradas. Em um cenário do mundo real, este relatório seria usado para identificar usuários que precisam alterar suas senhas imediatamente.
Recomendar Melhorias na Política de Senhas
Nesta etapa, você formulará recomendações para melhorar as políticas de senhas com base nas descobertas da auditoria de senhas. Identificar senhas fracas é apenas o primeiro passo; o próximo passo crucial é implementar medidas para prevenir tais vulnerabilidades no futuro.
Com base nas senhas quebradas (password, 123456, test, admin), fica claro que a política de senhas atual (ou a falta dela) permite senhas muito simples e comuns.
Aqui estão algumas recomendações-chave para melhorar as políticas de senhas:
- Comprimento Mínimo: Imponha um comprimento mínimo de senha, tipicamente 12 caracteres ou mais. Senhas mais longas são exponencialmente mais difíceis de quebrar.
- Requisitos de Complexidade: Exija o uso de uma mistura de tipos de caracteres:
- Letras maiúsculas (A-Z)
- Letras minúsculas (a-z)
- Números (0-9)
- Caracteres especiais (!@#$%^&*()_+-=[]{}|;:'",.<>/?`~)
- Evitar Senhas Comuns: Implemente uma lista negra de senhas comumente usadas ou facilmente adivinháveis (como as encontradas em nosso
wordlist.txt). Muitos sistemas podem verificar novas senhas contra tais listas negras. - Sem Informações Pessoais: Aconselhe os usuários a não usar informações pessoais (nomes, aniversários, nomes de animais de estimação) que possam ser facilmente adivinhadas ou encontradas online.
- Alterações Regulares (com cautela): Embora historicamente recomendado, alterações frequentes e obrigatórias de senha podem levar os usuários a escolher senhas mais simples e previsíveis. Uma abordagem melhor é impor senhas fortes e exigir alterações apenas se uma violação for suspeita.
- Autenticação Multifator (MFA): Para sistemas críticos, implemente MFA. Mesmo que uma senha seja comprometida, o MFA adiciona uma camada extra de segurança.
- Gerenciadores de Senhas: Incentive ou forneça gerenciadores de senhas aos usuários. Essas ferramentas podem gerar e armazenar senhas fortes e exclusivas para diferentes serviços.
Para demonstrar compreensão, considere como você comunicaria essas recomendações. Por exemplo, você poderia redigir uma declaração de política simples.
Vamos criar um arquivo chamado password_policy_recommendations.txt no seu diretório ~/project e adicionar algumas recomendações importantes a ele.
cd ~/project
echo "--- Password Policy Recommendations ---" | tee password_policy_recommendations.txt > /dev/null
echo "1. Minimum length: 12 characters" | tee -a password_policy_recommendations.txt > /dev/null
echo "2. Complexity: Mix of uppercase, lowercase, numbers, special characters" | tee -a password_policy_recommendations.txt > /dev/null
echo "3. Avoid common passwords and personal information" | tee -a password_policy_recommendations.txt > /dev/null
echo "4. Implement Multi-Factor Authentication (MFA) for critical systems" | tee -a password_policy_recommendations.txt > /dev/null
Agora, visualize o conteúdo do arquivo password_policy_recommendations.txt.
cat password_policy_recommendations.txt
A saída deve mostrar suas recomendações:
--- Password Policy Recommendations ---
1. Minimum length: 12 characters
2. Complexity: Mix of uppercase, lowercase, numbers, special characters
3. Avoid common passwords and personal information
4. Implement Multi-Factor Authentication (MFA) for critical systems
Este arquivo representa um relatório básico das suas recomendações.
Automatizar o Processo de Auditoria de Senhas
Nesta etapa, você explorará como automatizar partes do processo de auditoria de senhas. Embora o John the Ripper seja uma ferramenta manual, sua execução pode ser roteirizada para rodar periodicamente, tornando o processo de auditoria mais eficiente e proativo. A automação ajuda a monitorar continuamente a força das senhas e a identificar novas vulnerabilidades à medida que elas surgem.
Uma maneira simples de automatizar é criar um script shell que execute as etapas que você aprendeu: coletar hashes, executar o John the Ripper e gerar um relatório.
Vamos criar um script shell simples chamado audit_script.sh no seu diretório ~/project.
cd ~/project
nano audit_script.sh
Dentro do editor nano, adicione o seguinte conteúdo:
#!/bin/bash
## Define paths
HASH_FILE="/etc/shadow_dummy" ## In a real scenario, this would be /etc/shadow
WORDLIST_FILE="wordlist.txt"
OUTPUT_DIR="~/project/audit_results"
CRACKED_REPORT="$OUTPUT_DIR/cracked_passwords_$(date +%Y%m%d_%H%M%S).txt"
## Create output directory if it doesn't exist
mkdir -p "$OUTPUT_DIR"
echo "--- Starting Password Audit ---"
## Step 1: Copy hashes
cp "$HASH_FILE" "$OUTPUT_DIR/hashes.txt"
echo "Hashes copied to $OUTPUT_DIR/hashes.txt"
## Step 2: Run John the Ripper
echo "Running John the Ripper..."
john --wordlist="$WORDLIST_FILE" "$OUTPUT_DIR/hashes.txt"
## Step 3: Generate report
echo "Generating cracked password report..."
john --show "$OUTPUT_DIR/hashes.txt" > "$CRACKED_REPORT"
echo "Audit complete. Report saved to $CRACKED_REPORT"
echo "--- Audit Finished ---"
Pressione Ctrl+X, depois Y, e depois Enter para salvar e sair do nano.
Em seguida, torne o script executável:
chmod +x audit_script.sh
Agora, execute o script para vê-lo em ação:
./audit_script.sh
Você verá uma saída semelhante às etapas manuais, indicando que o processo de auditoria está em execução e um relatório está sendo gerado.
--- Starting Password Audit ---
Hashes copied to /home/labex/project/audit_results/hashes.txt
Running John the Ripper...
Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (LM HASH, descrypt/BSDI crypt/other crypt(3) [DES/AES-NI])
Press 'q' or Ctrl-C to abort, almost any other key for status
password (user1)
123456 (user2)
test (user3)
admin (user4)
4g 0:00:00:00 DONE (2023-10-27 08:35) 400% (ETA: 08:35) 0.000c/s 0p/s 4.000w/s 4.000P/s user1, user2, user3, user4
Session completed.
Generating cracked password report...
Audit complete. Report saved to /home/labex/project/audit_results/cracked_passwords_YYYYMMDD_HHMMSS.txt
--- Audit Finished ---
Finalmente, verifique se o diretório audit_results e um arquivo de relatório dentro dele foram criados.
ls ~/project/audit_results/
Você deverá ver hashes.txt e um arquivo cracked_passwords_YYYYMMDD_HHMMSS.txt (onde YYYYMMDD_HHMMSS é o timestamp atual).
cracked_passwords_20231027_083500.txt hashes.txt
Este script pode ser agendado para rodar periodicamente usando ferramentas como cron em um sistema Linux real, permitindo a auditoria contínua de senhas.
Resumo
Neste laboratório, você aprendeu com sucesso a usar o John the Ripper para auditoria de senhas. Você começou coletando hashes de senhas de um arquivo shadow fictício, depois usou o John the Ripper com uma lista de palavras para identificar senhas fracas. Você gerou um relatório das senhas quebradas e formulou recomendações-chave para melhorar as políticas de senhas, como impor comprimento mínimo, complexidade e evitar senhas comuns. Finalmente, você criou um script shell básico para automatizar o processo de auditoria de senhas, demonstrando como essas tarefas podem ser integradas a uma estratégia contínua de monitoramento de segurança. Esta experiência prática fornece uma compreensão fundamental da auditoria de segurança de senhas, uma habilidade crítica para qualquer administrador de sistema ou profissional de segurança.
