Acceso Remoto Seguro en Linux con SSH

CompTIABeginner
Practicar Ahora

Introducción

En este laboratorio, aprenderá los fundamentos de la seguridad del acceso remoto a un sistema Linux utilizando el protocolo Secure Shell (SSH). Obtendrá experiencia práctica con funcionalidades esenciales de SSH, incluyendo la configuración de autenticación basada en claves para una seguridad mejorada, la transferencia segura de archivos entre sistemas y la creación de túneles SSH para el reenvío de puertos.

Comenzará configurando un contenedor Docker para simular un entorno de servidor remoto, haciendo el laboratorio más realista. Luego instalará el cliente OpenSSH en su máquina anfitriona y generará un nuevo par de claves RSA utilizando la utilidad ssh-keygen. A continuación, configurará el servidor Docker para aceptar esta clave para la autenticación, estableciendo una conexión segura y sin contraseña entre su anfitrión y el servidor contenedorizado. Finalmente, practicará el uso del comando scp para transferencias seguras de archivos y el comando ssh -L para reenviar un puerto local a un servicio remoto, creando efectivamente un túnel seguro.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 81%. Ha recibido una tasa de reseñas positivas del 96% por parte de los estudiantes.

Configurar Servidor SSH de Docker y Generar un Par de Claves

En este paso, configurará un contenedor Docker para simular un servidor SSH remoto y generará un par de claves seguro en su máquina anfitriona. Este enfoque proporciona un entorno más realista al separar el cliente (su anfitrión) del servidor (contenedor Docker).

Dado que Docker y el cliente OpenSSH ya están instalados en este entorno, puede proceder directamente a la configuración del servidor.

Primero, asegúrese de que el servicio Docker esté en ejecución:

sudo systemctl start docker
sudo systemctl enable docker

Ahora, creemos un contenedor Docker que actuará como nuestro servidor SSH. Utilizaremos Ubuntu como imagen base y lo configuraremos con capacidades de servidor SSH. Cree un Dockerfile:

cat > Dockerfile << 'EOF'
FROM ubuntu:22.04

## Instalar servidor OpenSSH y otras utilidades
RUN apt-get update && \
    apt-get install -y openssh-server nginx sudo && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

## Crear un usuario para el acceso SSH
RUN useradd -m -s /bin/bash sshuser && \
    echo 'sshuser:password123' | chpasswd && \
    usermod -aG sudo sshuser

## Configurar SSH
RUN mkdir /var/run/sshd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/' /etc/ssh/sshd_config && \
    sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config && \
    sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config

## Crear directorio SSH para el usuario
RUN mkdir -p /home/sshuser/.ssh && \
    chown sshuser:sshuser /home/sshuser/.ssh && \
    chmod 700 /home/sshuser/.ssh

## Exponer puerto SSH
EXPOSE 22 80

## Iniciar servicio SSH
CMD ["/usr/sbin/sshd", "-D"]
EOF

Construya la imagen Docker:

sudo docker build -t ssh-server .

Ejecute el contenedor Docker, mapeando el puerto 2222 de su anfitrión al puerto 22 del contenedor:

sudo docker run -d --name ssh-lab-server -p 2222:22 -p 8080:80 ssh-server

Verifique que el contenedor se esté ejecutando:

sudo docker ps

Debería ver una salida que muestre el contenedor en ejecución:

CONTAINER ID   IMAGE        COMMAND               CREATED         STATUS         PORTS                                        NAMES
...            ssh-server   "/usr/sbin/sshd -D"   ...             Up ...         0.0.0.0:2222->22/tcp, 0.0.0.0:8080->80/tcp   ssh-lab-server

A continuación, generará un par de claves SSH. Las claves SSH proporcionan una forma más segura de iniciar sesión en un servidor con SSH que el uso de una contraseña sola. Un par de claves consta de una clave privada, que debe mantenerse en secreto, y una clave pública, que se puede compartir.

Utilizaremos el comando ssh-keygen para crear un nuevo par de claves. Especificaremos el tipo de clave como rsa y el tamaño de la clave como 2048 bits para una seguridad sólida. La bandera -f nos permite especificar un nombre de archivo para nuestras claves, lo que ayuda a organizarlas. Llamaremos a nuestra clave ~/.ssh/id_rsa_lab_ssh.

Ejecute el siguiente comando. Cuando se le solicite una frase de contraseña (passphrase), simplemente presione Enter dos veces para continuar sin ella. Para este laboratorio, omitiremos la frase de contraseña por simplicidad, pero en un escenario del mundo real, siempre debe usar una frase de contraseña segura para proteger su clave privada.

ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa_lab_ssh

El comando generará el par de claves y le mostrará dónde se guardan los archivos.

Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/labex/.ssh/id_rsa_lab_ssh
Your public key has been saved in /home/labex/.ssh/id_rsa_lab_ssh.pub
The key fingerprint is:
SHA256:... labex@...
The key's randomart image is:
+---[RSA 2048]----+
|        .o*+..   |
|       . =.o. .  |
|      . o o. .   |
|       o .  .    |
|      . S        |
|     . . .       |
|      o .        |
|     o .         |
|    E .          |
+----[SHA256]-----+

Para confirmar que los archivos de clave se han creado, puede listar el contenido del directorio ~/.ssh. Debería ver su nueva clave privada (id_rsa_lab_ssh) y clave pública (id_rsa_lab_ssh.pub).

ls -l ~/.ssh/id_rsa_lab_ssh*

La salida será similar a esta, mostrando los dos nuevos archivos:

-rw------- 1 labex labex 1876 ... /home/labex/.ssh/id_rsa_lab_ssh
-rw-r--r-- 1 labex labex  401 ... /home/labex/.ssh/id_rsa_lab_ssh.pub

Ahora ha instalado correctamente el servidor SSH y ha creado un par de claves, que utilizará en los siguientes pasos para configurar y probar la autenticación segura.

Configurar y Probar la Autenticación Basada en Claves SSH

En este paso, configurará el servidor SSH de Docker para que reconozca su clave pública, lo que le permitirá iniciar sesión sin contraseña. Este proceso implica copiar su clave pública al contenedor Docker y luego probar la conexión.

Para que el servidor SSH lo autentique utilizando su clave, su clave pública debe colocarse en el archivo ~/.ssh/authorized_keys en el servidor. Dado que nuestro servidor se está ejecutando en un contenedor Docker, necesitamos copiar la clave pública de su máquina anfitriona al contenedor.

Primero, copie su clave pública al contenedor Docker utilizando el comando docker cp:

sudo docker cp ~/.ssh/id_rsa_lab_ssh.pub ssh-lab-server:/home/sshuser/.ssh/authorized_keys

A continuación, debemos establecer los permisos de archivo correctos dentro del contenedor. SSH es muy particular con la seguridad y se negará a usar claves si los permisos son demasiado abiertos. Ejecute el siguiente comando para establecer los permisos adecuados:

sudo docker exec ssh-lab-server chown sshuser:sshuser /home/sshuser/.ssh/authorized_keys
sudo docker exec ssh-lab-server chmod 600 /home/sshuser/.ssh/authorized_keys

Con la clave pública añadida y los permisos establecidos, está listo para probar la autenticación basada en claves. Intentará conectarse por SSH al contenedor Docker utilizando el puerto 2222 (que mapeamos al puerto 22 del contenedor) como el usuario sshuser, especificando la clave privada que creó.

Utilice el comando ssh con la bandera -i para indicar el archivo de su clave privada y -p para especificar el puerto:

ssh -i ~/.ssh/id_rsa_lab_ssh -p 2222 sshuser@localhost

Dado que se está conectando a un nuevo host por primera vez, es posible que se le pida que verifique la autenticidad del host. Escriba yes y presione Enter.

The authenticity of host '[localhost]:2222 ([127.0.0.1]:2222)' can't be established.
ED25519 key fingerprint is SHA256:....
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[localhost]:2222' (ED25519) to the list of known hosts.

Si todo está configurado correctamente, iniciará sesión inmediatamente sin que se le solicite una contraseña. Verá un mensaje de bienvenida y su prompt de comando cambiará para mostrar que ahora está dentro del contenedor Docker:

Welcome to Ubuntu 22.04.3 LTS (GNU/Linux 5.15.0-88-generic x86_64)
...
sshuser@containerid:~$

Para salir de la sesión SSH y volver al prompt de su terminal anfitriona, simplemente escriba exit y presione Enter.

exit

Iniciar sesión correctamente sin contraseña confirma que su autenticación basada en claves está funcionando correctamente entre su anfitrión y el contenedor Docker. Este método es significativamente más seguro que la autenticación tradicional por contraseña.

Transferir Archivos de Forma Segura Usando scp

En este paso, aprenderá a usar el Secure Copy Protocol (scp) para transferir archivos de forma segura entre hosts. scp aprovecha el protocolo SSH subyacente, lo que significa que se beneficia de los mismos mecanismos de cifrado y autenticación que ya ha configurado, incluida la autenticación basada en claves.

Primero, creemos un archivo de ejemplo en su directorio de trabajo actual, ~/project, que podamos usar para la transferencia. Lo llamaremos source_file.txt.

echo "This is a test file for scp." > source_file.txt

Puede verificar que el archivo se creó listándolo:

ls -l source_file.txt

La salida debería mostrar su archivo recién creado:

-rw-r--r-- 1 labex labex 29 ... source_file.txt

Ahora, utilizará scp para copiar source_file.txt al directorio /tmp en el contenedor Docker, demostrando la transferencia segura de archivos a un servidor remoto. La sintaxis básica para scp es scp -i [private_key] -P [port] [source_file] [user]@[host]:[destination_path].

Utilizará la bandera -i para especificar su clave privada, -P para especificar el puerto 2222 (el puerto SSH de nuestro contenedor Docker) y transferirá el archivo a la cuenta sshuser en el contenedor:

scp -i ~/.ssh/id_rsa_lab_ssh -P 2222 source_file.txt sshuser@localhost:/tmp/destination_file.txt

Verá una salida que indica el progreso de la transferencia de archivos, que debería ser instantánea para un archivo pequeño.

source_file.txt                                   100%   29     6.7KB/s   00:00

Para confirmar que el archivo se copió correctamente, conéctese al contenedor Docker y liste el archivo de destino:

sudo docker exec ssh-lab-server ls -l /tmp/destination_file.txt

La salida confirmará la existencia y los detalles del archivo copiado:

-rw-r--r-- 1 sshuser sshuser 29 ... /tmp/destination_file.txt

También puede verificar que el contenido del archivo se transfirió correctamente:

sudo docker exec ssh-lab-server cat /tmp/destination_file.txt

Esto debería mostrar:

This is a test file for scp.

Ahora ha transferido con éxito un archivo utilizando scp, demostrando una forma segura y práctica de mover datos entre sistemas a través de una red.

Crear un Túnel SSH para Reenvío de Puertos con ssh -L

En este paso, aprenderá una de las características más potentes de SSH: el tunneling, también conocido como reenvío de puertos. Esto le permite reenviar de forma segura el tráfico de red desde un puerto en su máquina local a un puerto en un servidor remoto, encapsulando efectivamente un protocolo sin cifrar dentro de una conexión SSH segura. Practicaremos el reenvío de puertos local.

Para demostrar esto, necesitamos un servicio ejecutándose en un puerto al que podamos conectarnos. Afortunadamente, nuestro contenedor Docker ya tiene Nginx instalado y configurado. Necesitamos iniciar el servicio Nginx dentro del contenedor.

Primero, inicie el servicio Nginx dentro del contenedor Docker:

sudo docker exec ssh-lab-server service nginx start

Puede verificar que Nginx se está ejecutando correctamente dentro del contenedor:

sudo docker exec ssh-lab-server service nginx status

La salida debería mostrar el servicio como en ejecución:

 * nginx is running

Ahora, creemos el túnel SSH. Utilizaremos el comando ssh con la bandera -L, que significa reenvío de puertos local. La sintaxis es ssh -L [LOCAL_PORT]:[DESTINATION_HOST]:[DESTINATION_PORT] [USER]@[SERVER].

Reenviaremos el tráfico desde el puerto 9090 en nuestra máquina local al puerto 80 dentro del contenedor Docker. La bandera -N le indica a SSH que no ejecute un comando remoto, lo cual es ideal para simplemente reenviar puertos. Tenga en cuenta que usamos el puerto 2222 para conectarnos al servicio SSH de nuestro contenedor Docker.

Ejecute este comando. Este comando ocupará su terminal actual y no devolverá un prompt. Necesitará abrir una nueva terminal para probar el túnel.

ssh -i ~/.ssh/id_rsa_lab_ssh -N -L 9090:localhost:80 -p 2222 sshuser@localhost

Ahora, abra una nueva terminal haciendo clic en el icono + en la barra de pestañas de la terminal. En esta nueva terminal, puede probar el túnel usando curl. Al acceder a localhost:9090, su solicitud se reenviará de forma segura a través de SSH al puerto 80 dentro del contenedor Docker.

curl http://localhost:9090

Debería ver el contenido HTML de la página de bienvenida predeterminada de Nginx, lo que confirma que el túnel está funcionando.

<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

Ha creado con éxito un túnel seguro que reenvía el tráfico desde su máquina anfitriona a un servicio que se ejecuta dentro del contenedor Docker. Para cerrar la conexión, regrese a la primera terminal (la que ejecuta el comando ssh) y presione Ctrl+C. Luego puede cerrar la segunda terminal.

Resumen

En este laboratorio, aprendió las habilidades esenciales para asegurar el acceso remoto en un sistema Linux utilizando el protocolo Secure Shell (SSH). Los objetivos clave cubiertos incluyen la configuración y prueba de la autenticación basada en claves, la transferencia segura de archivos con scp y la creación de un túnel SSH para el reenvío de puertos.

Comenzó preparando el entorno, lo que implicó actualizar la lista de paquetes del sistema e instalar los paquetes openssh-server y openssh-client. Después de verificar que el servicio SSH estaba activo, generó un par de claves RSA seguro de 2048 bits utilizando el comando ssh-keygen. Este paso fundamental creó las claves pública y privada necesarias para establecer conexiones seguras y sin contraseña en los pasos posteriores.