Solucionar Problemas Comuns do John the Ripper

Introdução

John the Ripper (JtR) é uma ferramenta de quebra de senhas open-source poderosa e amplamente utilizada. Embora seja incrivelmente eficaz, os usuários, especialmente os iniciantes, podem encontrar problemas comuns que interrompem seu progresso. Esses problemas podem variar de mensagens de erro crípticas a lentidão de desempenho.

Neste laboratório, você aprenderá a solucionar alguns dos problemas mais frequentes encontrados ao usar o John the Ripper. Abordaremos erros como "No hashes loaded" (Nenhum hash carregado), lidaremos com formatos de hash inválidos, abordaremos gargalos de desempenho, gerenciaremos arquivos de sessão corrompidos e aprenderemos onde encontrar ajuda quando estiver travado. Ao final deste laboratório, você estará mais bem equipado para diagnosticar e resolver problemas do JtR de forma eficiente.

Resolver o Erro "No hashes loaded"

Nesta etapa, investigaremos um dos erros mais comuns no John the Ripper: No password hashes loaded (Nenhum hash de senha carregado). Este erro geralmente ocorre por duas razões principais: o John já quebrou todos os hashes no arquivo fornecido, ou o arquivo não está em um formato que o John possa entender.

Primeiro, vamos executar o John em um arquivo de hash válido. O script de configuração já criou um arquivo chamado shadow.txt em seu diretório atual (~/project) que contém o hash de senha de um usuário em um formato que o John reconhece.

Vamos tentar quebrá-lo usando uma wordlist simples.

john --wordlist=pass.list shadow.txt

Você deverá ver uma saída indicando que o John carregou um hash e está tentando quebrá-lo. Ele deverá encontrar a senha rapidamente.

Using default input encoding: UTF-8
Loaded 1 password hash (descrypt, traditional crypt(3) [DES 128/128 SSE2-16])
Cost 1 (algorithm [1:descrypt]...
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (dummyuser)
1g 0:00:00:00 DONE (2023-10-27 10:30) 100.0g/s 100.0p/s 100.0c/s 100.0C/s password123
Use the "--show" option to display all of the cracked passwords reliably
Session completed

Agora que a senha foi quebrada, o John a armazena em um arquivo chamado john.pot. Vamos tentar executar o mesmo comando novamente.

john --wordlist=pass.list shadow.txt

Desta vez, você verá o erro.

Using default input encoding: UTF-8
No password hashes loaded (see FAQ)

Isso ocorre porque o John verifica o arquivo john.pot antes de iniciar e ignora quaisquer hashes que já foram quebrados. Você pode visualizar o conteúdo do arquivo john.pot para confirmar.

cat ~/.john/john.pot

A saída mostrará o hash e a senha quebrada.

$1$notarealhash$b5gQ1P2kPiyP2t.OqI0kS1:password123

Outra razão para este erro é um formato de arquivo inválido. Vamos criar um arquivo que não contenha nenhum hash.

echo "this is just a text file" > plain.txt

Agora, tente executá-lo no John.

john plain.txt

Você verá o mesmo erro "No password hashes loaded" porque o John não conseguiu encontrar nenhum dado no arquivo que se parecesse com um hash de senha. Sempre certifique-se de que seu arquivo de destino contenha hashes em um formato suportado.

Depurar o Erro "Invalid hash type"

Nesta etapa, abordaremos problemas relacionados a tipos de hash. Às vezes, o John não consegue detectar automaticamente o tipo de hash, ou um usuário pode especificar o incorreto usando o flag --format, levando a erros ou tentativas de quebra falhas.

Primeiro, vamos ver o que acontece quando o John encontra um arquivo com uma string de hash malformada. Temos um arquivo chamado invalid_hashes.txt para este propósito.

john invalid_hashes.txt

O John analisará o arquivo e relatará que não conseguiu carregar nenhum hash válido, semelhante ao erro da etapa anterior.

Using default input encoding: UTF-8
No password hashes loaded (see FAQ)

Agora, vamos usar um arquivo com um hash válido, mas especificar o formato incorreto. Nosso arquivo hashes_md5.txt contém um hash padrão raw-MD5, mas diremos ao John que é um hash NT.

john --wordlist=pass.list --format=nt hashes_md5.txt

O John produzirá um aviso ou erro porque os dados do hash não correspondem ao formato especificado.

Warning: invalid ciphertext ignored: user1:5d41402abc4b2a76b9719d911017c592
No password hashes loaded (see FAQ)

Para corrigir isso, você deve fornecer o formato de hash correto. Se você souber que o formato é raw-MD5, pode especificá-lo diretamente. Isso geralmente é mais rápido do que deixar o John detectá-lo automaticamente.

Vamos executar o comando com o formato correto.

john --wordlist=pass.list --format=raw-md5 hashes_md5.txt

Desta vez, o comando é bem-sucedido e quebra a senha.

Using default input encoding: UTF-8
Loaded 1 password hash (raw-MD5 [MD5 128/128 SSE2-16])
Cost 1 (iteration count) is 1 for all loaded hashes
Press 'q' or Ctrl-C to abort, almost any other key for status
labex            (user1)
1g 0:00:00:00 DONE (2023-10-27 10:35) 100.0g/s 1234Kp/s 1234Kc/s 1234KC/s 123..labex
Use the "--show" option to display all of the cracked passwords reliably
Session completed

Se você não tiver certeza do tipo de hash, pode omitir o flag --format e deixar o John tentar detectá-lo automaticamente. No entanto, para hashes ambíguos ou não padrão, especificar o formato é a melhor maneira de garantir o sucesso.

Abordar Gargalos de Desempenho

Nesta etapa, exploraremos como identificar e resolver problemas de desempenho. A quebra de senhas pode ser uma tarefa que consome muitos recursos, e o baixo desempenho pode torná-la impraticável.

Uma métrica chave para o desempenho no John the Ripper é "candidatos por segundo" (c/s). Você pode executar um benchmark para ver o quão bem seu sistema se sai com diferentes algoritmos de hashing.

john --test

Este comando executará uma série de benchmarks. Observe a saída para as taxas de c/s de vários algoritmos.

Benchmarking: descrypt, traditional crypt(3) [DES 128/128 SSE2-16]... DONE
Many salts:	1234K c/s real, 1234K c/s virtual
Only one salt:	1111K c/s real, 1111K c/s virtual

... (muitos outros algoritmos) ...

Benchmarking: raw-MD5 [MD5 128/128 SSE2-16]... DONE
Raw:	45678K c/s real, 45678K c/s virtual

Uma das maneiras mais eficazes de melhorar o desempenho em um sistema multi-core é usar processamento paralelo. O John pode fazer isso com a opção --fork=N, onde N é o número de processos a serem iniciados.

Antes de testarmos isso, vamos limpar o arquivo john.pot para que possamos quebrar novamente o hash da Etapa 1.

rm ~/.john/john.pot

Agora, vamos executar uma sessão de quebra em um único núcleo no shadow.txt. Enquanto estiver em execução, pressione qualquer tecla (como Enter) para ver o status. Observe a taxa de c/s.

john --wordlist=pass.list shadow.txt

Após um momento, pressione Enter. Você verá uma linha de status. Em seguida, pressione Ctrl+C para pará-lo.

Agora, vamos tentar novamente com dois processos paralelos.

john --fork=2 --wordlist=pass.list shadow.txt

Desta vez, o John usará dois núcleos de CPU para trabalhar na tarefa. Se você verificar o status, a taxa geral de c/s deverá ser significativamente maior, quase o dobro da taxa de um único núcleo. Isso pode reduzir drasticamente o tempo necessário para uma sessão de quebra.

Outras dicas de desempenho incluem:

• Usar wordlists direcionadas: Uma wordlist menor e mais relevante é mais rápida do que uma massiva e genérica.
• Especificar o formato: Como visto na Etapa 2, usar --format evita a sobrecarga da detecção automática.

Lidar com Arquivos de Sessão Corrompidos

Nesta etapa, aprenderemos como lidar com um arquivo de sessão corrompido. O John the Ripper salva automaticamente seu progresso em um arquivo de sessão (com a extensão .rec) localizado no diretório ~/.john/. Isso permite pausar e retomar sessões de quebra de longa duração. No entanto, se este arquivo ficar corrompido, você não poderá restaurar sua sessão.

Vamos iniciar uma nova sessão. Chamaremos ela de my_session.

john --session=my_session --wordlist=pass.list corrupt_me.txt

Deixe o comando rodar por alguns segundos, depois pressione Ctrl+C para pará-lo graciosamente. O John salvará seu progresso.

Session aborted

Você pode ver o arquivo de sessão que foi criado.

ls ~/.john/

john.log  john.pot  my_session.rec

Agora, vamos simular um arquivo corrompido adicionando alguns dados lixo a ele.

echo "THIS IS CORRUPTED DATA" >> ~/.john/my_session.rec

Com o arquivo de sessão corrompido, vamos tentar retomar nosso trabalho.

john --restore=my_session

O John falhará ao analisar o arquivo de recuperação e provavelmente sairá com uma mensagem de erro. O erro exato pode variar, mas indicará um problema com o arquivo .rec.

Error in recovery file: ~/.john/my_session.rec

Quando isso acontece, a única solução é remover o arquivo de sessão corrompido. Isso significa que você perderá o progresso dessa sessão específica e terá que recomeçá-la. No entanto, quaisquer senhas que já foram quebradas com sucesso estão seguras no arquivo john.pot.

Vamos remover o arquivo corrompido.

rm ~/.john/my_session.rec

Agora você pode iniciar a sessão novamente desde o início. Este é um passo crucial de solução de problemas para se recuperar de falhas inesperadas ou desligamentos do sistema durante uma tentativa de quebra.

Buscar Ajuda na Comunidade John the Ripper

Nesta etapa, abordaremos o que fazer quando você tentou de tudo e ainda está travado. A comunidade John the Ripper é um excelente recurso, mas para obter ajuda eficaz, você precisa fornecer as informações corretas.

O principal local para suporte da comunidade é a lista de e-mails john-users. Antes de postar, é uma boa prática pesquisar nos arquivos para ver se sua pergunta já foi respondida.

Quando precisar pedir ajuda, fornecer informações claras e completas é fundamental. Aqui está o que você deve sempre incluir em sua solicitação:

1. Versão do John the Ripper: Versões diferentes têm recursos e bugs diferentes.
2. O Comando Exato: O comando completo que você usou para executar o John.
3. A Saída Completa: Toda a saída do comando, incluindo quaisquer mensagens de erro.
4. Sistema Operacional: O SO que você está usando (por exemplo, Ubuntu 22.04, Windows 10).
5. Amostra do Hash: Um exemplo do hash que você está tentando quebrar (se não for sensível).

Você pode obter sua versão do John the Ripper com o flag --version. Vamos executá-lo agora.

john --version

A saída será algo como isto:

John the Ripper 1.9.0-jumbo-1 [linux-gnu 64-bit x86_64 AVX2 AC]

Saber como coletar essas informações tornará muito mais fácil para os membros da comunidade entenderem seu problema e fornecerem uma solução útil. Lembre-se de ser educado e paciente ao pedir ajuda às comunidades de código aberto.

Resumo

Neste laboratório, você ganhou experiência prática na solução de alguns dos problemas mais comuns com o John the Ripper.

Você aprendeu a:

• Diagnosticar o erro No hashes loaded verificando o arquivo john.pot para senhas já quebradas e verificando o formato do arquivo de entrada.
• Resolver problemas de tipo de hash usando o flag --format para especificar o algoritmo correto.
• Abordar gargalos de desempenho executando benchmarks e usando a opção --fork para processamento paralelo.
• Recuperar-se de uma tentativa de quebra falha removendo um arquivo de sessão corrompido (.rec).
• Coletar as informações necessárias, como a versão do JtR e a saída do comando, para buscar ajuda eficazmente da comunidade.

Com essas habilidades, você agora está mais preparado para usar o John the Ripper de forma mais eficaz e resolver problemas à medida que surgem.