Hydra: Opções HTTP POST e Ataques de Força Bruta

Introdução

Neste laboratório, exploraremos as opções HTTP POST disponíveis no Hydra, com foco em como direcionar efetivamente serviços que usam HTTP POST para autenticação. Aprenderemos como especificar nomes de usuário e senhas, bem como a URL para a qual a requisição POST deve ser enviada.

Este laboratório irá guiá-lo através da revisão das opções HTTP POST, da configuração de um formulário HTTP POST, da execução do Hydra com opções específicas e da validação do ataque POST. Você aprenderá como usar o Hydra para realizar brute-force em credenciais de login ao direcionar serviços que usam HTTP POST para autenticação.

Revisar as Opções HTTP POST

Nesta etapa, exploraremos as opções HTTP POST disponíveis no Hydra. O Hydra é uma ferramenta poderosa para realizar brute-force em credenciais de login e suporta vários protocolos, incluindo HTTP POST. Ao direcionar aplicações web que usam HTTP POST para autenticação, precisamos fornecer ao Hydra informações específicas sobre o formulário de login.

A sintaxe básica para usar o Hydra com HTTP POST é a seguinte:

hydra -l <username> -P <password_list> <target_ip> http-post-form "<url>:<post_data>:<failure_string>"

Vamos detalhar os componentes-chave:

hydra: O comando para invocar o Hydra.
-l <username>: Especifica um único nome de usuário para usar no ataque. Se você tiver uma lista de nomes de usuário, pode usar a opção -L <username_list> em vez disso.
-P <password_list>: Especifica o caminho para um arquivo contendo uma lista de senhas para tentar.
<target_ip>: O endereço IP do servidor de destino.
http-post-form: Especifica que estamos usando o módulo HTTP POST form. Este módulo é projetado para atacar formulários web que usam o método POST.
"<url>:<post_data>:<failure_string>": Esta é uma parte crucial que informa ao Hydra como interagir com o formulário de login.
- <url>: O caminho para o script ou página de login que lida com a requisição POST (por exemplo, /login.php).
- <post_data>: Os dados que serão enviados no corpo da requisição POST. Isso normalmente inclui os nomes dos campos de nome de usuário e senha do formulário HTML, juntamente com espaços reservados para o nome de usuário e senha que o Hydra preencherá. Os espaços reservados geralmente são ^USER^ para o nome de usuário e ^PASS^ para a senha (por exemplo, username=^USER^&password=^PASS^).
- <failure_string>: Uma string que aparece na resposta de uma tentativa de login falhada. O Hydra usa essa string para determinar se uma tentativa de login foi malsucedida. Você precisa identificar essa string tentando manualmente um login com credenciais incorretas e observando a resposta.

Nas etapas seguintes, configuraremos um formulário HTTP POST simples e, em seguida, usaremos o Hydra para atacá-lo, aplicando essas opções.

Configurar o Formulário HTTP POST

Nesta etapa, configuraremos um formulário HTTP POST simples que podemos usar como alvo para nossos ataques Hydra. Já criamos os arquivos necessários (login.html e login.php) no diretório ~/project durante a fase de configuração.

Vamos examinar o conteúdo desses arquivos para entender a estrutura do formulário e como o script PHP lida com a tentativa de login.

Primeiro, vamos olhar para login.html:

cat ~/project/login.html

<!doctype html>
<html>
  <head>
    <title>Login Form</title>
  </head>
  <body>
    <h1>Login</h1>
    <form method="post" action="login.php">
      <label for="username">Username:</label><br />
      <input type="text" id="username" name="username" /><br /><br />
      <label for="password">Password:</label><br />
      <input type="password" id="password" name="password" /><br /><br />
      <input type="submit" value="Login" />
    </form>
  </body>
</html>

Este código HTML define um formulário que usa o método POST e envia dados para login.php. Os campos de entrada são nomeados username e password. Isso nos diz que os dados POST devem incluir username=<value> e password=<value>.

Agora, vamos olhar para login.php:

cat ~/project/login.php

<?php
$username = $_POST['username'];
$password = $_POST['password'];

if ($username == 'testuser' && $password == 'password') {
  echo "Login successful!";
} else {
  echo "Invalid username or password";
}
?>

Este script PHP verifica se o username enviado é testuser e a password é password. Se corresponderem, ele exibe "Login successful!". Caso contrário, ele exibe "Invalid username or password".

A partir deste script, podemos identificar a string de falha: "Invalid username or password". Esta é a string que o Hydra procurará na resposta para determinar se uma tentativa de login falhou.

Screenshot of the login form and PHP script

Agora que entendemos a estrutura do formulário e a mensagem de falha, temos todas as informações necessárias para criar o comando Hydra na próxima etapa.

Verificar o Status do Serviço Web

Antes de prosseguir para a próxima etapa, verifique se o serviço web PHP está em execução e acessível. Execute o seguinte comando em seu terminal:

curl -s http://0.0.0.0:8080/login.php

Se você vir o conteúdo da página (como "Invalid username or password"), o serviço está funcionando corretamente.

Screenshot showing successful web service check

Se não houver resposta ou você receber um erro de conexão, você pode iniciar manualmente o servidor web embutido do PHP com:

nohup php -S 0.0.0.0:8080 -t /home/labex/project > /dev/null 2>&1 &

Aguarde um momento e tente o comando curl novamente.

Executar Hydra com HTTP POST

Agora que temos nosso formulário HTTP POST de destino configurado e entendemos sua estrutura, podemos usar o Hydra para tentar realizar brute-force nas credenciais de login. Usaremos as informações coletadas na etapa anterior para construir o comando Hydra.

Sabemos o seguinte:

A URL de destino é /login.php.
Os dados POST devem estar no formato username=^USER^&password=^PASS^.
A string de falha é "Invalid username or password".
Usaremos o nome de usuário testuser e a lista de senhas ~/project/password.txt.
O endereço IP de destino é 0.0.0.0 (assumindo que o servidor web está sendo executado localmente).

Vamos juntar tudo isso em um comando Hydra:

hydra -l testuser -P ~/project/password.txt 0.0.0.0 -s 8080 http-post-form "/login.php:username=^USER^&password=^PASS^:F=Invalid username or password"

Execute este comando no terminal:

Hydra command execution in terminal

O Hydra agora começará a tentar fazer login no formulário de destino usando o nome de usuário especificado e as senhas da lista. Ele enviará requisições HTTP POST para http://0.0.0.0:8080/login.php com o nome de usuário e cada senha nos dados POST. Se a resposta não contiver a string de falha "Invalid username or password", o Hydra considerará a tentativa de login bem-sucedida e relatará as credenciais.

A saída mostrará o progresso do ataque. Como a senha correta (password) está incluída em nosso arquivo password.txt, o Hydra deve eventualmente encontrá-la.

Hydra v9.2 (c) 2021 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).

Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2025-05-22 09:55:07
[DATA] max 3 tasks per 1 server, overall 3 tasks, 3 login tries (l:1/p:3), ~1 try per task
[DATA] attacking http-post-form://0.0.0.0:8080/login.php:username=^USER^&password=^PASS^:F=Invalid username or password
[8080][http-post-form] host: 0.0.0.0   login: testuser   password: password
1 of 1 target successfully completed, 1 valid password found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2025-05-22 09:55:08

A linha [http-post] host: 0.0.0.0 login: testuser password: password indica que o Hydra encontrou com sucesso as credenciais corretas.

Validar o Ataque POST

Nesta etapa, validaremos que o Hydra identificou com sucesso a senha correta para a conta testuser de duas maneiras:

Primeiro, examinando a saída do Hydra:

[8080][http-post-form] host: 0.0.0.0   login: testuser   password: password

Esta linha indica que o Hydra encontrou credenciais válidas: nome de usuário testuser com senha password.

Segundo, verificando manualmente essas credenciais na interface web:

Para acessar o formulário de login no ambiente LabEx:

Clique na aba "Web 8080" na barra de menu superior
Na barra de endereço, adicione /login.html ao final da URL atual
Insira as credenciais que o Hydra descobriu:
- Nome de usuário: testuser
- Senha: password
Clique no botão "Login"

Screenshot of successful login after Hydra attack

Se você vir "Login successful!" após enviar o formulário, isso confirma que as credenciais encontradas pelo Hydra estão de fato corretas.

Se você não vir a mensagem de sucesso, revise as etapas anteriores para garantir:

O arquivo password.txt em ~/project contém a senha password
O arquivo login.php em ~/project verifica corretamente o nome de usuário testuser e a senha password e retorna as mensagens apropriadas
O servidor web ainda está em execução (você pode reiniciá-lo com php -S 0.0.0.0:8080 -t /home/labex/project se necessário)

Ao concluir com sucesso esta etapa e verificar as credenciais tanto pela saída do Hydra quanto por testes manuais, você demonstrou sua capacidade de usar o Hydra para descobrir credenciais de login válidas e confirmar sua autenticidade.

Resumo

Neste laboratório, exploramos como usar o Hydra para atacar aplicações web que utilizam HTTP POST para autenticação. Aprendemos sobre as principais opções necessárias para o módulo http-post-form, incluindo a especificação da URL de destino, o formato dos dados POST com os espaços reservados para nome de usuário e senha (^USER^ e ^PASS^) e a identificação de uma string de falha na resposta para detectar tentativas de login malsucedidas.

Configuramos um formulário HTML simples e um script PHP para simular uma página de login, o que nos permitiu entender a estrutura da requisição POST e a resposta esperada. Ao criar e executar o comando Hydra apropriado, realizamos com sucesso o brute-force nas credenciais de login, demonstrando o poder do Hydra em atacar formulários HTTP POST.

Você aprendeu como:

Entender a sintaxe básica para usar o Hydra com HTTP POST.
Identificar as informações necessárias de um formulário web (URL, nomes de campos, mensagem de falha).
Construir um comando Hydra para direcionar um formulário HTTP POST.
Interpretar a saída do Hydra para validar um ataque de login bem-sucedido.

Este laboratório fornece uma compreensão fundamental do uso do Hydra para ataques HTTP POST, que é um cenário comum em testes de segurança de aplicações web.

Explorar as Opções Específicas do Módulo Hydra