Introducción
Secure Shell (SSH) no es solo una herramienta para el acceso remoto a terminales; también es una potente utilidad de red. El túnel SSH, también conocido como reenvío de puertos SSH, te permite dirigir el tráfico de red local a través de una conexión SSH segura hacia hosts remotos.
La idea central es que estás "tomando prestada" la conectividad de otra máquina. El túnel no crea una nueva capacidad de alcance de red de la nada; reutiliza la posición y el acceso del host remoto.
Esta técnica es ampliamente utilizada por administradores de sistemas, desarrolladores y profesionales de la seguridad para eludir firewalls corporativos rígidos, cifrar el tráfico de aplicaciones heredadas y acceder a servicios internos ocultos que no están expuestos directamente a la internet pública.
En este laboratorio, aprenderás los conceptos y las aplicaciones prácticas de los dos tipos principales de reenvío de puertos SSH:
- Reenvío de puertos local (
-L): Reenvía un puerto desde tu máquina local a un destino remoto. - Reenvío de puertos remoto (
-R): Reenvía un puerto desde un servidor remoto de vuelta a tu máquina local.
Comprender la topología de red
En este paso, exploraremos el entorno de red simulado que se ha preparado para ti.
Para practicar los túneles SSH, necesitamos un escenario que involucre varias máquinas. Dado que estamos trabajando dentro de un entorno de máquina virtual única, hemos simulado una topología de red compleja utilizando diferentes puertos de red en tu sistema local (127.0.0.1).
Aquí tienes el mapa conceptual de nuestra simulación. Tu Máquina Local está representada por tu sesión de terminal actual. El Host Bastión, o servidor de borde, se simula utilizando un contenedor Docker que expone SSH en 127.0.0.1:2222. El Servicio Interno es un servidor web que se ejecuta en la misma red privada de Docker en 172.31.0.20:80. Conceptualmente, imagina que este servicio está en lo profundo de una red corporativa y bloqueado por un firewall, lo que significa que solo se puede acceder a él desde el Host Bastión. Finalmente, el Servicio Local es un servidor web que se ejecuta en el puerto 8000 en la VM de LabEx. Puedes pensar en esto como un servidor de desarrollo que se ejecuta en tu computadora portátil personal y que deseas compartir con alguien en internet.
Verifiquemos que nuestros servicios simulados estén en ejecución. Usaremos el comando curl, que es una herramienta de línea de comandos para transferir datos con URLs.
Primero, verifica el "Servicio Local" que se ejecuta en el puerto 8000:
curl http://127.0.0.1:8000
Deberías ver la salida Local Developer Machine Data.
El servicio interno está intencionalmente no expuesto directamente en la VM de LabEx. Accederás a él a través del túnel SSH en el siguiente paso.
En los pasos siguientes, utilizaremos túneles SSH para manipular cómo accedemos a estos servicios, simulando escenarios reales de elusión de firewalls.
Configurar el reenvío de puertos local (-L)
En este paso, configurarás el reenvío de puertos local.
Imagina que estás en casa y necesitas acceder a un panel de control corporativo interno (nuestro servicio en 172.31.0.20:80). Un firewall bloquea el acceso directo a esa dirección interna desde el mundo exterior. Sin embargo, el firewall permite conexiones SSH a un servidor de borde específico (nuestro Host Bastión).
El reenvío de puertos local te permite abrir un puerto en tu máquina local, y SSH reenviará de forma segura cualquier tráfico enviado a ese puerto local a través del túnel SSH hacia el destino.
La sintaxis para el reenvío de puertos local es: ssh -L [local_port]:[destination_host]:[destination_port] [user]@[ssh_server]
El reenvío local es más fácil de entender como "hacer que un servicio remoto parezca local para mí".
Reenviaremos nuestro puerto local 8080 al servicio interno (172.31.0.20:80) a través de nuestro host bastión SSH simulado. También usaremos dos indicadores adicionales. El indicador -N le dice a SSH que no ejecute un comando remoto, lo cual es útil cuando solo deseas reenviar puertos. El indicador -f le dice a SSH que se ejecute en segundo plano, permitiéndonos seguir usando nuestra terminal.
Ejecuta el siguiente comando para crear el túnel:
ssh -N -f -L 8080:172.31.0.20:80 \
-o StrictHostKeyChecking=no \
-o UserKnownHostsFile=/dev/null \
-i ~/project/pivot_key -p 2222 pivot@127.0.0.1
El túnel ahora se está ejecutando silenciosamente en segundo plano.
Ahora, probemos el túnel. En lugar de acceder a la dirección Docker interna directamente, accederás a tu puerto local recién abierto 8080. El túnel SSH capturará esta solicitud, la cifrará, la enviará al host bastión, que luego la reenviará a 172.31.0.20:80.
curl http://127.0.0.1:8080
Deberías ver la salida Secret Internal Corporate Data. ¡Has eludido con éxito el firewall conceptual!
Configurar el reenvío de puertos remoto (-R)
En este paso, configurarás el reenvío de puertos remoto.
Imagina que estás desarrollando una aplicación web en tu computadora portátil local (nuestro servicio en el puerto 8000). Quieres mostrar tu progreso a un cliente, pero tu computadora portátil está detrás de un router doméstico (NAT) y no tiene una dirección IP pública.
El reenvío de puertos remoto resuelve esto permitiéndote conectarte a un servidor SSH público y abrir un puerto en ese servidor remoto. Cualquier tráfico que llegue a ese puerto remoto se reenvía de vuelta a través del túnel SSH a tu máquina local.
La sintaxis para el reenvío de puertos remoto es: ssh -R [remote_port]:[local_host]:[local_port] [user]@[ssh_server]
El reenvío remoto cambia la perspectiva: "hacer que mi servicio local parezca accesible desde el lado remoto".
Expondremos nuestro servicio local (127.0.0.1:8000) al host bastión en el puerto 8081.
Ejecuta el siguiente comando para crear el túnel remoto:
ssh -N -f -R 8081:127.0.0.1:8000 \
-o StrictHostKeyChecking=no \
-o UserKnownHostsFile=/dev/null \
-i ~/project/pivot_key -p 2222 pivot@127.0.0.1
El túnel ya está establecido en segundo plano. El host bastión ahora está escuchando en el puerto 8081. Cuando alguien accede al puerto 8081 en el servidor remoto, el tráfico se envía de vuelta a tu puerto local 8000.
Probemos esto consultando el servicio reenviado a través del contenedor del host bastión:
docker exec bastion_host curl -s http://127.0.0.1:8081
Deberías ver la salida Local Developer Machine Data. ¡Has expuesto con éxito un servicio local a un servidor remoto!
Acceder al servicio web interno
En este paso final, consolidaremos nuestra comprensión utilizando los túneles que creamos para descargar los datos y guardarlos en archivos en nuestro directorio de proyecto.
Asegúrate de estar en tu directorio de proyecto predeterminado:
cd ~/project
Primero, usemos el túnel de reenvío de puertos local (puerto 8080) para obtener los datos corporativos internos y guardarlos en un archivo llamado internal_data.txt. Usaremos el indicador -o con curl para especificar el archivo de salida.
curl http://127.0.0.1:8080 -o internal_data.txt
A continuación, usemos el túnel de reenvío de puertos remoto (puerto 8081) para obtener los datos del desarrollador local a través del host bastión y guardarlos en un archivo llamado remote_data.txt.
docker exec bastion_host curl -s http://127.0.0.1:8081 > remote_data.txt
Finalmente, verifiquemos el contenido de los archivos que acabas de descargar usando el comando cat:
cat internal_data.txt
cat remote_data.txt
Secret Internal Corporate Data
Local Developer Machine Data
Al descargar con éxito estos archivos a través de los puertos reenviados, has demostrado que los túneles SSH están enrutando activamente el tráfico de forma segura entre los puntos finales.
Resumen
¡Felicidades! Has completado con éxito el laboratorio de Túneles SSH y Reenvío de Puertos.
En este laboratorio, aprendiste a comprender los conceptos de los túneles SSH y cómo se pueden utilizar para eludir las restricciones de red. Configuraste el reenvío de puertos local (-L) para acceder de forma segura a servicios internos ocultos mediante el enrutamiento del tráfico local a través de un host bastión. Además, configuraste el reenvío de puertos remoto (-R) para exponer servicios de desarrollo local a un servidor remoto, eludiendo con éxito el NAT local y los firewalls. Finalmente, aprendiste a ejecutar túneles SSH silenciosamente en segundo plano utilizando los indicadores -N y -f.
Estas habilidades son esenciales para la administración segura de sistemas, el desarrollo remoto y la navegación segura por topologías de red complejas.
