Ajustar la Velocidad de Ataque y los Hilos de Hydra

Introducción

En este laboratorio, aprenderá a optimizar el rendimiento del ataque de fuerza bruta de Hydra ajustando las configuraciones de hilos (threads). Explorará cómo diferentes configuraciones de hilos afectan la velocidad del ataque y el uso de recursos del sistema a través de escenarios prácticos de ataque SSH.

Los ejercicios lo guiarán a través de la modificación del número de hilos, la ejecución de ataques con listas de contraseñas y el análisis de las diferencias de rendimiento. Obtendrá experiencia práctica con las capacidades de procesamiento paralelo de Hydra mientras comprende el equilibrio entre la eficiencia del ataque y la carga del sistema.

Comprender las Opciones de Hilos de Hydra

En este paso, aprenderá sobre las opciones de hilos (threads) de Hydra y cómo afectan la velocidad de los ataques de fuerza bruta. Hydra es una herramienta popular para descifrar contraseñas que admite ataques paralelos utilizando múltiples hilos. Los hilos permiten que Hydra pruebe múltiples combinaciones de contraseñas simultáneamente, lo que acelera significativamente el proceso de descifrado en comparación con probar una contraseña a la vez.

Primero, abra una terminal en su VM de LabEx y navegue al directorio de trabajo predeterminado:
```
cd ~/project
```
Consultemos el menú de ayuda de Hydra para comprender las opciones relacionadas con los hilos:
```
hydra -h | grep -i thread
```
El comando grep -i thread filtra la salida para mostrar solo la información relacionada con los hilos, lo que facilita la búsqueda de lo que necesitamos. Debería ver una salida similar a:
```
-t TASKS  run TASKS number of connects in parallel (default: 16)
```
La opción -t controla el número de conexiones paralelas (hilos) que Hydra utilizará. Piense en los hilos como trabajadores: más trabajadores pueden hacer más trabajos simultáneamente. Más hilos significan ataques más rápidos, pero también un mayor uso de recursos y tráfico de red. Esto es importante porque usar demasiados hilos podría sobrecargar su sistema o activar alertas de seguridad en el sistema de destino.
Creemos una pequeña lista de contraseñas de prueba para demostrar el comportamiento de los hilos:
```
cat > test_passwords.txt << EOF
test1
test2
test3
test4
test5
EOF
```
Ahora veamos cómo diferentes cantidades de hilos afectan la velocidad del ataque. Primero, intente con 1 hilo:
```
hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 1 -vV
```
Observe cómo prueba las contraseñas una a la vez, con solo un proceso hijo.
Ahora intente con 4 hilos:
```
hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 4 -vV
```
Verá múltiples procesos hijos trabajando simultáneamente, probando diferentes contraseñas en paralelo. Esta ejecución paralela debería ser notablemente más rápida que la versión de un solo hilo.
Finalmente, intente con 8 hilos:
```
hydra -l testuser -P test_passwords.txt 127.0.0.1 ssh -t 8 -vV
```
Aunque solo tenemos 5 contraseñas, Hydra aún creará 8 procesos hijos, pero solo 5 estarán trabajando activamente. Esto demuestra cómo el número de hilos afecta el procesamiento paralelo.

Configurar un Ataque SSH Simple

En este paso, preparará un escenario de ataque SSH simple utilizando Hydra. Esta demostración le ayudará a comprender cómo funcionan las herramientas de descifrado de contraseñas en un entorno controlado. Utilizaremos una lista de contraseñas completa y atacaremos un servidor SSH local que se ejecuta en su propia máquina por seguridad.

Primero, asegúrese de estar en el directorio de trabajo correcto:
```
cd ~/project
```
El archivo de lista de contraseñas passwords.txt se ha creado con un conjunto completo de contraseñas comunes. Esta lista más grande nos ayudará a demostrar mejor el impacto de las diferentes configuraciones de hilos (threads) en el rendimiento del ataque. Verifique que el archivo de contraseñas se haya creado correctamente:
```
cat passwords.txt
```
Para este laboratorio, atacaremos el servidor SSH local (127.0.0.1), que es su propia máquina. Esto es más seguro que atacar sistemas remotos. Primero, compruebe si SSH se está ejecutando:
```
sudo service ssh status
```
Si no se está ejecutando, inícielo con: sudo service ssh start

Ejecutar un Ataque con Hilos Predeterminados

En este paso, ejecutará un ataque de fuerza bruta SSH utilizando Hydra con la configuración de hilos predeterminada. Hydra utiliza automáticamente 16 hilos paralelos de forma predeterminada, lo que significa que intentará 16 combinaciones de contraseñas diferentes simultáneamente. Con nuestra lista de contraseñas más grande, podrá observar el impacto de la configuración de hilos más claramente.

Primero, navegue a su directorio de trabajo:
```
cd ~/project
```
Ejecute el ataque de Hydra contra el servidor SSH local:
```
hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV
```
Observe la salida cuidadosamente. Verá:
- Hydra comenzando con 16 tareas (hilos)
- Cada intento de inicio de sesión que se muestra en tiempo real
- La velocidad actual medida en intentos por minuto
- Un inicio de sesión exitoso cuando encuentra la contraseña correcta
Para obtener mediciones de tiempo precisas, ejecute el comando con la utilidad time:
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV
```
Registre estos resultados de tiempo cuidadosamente. Con nuestra lista de contraseñas más grande, podrá ver claras diferencias de rendimiento cuando ajustemos el número de hilos.

Aumentar el Número de Hilos y Comparar la Velocidad

En este paso, aprenderá cómo el ajuste del número de hilos de Hydra afecta el rendimiento del descifrado de contraseñas. Compararemos los resultados de diferentes configuraciones de hilos para comprender el equilibrio (trade-off) entre la velocidad y el uso de recursos.

Primero, asegúrese de estar en el directorio de trabajo correcto:
```
cd ~/project
```
Ejecute Hydra con un mayor número de hilos (32) y mida el tiempo de ejecución:
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 32
```
Ahora pruebe con un número de hilos aún mayor (64) para ver si el rendimiento sigue mejorando:
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 64
```
Analice cómo el aumento de hilos afecta:
- La duración general del ataque
- El uso de recursos del sistema (visible en las columnas Usuario/Sistema (User/System) de la salida de time)
- La tasa de intentos de conexión de red (que se muestra en la salida detallada de Hydra)

Probar Ataque con Hilos Reducidos

En este paso, exploraremos cómo la reducción del número de hilos de Hydra afecta el rendimiento del descifrado de contraseñas. Probaremos con un número de hilos más bajo para comprender el equilibrio entre la velocidad y el uso de recursos.

Primero, asegúrese de estar en el directorio de trabajo correcto:
```
cd ~/project
```
Ejecute Hydra con 8 hilos (la mitad de nuestro mínimo anterior) y mida el tiempo de ejecución:
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 8
```
Ahora pruebe con solo 4 hilos para ver la configuración práctica mínima:
```
time hydra -l testuser -P passwords.txt 127.0.0.1 ssh -vV -t 4
```
Considere estas compensaciones (trade-offs) prácticas para el uso en el mundo real:
- Un mayor número de hilos (16-64) para ataques rápidos en sistemas potentes
- Un menor número de hilos (4-8) para entornos sigilosos o con recursos limitados
- El impacto en la red varía con el número de hilos: más hilos crean un tráfico más detectable

Resumen

En este laboratorio, ha aprendido cómo configurar la velocidad de ataque y la configuración de hilos (threads) de Hydra para ataques de fuerza bruta eficientes. Los puntos clave incluyen el uso del parámetro -t para controlar las conexiones paralelas y el análisis de cómo el número de hilos afecta el rendimiento a través de pruebas prácticas con diferentes valores.

También obtuvo experiencia práctica al configurar un escenario de ataque SSH, crear una lista de contraseñas y observar la relación entre el número de hilos, la velocidad de ataque y el uso de recursos del sistema. Este ejercicio práctico ayudó a demostrar las técnicas de optimización para Hydra en varios entornos de prueba.