Redirigimos todo el tráfico del contenedor a través de un proxy SOCKS con tun2socks

A veces es necesario enrutar todo el tráfico saliente de un contenedor específico a través de un servidor proxy. Esto puede ser útil para garantizar el anonimato, sortear bloqueos geográficos o para probar configuraciones de red. En este artículo veremos cómo configurar este sistema usando la utilidad tun2socks y reglas de iptables, y cómo gestionar este proceso con systemd.

¿Qué es tun2socks?

tun2socks es una potente herramienta que permite reenviar el tráfico de red destinado a un dispositivo TUN a través de un proxy SOCKS. Crea una interfaz de red virtual (dispositivo TUN) cuyo tráfico se encapsula en una conexión SOCKS. Esto es especialmente útil cuando el proxy a nivel de aplicación no es posible o no es deseable.

Instalación de tun2socks

Para empezar necesitamos instalar tun2socks. Usaremos los binarios precompilados desde GitHub.

1. Ve a la página de releases de tun2socks: https://github.com/xjasonlyu/tun2socks/releases

2. Selecciona la versión estable más reciente y descarga el archivo apropiado para tu arquitectura (por ejemplo, tun2socks-linux-amd64.tar.gz para sistemas Linux de 64 bits).

3. Descomprime el archivo y mueve el ejecutable a una ruta del sistema, por ejemplo, /usr/local/bin/:

   # Ejemplo para linux-amd64, sustituye la versión por la actual
   wget https://github.com/xjasonlyu/tun2socks/releases/download/v2.5.1/tun2socks-linux-amd64.tar.gz
   tar -xvf tun2socks-linux-amd64.tar.gz
   sudo mv tun2socks-linux-amd64/tun2socks /usr/local/bin/tun2socks
   sudo chmod +x /usr/local/bin/tun2socks
   

   Asegúrate de que la ruta al binario en tu script coincide con la real. En nuestro ejemplo es /usr/local/bin/tun2socks.

Script de redirección de tráfico

Ahora veamos el script que automatiza el proceso de configurar el dispositivo TUN, iptables y lanzar tun2socks.

Nota importante: Para funcionar correctamente con systemd, modificaremos un poco el script para que tun2socks se ejecute en segundo plano y el script pueda terminar, dejando a systemd gestionar el proceso tun2socks.

#!/bin/bash
set -euo pipefail

# Configuración
TUN_DEV="tun0" # Nombre del dispositivo TUN
TUN_ADDR="10.0.0.2/24" # Dirección IP para el dispositivo TUN
FWMARK="100" # Marca para el tráfico
ROUTE_TABLE="100" # Número de la tabla de enrutamiento
CONTAINER_IP="172.29.172.2" # Dirección IP de tu contenedor cuyo tráfico debe redirigirse
SOCKS_PROXY="socks5://username:password@xxx.xxx.xxx.xx:yyyyy" # Dirección del proxy SOCKS5 (con autenticación)
TUN2SOCKS_BIN="/usr/local/bin/tun2socks" # Ruta al ejecutable tun2socks

# Ruta al archivo PID que usará systemd
PID_FILE="/var/run/tun2socks.pid"

# Función para limpiar reglas
cleanup() {
    echo "[INFO] Limpiando rutas e iptables antiguos..."
    # Eliminamos reglas en orden inverso al de creación
    iptables -t nat -D POSTROUTING -o "$TUN_DEV" -j MASQUERADE 2>/dev/null || true
    iptables -t mangle -D PREROUTING -s "$CONTAINER_IP" -p tcp -j MARK --set-mark "$FWMARK" 2>/dev/null || true

    ip route flush table "$ROUTE_TABLE" 2>/dev/null || true
    ip rule del fwmark "$FWMARK" table "$ROUTE_TABLE" priority "$FWMARK" 2>/dev/null || true

    ip link set "$TUN_DEV" down 2>/dev/null || true
    ip tuntap del dev "$TUN_DEV" mode tun 2>/dev/null || true

    # Eliminamos el archivo PID
    rm -f "$PID_FILE" 2>/dev/null || true
}

# Comprobamos argumentos de línea de comandos
if [ "$#" -eq 1 ] && [ "$1" == "cleanup_only" ]; then
    cleanup
    echo "[INFO] Limpieza completada."
    exit 0
fi

# Llamamos a cleanup al inicio para garantizar un estado limpio, si no es modo cleanup_only
cleanup

echo "[INFO] Creando $TUN_DEV..."
ip tuntap add dev "$TUN_DEV" mode tun
ip addr add "$TUN_ADDR" dev "$TUN_DEV"
ip link set "$TUN_DEV" up

echo "[INFO] Configurando ip rule e iptables..."
ip rule add fwmark "$FWMARK" table "$ROUTE_TABLE" priority "$FWMARK"
ip route replace default dev "$TUN_DEV" table "$ROUTE_TABLE"

iptables -t mangle -A PREROUTING -s "$CONTAINER_IP" -p tcp -j MARK --set-mark "$FWMARK"
iptables -t nat -A POSTROUTING -o "$TUN_DEV" -j MASQUERADE

echo "[INFO] Iniciando tun2socks..."
"$TUN2SOCKS_BIN" \
  --device "$TUN_DEV" \
  --proxy "$SOCKS_PROXY" \
  --nohup \
  --log-level info &

# Guardamos el PID de tun2socks para systemd
echo $! > "$PID_FILE"

echo "[INFO] Configuración completada. tun2socks iniciado."

Análisis del script

Expliquemos con más detalle qué hace cada parte del script:

Configuración

Al inicio del script se definen las variables clave:

• TUN_DEV: Nombre de la interfaz de red virtual (p. ej., tun0).
• TUN_ADDR: Dirección IP y máscara de subred que se asignarán a TUN_DEV. Esta dirección será usada como gateway para el contenedor.
• FWMARK: Marca numérica arbitraria que se utilizará para marcar los paquetes que se deben redirigir.
• ROUTE_TABLE: Número de la tabla de enrutamiento personalizada a la que se enviará el tráfico marcado.
• CONTAINER_IP: ¡Parámetro críticamente importante! Esta es la dirección IP de tu contenedor cuyo tráfico quieres redirigir. Necesitarás averiguarla.
• SOCKS_PROXY: Dirección completa de tu proxy SOCKS5, incluyendo protocolo, usuario, contraseña y puerto.
• PID_FILE: Ruta al archivo donde se guardará el PID del proceso tun2socks para que systemd pueda rastrearlo.

Función cleanup

La función cleanup() se encarga de eliminar todas las reglas iptables, rutas y el propio dispositivo TUN creados previamente. Esto es importante para garantizar un estado “limpio” antes de cada nueva configuración y al detener el servicio. También elimina el archivo PID.

Lógica de arranque y limpieza

El script comprueba los argumentos de la línea de comandos. Si se ejecuta con el argumento cleanup_only, ejecuta únicamente la función cleanup y termina. En caso contrario, primero limpia configuraciones previas y luego crea las nuevas.

Creación del dispositivo TUN

• ip tuntap add dev "$TUN_DEV" mode tun: Crea una nueva interfaz TUN con el nombre especificado.
• ip addr add "$TUN_ADDR" dev "$TUN_DEV": Asigna la dirección IP al dispositivo TUN creado.
• ip link set "$TUN_DEV" up: Activa la interfaz TUN.

Configuración de ip rule e iptables

Este es el corazón del mecanismo de redirección:

• ip rule add fwmark "$FWMARK" table "$ROUTE_TABLE" priority "$FWMARK": Crea una regla de enrutamiento que dice: “cualquier paquete con la marca FWMARK debe procesarse usando la tabla de enrutamiento ROUTE_TABLE”. La prioridad FWMARK asegura que esta regla se evalúe antes que otras.

• ip route replace default dev "$TUN_DEV" table "$ROUTE_TABLE": Dentro de nuestra tabla especial ROUTE_TABLE establecemos la ruta por defecto que apunta a nuestro dispositivo TUN. Esto significa que todo el tráfico que entre en esta tabla irá a través de TUN_DEV.

• iptables -t mangle -A PREROUTING -s "$CONTAINER_IP" -p tcp -j MARK --set-mark "$FWMARK": Esta regla iptables en la cadena PREROUTING (que procesa paquetes antes de que pasen por el enrutamiento) en la tabla mangle (usada para modificar paquetes). Dice: “si un paquete TCP proviene de CONTAINER_IP, márcalo con FWMARK”. Así es como identificamos el tráfico que debe redirigirse.

• iptables -t nat -A POSTROUTING -o "$TUN_DEV" -j MASQUERADE: Esta regla en la tabla nat en la cadena POSTROUTING (que procesa paquetes justo antes de enviarlos). Realiza masquerading (SNAT), es decir, cambia la IP origen de los paquetes salientes que pasan por TUN_DEV a la IP asociada a TUN_DEV. Esto es necesario para el correcto funcionamiento del proxy.

Inicio de tun2socks

• "$TUN2SOCKS_BIN" --device "$TUN_DEV" --proxy "$SOCKS_PROXY" --nohup --log-level info &: Inicia el propio tun2socks. Se enlaza al TUN_DEV creado y usa el SOCKS_PROXY especificado para redirigir todo el tráfico que llega a TUN_DEV. La opción --nohup permite que tun2socks siga ejecutándose después de que el proceso padre (el script) termine, y & lo lanza en segundo plano. --log-level info es útil para depuración.

• echo $! > "$PID_FILE": Guarda el PID del proceso tun2socks lanzado en segundo plano en un archivo, para que systemd pueda rastrearlo.

Cómo usar (con systemd)

Ahora que el script está listo, podemos integrarlo con systemd para facilitar su gestión.

1. Guarda el script: Crea un archivo, por ejemplo, /usr/local/bin/tun2socks_redirect.sh, y pega en él el contenido del script modificado.

   sudo nano /usr/local/bin/tun2socks_redirect.sh
   

2. Hazlo ejecutable:

   sudo chmod +x /usr/local/bin/tun2socks_redirect.sh
   

3. Determina la IP del contenedor: Si usas Docker, puedes obtener la IP del contenedor ejecutando docker inspect <nombre_contenedor> | grep "IPAddress".

4. Actualiza CONTAINER_IP y SOCKS_PROXY: Asegúrate de cambiar los valores de CONTAINER_IP y SOCKS_PROXY en el script /usr/local/bin/tun2socks_redirect.sh por los tuyos.

Creación del archivo unit de systemd

Crearemos el unit file de systemd para nuestro servicio.

1. Crea el archivo /etc/systemd/system/tun2socks-redirect.service:

   sudo nano /etc/systemd/system/tun2socks-redirect.service
   

2. Pega el siguiente contenido:

   [Unit]
   Description=Tun2socks Traffic Redirection Service
   After=network-online.target
   Wants=network-online.target
   
   [Service]
   Type=forking
   # Usamos Type=forking porque nuestro script lanza tun2socks en segundo plano
   # y el script termina. tun2socks se demoniza por sí mismo (gracias a --nohup).
   # PIDFile se usa para rastrear el PID de tun2socks.
   PIDFile=/var/run/tun2socks.pid
   ExecStartPre=/usr/local/bin/tun2socks_redirect.sh
   # ExecStart es el comando que systemd rastreará.
   # Como nuestro script ya inicia tun2socks en segundo plano, systemd lo rastreará a través de PIDFile.
   ExecStart=/bin/true
   # ExecStopPost se ejecuta después de detener el servicio, para limpieza
   ExecStopPost=/usr/local/bin/tun2socks_redirect.sh cleanup_only
   # User=root - el script requiere privilegios root
   User=root
   Restart=on-failure
   RestartSec=5s
   
   [Install]
   WantedBy=multi-user.target
   

Explicaciones del unit file:

• [Unit]:
  • Description: Breve descripción del servicio.
  • After=network-online.target: El servicio se iniciará después de que la red esté completamente configurada.
  • Wants=network-online.target: Indica una dependencia deseada de la red.
• [Service]:
  • Type=forking: Indica a systemd que el proceso principal del servicio hará fork, dejando un proceso hijo (nuestro tun2socks), y el proceso padre (el script) terminará. systemd usará PIDFile para rastrear el proceso real del servicio.
  • PIDFile=/var/run/tun2socks.pid: Ruta al archivo donde nuestro script guarda el PID de tun2socks. Esto es crítico para Type=forking.
  • ExecStartPre=/usr/local/bin/tun2socks_redirect.sh: Comando que se ejecuta antes del arranque principal del servicio. Aquí nuestro script configura el dispositivo TUN y las reglas iptables, y lanza tun2socks en segundo plano.
  • ExecStart=/bin/true: Dado que tun2socks ya fue iniciado por nuestro ExecStartPre y systemd lo rastrea por PIDFile, no necesitamos ejecutar nada en ExecStart. /bin/true simplemente devuelve éxito.
  • ExecStopPost=/usr/local/bin/tun2socks_redirect.sh cleanup_only: Comando que se ejecuta después de detener el servicio. Llamado con el argumento cleanup_only el script solo limpia las reglas.
  • User=root: El servicio debe ejecutarse como root porque modifica configuraciones de red y reglas iptables.
  • Restart=on-failure: Si el servicio termina con error, systemd intentará reiniciarlo.
  • RestartSec=5s: Retardo antes de intentar reiniciar.
• [Install]:
  • WantedBy=multi-user.target: El servicio se iniciará al arrancar el sistema en modo multiusuario.

Habilitar e iniciar el servicio Systemd

Después de crear el unit file y ajustar el script:

1. Recarga el demonio systemd:

   sudo systemctl daemon-reload
   

2. Habilita el servicio para que arranque automáticamente:

   sudo systemctl enable tun2socks-redirect.service
   

3. Inicia el servicio:

   sudo systemctl start tun2socks-redirect.service
   

4. Comprueba el estado del servicio:

   sudo systemctl status tun2socks-redirect.service
   

   Deberías ver que el servicio está activo (active (running)).

5. Revisa los logs:

   journalctl -u tun2socks-redirect.service -f
   

   Esto te ayudará a seguir la salida del script y de tun2socks.

Ahora tu servicio se iniciará automáticamente al arrancar el sistema e intentará mantener funcionando tun2socks y las reglas de enrutamiento. Para detener el servicio usa sudo systemctl stop tun2socks-redirect.service, y limpiará las reglas automáticamente. Para reiniciarlo usa sudo systemctl restart tun2socks-redirect.service.

Conclusión

De este modo hemos configurado un sistema que redirige todo el tráfico TCP de un contenedor especificado a través de un servidor proxy SOCKS. Este método ofrece flexibilidad y control sobre el tráfico de red, permitiéndote gestionar fácilmente su enrutamiento a través de proxies externos, y la integración con systemd mejora significativamente la fiabilidad y la facilidad de gestión.

Espero que este artículo te haya sido útil! Si tienes preguntas o sugerencias, no dudes en dejar comentarios.