Ajustar a Velocidade de Ataque e Threads do Hydra

Introdução

Neste laboratório, você aprenderá como otimizar o desempenho de um ataque de força bruta do Hydra ajustando as configurações de threads. Você explorará como diferentes configurações de threads afetam a velocidade do ataque e o uso de recursos do sistema através de cenários práticos de ataque SSH.

Os exercícios irão guiá-lo através da modificação da contagem de threads, da execução de ataques com listas de senhas e da análise das diferenças de desempenho. Você obterá experiência prática com as capacidades de processamento paralelo do Hydra, ao mesmo tempo em que compreende o equilíbrio entre a eficiência do ataque e a carga do sistema.

Entenda as Opções de Threads do Hydra

Nesta etapa, você aprenderá sobre as opções de threads do Hydra e como elas afetam a velocidade dos ataques de força bruta. Hydra é uma ferramenta popular de quebra de senhas que suporta ataques paralelos usando múltiplos threads. Threads permitem que o Hydra tente múltiplas combinações de senhas simultaneamente, acelerando significativamente o processo de quebra em comparação com a tentativa de uma senha por vez.

1. Primeiro, abra um terminal em sua VM LabEx e navegue para o diretório de trabalho padrão:

   cd ~/project

2. Vamos verificar o menu de ajuda do Hydra para entender as opções relacionadas a threads:

   hydra -h | grep -i thread

   O comando grep -i thread filtra a saída para mostrar apenas informações relacionadas a threads, tornando mais fácil encontrar o que precisamos. Você deve ver uma saída semelhante a:

   -t TASKS  run TASKS number of connects in parallel (default: 16)

3. A opção -t controla o número de conexões paralelas (threads) que o Hydra usará. Pense em threads como trabalhadores - mais trabalhadores podem fazer mais trabalhos simultaneamente. Mais threads significam ataques mais rápidos, mas também maior uso de recursos e tráfego de rede. Isso é importante porque usar muitos threads pode sobrecarregar seu sistema ou acionar alertas de segurança no sistema de destino.

4. Vamos criar uma pequena lista de senhas de teste para demonstrar o comportamento dos threads:

   cat > test_passwords.txt << EOF
   test1
   test2
   test3
   test4
   test5
   EOF

5. Agora, vamos ver como diferentes contagens de threads afetam a velocidade do ataque. Primeiro, tente com 1 thread:

   hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 1 -vV

   Observe como ele tenta as senhas uma de cada vez, com apenas um processo filho.

6. Agora, tente com 4 threads:

   hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 4 -vV

   Você verá múltiplos processos filhos trabalhando simultaneamente, tentando senhas diferentes em paralelo. Essa execução paralela deve ser notavelmente mais rápida do que a versão de thread único.

7. Finalmente, tente com 8 threads:

   hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 8 -vV

   Embora tenhamos apenas 5 senhas, o Hydra ainda criará 8 processos filhos, mas apenas 5 estarão ativamente trabalhando. Isso demonstra como a contagem de threads afeta o processamento paralelo.

Configurar um Ataque SSH Simples

Nesta etapa, você preparará um cenário de ataque SSH simples usando o Hydra. Esta demonstração o ajudará a entender como as ferramentas de quebra de senhas funcionam em um ambiente controlado. Usaremos uma lista de senhas abrangente e visaremos um servidor SSH local em execução em sua própria máquina para segurança.

1. Primeiro, certifique-se de estar no diretório de trabalho correto:

   cd ~/project

2. O arquivo de lista de senhas passwords.txt foi criado com um conjunto abrangente de senhas comuns. Esta lista maior nos ajudará a demonstrar melhor o impacto de diferentes configurações de threads no desempenho do ataque. Verifique se o arquivo de senhas foi criado corretamente:

   cat passwords.txt

3. Para este laboratório, visaremos o servidor SSH local (127.0.0.1), que é sua própria máquina. Isso é mais seguro do que atacar sistemas remotos. Primeiro, verifique se o SSH está em execução:

   sudo service ssh status

   Se não estiver em execução, inicie-o com: sudo service ssh start

Executar Ataque com Threads Padrão

Nesta etapa, você executará um ataque de força bruta SSH usando o Hydra com as configurações de thread padrão. O Hydra usa automaticamente 16 threads paralelos por padrão, o que significa que tentará 16 combinações de senhas diferentes simultaneamente. Com nossa lista de senhas maior, você poderá observar o impacto da configuração de threads de forma mais clara.

1. Primeiro, navegue até o seu diretório de trabalho:

   cd ~/project

2. Execute o ataque Hydra contra o servidor SSH local:

   hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV

3. Observe a saída cuidadosamente. Você verá:

   • Hydra iniciando com 16 tarefas (threads)
   • Cada tentativa de login sendo exibida em tempo real
   • A velocidade atual medida em tentativas por minuto
   • Um login bem-sucedido quando encontrar a senha correta

4. Para obter medições de tempo precisas, execute o comando com o utilitário time:

   time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV

5. Registre esses resultados de tempo cuidadosamente. Com nossa lista de senhas maior, você poderá ver diferenças claras de desempenho quando ajustarmos a contagem de threads.

Aumentar Threads e Comparar Velocidade

Nesta etapa, você aprenderá como ajustar a contagem de threads do Hydra afeta o desempenho da quebra de senhas. Compararemos os resultados de diferentes configurações de threads para entender a relação entre velocidade e uso de recursos.

1. Primeiro, certifique-se de estar no diretório de trabalho correto:

   cd ~/project

2. Execute o Hydra com um número maior de threads (32) e meça o tempo de execução:

   time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 32

3. Agora, teste com ainda mais threads (64) para ver se o desempenho continua melhorando:

   time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 64

4. Analise como o aumento de threads afeta:

   • Duração geral do ataque
   • Uso de recursos do sistema (visível nas colunas User/System da saída do tempo)
   • Taxa de tentativas de conexão de rede (mostrada na saída verbose do Hydra)

Testar Ataque com Threads Reduzidas

Nesta etapa, exploraremos como a redução da contagem de threads do Hydra afeta o desempenho da quebra de senhas. Testaremos com contagens de threads mais baixas para entender o equilíbrio entre velocidade e uso de recursos.

1. Primeiro, certifique-se de estar no diretório de trabalho correto:

   cd ~/project

2. Execute o Hydra com 8 threads (metade do nosso mínimo anterior) e meça o tempo de execução:

   time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 8

3. Agora, teste com apenas 4 threads para ver a configuração prática mínima:

   time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 4

4. Considere estas compensações práticas para uso no mundo real:

   • Threads mais altas (16-64) para ataques rápidos em sistemas poderosos
   • Threads mais baixas (4-8) para ambientes furtivos ou com recursos limitados
   • O impacto na rede varia com a contagem de threads - mais threads criam mais tráfego detectável

Resumo

Neste laboratório, você aprendeu como configurar a velocidade de ataque e as configurações de threads do Hydra para ataques de força bruta eficientes. Os principais pontos incluem o uso do parâmetro -t para controlar as conexões paralelas e a análise de como a contagem de threads afeta o desempenho por meio de testes práticos com diferentes valores.

Você também ganhou experiência prática ao configurar um cenário de ataque SSH, criar uma lista de senhas e observar a relação entre a contagem de threads, a velocidade do ataque e o uso de recursos do sistema. Este exercício prático ajudou a demonstrar técnicas de otimização para o Hydra em vários ambientes de teste.