14 - Acceso remoto: SSH

En esta práctica, aprenderemos a configurar y utilizar SSH en un entorno basado en Alpine Linux. SSH (Secure Shell) es una herramienta esencial para administrar servidores de forma remota de manera segura. Realizaremos los siguientes pasos:

• Instalaremos y configuraremos un servidor SSH en Alpine Linux.

• Estableceremos conexiones seguras desde un cliente mediante autenticación por claves públicas/privadas.

• Configuraremos túneles SSH para redirigir tráfico de red y explorar casos prácticos.

Accede a la máquina virtual Alpine y actualiza los repositorios de paquetes:

sudo apk update

Instala el servidor OpenSSH:

sudo apk add openssh

Verifica que el servicio SSH esté instalado correctamente ejecutando:

ssh -V

Conéctate inicialmente con el usuario alumno desde tu cliente SSH de la máquina host (o cualquier otra máquina virtual):

ssh alumno@<IP_ALPINE>

Verifica que puedes acceder correctamente.

Intenta conectarte como root (por defecto, no estará permitido):

ssh root@<IP_ALPINE>

Deberías recibir un mensaje como:

root@<IP_ALPINE>: Permission denied (publickey,password,keyboard-interactive).

Para habilitar el acceso a root, en el servidor, edita el archivo de configuración de SSH:

sudo nano /etc/ssh/sshd_config

#PermitRootLogin prohibit-password

Modifícala para habilitar el acceso root:

PermitRootLogin yes

Guarda los cambios y reinicia el servicio SSH:

 
sudo rc-service sshd restart 

Prueba nuevamente conectarte como root:

ssh root@<IP_ALPINE>

Ahora deberías acceder exitosamente.

Vuelve a deshabilitar el acceso a root:

PermitRootLogin no

Reinicia de nuevo el servicio SSH.

La autenticación por claves SSH permite establecer una conexión segura sin necesidad de contraseñas. En su lugar, se utiliza un par de claves: una privada (en el cliente) y una pública (en el servidor).

En el cliente SSH (por ejemplo, tu máquina host), genera un par de claves:

 ssh-keygen -t rsa -b 4096 -C "alumno@<IP_ALPINE>" 

• -t rsa: Especifica el tipo de clave que se generará. En este caso, RSA es uno de los algoritmos de cifrado más comunes y seguros. Otras opciones para el parámetro -t son:
  • rsa: Claves RSA (predeterminado).
  • dss: Claves DSA (no recomendado, ya que es menos seguro).
  • ecdsa: Claves ECDSA (más eficientes).
  • ed25519: Un tipo de clave moderno que es más seguro y eficiente que RSA, recomendado para nuevas configuraciones.

• -b 4096: Define el tamaño de la clave en bits. Cuanto mayor sea el número, más segura será la clave. Para RSA, 4096 bits es un tamaño recomendado para una clave robusta, mientras que valores menores (2048 bits) siguen siendo comunes pero menos seguros. Tamaños recomendados:
  • Para RSA: 2048 bits (mínimo) o 4096 bits (recomendado).
  • Para ECDSA: 256 bits (mínimo) o 521 bits.
  • Para ED25519: 256 bits (recomendado, ya que el algoritmo ya es muy seguro).

• -C “alumno@<IP_ALPINE>“: Es una etiqueta para identificar la clave. Normalmente se utiliza para agregar un comentario que describe a quién pertenece la clave. Es útil, especialmente si tienes múltiples claves en tu máquina. En este caso, el comentario es el nombre de usuario y la dirección IP de la máquina a la que se conectará.

Cuando se te pregunte por una ubicación para guardar las claves, acepta la ruta predeterminada (~/.ssh/id_rsa). Puedes establecer una contraseña para proteger la clave privada, o dejarla en blanco para conexiones sin contraseña. Esto generará dos archivos:

• Clave privada: ~/.ssh/id_rsa

• Clave pública: ~/.ssh/id_rsa.pub

Utiliza el siguiente comando para copiar la clave pública al servidor:

 ssh-copy-id alumno@<IP_ALPINE> 

Si no tienes el comando ssh-copy-id, puedes copiar la clave manualmente:

Abre el archivo ~/.ssh/id_rsa.pub en tu cliente:

cat ~/.ssh/id_rsa.pub

Copia su contenido y pégalo en el archivo ~/.ssh/authorized_keys del servidor:

nano ~/.ssh/authorized_keys

Desde el cliente, intenta conectarte al servidor sin contraseña:

 ssh alumno@<IP_ALPINE> 

Para reforzar la seguridad, desactiva la autenticación por contraseña en el servidor:

Abre el archivo de configuración de SSH:

sudo nano /etc/ssh/sshd_config

Busca y modifica la siguiente línea:

PasswordAuthentication no

Reinicia el servicio SSH:

sudo rc-service sshd restart

Con esto, solo será posible conectarse mediante claves SSH.

Vamos a crear un entorno con Docker que contenga los servicios de MariaDB y phpMyAdmin, y luego accederemos a estos servicios de forma segura mediante un túnel SSH. Este enfoque nos permitirá evitar exponer puertos sensibles a la red pública, añadiendo una capa de seguridad adicional.

Utilizaremos las imágenes docker smr-mariadb y smr-phpmyadmin. Cópialas mediante ssh a tu máquina virtual.

Crea un directorio para el proyecto y dentro de él, crea el archivo docker-compose.yml que definirá los servicios de MariaDB y phpMyAdmin.

 
mkdir ~/tunnel-ssh 
cd ~/tunnel-ssh 
nano docker-compose.yml 

Añade el siguiente contenido en el archivo docker-compose.yml:

 
name: "tunne-ssh" 

services: 
   mariadb: 
      image: smr/mariadb 
      environment: 
         MYSQL_ROOT_PASSWORD: root 
         MYSQL_DATABASE: testdb 
      ports: 
         - "3306:3306" 
      volumes: 
         - ./mariadb-data:/var/lib/mysql

   phpmyadmin: 
      image: smr/phpmyadmin 
      environment: 
         PMA_HOST: mariadb 
         MYSQL_ROOT_PASS: root 
      ports: 
         - "8080:80"

Guarda el archivo y cierra el editor.

Inicia los contenedores con Docker Compose:

 
sudo docker-compose up -d 

Ahora, vamos a crear un túnel SSH para acceder a los servicios MariaDB y phpMyAdmin sin exponer sus puertos directamente a la red pública. Esto se realiza mediante el reenvío de puertos a través de una conexión SSH segura.

Configuración necesaria en el servidor SSH

Antes de poder crear el túnel, asegúrate de que el servidor SSH de la máquina remota (donde están los contenedores Docker) esté configurado correctamente para permitir el reenvío de puertos.

AllowTcpForwarding yes

Esta opción permite el reenvío de puertos TCP.

GatewayPorts yes

Esta opción permite que los puertos reenviados a través del túnel SSH sean accesibles desde máquinas externas (y no solo desde localhost). Si necesitas que el túnel sea accesible desde otros equipos, habilita esta opción.

Reinicia el servicio SSH para que los cambios surtan efecto:

 
sudo service sshd restart 

Crear un túnel SSH para phpMyAdmin (puerto 8080)

Para acceder a phpMyAdmin de forma segura, crearemos un túnel SSH que redirija el puerto 8080 de la máquina remota (donde están los contenedores Docker) a un puerto local en tu máquina. En tu máquina local (cliente), ejecuta el siguiente comando para crear el túnel:

 
ssh -L 8080:localhost:8080 alumno@<IP_ALPINE> 

Esto crea un túnel seguro que redirige el puerto 8080 de tu máquina local al puerto 8080 en la máquina remota.

Acceder a phpMyAdmin

Ahora, abre un navegador web en tu máquina local y accede a http://localhost:8080. Podrás ver la interfaz de phpMyAdmin y conectarte a la base de datos MariaDB usando el usuario root y la contraseña que configuraste en el archivo docker-compose.yml.