Guardar Resultados de Ataques con Hydra

Introducción

En este laboratorio, aprenderás a guardar los resultados de un ataque Hydra. Hydra, una poderosa herramienta para descifrar contraseñas, se utilizará para probar la seguridad de un formulario de inicio de sesión HTTP simulado. Empezarás ejecutando un ataque HTTP básico contra un servidor web objetivo, utilizando listas de nombres de usuario y contraseñas.

Este laboratorio te guiará a través de la guardado de los resultados del ataque utilizando la opción -o y la salida en formato JSON con la opción -b. Finalmente, compararás las salidas de texto y JSON para comprender las diferentes maneras en que Hydra puede presentar sus hallazgos.

Configurar el Servicio de Destino y Listas de Usuarios/Contraseñas

En este paso, configurarás un servicio de inicio de sesión HTTP simulado y crearás las listas necesarias de nombres de usuario y contraseñas para que Hydra las utilice. Esto proporcionará un entorno controlado para practicar la captura de la salida de Hydra.

Primero, navega a tu directorio de proyecto:

cd ~/project

A continuación, crearás un script Python simple que simula un servicio de inicio de sesión HTTP. Este script escuchará en el puerto 80 y responderá a las solicitudes POST a /login.php. Considerará admin como el nombre de usuario correcto y password como la contraseña correcta.

Crea el archivo login.py usando nano:

nano login.py

Pega el siguiente código Python en el editor nano:

from http.server import BaseHTTPRequestHandler, HTTPServer
import urllib.parse
import os

class LoginHandler(BaseHTTPRequestHandler):
    def do_POST(self):
        if self.path == '/login.php':
            content_length = int(self.headers['Content-Length'])
            post_data = self.rfile.read(content_length).decode('utf-8')
            parsed_data = urllib.parse.parse_qs(post_data)

            username = parsed_data.get('username', [''])[0]
            password = parsed_data.get('password', [''])[0]

            if username == 'admin' and password == 'password':
                self.send_response(200)
                self.send_header('Content-type', 'text/html')
                self.end_headers()
                self.wfile.write(b"Login successful!")
            else:
                self.send_response(401)
                self.send_header('Content-type', 'text/html')
                self.end_headers()
                self.wfile.write(b"Nombre de usuario o contraseña inválidos")
        else:
            self.send_response(404)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(b"No encontrado")

def run(server_class=HTTPServer, handler_class=LoginHandler, port=80):
    server_address = ('', port)
    httpd = server_class(server_address, handler_class)
    print(f"Iniciando servidor httpd en el puerto {port}")
    httpd.serve_forever()

if __name__ == "__main__":
    run()

Guarda el archivo presionando Ctrl+X, luego Y y luego Enter.

Ahora, ejecuta el servidor HTTP de Python en segundo plano. Esto simulará el servicio de destino para Hydra.

nohup python3 login.py > /dev/null 2>&1 &

El comando nohup permite que el proceso continúe ejecutándose incluso después de cerrar la terminal, y > /dev/null 2>&1 & redirige toda la salida a /dev/null y ejecuta el proceso en segundo plano.

A continuación, crearás las listas de nombres de usuario y contraseñas que Hydra utilizará para su ataque.

Crea un archivo llamado users.txt en el directorio ~/project:

nano users.txt

Agrega los siguientes nombres de usuario al archivo:

admin
user
test

Guarda el archivo presionando Ctrl+X, luego Y y luego Enter.

Finalmente, crea un archivo llamado passwords.txt en el directorio ~/project:

nano passwords.txt

Agrega las siguientes contraseñas al archivo:

password
123456
test

Guarda el archivo presionando Ctrl+X, luego Y y luego Enter.

Ahora has configurado correctamente el servicio HTTP de destino y preparado las listas de nombres de usuario y contraseñas.

Ejecutar Ataque HTTP Básico

En este paso, realizarás un ataque HTTP básico con Hydra contra el servicio de inicio de sesión simulado que has configurado. Esto demostrará cómo Hydra intenta descifrar credenciales sin guardar la salida en un archivo.

Hydra es una herramienta potente para descifrar contraseñas y puede utilizarse para probar la seguridad de diversos servicios, incluido HTTP. En este escenario, atacarás un formulario de inicio de sesión HTTP simple.

Utilizarás el módulo http-post-form de Hydra, diseñado para atacar formularios web que utilizan el método HTTP POST para la presentación. El servicio de destino se ejecuta en 127.0.0.1 en el puerto 80, y el formulario de inicio de sesión se encuentra en /login.php.

Ejecuta el siguiente comando de Hydra en tu terminal:

hydra -L ~/project/users.txt -P ~/project/passwords.txt 127.0.0.1 http-post-form "/login.php:username=^USER^&password=^PASS^:Invalid username or password"

Analicemos este comando:

hydra: El comando para invocar la herramienta Hydra.
-L ~/project/users.txt: Especifica la ruta al archivo de lista de nombres de usuario. Hydra iterará a través de cada nombre de usuario en este archivo.
-P ~/project/passwords.txt: Especifica la ruta al archivo de lista de contraseñas. Hydra probará cada contraseña de este archivo para cada nombre de usuario.
127.0.0.1: La dirección IP de destino del servidor HTTP simulado.
http-post-form: Este es el módulo que Hydra utiliza para atacar formularios HTTP POST.
"/login.php:username=^USER^&password=^PASS^:Invalid username or password": Esta es la parte crucial que define cómo Hydra interactúa con el formulario:
- /login.php: La ruta a la página de inicio de sesión en el servidor de destino.
- username=^USER^&password=^PASS^: Define los parámetros enviados en la solicitud POST. ^USER^ y ^PASS^ son marcadores que Hydra reemplaza con valores de tus listas de nombres de usuario y contraseñas.
- Invalid username or password: Este es el mensaje de error que Hydra busca en la respuesta del servidor para determinar si un intento de inicio de sesión fue fallido. Si esta cadena no se encuentra, Hydra considera el intento de inicio de sesión exitoso.

Después de ejecutar el comando, Hydra mostrará su progreso y cualquier intento de inicio de sesión exitoso directamente en tu terminal.

Ejemplo de Salida (si tiene éxito):

Hydra vX.X (c) XXXX by van Hauser/THC - Use freely but only for legal purposes.

Hydra is starting...

[DATA] X task, X servers, X login tries (l:X/p:X), ~X try per server
[DATA] attacking service http-post-form on port 80
[ATTACK] attacking 127.0.0.1:80/login.php
[80][http-post-form] host: 127.0.0.1   login: admin   password: password

Esta salida indica que Hydra encontró correctamente la combinación de nombre de usuario admin y contraseña password. Si no se encuentra ningún inicio de sesión exitoso, Hydra se completará sin mostrar ninguna credencial de inicio de sesión exitosa.

Guardar Resultados con la Opción -o

En este paso, aprenderás cómo guardar los resultados de un ataque con Hydra en un archivo utilizando la opción -o. Esto es útil para analizar los resultados posteriormente o con fines de informe, ya que almacena cualquier credencial descifrada en un archivo persistente.

La opción -o te permite especificar un archivo de salida donde Hydra almacenará las credenciales descifradas. Si Hydra encuentra una combinación válida de nombre de usuario y contraseña, se escribirá en el archivo especificado en un formato simple y legible por humanos.

Continuarás con el mismo escenario: el servidor web simulado que se ejecuta en 127.0.0.1 en el puerto 80 con un formulario de inicio de sesión en /login.php, y los archivos users.txt y passwords.txt que creaste anteriormente.

Para guardar los resultados en un archivo llamado hydra.log en el directorio ~/project, ejecuta el siguiente comando:

hydra -L ~/project/users.txt -P ~/project/passwords.txt -o ~/project/hydra.log 127.0.0.1 http-post-form "/login.php:username=^USER^&password=^PASS^:Invalid username or password"

La única diferencia con el comando anterior es la adición de la opción -o ~/project/hydra.log. Esto le indica a Hydra que guarde los resultados en el archivo hydra.log en lugar de solo mostrarlos en la terminal.

Después de ejecutar el comando, Hydra intentará iniciar sesión utilizando cada combinación de nombre de usuario y contraseña. Si se encuentra un inicio de sesión exitoso, el nombre de usuario y la contraseña se escribirán en el archivo hydra.log.

Para ver el contenido del archivo hydra.log, utiliza el comando cat:

cat ~/project/hydra.log

Ejemplo de Salida (si tiene éxito):

Si Hydra encuentra la combinación admin:password, el archivo hydra.log contendrá una línea similar a esta:

127.0.0.1 http-post-form: admin:password

Si no se encuentra ningún inicio de sesión exitoso, el archivo hydra.log estará vacío.

Es importante tener en cuenta que la opción -o sobrescribirá el archivo de salida si ya existe. Si deseas agregar los resultados a un archivo existente, deberías usar la opción -O (O mayúscula) en su lugar. Sin embargo, para este laboratorio, la opción -o es suficiente.

Salida en JSON con la opción -b

En este paso, explorarás cómo obtener la salida de un ataque con Hydra en formato JSON utilizando la opción -b. JSON (Notación de Objetos JavaScript) es un formato ligero de intercambio de datos que es fácil de leer y escribir para los humanos, y fácil de analizar y generar para las máquinas. Este formato es particularmente útil cuando necesitas procesar los resultados programáticamente, por ejemplo, al integrar la salida de Hydra en otras herramientas o scripts.

La opción -b, cuando se combina con la opción -o, le indica a Hydra que guarde la salida en el formato especificado en el archivo. La opción -b requiere un parámetro de formato: text (predeterminado), json o jsonv1.

Para guardar los resultados en formato JSON en un archivo llamado hydra.json en el directorio ~/project, ejecuta el siguiente comando:

hydra -L ~/project/users.txt -P ~/project/passwords.txt -o ~/project/hydra.json -b json 127.0.0.1 http-post-form "/login.php:username=^USER^&password=^PASS^:Invalid username or password"

En este comando, has añadido la opción -b json junto con la opción -o ~/project/hydra.json. Esto indica a Hydra que guarde la salida en formato JSON en el archivo hydra.json.

Después de ejecutar el comando, Hydra intentará iniciar sesión con cada combinación de nombre de usuario y contraseña. Si se encuentra un inicio de sesión exitoso, el nombre de usuario y la contraseña se escribirán en el archivo hydra.json en formato JSON.

Para ver el contenido del archivo hydra.json, utiliza el comando cat:

cat ~/project/hydra.json

Ejemplo de Salida (si tiene éxito):

Si Hydra encuentra la combinación admin:password, el archivo hydra.json contendrá un objeto JSON similar a este:

{
  "generator": {
    "software": "Hydra",
    "version": "v9.2",
    "built": "2025-05-30 08:10:07",
    "server": "127.0.0.1",
    "service": "http-post-form",
    "jsonoutputversion": "1.00",
    "commandline": "hydra -L users.txt -P passwords.txt -o hydra.json -b json 127.0.0.1 http-post-form /login.php:username=^USER^&password=^PASS^:Invalid username or password"
  },
  "results": [
    {
      "port": 80,
      "service": "http-post-form",
      "host": "127.0.0.1",
      "login": "admin",
      "password": "password"
    }
  ],
  "success": true,
  "errormessages": [],
  "quantityfound": 1
}

Si no se encuentra ningún inicio de sesión exitoso, el archivo hydra.json contendrá un array JSON vacío:

[]

Este formato JSON te permite analizar fácilmente los resultados utilizando lenguajes de scripting como Python o JavaScript para un análisis o automatización posteriores.

Resumen

En este laboratorio, aprendiste a realizar un ataque HTTP básico utilizando Hydra, una potente herramienta para descifrar contraseñas. Configuraste un servicio de inicio de sesión HTTP simulado y creaste listas de nombres de usuario y contraseñas. Luego, utilizaste Hydra para intentar descifrar el formulario de inicio de sesión HTTP simulado en 127.0.0.1.

Exploraste cómo guardar la salida de Hydra en un archivo utilizando la opción -o, creando un archivo legible por humanos, hydra.log. Además, aprendiste a obtener los resultados en formato JSON utilizando la opción -b, generando un archivo legible por máquina, hydra.json. Este laboratorio demostró la flexibilidad de Hydra para presentar sus hallazgos, permitiendo tanto una revisión rápida como el procesamiento programático de los resultados del ataque.