Atacar Servicios HTTP con Hydra

Introducción

En este laboratorio, aprenderá cómo realizar ataques de fuerza bruta en servicios HTTP utilizando Hydra, una herramienta versátil para descifrar contraseñas. Explorará la configuración de un servidor HTTP de Python con autenticación básica y probará su seguridad mediante ataques sistemáticos de credenciales.

El ejercicio abarca la creación de listas de palabras (wordlists), la configuración de los parámetros de Hydra y el análisis de los resultados del ataque para identificar las debilidades de autenticación. Esta sesión práctica demuestra técnicas esenciales para evaluar la seguridad de los servicios web contra intentos de fuerza bruta (brute-force attempts).

Instalar un Servidor HTTP Local

En este paso, instalará un servidor HTTP local utilizando el módulo incorporado de Python. Este servidor simulará un servidor web real con autenticación básica, que utilizaremos como objetivo para nuestro ataque de fuerza bruta (brute-force attack) con Hydra más adelante. Comprender cómo funcionan los servidores web es fundamental antes de intentar probar su seguridad.

El módulo http.server de Python proporciona una forma rápida de crear un servidor web básico para fines de prueba. Si bien no es adecuado para producción, es perfecto para nuestro laboratorio, ya que demuestra los conceptos básicos del protocolo HTTP sin una configuración compleja. El servidor se ejecutará en el puerto 8000 de forma predeterminada.

1. Primero, navegue a su directorio de proyecto. Esto asegura que todos los archivos estén organizados en un solo lugar:

cd ~/project

2. Cree un directorio dedicado para sus archivos del servidor web. Mantener el contenido web separado ayuda a mantener la organización:

mkdir http_server
cd http_server

3. Cree una página de inicio simple. Este archivo HTML se servirá cuando alguien acceda a su servidor web:

echo "<h1>Welcome to LabEx HTTP Server</h1>" > index.html

4. Inicie el servidor HTTP de Python. El símbolo & lo ejecuta en segundo plano para que pueda seguir utilizando la terminal:

python3 -m http.server 8000 &

Presione Enter, si desea continuar usando la terminal.

5. Verifique que el servidor se esté ejecutando. El comando netstat muestra las conexiones de red activas y los puertos de escucha:

netstat -tulnp | grep 8000

Debería ver una salida que confirme que Python está escuchando en el puerto 8000:

tcp    0    0 0.0.0.0:8000    0.0.0.0:*    LISTEN    1234/python3

6. Pruebe la funcionalidad del servidor. El comando curl recupera la página web para confirmar que todo funciona:

curl http://localhost:8000

Debería recibir el contenido HTML que creó, lo que demuestra que el servidor está operativo:

<h1>Welcome to LabEx HTTP Server</h1>

Con el servidor web básico en funcionamiento, estamos listos para implementar la autenticación en el siguiente paso. Esta base es crucial porque Hydra interactuará con este servidor exactamente como lo haría con cualquier servidor web real que utilice autenticación básica (basic authentication).

Configurar el Servidor HTTP con Autenticación Básica (Basic Auth)

En este paso, configurará la autenticación básica (basic authentication) para el servidor HTTP que instaló anteriormente. La autenticación básica es un método simple en el que el cliente envía un nombre de usuario y una contraseña con cada solicitud. Esto crea una capa de seguridad que luego probaremos intentando forzarla mediante fuerza bruta (brute-force) utilizando Hydra, lo que demuestra por qué las contraseñas débiles son peligrosas.

1. Primero, asegúrese de estar en el directorio correcto donde configuraremos nuestro servidor web protegido:

cd ~/project/http_server

2. Cree un archivo de contraseñas utilizando la utilidad htpasswd. Esta herramienta viene con el paquete apache2-utils (ya instalado en la VM de LabEx) y ayuda a administrar los archivos de contraseñas para la autenticación básica:

htpasswd -c .htpasswd admin

Cuando se le solicite, ingrese password123 como contraseña. Estamos utilizando intencionalmente una contraseña débil aquí para demostrar lo fácil que es descifrar contraseñas simples.

3. Ahora crearemos un script de Python para servir contenido HTTP con autenticación básica. Este script verificará las credenciales antes de permitir el acceso:

nano auth_server.py

4. Pegue el siguiente código de Python. Esto crea un servidor HTTP personalizado que:
   • Requiere autenticación básica (Basic Authentication)
   • Valida las credenciales con nuestro archivo .htpasswd
   • Sirve contenido solo después de una autenticación exitosa

from http.server import HTTPServer, BaseHTTPRequestHandler
import base64

class AuthHandler(BaseHTTPRequestHandler):
    def do_GET(self):
        auth_header = self.headers.get('Authorization')
        if not auth_header or not auth_header.startswith('Basic '):
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            self.wfile.write(b'Authentication required')
            return

        auth_decoded = base64.b64decode(auth_header[6:]).decode('utf-8')
        username, password = auth_decoded.split(':', 1)

        if username == 'admin' and password == 'password123':
            self.send_response(200)
            self.send_header('Content-type', 'text/html')
            self.end_headers()
            with open('index.html', 'rb') as f:
                self.wfile.write(f.read())
        else:
            self.send_response(401)
            self.send_header('WWW-Authenticate', 'Basic realm="LabEx"')
            self.end_headers()
            self.wfile.write(b'Authentication failed')

if __name__ == '__main__':
    server_address = ('', 8000)
    httpd = HTTPServer(server_address, AuthHandler)
    print("Server running on port 8000...")
    httpd.serve_forever()

5. Guarde el archivo (Ctrl+O, Enter, Ctrl+X en nano) y detenga el servidor HTTP anterior que no tenía autenticación:

pkill -f "python3 -m http.server"

6. Inicie nuestro nuevo servidor HTTP autenticado en segundo plano:

python3 auth_server.py &

7. Probemos la autenticación intentando acceder al servidor sin credenciales:

curl -v http://localhost:8000

Debería recibir una respuesta 401 Unauthorized, lo que significa que nuestra autenticación está funcionando.

8. Ahora intente acceder con las credenciales correctas que configuramos anteriormente:

curl -v -u admin:password123 http://localhost:8000

Ahora debería ver el contenido HTML de su archivo index.html, lo que demuestra que la autenticación funciona correctamente.

El servidor ahora está debidamente protegido con autenticación básica y listo para nuestra demostración de ataque de fuerza bruta (brute-force attack) en los próximos pasos. Esta configuración imita escenarios del mundo real donde los servidores web utilizan autenticación básica, mostrando tanto cómo funciona como sus posibles vulnerabilidades.

Preparar Listas de Nombres de Usuario y Contraseñas

En este paso, creará listas de palabras (wordlists) que Hydra utilizará para probar posibles combinaciones de nombres de usuario y contraseñas contra la autenticación básica (basic authentication) HTTP. Estas listas forman la base de un ataque de diccionario (dictionary attack), donde sistemáticamente probamos credenciales comunes en lugar de adivinar al azar.

1. Primero, navegue a su directorio de proyecto. Esto asegura que todos sus archivos permanezcan organizados en un solo lugar:

cd ~/project

2. Cree un directorio dedicado para sus listas de palabras. Mantenerlas separadas facilita su administración:

mkdir wordlists
cd wordlists

3. Cree un archivo de lista de nombres de usuario utilizando nano, un editor de texto simple. Lo llenaremos con nombres de usuario administrativos comunes que se utilizan con frecuencia como valores predeterminados:

nano usernames.txt

Agregue estos nombres de usuario comunes (uno por línea):

admin
root
user
test
guest
administrator

4. Del mismo modo, cree un archivo de lista de contraseñas. Estas son contraseñas que se utilizan comúnmente o son fáciles de adivinar:

nano passwords.txt

Agregue estas contraseñas comunes (una por línea):

password123
password
123456
admin
letmein
qwerty

5. Verifique el contenido de sus archivos para asegurarse de que se crearon correctamente. El comando cat muestra el contenido del archivo en la terminal:

cat usernames.txt
cat passwords.txt

6. (Opcional) Genere contraseñas adicionales utilizando crunch, un generador de listas de palabras. Este comando crea hasta 100 combinaciones de números de 4 dígitos, lo cual es útil para probar contraseñas numéricas simples:

crunch 4 4 0123456789 | head -n 100 > numbers.txt

7. Combine sus listas de contraseñas en un solo archivo. Esto le da a Hydra más variaciones para probar durante el ataque:

cat passwords.txt numbers.txt > combined_passwords.txt

8. Verifique la lista de contraseñas combinada. El comando head muestra solo las primeras 10 líneas, lo que le brinda una verificación rápida de que la combinación funcionó:

head combined_passwords.txt

Debería ver una salida como:

password123
password
123456
admin
letmein
qwerty
0000
0001
0002
0003

Estas listas de palabras contienen tanto las credenciales correctas (admin/password123) que configuramos anteriormente como muchas combinaciones incorrectas. Esta configuración simula de manera realista cómo un atacante intentaría forzar un inicio de sesión (brute-force a login) probando numerosas credenciales posibles. En el siguiente paso, utilizaremos Hydra para automatizar la prueba de estas combinaciones contra nuestro servidor HTTP.

Ejecutar Ataque Hydra en el Servicio HTTP

En este paso, utilizará Hydra para realizar un ataque de fuerza bruta (brute-force attack) contra el servicio de autenticación básica (basic authentication) HTTP que configuró anteriormente. Hydra es una poderosa herramienta para descifrar contraseñas que sistemáticamente prueba todas las combinaciones de nombre de usuario/contraseña de las listas de palabras (wordlists) para encontrar credenciales válidas. Esto demuestra por qué las contraseñas débiles son vulnerables a los ataques automatizados.

1. Primero, asegúrese de que su servidor HTTP todavía esté en funcionamiento. Este comando verifica si el proceso del servidor existe y lo reinicia si es necesario:

pgrep -fa "python3 auth_server.py" || cd ~/project/http_server && python3 auth_server.py &

2. Navegue a su directorio de listas de palabras (wordlists) donde almacenó los archivos de nombre de usuario y contraseña. Estos archivos contienen las combinaciones que Hydra probará:

cd ~/project/wordlists

3. Ejecute Hydra con este comando para atacar el servicio HTTP. El indicador -L especifica la lista de nombres de usuario, -P la lista de contraseñas y http-get / indica que estamos atacando una solicitud HTTP GET básica:

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

4. Observe la salida de Hydra mientras prueba las combinaciones. Cuando tenga éxito, verá una salida que muestra qué credenciales funcionaron:

[DATA] attacking http-get://localhost:8000/
[8000][http-get] host: localhost   login: admin   password: password123
1 of 1 target successfully completed, 1 valid password found

5. Para ver una salida más detallada que incluya cada intento que realiza Hydra, agregue el indicador -v (verbose):

hydra -v -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get /

6. (Opcional) Guarde los resultados en un archivo para su análisis posterior. El indicador -o especifica el archivo de salida:

hydra -L usernames.txt -P combined_passwords.txt localhost -s 8000 http-get / -o hydra_results.txt

7. Verifique el archivo de resultados guardado para ver las credenciales exitosas:

cat hydra_results.txt

El ataque debería encontrar con éxito las credenciales (admin/password123) que configuramos anteriormente. Esto muestra cuán rápido se pueden descubrir las credenciales débiles a través de ataques automatizados de fuerza bruta (automated brute-force attacks), lo que enfatiza la importancia de las contraseñas seguras.

Resumen

En este laboratorio, ha aprendido cómo configurar un servidor HTTP local con Python e implementar la autenticación básica (basic authentication) con fines de pruebas de seguridad. El proceso incluyó la creación de directorios web, la configuración de la autenticación con htpasswd y la verificación de la funcionalidad del servidor utilizando herramientas comunes como curl.

Además, obtuvo experiencia práctica en la preparación de listas de credenciales (credential lists) y la ejecución de ataques de fuerza bruta (brute-force attacks) contra servicios HTTP utilizando Hydra. Este ejercicio demostró la importancia de las contraseñas seguras y las vulnerabilidades de los mecanismos de autenticación básica (basic authentication) cuando se utilizan credenciales débiles.