Use o John the Ripper para Quebrar Hashes MD5

Introdução

Neste laboratório, você explorará as capacidades do John the Ripper, uma ferramenta de quebra de senhas de código aberto amplamente utilizada. Você se concentrará em quebrar hashes MD5, que são comumente usados para armazenar representações de senhas. Compreender como quebrar hashes é crucial para profissionais de segurança avaliarem a força das senhas e identificarem vulnerabilidades. Você aprenderá a gerar hashes MD5, prepará-los para o John the Ripper e, em seguida, usará diferentes técnicas de quebra, incluindo ataques de wordlist (lista de palavras) e modo incremental.

Gerar Hashes MD5 a partir de Senhas

Nesta etapa, você gerará hashes MD5 para algumas senhas de exemplo. Isso simulará um cenário em que você tem acesso a senhas com hash e precisa quebrá-las. Você usará o comando echo canalizado para md5sum para criar esses hashes.

Primeiro, vamos gerar um hash MD5 para a senha password123:

echo -n "password123" | md5sum

Você deverá ver uma saída semelhante a esta:

202cb962ac59075b964b07152d234b70  -

Em seguida, gere hashes MD5 para mais algumas senhas: labex e secret.

echo -n "labex" | md5sum
echo -n "secret" | md5sum

As saídas serão:

202cb962ac59075b964b07152d234b70  -
a0b923820dcc509a86619210ed1572e4  -
5ebe2294ecd0e0f08eab7690d2a6ee69  -

Esses hashes gerados serão usados nas etapas subsequentes para a quebra.

Criar um Arquivo de Hash para MD5

Nesta etapa, você criará um arquivo contendo os hashes MD5 que você gerou. O John the Ripper geralmente aceita um arquivo como entrada, onde cada linha contém um hash a ser quebrado. Você criará um arquivo chamado hashes.txt em seu diretório ~/project e o preencherá com os hashes MD5.

Primeiro, vamos criar o arquivo hashes.txt e adicionar os hashes MD5. Adicionaremos apenas a parte do hash, não o - ou o nome do arquivo.

echo "202cb962ac59075b964b07152d234b70" > ~/project/hashes.txt
echo "a0b923820dcc509a86619210ed1572e4" >> ~/project/hashes.txt
echo "5ebe2294ecd0e0f08eab7690d2a6ee69" >> ~/project/hashes.txt

Agora, verifique o conteúdo do arquivo hashes.txt usando o comando cat:

cat ~/project/hashes.txt

A saída deve ser semelhante a esta:

202cb962ac59075b964b07152d234b70
a0b923820dcc509a86619210ed1572e4
5ebe2294ecd0e0f08eab7690d2a6ee69

Este arquivo servirá como entrada para o John the Ripper.

Especificar o Tipo de Hash para o John the Ripper

Nesta etapa, você aprenderá como informar ao John the Ripper com qual tipo de hash ele está lidando. O John the Ripper suporta uma ampla variedade de tipos de hash, e especificar o tipo correto é crucial para o sucesso na quebra. Para hashes MD5, você usará o formato raw-md5.

Para verificar se o John the Ripper reconhece raw-md5 e para ver outros formatos suportados, você pode usar a opção --list=formats. No entanto, para este laboratório, usaremos diretamente o formato raw-md5.

Você pode testar o John the Ripper com um único hash e especificar o formato usando a opção --format. Isso ainda não quebrará o hash, mas confirma que o John pode processar o formato.

john --format=raw-md5 ~/project/hashes.txt --stdout

Este comando tentará processar os hashes em hashes.txt como raw-md5 e imprimi-los na saída padrão. Você ainda não verá senhas quebradas, mas isso confirma que o formato é reconhecido. A saída serão os próprios hashes, pois o John está apenas processando-os sem quebrá-los.

202cb962ac59075b964b07152d234b70
a0b923820dcc509a86619210ed1572e4
5ebe2294ecd0e0f08eab7690d2a6ee69

Esta etapa garante que o John the Ripper esteja configurado corretamente para lidar com hashes MD5.

Quebrar Hashes MD5 com Lista de Palavras

Nesta etapa, você usará uma lista de palavras (wordlist) para quebrar os hashes MD5. Um ataque de lista de palavras tenta quebrar senhas testando cada palavra em uma lista predefinida. Este é um método comum e frequentemente eficaz para quebrar senhas fracas.

Primeiro, você precisa de uma lista de palavras. Para este laboratório, você criará um arquivo simples de lista de palavras chamado wordlist.txt em seu diretório ~/project contendo senhas comuns, incluindo aquelas que você hasheou anteriormente.

echo "password123" > ~/project/wordlist.txt
echo "labex" >> ~/project/wordlist.txt
echo "secret" >> ~/project/wordlist.txt
echo "test" >> ~/project/wordlist.txt
echo "admin" >> ~/project/wordlist.txt

Agora, use o John the Ripper com a opção wordlist para quebrar os hashes:

john --format=raw-md5 --wordlist=~/project/wordlist.txt ~/project/hashes.txt

O John the Ripper processará o arquivo hashes.txt, tentando cada palavra de wordlist.txt contra os hashes MD5. Se uma correspondência for encontrada, ele exibirá a senha quebrada.

A saída deve mostrar as senhas quebradas:

Using default input encoding: UTF-8
Loaded 3 password hashes with no different salts (raw-md5 [MD5])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (202cb962ac59075b964b07152d234b70)
labex            (a0b923820dcc509a86619210ed1572e4)
secret           (5ebe2294ecd0e0f08eab7690d2a6ee69)
3g 0:00:00:00 DONE (2023-10-27 10:30) 100.0% (ETA: 00:00:00) 3.000g/s 15.00p/s 15.00c/s 15.00C/s password123 labex secret
Session completed.

Você também pode usar john --show para exibir as senhas quebradas do arquivo "pot" (potfile) do John the Ripper:

john --show ~/project/hashes.txt

Saída:

202cb962ac59075b964b07152d234b70:password123
a0b923820dcc509a86619210ed1572e4:labex
5ebe2294ecd0e0f08eab7690d2a6ee69:secret

3 password hashes cracked, 0 left

Isso demonstra a eficácia dos ataques de lista de palavras contra senhas comuns ou facilmente adivinháveis.

Quebrar Hashes MD5 com Modo Incremental

Nesta etapa, você usará o modo incremental do John the Ripper para quebrar hashes MD5. O modo incremental é um poderoso ataque de força bruta que tenta combinações de caracteres com base em um conjunto de caracteres (por exemplo, letras minúsculas, números, símbolos). É útil quando um ataque de lista de palavras falha, pois não depende de palavras pré-existentes.

Primeiro, vamos limpar o arquivo "pot" (potfile) do John para garantir que estamos começando do zero para esta tentativa de quebra. Isso é importante porque o John armazena senhas quebradas, e queremos ver o processo de quebra novamente.

john --session=my_session --restore=NONE

Agora, vamos tentar quebrar os hashes usando o modo incremental. Para fins de demonstração, usaremos um conjunto de caracteres muito pequeno e um comprimento máximo curto para manter o tempo de quebra gerenciável. Em um cenário real, o modo incremental pode levar muito tempo, dependendo da complexidade e do comprimento da senha.

john --format=raw-md5 --incremental=alnum --max-len=8 ~/project/hashes.txt

Aqui:

• --incremental=alnum: Diz ao John para usar caracteres alfanuméricos (a-z, A-Z, 0-9). O John possui modos incrementais predefinidos como alnum, alpha, digits, etc.
• --max-len=8: Limita o comprimento máximo da senha a 8 caracteres. Isso é crucial para manter o tempo de quebra curto para este laboratório.

O John the Ripper começará a gerar e testar combinações. Como nossas senhas (password123, labex, secret) estão dentro do conjunto de caracteres alnum e max-len=8 (para labex e secret), o John eventualmente as quebrará. password123 tem 11 caracteres de comprimento, portanto, não será quebrada com max-len=8.

A saída mostrará as senhas quebradas à medida que o John as encontra:

Using default input encoding: UTF-8
Loaded 3 password hashes with no different salts (raw-md5 [MD5])
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
labex            (a0b923820dcc509a86619210ed1572e4)
secret           (5ebe2294ecd0e0f08eab7690d2a6ee69)
2g 0:00:00:00 DONE (2023-10-27 10:35) 100.0% (ETA: 00:00:00) 2.000g/s 10.00p/s 10.00c/s 10.00C/s labex secret
Session completed.

Você pode novamente usar john --show para exibir as senhas quebradas:

john --show ~/project/hashes.txt

Saída:

a0b923820dcc509a86619210ed1572e4:labex
5ebe2294ecd0e0f08eab7690d2a6ee69:secret

2 password hashes cracked, 1 left

Observe que password123 não foi quebrada desta vez porque seu comprimento (11 caracteres) excedeu o limite --max-len=8. Isso destaca a importância de definir parâmetros apropriados para ataques incrementais.

Resumo

Neste laboratório, você usou com sucesso o John the Ripper para quebrar hashes MD5. Você começou gerando hashes MD5 a partir de senhas de exemplo e, em seguida, criou um arquivo de hash para o John the Ripper processar. Você aprendeu como especificar o tipo de hash (raw-md5) e, em seguida, aplicou duas técnicas de quebra diferentes: ataque de lista de palavras (wordlist attack) e modo incremental (incremental mode).

Você observou que os ataques de lista de palavras são eficazes contra senhas comuns encontradas em dicionários, enquanto o modo incremental fornece uma abordagem de força bruta para senhas mais complexas ou desconhecidas, embora com tempos de quebra potencialmente muito mais longos. Este laboratório fornece uma compreensão fundamental das técnicas de quebra de senhas usando o John the Ripper, que é uma habilidade valiosa para profissionais de cibersegurança.