John the Ripper e Aceleração de Hardware (GPU)

Introdução

Neste laboratório, você explorará a poderosa combinação do John the Ripper (JtR) e Unidades de Processamento Gráfico (GPUs) para a quebra acelerada de senhas. A quebra tradicional baseada em CPU pode ser lenta, especialmente para senhas complexas. As GPUs, com suas capacidades massivas de processamento paralelo, podem reduzir drasticamente o tempo necessário para quebrar senhas.

Você começará entendendo os princípios fundamentais por trás da quebra por GPU, depois prosseguirá com os passos práticos de configuração do seu ambiente. Isso inclui a instalação de drivers de GPU e frameworks necessários como CUDA ou OpenCL. Em seguida, você configurará o John the Ripper para utilizar sua GPU, medirá seu desempenho (benchmark) e aprenderá técnicas comuns de solução de problemas. Ao final deste laboratório, você terá uma compreensão sólida de como usar efetivamente a aceleração por GPU com o John the Ripper.

Compreender os Princípios da Quebra por GPU

Nesta etapa, você aprenderá os princípios fundamentais que permitem às GPUs acelerar a quebra de senhas.

As GPUs são projetadas para processamento paralelo, o que significa que podem realizar muitos cálculos simultaneamente. Essa arquitetura é ideal para tarefas como a quebra de senhas, onde a mesma operação (por exemplo, gerar o hash de um candidato a senha) precisa ser realizada milhões ou bilhões de vezes.

Conceitos Chave:

• Paralelismo: Ao contrário das CPUs, que se destacam em tarefas sequenciais, as GPUs possuem milhares de núcleos menores que podem trabalhar em partes independentes de um problema de forma concorrente. Na quebra de senhas, cada núcleo pode testar um candidato a senha diferente.
• Algoritmos de Hash: A quebra de senhas envolve gerar repetidamente o hash de senhas candidatas e comparar o resultado com um hash conhecido. Muitos algoritmos de hash (como MD5, SHA-1, bcrypt, scrypt) são computacionalmente intensivos, tornando-os bons candidatos para aceleração por GPU.
• CUDA/OpenCL: Estas são plataformas de computação paralela e modelos de programação que permitem aos desenvolvedores de software usar uma GPU para processamento de propósito geral.
  • CUDA (Compute Unified Device Architecture): Desenvolvido pela NVIDIA, é uma plataforma proprietária para GPUs NVIDIA.
  • OpenCL (Open Computing Language): Um padrão aberto para programação paralela em plataformas heterogêneas (CPUs, GPUs, FPGAs, etc.) de diferentes fornecedores. O John the Ripper suporta ambos.

Como Funciona:

1. Carregar Hashes: O John the Ripper carrega os hashes de senha alvo na memória da GPU.
2. Gerar Candidatos: A GPU gera um grande número de candidatos a senha (por exemplo, a partir de uma wordlist ou por força bruta).
3. Gerar Hash e Comparar: Cada núcleo da GPU gera simultaneamente o hash de seus candidatos atribuídos e compara o hash resultante com os hashes alvo.
4. Relatar Quebras: Se uma correspondência for encontrada, a senha quebrada é relatada.

Essa execução paralela reduz significativamente o tempo necessário para encontrar uma senha correspondente.

Instalar Drivers de GPU e CUDA/OpenCL

Nesta etapa, você preparará seu ambiente LabEx para aceleração por GPU instalando os drivers necessários e o framework OpenCL. Como os ambientes LabEx são virtualizados e podem não ter acesso direto a GPUs físicas, simularemos a configuração instalando as bibliotecas de desenvolvimento OpenCL, que são essenciais para os módulos de GPU do John the Ripper.

Primeiro, atualize a lista de pacotes para garantir que você obtenha as versões mais recentes do software.

sudo apt update

Em seguida, instale o pacote ocl-icd-opencl-dev. Este pacote fornece o carregador (loader) do OpenCL Installable Client Driver (ICD) e os arquivos de desenvolvimento, que são cruciais para que aplicativos como o John the Ripper interajam com dispositivos compatíveis com OpenCL.

sudo apt install -y ocl-icd-opencl-dev

Após a instalação, você pode verificar se as bibliotecas OpenCL estão presentes. Embora você não tenha uma GPU física para consultar com clinfo, a presença dos arquivos de desenvolvimento indica que o sistema está configurado para compilar e executar aplicativos OpenCL.

ls -l /usr/lib/x86_64-linux-gnu/libOpenCL.so

Você deverá ver uma saída semelhante a esta, confirmando a existência da biblioteca:

lrwxrwxrwx 1 root root 19 Mar 28  2023 /usr/lib/x86_64-linux-gnu/libOpenCL.so -> libOpenCL.so.1.0.0

Esta etapa garante que os componentes fundamentais do OpenCL estejam disponíveis para o John the Ripper detectar e utilizar.

Configurar o John the Ripper para Uso de GPU

Nesta etapa, você instalará o John the Ripper e verificará sua capacidade de detectar OpenCL. Embora o ambiente LabEx possa não ter uma GPU física, os módulos OpenCL do John the Ripper ainda estarão presentes e poderão ser configurados.

Primeiro, instale o John the Ripper.

sudo apt install -y john

Após a instalação, você pode verificar as capacidades do John the Ripper, procurando especificamente pelo suporte OpenCL. O comando john --list=opencl-devices do John the Ripper é usado para listar os dispositivos OpenCL detectados. Em um ambiente virtualizado sem uma GPU física, ele pode não listar nenhum dispositivo real, mas o próprio comando confirma que os módulos OpenCL foram compilados no John the Ripper.

john --list=opencl-devices

Você poderá ver uma saída indicando "No OpenCL devices found" (Nenhum dispositivo OpenCL encontrado) ou algo semelhante, o que é esperado neste ambiente virtual. A parte importante é que o comando é executado sem erros, confirmando que as capacidades OpenCL do JtR estão presentes.

No OpenCL devices found.

Em seguida, vamos criar um arquivo de hash fictício para nos prepararmos para a quebra. Usaremos um hash MD5 simples para demonstração.

echo "testuser:5d41402abc4b2a76b9719d911017c592" > ~/project/hashes.txt

Isso cria um arquivo hashes.txt em seu diretório ~/project com um hash para a senha "hello".

Agora, tente quebrar o hash usando o John the Ripper. Mesmo sem uma GPU física, o John the Ripper tentará usar seus módulos habilitados para OpenCL, se disponíveis, recorrendo à CPU se nenhum dispositivo for encontrado.

john --format=raw-md5 ~/project/hashes.txt --wordlist=/usr/share/john/password.lst

Você deverá ver uma saída indicando que o John the Ripper está processando o hash. Se a senha "hello" estiver na wordlist padrão, ela será quebrada.

Using default input encoding: UTF-8
Loaded 1 password hash (Raw-MD5 [MD5])
Cost 1 (iteration count) is 1 for all loaded hashes
Will run 4 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
hello            (testuser)
1g 0:00:00:00 DONE (2024-01-01 12:00) 100.0% 1000000g/s 1000000p/s 1000000c/s 1000000C/s testuser
Session completed.

Esta etapa confirma que o John the Ripper está instalado, seus componentes OpenCL são reconhecidos e ele pode processar hashes.

Benchmarking do Desempenho de Quebra por GPU

Nesta etapa, você aprenderá como fazer o benchmark do desempenho do John the Ripper. Embora estejamos em um ambiente virtualizado sem uma GPU física, entender o processo de benchmarking é crucial para cenários do mundo real. O John the Ripper possui uma ferramenta de benchmarking integrada que pode testar vários tipos de hash.

Para fazer o benchmark do John the Ripper, use a opção --test. Este comando executará uma série de testes em diferentes algoritmos de hash, mostrando a velocidade de quebra (adivinhações por segundo) para cada um.

john --test

A saída será extensa, mostrando o desempenho para vários tipos de hash. Procure por linhas que incluam "OpenCL" em sua descrição, caso algum dispositivo OpenCL tenha sido detectado. Mesmo que nenhuma GPU física esteja presente, o John the Ripper ainda poderá relatar o desempenho teórico do OpenCL com base em seus módulos compilados.

Exemplo de saída (truncada por brevidade):

Benchmarking: Raw-MD5 [MD5]... DONE
Many salts:     1000000 c/s real, 1000000 c/s virtual
Only one salt:  1000000 c/s real, 1000000 c/s virtual

Benchmarking: bcrypt ($2*$, $2a$, $2x$, $2y$, $2b$) [Blowfish OpenCL]... DONE
Many salts:     1000000 c/s real, 1000000 c/s virtual
Only one salt:  1000000 c/s real, 1000000 c/s virtual

Os valores c/s (candidatos por segundo) ou p/s (senhas por segundo) indicam a velocidade de quebra. Em um ambiente real com uma GPU poderosa, esses números seriam significativamente mais altos para algoritmos acelerados por GPU em comparação com benchmarks apenas de CPU.

Você também pode fazer o benchmark de um tipo de hash específico, por exemplo, raw-md5, para obter resultados mais focados:

john --test=0 --format=raw-md5

Este comando faz o benchmark especificamente do formato raw-md5. A opção --test=0 executa o benchmark por um curto período, o que é útil para verificações rápidas.

Compreender esses resultados de benchmark é fundamental para avaliar a eficácia da sua configuração de GPU e comparar diferentes configurações de hardware.

Solução de Problemas de Quebra por GPU

Nesta etapa, você aprenderá técnicas comuns de solução de problemas para o John the Ripper e aceleração por GPU. Embora o ambiente LabEx não possua uma GPU física, entender essas etapas é crucial para aplicações do mundo real.

Problemas Comuns e Soluções:

1. "No OpenCL devices found" (Nenhum dispositivo OpenCL encontrado) ou "CUDA error":

   • Causa: Drivers de GPU incorretos ou ausentes, ou SDK OpenCL/CUDA não instalado corretamente.
   • Solução: Certifique-se de que seus drivers de GPU estejam atualizados e instalados corretamente. Para GPUs NVIDIA, instale o CUDA Toolkit. Para GPUs AMD/Intel, certifique-se de que os drivers OpenCL estejam instalados. Em um ambiente virtual, esta mensagem é esperada se nenhuma GPU virtual for exposta.
   • Verificação: Execute john --list=opencl-devices ou nvidia-smi (para NVIDIA) para verificar a detecção do dispositivo.

2. Desempenho Insuficiente:

   • Causa: Drivers desatualizados, memória de GPU insuficiente ou uso de um tipo de hash otimizado para CPU na GPU.
   • Solução: Atualize os drivers. Certifique-se de que sua GPU tenha memória suficiente para o tipo de hash e a wordlist escolhidos. Alguns tipos de hash (por exemplo, bcrypt, scrypt) são intencionalmente projetados para serem lentos e intensivos em memória, tornando-os menos eficientes em GPUs em comparação com hashes mais simples como MD5.
   • Verificação: Use john --test para fazer o benchmark do desempenho e compará-lo com os valores esperados para sua GPU.

3. Travamentos ou Congelamentos:

   • Causa: Superaquecimento, overclocking instável ou conflitos de driver.
   • Solução: Monitore a temperatura da GPU. Reduza o overclocking, se aplicado. Reinstale os drivers de forma limpa.
   • Verificação: Use watch -n 1 nvidia-smi (para NVIDIA) para monitorar o uso e a temperatura da GPU.

4. John the Ripper não utilizando a GPU:

   • Causa: JtR não compilado com suporte a GPU, ou formato de hash específico não suportado pelo módulo de GPU.
   • Solução: Certifique-se de ter instalado a versão correta do JtR (por exemplo, john-opencl ou john-cuda, se disponíveis, ou uma compilação a partir do código-fonte com flags de GPU). Verifique se o formato de hash que você está quebrando possui uma implementação OpenCL/CUDA no JtR.
   • Verificação: Execute john --list=formats e procure por formatos com OpenCL ou CUDA em sua descrição.

Simulando uma etapa de solução de problemas:

Vamos imaginar que você encontrou um problema e precisou verificar a versão do John the Ripper para garantir que ele suporta OpenCL.

john --version

Este comando exibirá a versão do John the Ripper instalada, o que pode ajudar a identificar se você tem uma compilação que inclui suporte a GPU.

John the Ripper 1.9.0-jumbo-1 (linux-gnu)
Copyright (c) 1996-2023 by Solar Designer and others
...

Compreender esses problemas comuns e suas soluções o ajudará a solucionar efetivamente problemas ao usar o John the Ripper com aceleração por GPU em cenários do mundo real.

Resumo

Neste laboratório, você obteve uma compreensão abrangente de como utilizar o John the Ripper com aceleração de hardware por GPU para quebra de senhas mais rápida. Você começou explorando os princípios fundamentais do paralelismo de GPU e o papel de frameworks como o OpenCL.

Em seguida, você procedeu com as etapas práticas de configuração do seu ambiente, incluindo a instalação das bibliotecas de desenvolvimento OpenCL necessárias. Você aprendeu como instalar o John the Ripper, verificar suas capacidades OpenCL e realizar quebras básicas de hash. Além disso, você explorou as ferramentas de benchmarking integradas do John the Ripper para avaliar o desempenho e discutiu técnicas comuns de solução de problemas para questões de quebra por GPU.

Ao concluir este laboratório, você está agora equipado com o conhecimento para utilizar efetivamente a aceleração por GPU com o John the Ripper, aprimorando significativamente suas capacidades de quebra de senhas em cenários do mundo real.