Compartir internet de un servidor al cliente con SSH (proxy SOCKS)

¿Tienes dos máquinas en red y solo una de ellas tiene internet, la del servidor con su tarjeta NAT? No hace falta mover cables ni cargar el cliente USB de datos: podemos hacer que el cliente salga a internet a través del servidor usando un túnel SSH dinámico. Es un clásico de redes que además cifra tu tráfico. En esta guía montamos el reenvío de puertos en el servidor y el túnel SOCKS en el cliente.

🤔 ¿Qué vamos a conseguir?

• Activar el reenvío de paquetes IPv4 (ip_forward) en el servidor para que haga de pasarela.
• Configurar el MASQUERADE con iptables para compartir la conexión NAT con la red interna.
• Montar un túnel SSH dinámico (ssh -D) desde el cliente hacia el servidor.
• Configurar el navegador con un proxy SOCKS en el puerto local para navegar con el cliente.
• Hacerlo persistente para que sobreviva a reinicios (script + rc.local).

🧰 Prerrequisitos

• Dos máquinas Linux/WSL conectadas en red (por ejemplo en VirtualBox: una con tarjeta NAT + Red Interna, la otra solo Red Interna).
• ssh y openssh-server instalados y funcionando (ver la guía de instalación abajo).
• Conocimientos básicos de terminal y un editor de texto plano (nano, gedit…).
• La IP del servidor en la red interna (uso 192.168.101.1) y saber la tuya con ip addr.

Instala el cliente y servidor SSH en Debian/Ubuntu:

sudo apt update
sudo apt install openssh-client openssh-server
sudo systemctl enable --now ssh

La topología típica: el servidor tiene dos tarjetas, una con NAT (salida a internet) y otra en Red Interna (192.168.101.x). El cliente solo tiene la tarjeta de Red Interna, así que no llega solo a internet; usará el servidor de puente.

🐳 Opción Docker: laboratorio para practicar

Si prefieres practicar el lado SSH sin máquinas virtuales, levanta el servidor SSH (el destino del túnel) en un minuto:

docker run -d --name ssh-lab -p 2222:22 \
  -e PASSWORD_ACCESS=true \
  linuxserver/openssh-server

Eso expone el puerto 2222 del contenedor; desde el cliente te conectarías con ssh -p 2222. Más información en linuxserver/openssh-server.

Ojo: para que el túnel SOCKS dé internet de verdad al navegador, el host que ejecuta el servidor SSH debe tener salida a internet. El contenedor sirve para practicar la parte del túnel y del proxy.

🛠️ Reenvío de puertos e iptables en el servidor

Lo primero es decirle al servidor que reenvíe los paquetes entre sus tarjetas, de red interna a NAT. Creamos un script con esas tres líneas:

echo "1" > /proc/sys/net/ipv4/ip_forward
iptables -A FORWARD -j ACCEPT
iptables -t nat -A POSTROUTING -s 192.168.101.0/24 -o eth0 -j MASQUERADE

Guárdalo en un fichero .sh. Yo lo llamo iptables.sh:

sudo nano /home/tu_usuario/iptables.sh

Explico cada línea:

• echo "1" > /proc/sys/net/ipv4/ip_forward: activa el reenvío de paquetes IP en el kernel (sin esto el tráfico del cliente no “pasa de largo” por el servidor).
• iptables -A FORWARD -j ACCEPT: permite reenviar paquetes entre interfaces.
• iptables -t nat -A POSTROUTING ... -j MASQUERADE: enmascara (traduce) las IPs de la red interna 192.168.101.0/24 por la IP de salida del servidor (eth0), como haría un router doméstico. Adapta 192.168.101.0/24 a tu red y eth0 al nombre de tu tarjeta con salida (míralo con ip addr).

Por qué un script y no los comandos sueltos: si ejecutas esas tres líneas por terminal funcionan, pero al reiniciar el equipo todo el iptables y el ip_forward se pierden. Guardarlos en un script y ejecutarlo al arrancar los hace persistentes.

🚀 Hacer el reenvío persistente con rc.local

Para que el script se ejecute en cada arranque, lo referenciamos desde /etc/rc.local. Lo abrimos con un editor de texto:

sudo nano /etc/rc.local

Dentro, en la última línea antes de exit 0, añadimos la llamada a nuestro script:

sh /home/tu_usuario/iptables.sh

Quedando algo así:

#!/bin/sh
sh /home/tu_usuario/iptables.sh
exit 0

En algunos sistemas modernos debes asegurarte de que /etc/rc.local está habilitado y es ejecutable (sudo chmod +x /etc/rc.local). Puede que necesites usar systemctl enable rc-local según tu versión.

El original hacía este paso por Webmin (Servidores → servidor DHCP → cliente → editar opciones) para reservar IPs y configurar el DNS. Ese enfoque sirve si además quieres un servidor DHCP gestionando tu red; aquí nos centramos en el túnel. De todos modos, conviene que el cliente tenga configurado un DNS (por ejemplo el del router, 192.168.101.1 o 8.8.8.8) para resolver nombres al navegar.

🚀 Montar el túnel SSH dinámico desde el cliente

Ya tenemos el servidor listo para reenviar. Ahora, desde el cliente, abrimos una terminal y lanzamos el túnel SSH dinámico:

ssh -D 8080 -p 22 -N jorge@192.168.101.1

Te pedirá la contraseña del servidor (cuidado: si la escribes mal, te la vuelve a pedir; un máximo de 3 intentos). Cuando la introduzcas bien, el “prompt” se quedará colgado sin devolverte el control: eso es correcto, el túnel está activo.

Desgloso el comando:

• -D 8080: activa el reenvío dinámico de puertos (SOCKS). El cliente escuchará en su propio puerto local 8080.
• -p 22: conecta al servidor a través de su puerto 22 (el puerto estándar y seguro de SSH).
• -N: modo “no command”; no abre la terminal del servidor ni ejecuta nada en él, ejecuta el túnel de forma transparente al usuario.
• jorge@192.168.101.1: usuario e IP del servidor.

Con esto el cliente ya tiene un “puente” hacia el servidor. Pero para navegar hay que decirle al navegador que use ese túnel como proxy.

🚀 Configurar el navegador con el proxy SOCKS

Abrimos el navegador (Firefox en el ejemplo) y vamos a preferencias de red:

Editar → Preferencias → Avanzado → Red → Configuración

Ahora marca la opción Configuración manual del proxy (por defecto viene “Sin proxy”) y rellena Servidor SOCKS con localhost (la máquina local, donde vive el túnel) y el puerto 8080, el mismo que indicamos con -D:

Pulsa Aceptar y recarga cualquier página. Ahora el cliente ya navega a través del servidor gracias al túnel SSH.

🧪 Comprobar que todo funciona

• El servidor reenvía: en el servidor, comprueba que está activo el reenvío:

cat /proc/sys/net/ipv4/ip_forward   # debe devolver 1

• El túnel está levantado: en el cliente, el terminal con ssh -D 8080 sigue “colgado” sin errores. Puedes ver el puerto local escuchando:

ss -tlnp | grep 8080

• El navegador navega: abre una web (por ejemplo https://ifconfig.co o cualquier IP) y parte del tráfico saldrá con la IP del servidor.

Para probar sin navegador, desde el cliente usa curl con el proxy: curl --socks5 localhost:8080 https://ifconfig.co y verás la IP del servidor.

⚠️ Errores comunes

🪜 Siguiente nivel

1. Entiende todas las formas de conexión SSH (por usuario, comando único, puerto personalizado, ~/.ssh/config): Formas de conectarse por SSH.
2. Sustituye la contraseña por claves para dejar el túnel automático y sin prompts: Conexión SSH mediante clave pública privada.
3. Cifra también el tráfico FTP con SFTP y aprende a conectarte a servidores de archivos: Cómo conectarse a un servidor FTP.
4. Monta tu propio servidor DHCP para que los clientes de la red se configuren solos y reparte IPs en el rango 192.168.101.x: Instalación y configuración DHCP.
5. Automatiza la conexión y el reenvío con ~/.ssh/config, alias y autossh para túneles permanentes.

🔗 Enlaces y recursos

• OpenSSH — documentación oficial
• OpenSSH — man ssh
• DigitalOcean — SSH essentials y túneles
• ArchWiki — iptables
• OpenSSH — redirección de puertos (SSH tunneling)

Cuando termines de navegar y quieras deshacer la configuración, vuelve a Editar → Preferencias → Avanzado → Red → Configuración y pon “Sin proxy”; cierra el túnel con Ctrl + C en el terminal del ssh -D. Así dejarás el cliente como estaba.