Configurar un entorno de prueba para Hydra

Introducción

En este laboratorio, aprenderá cómo configurar un entorno de prueba para Hydra instalando y configurando un servidor OpenSSH en su máquina virtual (VM) de LabEx. Este entorno controlado le permitirá practicar de forma segura técnicas de cracking de contraseñas en ejercicios posteriores.

Configurará el servidor SSH para habilitar la autenticación por contraseña y el inicio de sesión como root, lo cual es esencial para las pruebas de Hydra. El proceso incluye modificar archivos de configuración, reiniciar servicios y verificar la configuración para pruebas de seguridad posteriores.

Instalar un servidor SSH local

En este paso, instalará un servidor OpenSSH en su máquina virtual (VM) de LabEx. Comencemos por entender qué es SSH - significa Secure Shell (Shell Seguro), que es un protocolo de red que crea un canal seguro entre dos computadoras a través de una red insegura. Esto es particularmente importante cuando necesita acceder de forma remota a un sistema mientras mantiene su comunicación encriptada.

El servidor OpenSSH que estamos instalando es la implementación más común del protocolo SSH en sistemas Linux. Al configurarlo, estamos creando un entorno controlado donde podemos probar de forma segura herramientas de cracking de contraseñas como Hydra más adelante en el laboratorio. Esto es similar a cómo los profesionales de seguridad prueban los sistemas en busca de vulnerabilidades en un entorno seguro y aislado.

Primero, necesitamos actualizar la lista de paquetes. Esto asegura que su sistema conozca las últimas versiones disponibles de los paquetes de software:
```
sudo apt update
```
El comando sudo le otorga privilegios de administrador, mientras que apt update actualiza la lista de paquetes disponibles en su sistema.
Ahora instale el paquete del servidor OpenSSH. Esto descargará y configurará todos los componentes necesarios para ejecutar un servidor SSH:
```
sudo apt install -y openssh-server
```
La opción -y responde automáticamente "sí" a cualquier pregunta durante la instalación, lo que hace que el proceso sea más fluido.
Dado que estamos trabajando en un contenedor Docker (un entorno ligero y aislado), necesitamos iniciar manualmente el servicio SSH. Normalmente, se iniciaría automáticamente, pero manejaremos esa configuración más adelante:
```
sudo service ssh start
```
Verifiquemos que el servidor SSH esté funcionando correctamente. Este comando comprueba el estado actual del servicio SSH:
```
sudo service ssh status
```
Debería ver una salida que contenga "active (running)" lo que confirma que el servicio está funcionando correctamente.
Finalmente, comprobaremos que el servidor SSH esté escuchando en el puerto predeterminado (22). Los puertos son como puertas que utilizan los servicios para comunicarse, y SSH tradicionalmente utiliza el puerto 22:
```
ss -tulnp | grep sshd
```
El comando ss muestra estadísticas de sockets, y estamos filtrando las entradas relacionadas con SSH. Debería ver una salida que muestre sshd escuchando en *:22 o 0.0.0.0:22, lo que significa que está listo para aceptar conexiones en todas las interfaces de red.

Configurar el servidor SSH para pruebas

En este paso, configurará el servidor SSH para habilitar la autenticación por contraseña, lo cual es necesario para realizar pruebas con Hydra en pasos posteriores. SSH (Secure Shell, Shell Seguro) es un protocolo que permite el acceso remoto seguro a sistemas. Por defecto, las configuraciones modernas de SSH priorizan la seguridad deshabilitando la autenticación por contraseña a favor de la autenticación basada en claves. Sin embargo, dado que Hydra es una herramienta de cracking de contraseñas, necesitamos habilitar temporalmente la autenticación por contraseña con fines de prueba.

Primero, realice una copia de seguridad del archivo de configuración original de SSH. Esta es una buena práctica antes de realizar cualquier cambio en el sistema, lo que le permite restaurar la configuración original si es necesario:
```
sudo cp /etc/ssh/sshd_config /etc/ssh/sshd_config.bak
```
Abra el archivo de configuración del servidor SSH para editarlo. Estamos utilizando nano, un editor de texto simple adecuado para principiantes. El archivo contiene todas las configuraciones que controlan cómo opera su servidor SSH:
```
sudo nano /etc/ssh/sshd_config
```
Busque y modifique las siguientes líneas (o agréguelas si no existen). Estas configuraciones habilitan la autenticación por contraseña y permiten el inicio de sesión como root, lo cual necesitamos para nuestro entorno de prueba:
```
PasswordAuthentication yes
PermitRootLogin yes
```
Guarde el archivo (Ctrl+O, Enter) y salga de nano (Ctrl+X). Recuerde que los cambios no surtirán efecto hasta que reiniciemos el servicio SSH.
Reinicie el servicio SSH para aplicar los cambios. Esto le indica al sistema que recargue el archivo de configuración con nuestras nuevas configuraciones:
```
sudo service ssh restart
```
Verifique que la nueva configuración esté activa. Este comando comprueba la configuración actual de SSH y filtra nuestras configuraciones específicas para confirmar que están correctamente habilitadas:
```
sudo sshd -T | grep -E "passwordauthentication|permitrootlogin"
```
Debería ver una salida que confirme que ambas configuraciones están habilitadas. Si no es así, verifique que haya guardado el archivo correctamente y reiniciado el servicio.

Crear cuentas de usuario de prueba

En este paso, creará cuentas de usuario de prueba con contraseñas intencionalmente débiles. Estas cuentas servirán como objetivos cuando más adelante utilicemos Hydra para demostrar ataques de fuerza bruta SSH. Crear este tipo de cuentas de prueba nos ayuda a simular de forma segura escenarios del mundo real en los que los atacantes podrían explotar credenciales débiles.

Vamos a crear tres usuarios de prueba con contraseñas débiles comunes. Estas contraseñas son deliberadamente simples porque queremos que Hydra pueda descifrarlas durante nuestras pruebas. En sistemas reales, siempre debe utilizar contraseñas fuertes y complejas.

Cree tres usuarios de prueba con contraseñas simples (los usaremos para las pruebas):
```
sudo useradd -m -s /bin/bash testuser1
echo "testuser1:password123" | sudo chpasswd

sudo useradd -m -s /bin/bash testuser2
echo "testuser2:qwerty" | sudo chpasswd

sudo useradd -m -s /bin/bash testuser3
echo "testuser3:letmein" | sudo chpasswd
```
El comando useradd crea cada usuario con un directorio personal (-m) y establece su shell en bash (-s /bin/bash). El comando chpasswd establece la contraseña para cada usuario.
Verifique que los usuarios se hayan creado correctamente:
```
id testuser1
id testuser2
id testuser3
```
El comando id muestra información del usuario. Debería ver una salida que confirme la existencia de cada usuario, incluyendo su ID de usuario (UID), ID de grupo (GID) y pertenencia a grupos. Este paso de verificación asegura que nuestras cuentas de prueba estén configuradas correctamente antes de continuar.
Compruebe que las contraseñas se hayan establecido correctamente intentando cambiar a cada usuario (deberá ingresar las contraseñas que acaba de establecer):
```
su - testuser1
exit
su - testuser2
exit
su - testuser3
exit
```
El comando su - username le permite cambiar a otra cuenta de usuario. Después de ingresar cada contraseña, debería ver brevemente que el indicador de comando cambie para indicar que ha iniciado sesión como ese usuario. El comando exit lo devuelve a su sesión original. Este paso confirma que las contraseñas funcionan como se espera.
(Opcional) Cree un archivo de texto que contenga las credenciales de prueba para referencia:
```
echo -e "testuser1:password123\ntestuser2:qwerty\ntestuser3:letmein" > ~/project/test_credentials.txt
```
Esto crea un archivo de texto que enumera todas las credenciales de prueba en el formato nombre de usuario:contraseña. Si bien no es estrictamente necesario, tener este archivo de referencia puede ser útil durante las pruebas. La opción -e habilita la interpretación de secuencias de escape de barra invertida como \n para saltos de línea.

Iniciar el servicio SSH

En este paso, asegurará que el servicio SSH esté funcionando correctamente y esté configurado para iniciar automáticamente. SSH (Secure Shell, Shell Seguro) es un protocolo de red que permite el acceso remoto seguro entre computadoras. En nuestro entorno de prueba de Hydra, necesitamos que SSH esté funcionando continuamente para poder realizar pruebas de cracking de contraseñas de manera confiable.

Primero, veamos si el servicio SSH está actualmente activo. Este comando muestra el estado actual del daemon de SSH (sshd):
```
sudo service ssh status
```
Si no está en ejecución, verá "inactive (dead)" en la salida. Esto significa que el servicio SSH está actualmente detenido y no está aceptando ninguna conexión.
Si el servicio no está en ejecución, necesitamos iniciarlo. Este comando inicializa el daemon de SSH:
```
sudo service ssh start
```
Después de iniciar el servicio, verifiquemos que esté funcionando correctamente. El comando de estado ahora debería mostrar una salida diferente:
```
sudo service ssh status
```
Ahora debería ver "active (running)" en la salida, lo que indica que el servicio SSH está listo para aceptar conexiones.
Dado que estamos trabajando en un contenedor Docker (un entorno ligero y aislado), necesitamos asegurarnos de que SSH se inicie automáticamente cuando el contenedor se reinicie. Esta línea agrega un comando de inicio a su archivo de configuración de bash:
```
echo 'sudo service ssh start' >> ~/.bashrc
```
El archivo .bashrc se ejecuta automáticamente cuando inicia una nueva sesión de terminal, por lo que esto asegura que SSH siempre se iniciará cuando el contenedor se inicie.
Finalmente, confirmemos que SSH esté escuchando en el puerto de red correcto (el puerto 22 es el predeterminado para SSH). Este comando muestra todas las conexiones de red activas:
```
sudo netstat -tulnp | grep sshd
```
Debería ver una salida que muestre a sshd escuchando en 0.0.0.0:22, lo que significa que el servidor SSH está configurado correctamente para aceptar conexiones desde cualquier interfaz de red en el puerto estándar de SSH.

Verificar la accesibilidad del servidor SSH

En este último paso, verificaremos que tu servidor SSH esté configurado correctamente y sea accesible. Esto es crucial porque Hydra (la herramienta de cracking de contraseñas que usaremos en laboratorios posteriores) requiere un servicio SSH funcional para realizar pruebas. Realizaremos varios chequeos para asegurarnos de que todo funcione como se espera.

Primero, veamos si el servicio SSH está realmente en funcionamiento. A veces, los servicios pueden fallar al iniciar o fallar inesperadamente, así que este es nuestro primer chequeo básico:
```
sudo service ssh status
```
La salida debe mostrar claramente "active (running)". Si no lo hace, tendríamos que solucionar los problemas del servicio antes de continuar.
Ahora probaremos el acceso SSH local utilizando una de las cuentas de prueba que creamos anteriormente. Esto simula cómo Hydra intentará conectarse:
```
ssh testuser1@localhost
```
Cuando se le solicite, ingrese la contraseña "password123" (la que configuramos anteriormente). Después de iniciar sesión correctamente, escriba exit para volver a su sesión principal. Esto confirma que la autenticación básica de contraseña funciona.
Vamos a probar específicamente la autenticación por contraseña (ya que Hydra principalmente realiza ataques de fuerza bruta en contraseñas). Forzaremos a SSH a utilizar la autenticación por contraseña e intentaremos proporcionar intencionalmente una contraseña incorrecta:
```
ssh -o PreferredAuthentications=password -o PubkeyAuthentication=no testuser1@localhost
```
Ingrese cualquier contraseña incorrecta cuando se le solicite. El servidor debe rechazar la conexión, que es el comportamiento esperado que queremos ver.
A continuación, verificaremos que el servidor SSH esté escuchando en la interfaz de red y el puerto correctos. Esto asegura que las conexiones remotas (como las de Hydra) puedan alcanzar el servicio:
```
sudo netstat -tulnp | grep sshd
```
Debería ver que sshd está escuchando en 0.0.0.0:22, lo que significa que acepta conexiones desde cualquier interfaz de red en el puerto estándar de SSH (22).
Finalmente, examinemos los registros de autenticación para ver nuestros intentos de prueba registrados. Los registros son valiosos para solucionar problemas y entender lo que está sucediendo detrás de escena:
```
sudo tail -n 10 /var/log/auth.log
```
Busque entradas que muestren su inicio de sesión exitoso (paso 2) y su intento fallido (paso 3). Estos registros también serán importantes cuando analicemos los intentos de ataque de Hydra más adelante.

Resumen

En este laboratorio, has aprendido cómo configurar un entorno de prueba para Hydra instalando y configurando un servidor OpenSSH en una máquina virtual (VM) de LabEx. El proceso incluyó actualizar paquetes, instalar el servidor SSH y verificar su estado de funcionamiento mientras se configuraban los ajustes de autenticación con fines de prueba.

También practicaste la creación de cuentas de usuario de prueba para simular escenarios del mundo real y preparaste el entorno para pruebas de seguridad de contraseñas. Este laboratorio proporcionó una experiencia práctica esencial en la configuración de servidores SSH y el establecimiento de entornos controlados para la experimentación con herramientas de seguridad.