====== 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.

===== Instalación =====

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

<sxh terminal>
sudo apk update
</sxh>

Instala el servidor OpenSSH:

<sxh terminal>
sudo apk add openssh
</sxh>

Verifica que el servicio SSH esté instalado correctamente ejecutando:
<sxh terminal>
ssh -V
</sxh>

===== Habilitar/deshabilitar acceso root =====

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

<sxh terminal>
ssh alumno@<IP_ALPINE>
</sxh>

Verifica que puedes acceder correctamente.

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

<sxh terminal>
ssh root@<IP_ALPINE>
</sxh>

Deberías recibir un mensaje como: 

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

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

<sxh terminal>
sudo nano /etc/ssh/sshd_config
</sxh>

<sxh>
#PermitRootLogin prohibit-password
</sxh>

Modifícala para habilitar el acceso root:  

<sxh>
PermitRootLogin yes
</sxh>

Guarda los cambios y reinicia el servicio SSH:  

<sxh terminal> 
sudo rc-service sshd restart 
</sxh>

Prueba nuevamente conectarte como root: 

<sxh terminal>
ssh root@<IP_ALPINE>
</sxh>

Ahora deberías acceder exitosamente.

Vuelve a deshabilitar el acceso a root:

<sxh>
PermitRootLogin no
</sxh>

Reinicia de nuevo el servicio SSH.

===== Configuración de la autenticación por claves 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).

==== Generación de claves en el cliente ====

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

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

  * **-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á.

<note> Aunque en esta práctica estamos utilizando **RSA** debido a su compatibilidad y uso extendido, una opción moderna y más eficiente es **ED25519**. Este tipo de clave es más rápido y seguro, pero puede no ser compatible con versiones más antiguas de SSH. Para nuevas configuraciones, **ED25519** es altamente recomendado debido a su mayor eficiencia y seguridad. </note>

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

==== Copiar la clave pública al servidor ====

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

<sxh terminal> ssh-copy-id alumno@<IP_ALPINE> </sxh>
Introduce la contraseña del usuario alumno cuando se te solicite.
Este comando añade la clave pública al archivo ~/.ssh/authorized_keys del usuario en el servidor.

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

Abre el archivo ~/.ssh/id_rsa.pub en tu cliente: <sxh terminal>
cat ~/.ssh/id_rsa.pub
</sxh>

Copia su contenido y pégalo en el archivo ~/.ssh/authorized_keys del servidor: <sxh terminal>
nano ~/.ssh/authorized_keys
</sxh>

==== Probar la conexión con clave ====

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

<sxh terminal> ssh alumno@<IP_ALPINE> </sxh>
Si todo está configurado correctamente, deberías acceder al servidor sin que se te pida una contraseña.

==== Deshabilitar la autenticación por contraseña (opcional) ====

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

Abre el archivo de configuración de SSH: <sxh terminal>
sudo nano /etc/ssh/sshd_config
</sxh>

Busca y modifica la siguiente línea: <sxh>
PasswordAuthentication no
</sxh>

Reinicia el servicio SSH: <sxh terminal>
sudo rc-service sshd restart
</sxh>

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

===== Crear túnel 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 [[http://resources.cesguiro.es/docker-images|smr-mariadb]] y [[http://resources.cesguiro.es/docker-images|smr-phpmyadmin]]. Cópialas mediante ssh a tu máquina virtual.

<note important>El uso de túneles SSH es importante porque evita exponer puertos directamente a Internet, lo que protege los servicios contra accesos no autorizados y ataques. Además, el tráfico a través de un túnel SSH está cifrado, lo que asegura la confidencialidad de los datos.</note> 

==== Preparativos ====

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

<sxh terminal> 
mkdir ~/tunnel-ssh 
cd ~/tunnel-ssh 
nano docker-compose.yml 
</sxh>

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

<sxh 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"
</sxh>

Guarda el archivo y cierra el editor.

Inicia los contenedores con Docker Compose:

<sxh terminal> 
sudo docker-compose up -d 
</sxh>


==== Acceso mediante túnel SSH ====

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.

<sxh>
AllowTcpForwarding yes
</sxh>

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


<sxh>
GatewayPorts yes
</sxh>

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:

<sxh terminal> 
sudo service sshd restart 
</sxh>

**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:

<sxh terminal> 
ssh -L 8080:localhost:8080 alumno@<IP_ALPINE> 
</sxh> 

<note> En este comando: - **-L** indica un túnel SSH local. **8080:localhost:8080** redirige el puerto 8080 de tu máquina local al puerto 8080 de la máquina remota (que es donde phpMyAdmin está expuesto). **alumno@<IP_ALPINE>** es el usuario y la IP de tu máquina remota donde se ejecutan los contenedores Docker. </note>

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.