Introdução
Neste laboratório, você explorará várias técnicas para otimizar o desempenho do John the Ripper, uma poderosa ferramenta de quebra de senhas. A quebra eficiente de senhas geralmente requer o aproveitamento eficaz dos recursos de hardware disponíveis. Você aprenderá a configurar o John the Ripper para utilizar múltiplos núcleos de CPU, entender suas capacidades de quebra por GPU, ajustar as configurações de benchmarking para medição precisa de desempenho, comparar seu desempenho de GPU com o Hashcat e monitorar os recursos do sistema durante as operações de quebra. Essas habilidades são cruciais para qualquer pessoa envolvida em cibersegurança, testes de penetração ou administração de sistemas, permitindo-lhes maximizar a eficiência de suas tarefas de auditoria de senhas.
Utilize Múltiplos Núcleos de CPU
Nesta etapa, você aprenderá a configurar o John the Ripper para utilizar múltiplos núcleos de CPU, o que pode acelerar significativamente o processo de quebra em sistemas com processadores multi-core. Por padrão, o John the Ripper pode não usar todos os núcleos disponíveis. Você pode especificar o número de núcleos de CPU a serem usados com a opção --fork.
Primeiro, vamos executar um benchmark simples sem especificar o número de núcleos para ver o desempenho padrão.
john --test=0
Você verá uma saída semelhante a esta, mostrando o desempenho para vários tipos de hash:
Benchmarking: Traditional DES [32/32 BS SSE2-i]... DONE
Many calculations will be done, please be patient.
Raw: 100000 c/s real, 100000 c/s virtual
Benchmarking: BSDI DES [32/32 BS SSE2-i]... DONE
Raw: 100000 c/s real, 100000 c/s virtual
...
Agora, vamos executar o benchmark novamente, dizendo explicitamente ao John the Ripper para usar múltiplos núcleos de CPU. Para descobrir o número de núcleos de CPU disponíveis em seu sistema, você pode usar o comando nproc.
nproc
Este comando exibirá o número de unidades de processamento disponíveis. Por exemplo, se ele exibir 2, você tem 2 núcleos de CPU.
Agora, use a opção --fork com o número de núcleos que você deseja utilizar. Substitua $(nproc) pelo número real de núcleos se preferir, mas $(nproc) é dinâmico.
john --test=0 --fork=$(nproc)
Compare os números de desempenho "Raw" dos dois benchmarks. Você deverá observar um aumento na velocidade de quebra ao usar múltiplos núcleos, especialmente para tipos de hash intensivos em CPU. A opção --fork cria processos separados, cada um trabalhando em uma parte da tarefa de quebra, aproveitando assim o processamento paralelo.
Finalmente, vamos tentar quebrar um arquivo de senhas usando múltiplos núcleos. Temos um arquivo passwords.txt em seu diretório ~/project.
john --wordlist=~/project/wordlist.txt --fork=$(nproc) ~/project/passwords.txt
Após a conclusão da quebra, você pode visualizar as senhas quebradas:
john --show ~/project/passwords.txt
Este comando exibirá quaisquer senhas que o John the Ripper quebrou com sucesso.
Configurar o John the Ripper para Quebra por GPU (se aplicável)
Nesta etapa, discutiremos a configuração do John the Ripper para quebra por GPU. Embora o ambiente LabEx normalmente não forneça recursos de GPU dedicados para laboratórios gerais, a compreensão deste conceito é crucial para otimizar o John the Ripper em sistemas com GPUs compatíveis. O John the Ripper suporta quebra por GPU através de suas implementações OpenCL e CUDA, que podem oferecer acelerações significativas em relação à quebra por CPU para certos tipos de hash.
Para verificar se sua compilação do John the Ripper suporta OpenCL ou CUDA, você pode executar o seguinte comando:
john --list=opencl-devices
Se dispositivos OpenCL forem detectados, você verá uma saída semelhante a esta (embora provavelmente vazia neste ambiente):
No OpenCL devices found.
Se você estivesse em um sistema com uma GPU compatível e drivers OpenCL instalados, veria uma lista de dispositivos de GPU disponíveis. Por exemplo:
Device #0: NVIDIA GeForce RTX 3080, 10240MB, 1710MHz, 68CU
Para utilizar um dispositivo de GPU específico para quebra, você normalmente usaria a opção --format com um formato habilitado para OpenCL (por exemplo, raw-md5-opencl) e, potencialmente, a opção --device para selecionar uma GPU específica se houver várias.
Por exemplo, em um sistema com GPU, você poderia executar:
john --format=raw-md5-opencl --wordlist=~/project/wordlist.txt ~/project/passwords.txt
Nota: Como este ambiente LabEx não possui uma GPU, o comando acima provavelmente falhará ou será executado com fallback para CPU, se disponível. O objetivo desta etapa é ilustrar o comando e o conceito, não realizar quebra por GPU real neste ambiente específico.
Para verificar se o John the Ripper está configurado para tentar a quebra por GPU, você procuraria por mensagens indicando a inicialização do OpenCL ou CUDA ao executar um comando de quebra com um formato habilitado para GPU.
Ajustar Configurações de Benchmark do John the Ripper
Nesta etapa, você aprenderá a ajustar as configurações de benchmark do John the Ripper para obter métricas de desempenho mais precisas e relevantes. O benchmark padrão (john --test=0) executa um teste rápido em vários tipos de hash. No entanto, você pode especificar um tipo de hash particular ou uma duração específica para o benchmark. Isso é útil quando você deseja medir o desempenho para um cenário de quebra específico.
Primeiro, vamos listar todos os formatos de hash disponíveis que o John the Ripper suporta. Isso pode ajudá-lo a identificar o formato específico que você deseja testar.
john --list=formats
Este comando exibirá uma longa lista de formatos de hash suportados, por exemplo:
raw-md5
raw-sha1
raw-sha256
...
Agora, vamos testar um formato de hash específico, por exemplo, raw-md5. Você pode especificar o formato usando a opção --format.
john --test=0 --format=raw-md5
Você verá os resultados do benchmark especificamente para o formato raw-md5.
Para obter um benchmark mais estável e preciso, especialmente para comparações de desempenho, você pode aumentar a duração do teste usando a opção --max-run-time. Esta opção especifica o tempo máximo em segundos para a execução do benchmark.
Vamos executar um benchmark raw-md5 por 10 segundos:
john --test=0 --format=raw-md5 --max-run-time=10
Observe como os números de desempenho "Raw" podem se estabilizar ou fornecer uma média mais consistente ao longo de um tempo de execução mais longo. Isso é particularmente útil ao comparar diferentes configurações de hardware ou compilações do John the Ripper.
Você também pode combinar isso com a opção --fork da Etapa 1 para testar o desempenho multi-core para um tipo de hash específico durante um período definido.
john --test=0 --format=raw-md5 --fork=$(nproc) --max-run-time=10
Ao ajustar essas configurações de benchmark, você pode obter dados de desempenho mais precisos e relevantes para suas necessidades específicas de quebra, ajudando-o a tomar decisões informadas sobre atualizações de hardware ou alterações de configuração.
Compreender Hashcat vs. John the Ripper para GPU
Nesta etapa, discutiremos as diferenças entre Hashcat e John the Ripper, particularmente em relação às suas capacidades de quebra por GPU. Embora ambos sejam ferramentas poderosas de quebra de senhas, eles têm diferentes pontos fortes e fracos, especialmente quando se trata de alavancar GPUs.
John the Ripper (JtR):
- Pontos Fortes: Excelente para quebra baseada em CPU, altamente versátil com muitos formatos integrados, bom para sistemas de usuário único e tem um forte foco em ataques de dicionário e força bruta. Seu suporte a GPU (OpenCL/CUDA) é integrado, mas historicamente menos otimizado que o Hashcat para poder bruto da GPU.
- Pontos Fracos: O desempenho da GPU, embora presente, pode nem sempre corresponder à velocidade bruta do Hashcat para certos tipos de hash. A configuração para GPU pode, às vezes, ser menos direta.
Hashcat:
- Pontos Fortes: Amplamente considerado o cracker de senhas mais rápido e eficiente baseado em GPU. É altamente otimizado para processamento paralelo em GPUs (tanto NVIDIA CUDA quanto AMD OpenCL). Suporta uma vasta gama de tipos de hash e modos de ataque.
- Pontos Fracos: Principalmente focado em GPU, portanto, o desempenho da CPU não é seu principal ponto forte. Pode ser mais complexo de aprender para iniciantes devido às suas extensas opções e modos de ataque.
Diferenças Chave para Quebra por GPU:
- Otimização: O Hashcat é construído especificamente para aceleração por GPU e geralmente atinge taxas mais altas de hashes por segundo (H/s) em GPUs em comparação com o John the Ripper para o mesmo tipo de hash.
- Facilidade de Uso: As opções de GPU do John the Ripper são integradas à sua interface de linha de comando existente. O Hashcat tem sua própria sintaxe e opções distintas, que podem ser mais granulares para controle de GPU.
- Foco da Comunidade: O desenvolvimento e a comunidade do Hashcat estão fortemente centrados em maximizar o desempenho da quebra por GPU.
Quando usar qual:
- Use John the Ripper para quebra geral por CPU, quando precisar de uma ferramenta versátil com muitos recursos integrados, ou quando estiver trabalhando em sistemas sem GPUs potentes.
- Use Hashcat quando tiver acesso a GPUs potentes e precisar das velocidades de quebra mais rápidas para uma ampla gama de tipos de hash, especialmente em cenários de testes de penetração ou auditoria profissional.
Para ilustrar, se você tivesse o Hashcat instalado (o que não é o padrão neste ambiente), um comando típico para quebrar hashes MD5 usando uma GPU seria assim:
## This command is for illustration only and will not work without Hashcat installed
## hashcat -m 0 -a 0 ~/project/passwords.txt ~/project/wordlist.txt
Onde -m 0 especifica o tipo de hash MD5 e -a 0 especifica um ataque de dicionário.
Compreender essas diferenças ajuda você a escolher a ferramenta certa para o trabalho, maximizando sua eficiência em tarefas de auditoria de senhas com base no hardware disponível.
Monitorar Recursos do Sistema Durante a Quebra
Nesta etapa, você aprenderá a monitorar os recursos do sistema enquanto o John the Ripper executa operações de quebra. Monitorar o uso da CPU, o uso de memória e o I/O de disco pode ajudá-lo a identificar gargalos e garantir que seu sistema esteja sendo utilizado de forma eficiente. Isso é crucial para otimizar o desempenho e solucionar problemas.
Primeiro, vamos iniciar um processo de quebra do John the Ripper em segundo plano. Usaremos um ataque de dicionário simples em nosso arquivo passwords.txt.
john --wordlist=~/project/wordlist.txt ~/project/passwords.txt &
O & no final envia o processo para segundo plano, permitindo que você continue usando o terminal. Observe o ID do processo (PID) que é exibido, por exemplo: [1] 12345.
Agora, vamos monitorar o uso de CPU e memória do sistema usando o comando top. O top fornece uma visão dinâmica em tempo real de um sistema em execução.
top
Na saída do top, procure pelo processo john. Você verá seu uso de CPU (%CPU) e uso de memória (%MEM). Quando o John the Ripper estiver quebrando ativamente, você deverá ver seu valor de %CPU alto, especialmente se estiver usando vários núcleos (pode exceder 100% para processos multi-core). Pressione q para sair do top.
Outro comando útil para monitorar processos é o htop. Se o htop não estiver instalado, você pode instalá-lo:
sudo apt install -y htop
Após a instalação, execute o htop:
htop
O htop fornece uma visão mais amigável e interativa do que o top, mostrando o uso de CPU por núcleo, uso de memória e árvores de processos. Você pode facilmente classificar os processos por uso de CPU ou memória. Procure pelo processo john e observe seu consumo de recursos. Pressione F10 ou q para sair do htop.
Para monitorar o I/O de disco, você pode usar o comando iotop. Isso é particularmente útil se suas wordlists ou arquivos de hash forem muito grandes, pois o acesso ao disco pode se tornar um gargalo. Se o iotop não estiver instalado, instale-o:
sudo apt install -y iotop
Em seguida, execute o iotop:
sudo iotop
O iotop mostra a atividade de I/O de disco em tempo real. Procure por john ou processos relacionados para ver se eles estão lendo ou escrevendo intensamente no disco. Pressione q para sair do iotop.
Finalmente, vamos trazer o processo john em segundo plano para o primeiro plano e pará-lo, ou simplesmente matá-lo se ainda estiver em execução.
fg
## Pressione Ctrl+C para parar o processo
Se fg não funcionar ou você quiser matá-lo pelo PID:
killall john
Ao monitorar regularmente os recursos do sistema, você pode identificar se o John the Ripper está utilizando totalmente seu hardware ou se há outros processos consumindo recursos que poderiam ser alocados para a quebra. Isso ajuda a ajustar sua configuração de quebra para um desempenho ideal.
Resumo
Neste laboratório, você ganhou experiência prática na otimização do desempenho do John the Ripper. Você aprendeu a alavancar múltiplos núcleos de CPU usando a opção --fork para acelerar a quebra. Discutimos os princípios da quebra por GPU com o John the Ripper, mesmo em ambientes sem GPUs dedicadas, enfatizando a importância do suporte OpenCL/CUDA. Você também dominou o ajuste de configurações de benchmarking para obter métricas de desempenho precisas para tipos de hash e durações específicas. Além disso, você compreendeu as principais diferenças entre John the Ripper e Hashcat para quebra acelerada por GPU, permitindo que você escolha a ferramenta mais adequada para vários cenários. Finalmente, você aprendeu a monitorar recursos do sistema como CPU, memória e I/O de disco durante operações de quebra, o que é vital para identificar gargalos e garantir a utilização eficiente do hardware. Essas habilidades são fundamentais para qualquer pessoa que busca maximizar a eficiência de auditoria de senhas e testes de segurança.
