Quebrar Hashes de um Potfile do John the Ripper

Introdução

John the Ripper (JtR) é uma ferramenta popular para quebrar senhas. Quando ele quebra uma senha com sucesso, armazena o resultado em um arquivo chamado john.pot, frequentemente referido como "potfile". Isso impede que o JtR perca tempo tentando quebrar o mesmo hash novamente no futuro.

Neste laboratório, você trabalhará em um cenário onde uma tentativa de quebra de senha já foi parcialmente concluída pelo John the Ripper. Sua tarefa é identificar quais hashes não foram quebrados e, em seguida, usar uma ferramenta poderosa diferente, o Hashcat, para tentar quebrar os restantes. Este fluxo de trabalho é comum em testes de penetração e auditorias de segurança, onde várias ferramentas são usadas para maximizar os resultados.

Você aprenderá a:

• Localizar e entender o potfile do JtR.
• Usar ferramentas de linha de comando para extrair e comparar listas de hashes.
• Usar o Hashcat para realizar um ataque de dicionário nos hashes restantes.

Localizar um Potfile Existente do John the Ripper

Nesta etapa, você localizará e inspecionará o arquivo john.pot. Este arquivo é criado automaticamente pelo John the Ripper para armazenar os hashes que ele quebrou com sucesso, juntamente com suas senhas em texto plano. O local padrão para este arquivo é dentro de um diretório oculto chamado .john no diretório home do usuário.

Nosso ambiente de laboratório foi pré-configurado com um arquivo john.pot de uma sessão de cracking anterior simulada. Vamos visualizar seu conteúdo.

Use o comando cat para exibir o conteúdo do potfile. Todo o seu trabalho será feito no diretório padrão ~/project, mas o potfile está localizado em /home/labex/.john/.

cat ~/.john/john.pot

Você deverá ver a seguinte saída, que mostra os hashes e as senhas correspondentes que o JtR já encontrou.

$1$abc$gqNud23o1vjR/pYd9gH7k/:password123
$1$def$H9g2s3kLd/fG1hJkLpQ9r/:labex
$1$ghi$aB4c5dE6fG7hI8jK9lM0n/:secret

Compreender o Formato de um Potfile do JtR

Nesta etapa, analisaremos a estrutura do arquivo john.pot. Compreender este formato é crucial para processar seus dados.

Como você viu na etapa anterior, cada linha no potfile tem um formato específico:

HASH:SENHAPLANATEXTO

Vamos analisar a primeira linha do nosso arquivo:

$1$abc$gqNud23o1vjR/pYd9gH7k/:password123

• $1$abc$gqNud23o1vjR/pYd9gH7k/: Esta é a string completa do hash que foi quebrado. Este formato (começando com $1$) indica que é um hash MD5-crypt, comumente usado em sistemas Linux mais antigos.
• :: Um dois pontos é usado como delimitador, separando o hash da senha.
• password123: Esta é a senha em texto plano que corresponde ao hash.

Nosso objetivo é descobrir quais hashes da nossa lista original (all_hashes.txt) não estão presentes neste potfile. Para fazer isso, primeiro precisamos isolar apenas a parte do hash de cada linha em john.pot. Faremos isso na próxima etapa. Esta etapa atual é para compreensão conceitual, portanto, não há comandos para executar.

Extrair Hashes do Potfile do JtR

Nesta etapa, você extrairá apenas os valores de hash do arquivo john.pot. Podemos usar o comando cut, um utilitário padrão do Linux para extrair seções de cada linha de um arquivo.

Direcionaremos o cut para usar o dois pontos (:) como delimitador e para extrair o primeiro campo (-f1). Redirecionaremos a saída para um novo arquivo chamado cracked_hashes.txt em seu diretório atual (~/project).

Execute o seguinte comando em seu terminal:

cut -d: -f1 ~/.john/john.pot > cracked_hashes.txt

Agora, verifique se o arquivo foi criado corretamente visualizando seu conteúdo:

cat cracked_hashes.txt

A saída deverá conter apenas as strings de hash:

$1$abc$gqNud23o1vjR/pYd9gH7k/
$1$def$H9g2s3kLd/fG1hJkLpQ9r/
$1$ghi$aB4c5dE6fG7hI8jK9lM0n/

Reformatar os Hashes para um Ataque Hashcat

Nesta etapa, você identificará os hashes que o JtR não conseguiu quebrar. Você tem um arquivo com todos os hashes originais (all_hashes.txt) e um arquivo com os hashes que já foram quebrados (cracked_hashes.txt). Ao comparar esses dois arquivos, você pode criar uma nova lista contendo apenas os hashes não quebrados.

Usaremos o comando grep para realizar isso. As flags que usaremos são:

• -v: Inverte a correspondência, selecionando linhas não correspondentes.
• -F: Trata os padrões como strings fixas, não como expressões regulares.
• -f file: Obtém os padrões do arquivo especificado.

Este comando lerá os padrões de cracked_hashes.txt e removerá quaisquer linhas correspondentes de all_hashes.txt, salvando o resultado em uncracked_hashes.txt.

grep -v -F -f cracked_hashes.txt all_hashes.txt > uncracked_hashes.txt

Agora, verifique o conteúdo do seu novo arquivo. Ele deve conter os três hashes que não estavam no potfile.

cat uncracked_hashes.txt

Você deverá ver a seguinte saída:

user4:$1$jkl$oP1qR2sT3uV4wX5yZ6a7b/
user5:$1$mno$c8d9e0f1g2h3i4j5k6l7m/
user6:$1$pqr$n9o8p7q6r5s4t3u2v1w0x/

Este arquivo está agora pronto para ser usado com o Hashcat.

Usar Hashcat para Tentar Quebrar Hashes Perdidos pelo JtR

Nesta etapa final, você usará o Hashcat para atacar os hashes restantes. O Hashcat é um cracker de senhas muito rápido e versátil que pode alavancar GPUs para ganhos massivos de desempenho.

A sintaxe básica para um ataque de dicionário com Hashcat é hashcat -m <mode> <hash_file> <wordlist_file>.

• -m 500: Isso especifica o tipo de hash. 500 corresponde a MD5-crypt, que é o tipo de hash com o qual estamos trabalhando.
• --force: Esta opção é frequentemente necessária em ambientes virtualizados ou conteinerizados como este laboratório para ignorar avisos e forçar o Hashcat a executar.

Agora, execute o Hashcat contra o arquivo uncracked_hashes.txt usando o wordlist.txt fornecido.

hashcat -m 500 --force uncracked_hashes.txt wordlist.txt

O Hashcat iniciará. Você verá informações de status enquanto ele executa. Como nossa lista de palavras é pequena e contém as senhas corretas, o processo será muito rápido.

...
Session..........: hashcat
Status...........: Running
Hash.Name........: md5crypt, MD5 (Unix), Cisco-IOS $1$ (MD5)
Hash.Target......: uncracked_hashes.txt
...
Approaching final keyspace - workload adjusted.

Session..........: hashcat
Status...........: Cracked
...

Assim que o Hashcat terminar, ele armazena as senhas quebradas em seu próprio potfile. Para visualizar as senhas recém-quebradas, você pode usar a opção --show.

hashcat -m 500 --force --show uncracked_hashes.txt

A saída exibirá os hashes e suas senhas em texto plano recém-descobertas.

$1$jkl$oP1qR2sT3uV4wX5yZ6a7b/:dragon
$1$mno$c8d9e0f1g2h3i4j5k6l7m/:qwerty
$1$pqr$n9o8p7q6r5s4t3u2v1w0x/:sunshine

Parabéns, você usou com sucesso a saída de uma ferramenta de cracking para guiar a entrada de outra!

Resumo

Neste laboratório, você aprendeu um fluxo de trabalho prático para combinar os pontos fortes de diferentes ferramentas de cracking de senhas. Você começou com um potfile existente do John the Ripper, que representa os resultados de uma sessão de cracking anterior.

Você conseguiu:

• Localizar e interpretar o conteúdo de um arquivo john.pot.
• Usar o comando cut para extrair campos de dados específicos.
• Usar o comando grep para comparar duas listas e isolar os hashes não quebrados.
• Lançar um ataque de dicionário do Hashcat nos hashes restantes e quebrá-los com sucesso.

Este processo de identificar o trabalho restante e passá-lo para outra ferramenta é uma estratégia altamente eficiente em avaliações de segurança do mundo real, permitindo que você cubra mais terreno e aumente suas chances de sucesso.