Compreender Ataques de Dicionário com John the Ripper

Introdução

Neste laboratório, você obterá uma compreensão prática de ataques de dicionário usando John the Ripper, uma poderosa ferramenta de quebra de senhas. Você aprenderá a selecionar e combinar dicionários de forma eficaz, entenderá as limitações inerentes a este método de ataque e até mesmo gerará dicionários personalizados para aprimorar suas capacidades de quebra. Ao final deste laboratório, você será capaz de analisar as taxas de sucesso de ataques de dicionário e apreciar seu papel na cibersegurança.

Selecionar Dicionários Apropriados

Nesta etapa, você aprenderá a selecionar e usar um arquivo de dicionário apropriado para um ataque de dicionário com John the Ripper. Um ataque de dicionário tenta quebrar senhas tentando cada palavra em uma lista predefinida (dicionário). A eficácia deste ataque depende muito da qualidade e relevância do dicionário utilizado.

Primeiro, vamos verificar se o John the Ripper está instalado e se os arquivos de senha dummy passwords.txt e o arquivo de dicionário rockyou.txt estão presentes em seu diretório ~/project.

john --version
ls -l ~/project/passwords.txt ~/project/rockyou.txt

Você deverá ver uma saída semelhante a esta, confirmando a presença dos arquivos:

John the Ripper password cracker, version 1.9.0-jumbo-1 ...
-rw-r--r-- 1 labex labex XX Mar XX:XX /home/labex/project/passwords.txt
-rw-r--r-- 1 labex labex XX Mar XX:XX /home/labex/project/rockyou.txt

Agora, vamos realizar um ataque de dicionário básico usando o dicionário rockyou.txt contra nosso arquivo passwords.txt. A opção --wordlist especifica o arquivo de dicionário a ser usado.

john --wordlist=/home/labex/project/rockyou.txt /home/labex/project/passwords.txt

O John the Ripper tentará quebrar as senhas. Se for bem-sucedido, ele exibirá as senhas quebradas. Você poderá ver uma saída semelhante a esta:

Using default input encoding: UTF-8
Loaded 4 password hashes with no different salts (MD5 [MD5])
Will run till all hashes are cracked, or till a key is found for each (whichever comes first)
Press 'q' or Ctrl-C to abort, almost any other key for status
password         (user1)
admin            (user2)
123456           (user3)
labex            (user4)
4g 0:00:00:00 DONE (2023-03-15 10:30) 100.0% (ETA: 2023-03-15 10:30) 4g/s 16.0p/s 16.0c/s 16.0C/s password...labex
Session completed.

Para visualizar as senhas quebradas a qualquer momento, você pode usar a opção --show:

john --show /home/labex/project/passwords.txt

Este comando exibirá as senhas quebradas e os nomes de usuário correspondentes.

user1:password (user1)
user2:admin (user2)
user3:123456 (user3)
user4:labex (user4)

4 password hashes cracked, 0 left

Isso demonstra como selecionar e usar um dicionário para um ataque básico. O arquivo rockyou.txt é um exemplo comum de um dicionário contendo senhas frequentemente usadas.

Combinar Dicionários para Ataques Abrangentes

Nesta etapa, você aprenderá a combinar múltiplos dicionários para criar uma lista de palavras mais abrangente para o John the Ripper. A combinação de dicionários pode aumentar significativamente as chances de quebrar senhas, especialmente se as senhas alvo não forem encontradas em um único dicionário.

Primeiro, vamos criar outro pequeno arquivo de dicionário chamado common_words.txt em seu diretório ~/project.

echo "welcome" > ~/project/common_words.txt
echo "security" >> ~/project/common_words.txt
echo "network" >> ~/project/common_words.txt

Agora, combinaremos rockyou.txt e common_words.txt em um novo arquivo chamado combined_dictionary.txt. Podemos usar o comando cat para concatenar os arquivos e, em seguida, ordenar e remover duplicatas com uniq.

cat ~/project/rockyou.txt ~/project/common_words.txt | sort | uniq > ~/project/combined_dictionary.txt

Vamos inspecionar o conteúdo do novo combined_dictionary.txt para garantir que ele contenha palavras de ambos os dicionários originais e sem duplicatas.

cat ~/project/combined_dictionary.txt

Você deverá ver uma lista ordenada de palavras únicas de rockyou.txt e common_words.txt.

123456
admin
labex
network
password
secret
security
test
welcome

Agora, vamos usar este combined_dictionary.txt para um ataque de dicionário. Para esta demonstração, primeiro limparemos a sessão de quebra anterior do John para garantir um novo começo.

john --session=clear

Em seguida, execute o ataque usando o dicionário combinado:

john --wordlist=/home/labex/project/combined_dictionary.txt /home/labex/project/passwords.txt

O John the Ripper tentará quebrar as senhas usando a lista de palavras expandida. Se novas senhas tivessem sido adicionadas a passwords.txt que estivessem presentes em common_words.txt, elas seriam quebradas agora. Como nosso passwords.txt contém apenas senhas de rockyou.txt, a saída será semelhante à etapa anterior, mas demonstra o processo de uso de um dicionário combinado.

Using default input encoding: UTF-8
Loaded 4 password hashes with no different salts (MD5 [MD5])
Will run till all hashes are cracked, or till a key is found for each (whichever comes first)
Press 'q' or Ctrl-C to abort, almost any other key for status
password         (user1)
admin            (user2)
123456           (user3)
labex            (user4)
4g 0:00:00:00 DONE (2023-03-15 10:35) 100.0% (ETA: 2023-03-15 10:35) 4g/s 16.0p/s 16.0c/s 16.0C/s password...labex
Session completed.

Este processo destaca a importância de ter um dicionário diversificado e abrangente para uma quebra de senha eficaz.

Compreender as Limitações do Ataque de Dicionário

Nesta etapa, você explorará as limitações dos ataques de dicionário. Embora poderosos, os ataques de dicionário são eficazes apenas contra senhas que existem dentro do dicionário. Eles são ineficazes contra senhas complexas, únicas ou geradas aleatoriamente que não estão presentes na lista de palavras.

Para demonstrar essa limitação, vamos adicionar um novo usuário com uma senha forte e aleatória ao nosso arquivo passwords.txt. Usaremos uma senha que é altamente improvável de ser encontrada em um dicionário padrão. Por exemplo, P@ssw0rd!23AbC. Geraremos seu hash MD5.

echo "user5:$(echo -n 'P@ssw0rd!23AbC' | md5sum | awk '{print $1}')" >> /home/labex/project/passwords.txt

Agora, vamos limpar a sessão anterior do John e tentar quebrar as senhas novamente usando nosso combined_dictionary.txt.

john --session=clear
john --wordlist=/home/labex/project/combined_dictionary.txt /home/labex/project/passwords.txt

Observe a saída. O John the Ripper provavelmente quebrará as quatro primeiras senhas (user1, user2, user3, user4), mas falhará em quebrar a senha do user5 porque P@ssw0rd!23AbC não está em nosso dicionário.

Using default input encoding: UTF-8
Loaded 5 password hashes with no different salts (MD5 [MD5])
Will run till all hashes are cracked, or till a key is found for each (whichever comes first)
Press 'q' or Ctrl-C to abort, almost any other key for status
password         (user1)
admin            (user2)
123456           (user3)
labex            (user4)
4g 0:00:00:00 DONE (2023-03-15 10:40) 80.0% (ETA: 2023-03-15 10:40) 4g/s 16.0p/s 16.0c/s 16.0C/s password...labex
Session completed.

Para confirmar, use a opção --show:

john --show /home/labex/project/passwords.txt

Você verá que a senha do user5 permanece sem quebrar.

user1:password (user1)
user2:admin (user2)
user3:123456 (user3)
user4:labex (user4)

4 password hashes cracked, 1 left

Isso demonstra que os ataques de dicionário são limitados pelo conteúdo do dicionário. Senhas que não estão no dicionário, especialmente as fortes e únicas, não serão quebradas por este método. Isso destaca a importância de usar senhas fortes e imprevisíveis.

Implementar Geração de Dicionário Personalizado

Nesta etapa, você aprenderá a gerar um dicionário personalizado. Embora dicionários grandes pré-fabricados como rockyou.txt sejam úteis, às vezes você precisa criar um dicionário adaptado a um alvo ou cenário específico. Isso pode envolver o uso de informações conhecidas sobre o alvo (por exemplo, nomes de empresas, frases comuns, datas) para gerar senhas potenciais.

Usaremos a ferramenta crunch, que é excelente para gerar listas de palavras com base em conjuntos de caracteres e padrões especificados. O crunch não é instalado por padrão, então vamos instalá-lo primeiro.

sudo apt install -y crunch

Agora, vamos gerar um dicionário personalizado simples. Por exemplo, podemos gerar todas as combinações possíveis de letras minúsculas de um comprimento específico. Vamos criar um dicionário de todas as palavras de 4 caracteres em minúsculas.

crunch 4 4 -o ~/project/custom_4char_dictionary.txt -t @@@@

• 4 4: Especifica o comprimento mínimo e máximo das palavras a serem geradas (aqui, ambos são 4).
• -o ~/project/custom_4char_dictionary.txt: Especifica o arquivo de saída.
• -t @@@@: Especifica um padrão. @ representa letras minúsculas.

Este comando gerará um arquivo grande. Para fins de demonstração, vamos gerar um dicionário personalizado menor e mais gerenciável. Geraremos palavras de comprimento 3 a 4, usando apenas letras minúsculas e começando com 'a'.

crunch 3 4 abcdefghijklmnopqrstuvwxyz -o ~/project/custom_small_dictionary.txt -t a%@

• 3 4: Comprimento mínimo 3, comprimento máximo 4.
• abcdefghijklmnopqrstuvwxyz: Especifica o conjunto de caracteres a ser usado.
• -o ~/project/custom_small_dictionary.txt: Arquivo de saída.
• -t a%@: Padrão. a é um 'a' literal, % representa números, @ representa letras minúsculas. Vamos corrigir isso para gerar apenas letras minúsculas.

Vamos tentar um exemplo mais relevante para um dicionário personalizado: gerar variações de uma palavra conhecida, como "labex", com números anexados. Usaremos as regras de lista de palavras integradas do john para isso, o que é mais prático para variações comuns de senhas.

Primeiro, vamos criar uma lista de palavras base apenas com "labex".

echo "labex" > ~/project/base_word.txt

Agora, usaremos a opção --rules do John com um conjunto de regras comum (como Wordlist) para gerar variações. Isso é frequentemente usado com uma lista de palavras base.

john --wordlist=/home/labex/project/base_word.txt --rules=Wordlist --stdout > ~/project/labex_variations.txt

• --wordlist: A lista de palavras base.
• --rules=Wordlist: Aplica as regras padrão da lista de palavras (por exemplo, anexar números, alterar maiúsculas/minúsculas, etc.).
• --stdout: Imprime as palavras geradas na saída padrão.
• > ~/project/labex_variations.txt: Redireciona a saída para um arquivo.

Vamos inspecionar as variações geradas:

head -n 10 ~/project/labex_variations.txt

Você verá variações como labex1, Labex, labex!, etc.

labex
Labex
LABEX
labex1
labex2
labex3
labex4
labex5
labex6
labex7

Isso demonstra como gerar dicionários personalizados ou variações de palavras, o que pode ser crucial para ataques direcionados onde padrões específicos ou informações conhecidas sobre o alvo estão disponíveis.

Analisar Taxas de Sucesso de Ataques de Dicionário

Nesta etapa, você analisará as taxas de sucesso dos ataques de dicionário com base nos dicionários usados e na complexidade das senhas alvo. Compreender as taxas de sucesso ajuda a avaliar a eficácia de seus esforços de quebra e a postura de segurança dos sistemas.

Já vimos que palavras de dicionário simples são facilmente quebradas, enquanto senhas complexas não são. Vamos quantificar isso olhando para o número de senhas quebradas em comparação com o número total de hashes.

Primeiro, certifique-se de que a sessão do John esteja limpa.

john --session=clear

Agora, vamos executar o ataque novamente com nosso combined_dictionary.txt contra passwords.txt (que agora inclui user5 com uma senha forte).

john --wordlist=/home/labex/project/combined_dictionary.txt /home/labex/project/passwords.txt

Após a conclusão do ataque, use a opção --show para ver os resultados.

john --show /home/labex/project/passwords.txt

A saída mostrará as senhas quebradas e o número de hashes quebrados em comparação com o total.

user1:password (user1)
user2:admin (user2)
user3:123456 (user3)
user4:labex (user4)

4 password hashes cracked, 1 left

A partir desta saída, podemos calcular a taxa de sucesso: (Número de hashes quebrados / Número total de hashes) _ 100%.
Neste caso, (4 / 5) _ 100% = 80%.

Esta taxa de sucesso de 80% indica que, embora muitas senhas comuns tenham sido quebradas, a senha forte para user5 permaneceu segura contra este ataque de dicionário. Isso destaca que os ataques de dicionário são altamente eficazes contra senhas fracas, comuns ou baseadas em dicionário, mas falham contra senhas fortes e únicas.

Para analisar ainda mais, você pode experimentar diferentes dicionários (por exemplo, um dicionário muito pequeno e específico versus um muito grande e geral) e observar como a taxa de sucesso muda. Quanto maior e mais relevante for o dicionário, maior será a taxa de sucesso potencial contra senhas comuns. No entanto, para senhas verdadeiramente aleatórias e complexas, os ataques de dicionário sempre terão uma baixa taxa de sucesso, enfatizando a necessidade de outras técnicas de quebra (como força bruta) ou, mais importante, políticas de senhas fortes.

Esta análise reforça a importância de usar senhas fortes e únicas que não sejam facilmente adivinháveis ou encontradas em dicionários comuns para se proteger contra tais ataques.

Resumo

Neste laboratório, você ganhou experiência prática com John the Ripper e ataques de dicionário. Você aprendeu a selecionar e combinar dicionários para aprimorar os esforços de quebra. Você também compreendeu as limitações inerentes dos ataques de dicionário, particularmente contra senhas fortes e únicas. Além disso, você explorou métodos para gerar dicionários personalizados e analisou as taxas de sucesso desses ataques. Este laboratório forneceu insights práticos sobre uma técnica fundamental de quebra de senhas e reforçou a importância de práticas robustas de segurança de senhas.