Fortalecer SSH en OpenSSH

Introducción

En este laboratorio, aprenderá técnicas esenciales para mejorar la seguridad de SSH en OpenSSH a través de la autenticación por clave y el endurecimiento de la configuración. Practicará reemplazar la autenticación por contraseña con pares de claves seguros, deshabilitar el inicio de sesión como root y modificar los puertos predeterminados para mitigar los ataques de fuerza bruta.

Los ejercicios prácticos lo guiarán a través de la generación de claves criptográficas, la configuración de los permisos adecuados de los archivos y la prueba de su configuración segura de SSH. También aprenderá comandos clave para administrar los servicios de SSH y verificar sus configuraciones de seguridad.

Skills Graph

Instalar OpenSSH

En este paso, instalará el paquete del servidor OpenSSH en su máquina virtual (VM) de LabEx. OpenSSH (Open Secure Shell) es una implementación gratuita y de código abierto del protocolo SSH que proporciona comunicaciones cifradas seguras entre dos hosts no confiables a través de una red insegura. Es la herramienta estándar para la administración remota de servidores y la transferencia segura de archivos.

Antes de comenzar, es importante entender que SSH funciona en un modelo cliente-servidor. El servidor (que estamos instalando ahora) escucha las conexiones entrantes, mientras que los clientes (como la terminal de su máquina local) se conectan a él. Toda la comunicación está cifrada, protegiendo sus credenciales y datos.

Dado que la VM de LabEx utiliza contenedores Docker donde systemctl no está disponible (los contenedores Docker generalmente ejecutan un solo proceso en lugar de sistemas operativos completos), usaremos el comando service para administrar el demonio SSH. Esta es una alternativa más simple a systemctl que funciona bien en entornos contenerizados.

Siga estos pasos para instalar OpenSSH:

Primero, actualice la lista de paquetes para asegurarse de obtener la última versión. Esto obtiene la información más reciente de los paquetes de los repositorios de Ubuntu:
```
sudo apt update
```
Instale el paquete del servidor OpenSSH. La bandera -y confirma automáticamente cualquier solicitud durante la instalación:
```
sudo apt install -y openssh-server
```
Después de la instalación, verifique si el servicio SSH está en ejecución. El comando status muestra si el servicio está activo y escuchando conexiones:
```
service ssh status
```
Debería ver una salida que indique que el servicio está activo (en ejecución). Si no está en ejecución, lo iniciaremos en el siguiente paso.
Si el servicio no está en ejecución (lo que se mostraría como "inactivo" en la salida del estado), inícielo manualmente:
```
service ssh start
```
Verifique que SSH esté escuchando en el puerto predeterminado (22). El comando netstat muestra las conexiones de red y los puertos en escucha, mientras que grep filtra las entradas relacionadas con SSH:
```
sudo netstat -tulnp | grep sshd
```
Debería ver una salida similar a esta, que muestra que SSH está escuchando en todas las interfaces de red (0.0.0.0) en el puerto 22:
```
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      -
```

Configurar la autenticación por clave

En este paso, configurará la autenticación basada en claves SSH, que proporciona una seguridad mayor que la autenticación por contraseña tradicional. A diferencia de las contraseñas, que se pueden adivinar o forzar por fuerza bruta, la autenticación por clave utiliza un par de claves criptográficas: una privada (que se mantiene en secreto) y una pública (que se comparte con los servidores).

Cuando se conecta a un servidor SSH, este utiliza algoritmos matemáticos para verificar que posee la clave privada que coincide con la clave pública que tiene en archivo. Este método es más seguro y más conveniente una vez configurado.

Vamos a crear y configurar estas claves paso a paso:

Primero, generaremos un nuevo par de claves SSH. Este comando crea dos archivos en su directorio ~/.ssh:
```
ssh-keygen -t rsa -b 4096 -f ~/.ssh/labex_key -N ""
```
- -t rsa especifica el tipo de clave (algoritmo RSA)
- -b 4096 crea una clave fuerte de 4096 bits
- -f establece el nombre de archivo para su par de claves
- -N "" significa sin frase de contraseña (por simplicidad en el laboratorio)
Ahora tendrá:
- Clave privada: ~/.ssh/labex_key (¡nunca comparta esto!)
- Clave pública: ~/.ssh/labex_key.pub (esta se comparte con los servidores)
Los permisos adecuados de los archivos son cruciales para la seguridad de SSH. Estos comandos aseguran que solo usted pueda acceder a sus claves:
```
chmod 700 ~/.ssh
chmod 600 ~/.ssh/labex_key
chmod 644 ~/.ssh/labex_key.pub
```
Ahora autorizaremos su clave agregando la clave pública al archivo especial authorized_keys que SSH verifica:
```
cat ~/.ssh/labex_key.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys
```
A continuación, configuraremos el servidor SSH en sí. Edite el archivo de configuración principal:
```
sudo nano /etc/ssh/sshd_config
```
Busque y modifique estas configuraciones importantes:
```
PubkeyAuthentication yes
PasswordAuthentication no
```
Esto le dice a SSH que:
- Permita la autenticación por clave (habilitada por defecto, pero es bueno confirmarlo)
- Deshabilite los inicios de sesión por contraseña (obligando solo a acceder por clave)
Después de cambiar la configuración, siempre reinicie el servicio SSH:
```
service ssh restart
```
Finalmente, verifiquemos que todo funcione. Intente conectarse a su propia máquina (localhost) utilizando su nueva clave:
```
ssh -i ~/.ssh/labex_key localhost
```
La bandera -i especifica qué clave privada utilizar. Si tiene éxito, iniciará sesión inmediatamente sin ningún aviso de contraseña, lo que confirma que la autenticación por clave está funcionando correctamente.

Deshabilitar el inicio de sesión como root

En este paso, deshabilitaremos el inicio de sesión directo como root a través de SSH. Esto es importante porque la cuenta root tiene privilegios completos en el sistema, lo que la convierte en un objetivo principal para los hackers. Al deshabilitar el inicio de sesión como root, obligamos a los atacantes a adivinar tanto un nombre de usuario como una contraseña, lo que hace que los ataques de fuerza bruta sean mucho más difíciles.

Cuando necesite privilegios de root después de este cambio, primero iniciará sesión con una cuenta de usuario normal y luego usará sudo para realizar tareas administrativas. Esto crea una capa adicional de seguridad, ya que los atacantes necesitarían comprometer dos cuentas.

Modifiquemos la configuración de SSH:

Primero, abra el archivo de configuración principal de SSH con un editor de texto. Usaremos nano aquí, pero puede usar cualquier editor con el que se sienta cómodo:
```
sudo nano /etc/ssh/sshd_config
```
Busque la línea que dice PermitRootLogin (generalmente alrededor de la línea 32). Si no la encuentra, tendrá que agregarla. Cambie o agregue esta línea a:
```
PermitRootLogin no
```
Mientras editamos este archivo, establezcamos algunos parámetros de seguridad adicionales que funcionan bien con este cambio:
```
StrictModes yes
MaxAuthTries 3
LoginGraceTime 60
```
- StrictModes comprueba los permisos de los archivos por seguridad
- MaxAuthTries limita los intentos de inicio de sesión fallidos
- LoginGraceTime establece cuánto tiempo puede tardar un inicio de sesión
Guarde sus cambios en nano presionando:
- Ctrl+O para escribir
- Enter para confirmar
- Ctrl+X para salir
Para que los cambios surtan efecto, reinicie el servicio SSH:
```
service ssh restart
```
Probemos que nuestros cambios funcionaron intentando iniciar sesión como root a través de SSH (esto debería fallar):
```
ssh root@localhost
```
Debería ver un error como "Permission denied (publickey)", lo que significa que nuestra medida de seguridad está funcionando correctamente. A partir de ahora, necesitará usar una cuenta de usuario normal para iniciar sesión.

Cambiar el puerto predeterminado

En este paso, modificaremos el puerto predeterminado de SSH de 22 a un puerto personalizado (2222 en nuestro ejemplo). Esta es una medida de seguridad importante porque muchos bots automatizados y atacantes buscan servidores SSH en el puerto estándar 22. Al cambiar a un puerto no estándar, hacemos que nuestro servidor sea menos visible para estos escaneos automatizados.

Antes de realizar cualquier cambio, primero comprobemos la configuración actual del puerto de SSH. Esto nos ayuda a entender la configuración existente:

sudo grep -i port /etc/ssh/sshd_config

Por lo general, verá #Port 22 en la salida. El símbolo # significa que esta línea está comentada, por lo que SSH está utilizando actualmente el puerto predeterminado 22.

Ahora editaremos el archivo de configuración de SSH. Usaremos el editor de texto nano, que es fácil de usar para los principiantes:

sudo nano /etc/ssh/sshd_config

Dentro del archivo, busque la línea que contiene #Port 22. Necesitamos hacer dos cambios aquí:

Elimine el # para descomentar la línea (esto activa la configuración)
Cambie el número de puerto de 22 a 2222

La línea modificada debería verse así:

Port 2222

Después de realizar este cambio, guarde el archivo en nano presionando:

Ctrl+O (para escribir el archivo)
Enter (para confirmar el nombre del archivo)
Ctrl+X (para salir del editor)

Para que los cambios surtan efecto, necesitamos reiniciar el servicio SSH:

service ssh restart

Verifiquemos que SSH ahora esté escuchando en nuestro nuevo puerto (2222) en lugar del puerto predeterminado:

sudo netstat -tulnp | grep ssh

La salida debería mostrar que SSH está escuchando en el puerto 2222. Si todavía ve el puerto 22, revise nuevamente los cambios en el archivo de configuración.

Finalmente, pruebe la nueva configuración conectándose a SSH utilizando el puerto personalizado. Tenga en cuenta que ahora debemos especificar el puerto con la bandera -p:

ssh -p 2222 -i ~/.ssh/labex_key localhost

Después de conectarse con éxito, puede salir de la sesión de SSH presionando Ctrl+D. Recuerde que a partir de ahora, siempre deberá especificar este puerto personalizado cuando se conecte a su servidor SSH.

Probar la configuración fortalecida

En este último paso, verificaremos todas las medidas de fortalecimiento de seguridad que has implementado. La prueba es crucial para garantizar que tu servidor SSH esté configurado correctamente y sea seguro. Examinaremos tanto la configuración del lado del servidor como los intentos de conexión del lado del cliente.

Comencemos comprobando la configuración actual de SSH en tu servidor. Esto confirma que los cambios que hiciste anteriormente están activos:

Primero, verifica todas las configuraciones actuales de SSH:
```
sudo sshd -T | grep -E 'port|permitrootlogin|passwordauthentication|pubkeyauthentication'
```
El comando sshd -T muestra la configuración real en tiempo de ejecución. Estamos filtrando para parámetros de seguridad clave. Deberías ver:
```
port 2222
permitrootlogin no
passwordauthentication no
pubkeyauthentication yes
```
Esta salida confirma que SSH está funcionando en el puerto 2222, el inicio de sesión como root está deshabilitado, la autenticación por contraseña está desactivada y la autenticación por clave pública está habilitada.

Ahora probemos las conexiones desde la perspectiva del cliente:

Prueba una conexión exitosa con autenticación por clave:
```
ssh -p 2222 -i ~/.ssh/labex_key localhost "echo 'Key auth successful'"
```
Este comando intenta conectarse utilizando tu clave privada (la bandera -i especifica el archivo de clave). El comando ejecuta un simple echo en el servidor si tiene éxito. Deberías ver:
```
Key auth successful
```
Prueba un intento fallido de inicio de sesión como root:
```
ssh -p 2222 root@localhost 2>&1 | grep -i "permission denied"
```
Este comando intenta iniciar sesión como root, lo cual debería fallar porque deshabilitamos el inicio de sesión como root. El comando filtra el mensaje de error esperado.
Prueba un intento fallido de autenticación por contraseña:
```
ssh -p 2222 -o PreferredAuthentications=password -o PubkeyAuthentication=no localhost 2>&1 | grep -i "permission denied"
```
Aquí forzamos la autenticación por contraseña (deshabilitada en nuestra configuración) para verificar que esté correctamente bloqueada. Las opciones deshabilitan explícitamente la autenticación por clave.

Finalmente, comprobemos el estado de red del servidor:

Comprueba las conexiones SSH activas:
```
sudo netstat -tulnp | grep 2222
```
Esto muestra todos los puertos en escucha, filtrados por nuestro puerto personalizado de SSH (2222). Deberías ver sshd listado como escuchando en este puerto.
Verifica el estado del servicio SSH:
```
service ssh status
```
Confirma que el servicio SSH está funcionando correctamente. La salida debería indicar que el servicio está activo.

Resumen

En este laboratorio, has aprendido a mejorar la seguridad de SSH en OpenSSH a través de configuraciones prácticas. Los ejercicios cubrieron la instalación del servidor OpenSSH, la verificación de su estado y la implementación de la autenticación basada en claves con ajustes de permisos adecuados.

También exploraste técnicas críticas de fortalecimiento de seguridad, como deshabilitar el inicio de sesión como root y cambiar el puerto predeterminado de SSH. Estas medidas reducen efectivamente la vulnerabilidad a ataques de fuerza bruta y escaneos automatizados mientras se mantiene la funcionalidad del sistema.