Realizar un ataque de diccionario en SSH con Hydra

Introducción

En este laboratorio, aprenderá cómo realizar un ataque de diccionario en servicios SSH utilizando Hydra, una potente herramienta de cracking de contraseñas. Explorará el proceso de generación de listas de nombres de usuario y contraseñas, la configuración de parámetros de ataque y la ejecución de intentos de fuerza bruta dirigidos contra un servidor SSH.

El laboratorio ofrece experiencia práctica con la estructura de comandos de Hydra, la interpretación de la salida y el análisis de resultados. Practicará la verificación de archivos de entrada, el lanzamiento de ataques y la identificación de credenciales de inicio de sesión exitosas, al mismo tiempo que comprende los patrones comunes de fallo.

Skills Graph

Cargar listas de nombres de usuario y contraseñas

En este paso, preparará los componentes esenciales para un ataque de diccionario: listas de nombres de usuario y contraseñas. Un ataque de diccionario funciona probando sistemáticamente cada palabra de una lista predefinida (diccionario) como posibles credenciales. Para ataques SSH, necesitamos dos archivos separados: uno que contenga posibles nombres de usuario y otro que contenga posibles contraseñas.

1. Primero, navegue hasta el directorio del proyecto donde almacenaremos nuestros archivos. Esto mantiene todo organizado:

cd ~/project

2. Crearemos nuestra lista de nombres de usuario utilizando nano, un editor de texto sencillo. El nombre de archivo usernames.txt es convencional, pero podrías nombrarlo de otra manera:

nano usernames.txt

3. En el editor nano, ingrese nombres de usuario SSH comunes que los sistemas podrían utilizar. Cada nombre de usuario debe estar en una línea independiente. Estos son nombres de usuario predeterminados o comunes que los administradores podrían utilizar:

admin
root
user
test
guest
labex

4. Para guardar en nano: presione Ctrl+O (la letra O), luego presione Enter para confirmar el nombre de archivo. Salga de nano con Ctrl+X. Esto lo devuelve a la línea de comandos.

5. Ahora cree el archivo de contraseñas utilizando el mismo proceso. Contraseñas débiles como estas son sorprendentemente comunes en sistemas reales:

nano passwords.txt

6. Ingrese estas contraseñas comunes, una por línea. Note que algunas coinciden con nuestros nombres de usuario: las personas a menudo utilizan la misma cadena para ambos:

password
123456
admin
qwerty
letmein
labex

7. Guarde y salga de nano como antes (Ctrl+O, Enter, Ctrl+X).

8. Verifiquemos que nuestros archivos se hayan creado correctamente. El comando ls -l muestra que los archivos existen, mientras que cat muestra su contenido. Esta es una comprobación de calidad importante antes de continuar:

ls -l usernames.txt passwords.txt
cat usernames.txt
cat passwords.txt

Debería ver ambos archivos enumerados con sus tamaños, seguidos de su contenido mostrado. Estos archivos forman la base de nuestro ataque de diccionario: Hydra probará sistemáticamente cada combinación de nombre de usuario/contraseña de estas listas contra el servidor SSH en los siguientes pasos.

Configurar Hydra para un ataque de diccionario SSH

En este paso, configurará Hydra para realizar un ataque de diccionario SSH utilizando las listas de nombres de usuario y contraseñas creadas en el paso anterior. Un ataque de diccionario es un método en el que Hydra prueba sistemáticamente todas las combinaciones posibles de sus listas de palabras para encontrar credenciales válidas.

1. Primero, asegúrese de estar en el directorio de trabajo correcto donde se almacenan los archivos de su proyecto:

cd ~/project

Este comando cambia su directorio actual al directorio del proyecto donde trabajaremos.

2. Verifique que Hydra esté instalado comprobando su versión:

hydra -v

Debería ver una salida que muestra la versión de Hydra instalada. Esto confirma que Hydra está listo para usar y ayuda a solucionar problemas si surgen problemas más adelante.

3. Cree un archivo de destino llamado target.txt que contenga la dirección IP del servidor SSH local:

echo "127.0.0.1" > target.txt

Estamos usando 127.0.0.1 (localhost) como nuestro objetivo porque estamos probando en nuestra propia máquina en este entorno de laboratorio.

4. Entienda la estructura básica del comando de Hydra para ataques SSH:

hydra -L <username_list> -P <password_list> <target> ssh

Esto muestra los parámetros mínimos requeridos: lista de nombres de usuario (-L), lista de contraseñas (-P), dirección IP/nombre de host del objetivo y el servicio (ssh) que estamos atacando.

5. Prepare el comando real de Hydra utilizando sus archivos (pero no lo ejecute todavía):

hydra -L usernames.txt -P passwords.txt -t 4 -vV 127.0.0.1 ssh

Donde:

• -L especifica el archivo de la lista de nombres de usuario (usernames.txt)
• -P especifica el archivo de la lista de contraseñas (passwords.txt)
• -t 4 establece el número de conexiones en paralelo (4 hilos para una prueba más rápida)
• -vV habilita la salida detallada para que pueda ver el progreso del ataque

6. Guarde este comando en un archivo de script para su ejecución en el siguiente paso:

echo 'hydra -L usernames.txt -P passwords.txt -t 4 -vV 127.0.0.1 ssh' > attack.sh
chmod +x attack.sh

Crear un script facilita la repetición del ataque y asegura que no se equivoque al escribir el comando. El comando chmod hace que el script sea ejecutable.

7. Verifique que todos los archivos requeridos estén presentes antes de continuar:

ls -l usernames.txt passwords.txt target.txt attack.sh

Esta comprobación final confirma que tiene todos los archivos necesarios: lista de nombres de usuario, lista de contraseñas, archivo de destino y su script de ataque.

Ejecutar el ataque de diccionario SSH

En este paso, ejecutará el ataque de diccionario SSH de Hydra utilizando la configuración preparada en pasos anteriores. Hydra es una herramienta popular de cracking de contraseñas que prueba sistemáticamente diferentes combinaciones de nombres de usuario y contraseñas contra un servicio como SSH.

1. Primero, asegúrese de estar en el directorio de trabajo correcto donde se encuentra su script de ataque. Esto es importante porque Hydra necesita acceder a sus listas de palabras y archivos de configuración:

cd ~/project

2. Verifique que el script de ataque esté listo mostrando su contenido. Esto le permite revisar los parámetros del comando de Hydra antes de la ejecución:

cat attack.sh

Debería ver el comando de Hydra que preparamos anteriormente con la dirección IP de destino, el puerto y las rutas de las listas de palabras correctas.

3. Antes de ejecutar, asegúrese de que el servicio SSH esté en funcionamiento en el localhost, ya que estamos probando en nuestra propia máquina. Hydra necesita un servicio SSH activo para intentar conexiones:

sudo service ssh status

Si no está en funcionamiento, inícielo con:

sudo service ssh start

4. Ejecute el script de ataque. Esto lanzará Hydra con todos los parámetros que configuramos:

./attack.sh

5. Observe el progreso del ataque en tiempo real. Hydra proporcionará retroalimentación en vivo mostrando:

• Cada intento de conexión con combinaciones de nombre de usuario/contraseña
• Inicios de sesión exitosos (resaltados cuando se encuentran)
• Intentos fallidos (la mayoría de la salida)
• Estadísticas finales, incluyendo la tasa de éxito y el tiempo transcurrido

6. La salida esperada se parecerá a esto cuando se encuentre una credencial:

[DATA] attacking ssh://127.0.0.1:22/
[VERBOSE] Resolving addresses ... done
[22][ssh] host: 127.0.0.1   login: labex   password: labex
1 of 1 target successfully completed, 1 valid password found

7. El ataque se detendrá automáticamente en las siguientes condiciones:

• Cuando se hayan probado todas las combinaciones de sus listas de palabras
• Cuando se encuentre una credencial válida (comportamiento predeterminado de Hydra)
• Si lo interrumpe manualmente con Ctrl+C

8. Para guardar los resultados en un archivo para su posterior análisis, redirija la salida. Esto crea un registro permanente de todos los intentos y resultados:

./attack.sh > attack_results.txt

Ver los resultados de inicios de sesión exitosos

En este paso, analizará los resultados de su ataque de diccionario SSH para identificar los intentos de inicio de sesión exitosos. Cuando se realiza una prueba de seguridad, es crucial documentar y verificar adecuadamente sus hallazgos antes de continuar con un análisis más profundo.

1. Primero, navegue hasta el directorio de su proyecto donde se almacenan todos los archivos de su laboratorio:

cd ~/project

2. Verifique si ha guardado los resultados del ataque del paso anterior. El comando ls -l muestra información detallada de los archivos, incluyendo la fecha de creación y los permisos:

ls -l attack_results.txt

3. Si no guardó los resultados antes, ejecute este comando para generarlos ahora. El símbolo > redirige la salida de Hydra a un archivo de texto para su posterior análisis:

./attack.sh > attack_results.txt

4. Vea los resultados completos del ataque. El comando cat muestra todo el contenido de un archivo en su terminal:

cat attack_results.txt

5. Busque las entradas de inicios de sesión exitosos, que aparecerán en un formato similar a este. Cada intento exitoso contiene tres piezas clave de información:

[22][ssh] host: 127.0.0.1   login: labex   password: labex

6. Para extraer solo los intentos exitosos de archivos de resultados potencialmente grandes, use grep para filtrar las líneas que contengan "login:". Esto ahorra tiempo al revisar los resultados:

grep "login:" attack_results.txt

7. El formato de salida muestra tres elementos importantes que necesitará para la verificación:

• Dirección IP de destino (127.0.0.1) - la máquina que aceptó las credenciales
• Nombre de usuario exitoso (login) - el nombre de cuenta válido
• Contraseña válida - la contraseña que coincide con esa cuenta

8. Verifique las credenciales intentando iniciar sesión por SSH. Esto confirma que las credenciales realmente funcionan en una sesión SSH real:

ssh [email protected]

Escriba "yes" para aceptar la clave del host si se le solicita (esto sucede en la primera conexión), luego ingrese la contraseña cuando se le solicite.

9. Después de iniciar sesión exitosamente, salga adecuadamente de la sesión SSH para volver a su terminal local:

exit

10. Para una mejor legibilidad, formatee los resultados con esta tubería de comandos. El comando awk reorganiza la salida en campos claramente etiquetados:

grep "login:" attack_results.txt | awk '{print "Host:",$3,"| Username:",$5,"| Password:",$7}'

Comprender los mensajes de fallo de ataque

En este paso, examinaremos la salida de su ataque SSH de Hydra para entender por qué ciertos intentos de inicio de sesión fallaron. Analizar estos mensajes de fallo es crucial tanto para los profesionales de seguridad que evalúan las vulnerabilidades del sistema como para los probadores de penetración que refinan sus estrategias de ataque.

1. Primero, naveguemos hasta el directorio de su proyecto donde se almacenan los resultados del ataque. Esto asegura que estemos trabajando con los archivos correctos:

cd ~/project

2. Ahora veremos el archivo completo de los resultados del ataque. Este contiene toda la salida de los intentos de inicio de sesión de Hydra:

cat attack_results.txt

3. Para centrarse específicamente en los intentos fallidos, filtraremos los inicios de sesión exitosos y buscaremos patrones de error comunes. Los comandos grep ayudan a aislar los mensajes de fallo importantes:

grep -v "login:" attack_results.txt | grep -E "invalid|failed|error"

4. Estos son los mensajes de fallo más comunes que encontrará y lo que realmente significan:

• invalid password: El nombre de usuario era correcto, pero la contraseña no coincidía.
• invalid user: El nombre de usuario no existe en el sistema objetivo.
• connection refused: El servicio SSH no está en funcionamiento en el objetivo.
• connection timeout: Hay problemas de red o un firewall está bloqueando el acceso.
• too many connections: El objetivo ha detectado y bloqueado intentos de inicio de sesión rápidos.

5. Vamos a cuantificar cuántos de cada tipo de fallo ocurrieron. Contar estos ayudará a entender los patrones de ataque:

grep -c "invalid password" attack_results.txt
grep -c "invalid user" attack_results.txt

6. Para ver si los fallos ocurrieron en momentos específicos (lo que podría indicar un límite de tasa), extraeremos y contaremos las marcas de tiempo:

grep "invalid" attack_results.txt | awk '{print $1}' | uniq -c

7. Ahora crearemos un informe resumido simple de los fallos. Esta vista organizada ayuda a documentar sus hallazgos:

echo "Attack Failure Analysis" > failure_analysis.txt
echo "Invalid passwords: $(grep -c 'invalid password' attack_results.txt)" >> failure_analysis.txt
echo "Invalid users: $(grep -c 'invalid user' attack_results.txt)" >> failure_analysis.txt
cat failure_analysis.txt

8. Para una investigación más profunda, podemos verificar los registros SSH del sistema objetivo (si tiene acceso). Estos a menudo contienen información de error más detallada:

sudo grep 'sshd' /var/log/auth.log | tail -20

Resumen

En este laboratorio, has aprendido cómo realizar un ataque de diccionario en SSH utilizando Hydra preparando listas de nombres de usuario y contraseñas. El proceso incluyó la creación de archivos de credenciales, la verificación de su contenido y la estructuración del comando de Hydra con las banderas adecuadas (-L, -P y -t) para un ataque efectivo.

Además, has explorado cómo interpretar la salida de Hydra para identificar inicios de sesión exitosos y analizar los resultados del ataque. Este laboratorio demostró la importancia de la preparación adecuada de archivos, la configuración de comandos y las pruebas sistemáticas en ataques a credenciales SSH.