Proxy para Transparent Proxy / iptables

### **Proxy transparente (Transparent Proxy) con iptables**

En la mayoría de los casos, cuando hablamos de proxy, nos referimos a un proxy «normal» u «opaco». Este requiere una configuración explícita en cada aplicación. Pero existe otro enfoque mucho más potente: el proxy transparente (Transparent Proxy).

Esta tecnología intercepta y redirige el tráfico de red de forma imperceptible para el usuario final y sus aplicaciones. Los programas del ordenador del usuario ni siquiera sospechan que su tráfico pasa por un proxy.

**Analogía:**
Un proxy normal es como enviar un paquete a través de un servicio de mensajería que tú mismo has elegido y llamado.

Un proxy transparente es como si toda la oficina de correos envolviera por defecto todos tus paquetes y los enviara por una ruta especial sin avisarte.

El mecanismo que lo hace posible en el mundo Linux se llama iptables. En esta guía, veremos cómo funciona, para qué sirve y cómo configurar un sistema de este tipo en la práctica.

⛔️ **Advertencia importante antes de comenzar**
Esta guía está dirigida a usuarios avanzados. Trabajarás con iptables y obtendrás acceso root completo al sistema. Un comando incorrecto puede bloquear por completo tu acceso a la red (incluido SSH).

- **Prueba en VM**: prueba siempre este tipo de configuraciones primero en una máquina virtual.
- **Ten un plan B**: Asegúrate de tener acceso por consola al servidor (no SSH) por si acaso bloqueas tu red.
- **Proveedor de confianza**: Confías todo tu tráfico al servidor proxy. Asegúrate de utilizar un proveedor fiable y de confianza. No proxyfique tráfico sensible (banca) sin cifrado de extremo a extremo.
- **Compatibilidad**: para las nuevas distribuciones (Ubuntu 22+, Fedora), compruebe `iptables --version`; si es nft, cambie a: `sudo update-alternatives --set iptables /usr/sbin/iptables-legacy`. En contenedores (Docker), redsocks requiere cap_net_admin; utilice --privileged.

#### **Parte 1. ¿Para qué sirve un proxy transparente?**

El proxy transparente es un control total del tráfico a nivel de red.

- **Redes corporativas y Wi-Fi**: para filtrar contenido, almacenar datos en caché y realizar análisis de seguridad centralizados.
- **Gestión de dispositivos (IoT)**: puede proxy el tráfico de dispositivos en los que no se puede configurar el proxy manualmente (Smart TV, consolas de videojuegos, dispositivos IoT).
- **Elusión de la censura para toda la red**: en lugar de configurar una VPN en cada dispositivo, puede configurar una sola vez el router para que dirija todo el tráfico a través del proxy.

#### **Parte 2. Mecanismo de funcionamiento: iptables**

iptables es una herramienta para gestionar paquetes de red en el núcleo Linux (Netfilter). Utilizaremos la tabla nat (Network Address Translation).

La clave está en elegir correctamente la cadena para la interceptación:

- **Cadena PREROUTING**: intercepta el tráfico que pasa A TRAVÉS de su servidor (tráfico de tránsito). Esta es su elección si está configurando un gateway o un router para otros dispositivos de la red.
- **Cadena OUTPUT**: Intercepta el tráfico que genera el PROPIO SERVIDOR (por ejemplo, curl, apt-get o scripts ejecutados localmente).

#### **Parte 3. Implementación práctica con redsocks**

El simple REDIRECT no puede trabajar con proxies SOCKS5 remotos que requieren autenticación. Necesitaremos redsocks.

redsocks es un demonio que recibe el tráfico redirigido por iptables y luego establece él mismo la conexión con su proxy remoto.

**Nota**: El redsocks original es bastante antiguo (las últimas actualizaciones son de ~2018). Recomendamos utilizar el fork redsocks2 (REDSOCKS2), que tiene correcciones, nuevas características (redireccionamiento automático sin lista negra, compatibilidad con shadowsocks, IPv6) y está actualizado en 2025. Si su distribución tiene el paquete redsocks2, utilícelo.
De lo contrario:
`git clone https://github.com/semigodking/redsocks && cd redsocks && make && sudo make install`
(o una bifurcación similar https://github.com/Intika-Linux-Proxy/Red-Socks-2).

##### **Paso 1: Recopilación de datos de inicio de sesión del proxy**

El primer paso, y el más importante, es asegurarse de que dispone de todos los datos de autorización. Estas «claves» permitirán a su aplicación o navegador conectarse al servidor proxy y dirigir el tráfico a través de él.

Asegúrese de tener a mano los siguientes datos:

* **Dirección IP** (servidor host)
* **Puerto** para la conexión
* **Nombre de usuario** y **contraseña** para la autorización
* **Tipo de protocolo** (HTTP/HTTPS o SOCKS5)

![](/media/mdeditor/proxies_info_es_20251007053521695216.png)
*Fig. 1. En esta captura de pantalla se muestra dónde se encuentran todos los campos necesarios para conectarse al servidor proxy en la cuenta personal de **CyberYozh App**.*

##### **Paso 2. Instalación de redsocks**

```bash
sudo apt update
sudo apt install redsocks  # Para el original; para redsocks2, véase más arriba.
```

##### **Paso 3. Configuración de redsocks (TCP + DNS)**

Abra el archivo de configuración `sudo nano /etc/redsocks.conf`. Modifíquelo como se indica a continuación, sustituyendo los datos por los de su proxy. Configuraremos redsocks para el tráfico TCP, redudp para UDP/DNS y dnstc para TCP-DNS (para capturar solicitudes TCP poco frecuentes).

```bash
base {
    log_debug = off;
    log_info = on;
    log = «file:/var/log/redsocks.log»; // Ruta a los registros para depuración
    daemon = on;
    user = redsocks;
    group = redsocks;
    redirector = iptables;
}

// Sección para tráfico TCP (HTTP, HTTPS, etc.)
redsocks {
    local_ip = 0.0.0.0;
    local_port = 12345; // Puerto que escuchará redsocks para TCP

ip = 51.77.190.247;        // Dirección IP de su proxy SOCKS5 remoto
    port = 9595;         // Puerto de su proxy SOCKS5 remoto
    type = socks5;       // Usamos SOCKS5 (se puede usar http-connect para el proxy HTTP o http-relay para HTTP puro)

login = «pcobLdlPkt-res-any»;    // Nombre de usuario del proxy
    password = «PC_7CJ2WQqdHNm42dHWj»; // Contraseña del proxy
}

// Sección para tráfico DNS (UDP)
redudp {
    local_ip = 0.0.0.0;
    local_port = 10053; // Puerto que escuchará redsocks para DNS
    
    ip = 51.77.190.247;        // La misma IP del proxy SOCKS5
    port = 9595;         // El mismo puerto SOCKS5-proxy
    type = socks5;

login = «pcobLdlPkt-res-any»;    // El mismo nombre de usuario
    password = «PC_7CJ2WQqdHNm42dHWj»; // La misma contraseña
}

// Sección para TCP-DNS (para capturar solicitudes TCP poco frecuentes)
dnstc {
    local_ip = 127.0.0.1;
    local_port = 5300;
}
```

##### **Paso 4. Configuración de iptables (el paso más importante)**

Estas reglas son el núcleo de nuestro sistema. Evitarán fugas y bucles infinitos.

**Importante:** iptables no tiene un «modo de edición» integrado como un editor de texto. Las reglas se almacenan en la memoria del núcleo y se controlan mediante comandos. Para ver, eliminar, insertar o sustituir, utilice los comandos de iptables. Para ediciones complejas, descargue las reglas en un archivo, edítelo y vuelva a cargarlo. Esto es especialmente útil con iptables-persistent, donde las reglas se guardan en /etc/iptables/rules.v4.

##### Paso 1. Ver las reglas actuales

Primero, vea las reglas existentes para comprender qué editar.

```bash
# Ver todas las reglas de la tabla nat con números de línea
sudo iptables -t nat -L -n -v --line-numbers
```

- `-t nat`: Tabla nat (para nuestros REDIRECT).
- `-L`: Lista de reglas.
- `-n`: IP numéricas (sin DNS).
- `-v`: Detallado (contadores de paquetes).
- `--line-numbers`: Números de reglas (para eliminar/insertar).

Ejemplo de salida:
```
Cadena PREROUTING (política ACCEPT 0 paquetes, 0 bytes)
num   pkts bytes destino     prot opt in     out     origen               destino         
1        0     0 REDSOCKS   all  --  *      *       0.0.0.0/0            0.0.0.0/0           
```

##### Paso 2. Edición sencilla: eliminar, insertar y sustituir

Para cambios menores:
- **Eliminar una regla por número**: Especifique la cadena y el número.
```bash
  # Eliminar la regla n.º 1 en PREROUTING
  sudo iptables -t nat -D PREROUTING 1
  ```
- **Insertar una nueva regla en la posición**: Utilice -I (insertar).
  ```bash
  # Insertar en la posición 1 en PREROUTING (por ejemplo, con puertos adicionales)
  sudo iptables -t nat -I PREROUTING 1 -p tcp -m multiport --dports 80,443,8080 -j REDSOCKS
  ```
- **Reemplazar regla**: utilice -R (replace).
```bash
  # Reemplazar la regla n.º 1 en PREROUTING
  sudo iptables -t nat -R PREROUTING 1 -p tcp -m multiport --dports 80,443 -j REDSOCKS
  ```

##### Paso 3. Edición a través del archivo (para cambios complejos)

Descargue las reglas en un archivo de texto, edítelas y vuelva a cargarlas.
- **Descargar reglas**:
```bash
  sudo iptables-save > /tmp/iptables.rules  # Archivo temporal
  # O para persistente: sudo nano /etc/iptables/rules.v4
  ```
- **Editar el archivo**: Ábralo en nano o vi. El archivo tiene este aspecto (ejemplo):
```
  *nat
  :PREROUTING ACCEPT [0:0]
  :INPUT ACCEPT [0:0]
  :OUTPUT ACCEPT [0:0]
  :POSTROUTING ACCEPT [0:0]
  :REDSOCKS - [0:0]
  -A REDSOCKS -d 1.2.3.4 -j RETURN
  -A REDSOCKS -d 10.0.0.0/8 -j RETURN
  # ... demás excepciones
  -A REDSOCKS -p tcp -m multiport --dports 80,443 -j REDIRECT --to-port 12345
  -A PREROUTING -j REDSOCKS
  -A PREROUTING -p udp --dport 53 -j REDIRECT --to-port 10053
  -A PREROUTING -p tcp --dport 53 -j REDIRECT --to-port 5300
  -A POSTROUTING -o eth0 -j MASQUERADE
  COMMIT
  ```
  Añada/elimine líneas con -A, -I, etc. Guarde el archivo.

- **Cargar reglas**:
```bash
  sudo iptables-restore < /tmp/iptables.rules
  # Para persistente: sudo netfilter-persistent reload
  ```

Paso 4. Limpiar las reglas (si es necesario restablecerlas)

- Limpiar la cadena: `sudo iptables -t nat -F REDSOCKS` (flush).
- Eliminar la cadena: `sudo iptables -t nat -X REDSOCKS`.
- Borrado completo de nat: `sudo iptables -t nat -F` (¡con cuidado!).

**Consejos**: Después de los cambios, compruebe las reglas (`iptables -t nat -L`) y pruebe el tráfico (curl, dig). Para IPv6, utilice `ip6tables`. Si el sistema está en nftables, edite /etc/nftables.conf y aplique `sudo nft -f /etc/nftables.conf`.

**Comencemos a configurar iptables:**
```bash
# IMPORTANTE: Indique la IP de su proxy remoto.
PROXY_IP="51.77.190.247"

# --- CONFIGURACIÓN GENERAL ---
# Limpiamos la cadena REDSOCKS (si existe, para la prueba)
sudo iptables -t nat -F REDSOCKS || true
sudo iptables -t nat -X REDSOCKS || true

# Creamos una nueva cadena REDSOCKS para TCP
iptables -t nat -N REDSOCKS

# Excluimos el propio servidor proxy para evitar un ciclo infinito
iptables -t nat -A REDSOCKS -d $PROXY_IP -j RETURN

# Ignoramos las redes locales y reservadas
iptables -t nat -A REDSOCKS -d 0.0.0.0/8 -j RETURN
iptables -t nat -A REDSOCKS -d 10.0.0.0/8 -j RETURN
iptables -t nat -A REDSOCKS -d 127.0.0.0/8 -j RETURN
iptables -t nat -A REDSOCKS -d 169.254.0.0/16 -j RETURN
iptables -t nat -A REDSOCKS -d 172.16.0.0/12 -j RETURN
iptables -t nat -A REDSOCKS -d 192.168.0.0/16 -j RETURN
iptables -t nat -A REDSOCKS -d 224.0.0.0/4 -j RETURN
iptables -t nat -A REDSOCKS -d 240.0.0.0/4 -j RETURN

# --- CORRECCIÓN: Redirigimos solo el tráfico WEB ---
# NO queremos romper SSH, FTP, etc. Redirigimos solo HTTP y HTTPS.
# Para correo electrónico (25,465) u otros puertos, añada --dports
iptables -t nat -A REDSOCKS -p tcp -m multiport --dports 80,443 -j REDIRECT --to-port 12345

# (Opcional) Si está seguro de que desea proxy TODO el tráfico TCP:
# iptables -t nat -A REDSOCKS -p tcp -j REDIRECT --to-port 12345

# --- SELECCIONE SU ESCENARIO ---

# === ESCENARIO A: Proxy para la puerta de enlace (tráfico de OTROS dispositivos) ===
# Los clientes deben utilizar el servidor como puerta de enlace predeterminada (a través de DHCP o de forma estática)

# 1. Activamos el reenvío de IP (de forma permanente)
echo “net.ipv4.ip_forward=1” | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 2. Aplicamos las reglas al tráfico de tránsito
iptables -t nat -A PREROUTING -j REDSOCKS

# 3. Interceptamos el tráfico DNS (UDP 53) y lo enviamos a redsocks
iptables -t nat -A PREROUTING -p udp --dport 53 -j REDIRECT --to-port 10053

# 4. Interceptamos TCP-DNS
iptables -t nat -A PREROUTING -p tcp --dport 53 -j REDIRECT --to-port 5300

# 5. Activamos MASQUERADE (CRÍTICO para el gateway)
# Reemplaza eth0 por tu interfaz de red EXTERNA
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# === ESCENARIO B: Proxy para el propio servidor (tráfico LOCAL) ===

# 1. Aplicamos las reglas al tráfico local
iptables -t nat -A OUTPUT -j REDSOCKS

# 2. Interceptamos el tráfico DNS local
iptables -t nat -A OUTPUT -p udp --dport 53 -j REDIRECT --to-port 10053

# 3. Interceptamos TCP-DNS
iptables -t nat -A OUTPUT -p tcp --dport 53 -j REDIRECT --to-port 5300
```

**Importante**: No aplique ambos escenarios al mismo tiempo sin un conocimiento profundo. Elija el que se adapte a su tarea.

##### **Paso 5. Iniciar redsocks**

```bash
sudo systemctl start redsocks
# Asegúrese de que el servicio está en marcha
sudo systemctl status redsocks
```

#### **Parte 4. Problemas y soluciones avanzadas**

##### **Fugas de DNS (UDP vs TCP)* *

Esta guía resuelve el problema interceptando las solicitudes DNS por UDP (puerto 53) y TCP con dnstc. Sin embargo, si el proxy no admite UDP-associate (para redudp), el DNS no pasará; compruebe los registros. Para una protección completa, compruébelo en dnsleaktest.com.

##### **Problema con HTTPS y SSL**

redsocks no tiene este problema. Funciona en el nivel de transporte (TCP) y no intenta descifrar su tráfico HTTPS. Simplemente toma su paquete HTTPS ya cifrado y lo «envuelve» por completo en SOCKS5. El propietario del proxy no puede leer sus datos.

#### # **Nota sobre alternativas modernas**

redsocks es una herramienta potente, pero bastante antigua. En 2025, para los nuevos sistemas, especialmente los que utilizan nftables, a menudo se recomiendan alternativas más modernas, como ss-redir (de shadowsocks-libev) o V2Ray/Xray, que realizan tareas similares con mejor rendimiento y complementos. Para UDP sin redsocks, considere TPROXY en iptables/nftables. Si está en contenedores o en Android/routers (GL.iNet), redsocks funciona, pero requiere una firmware personalizada.

#### **Parte 5. Pruebas y depuración**

Si algo no funciona, aquí tienes una lista de comprobación:

- **Comprueba la IP**: `curl ifconfig.me` (debería mostrar la IP de tu proxy SOCKS5, no la del servidor).
- **Comprueba el DNS**: `dig google.com` o `nslookup google.com`. Comprueba la dirección IP que responde. Comprueba si hay fugas: abre browserleaks.com o dnsleaktest.com.
- **Comprueba los registros de redsocks**: son tu mejor aliado.
  ```bash
  tail -f /var/log/redsocks.log
  # O bien: journalctl -u redsocks
  ```
Busque mensajes de error de conexión o autenticación (por ejemplo, «authentication failed» — nombre de usuario/contraseña incorrectos).
- **Compruebe la disponibilidad del proxy**: Asegúrate de que tu servidor puede conectarse al servidor proxy:
```bash
  nc -zv 51.77.190.247 9595
  # (Respuesta esperada: Connection to 51.77.190.247 9595 port [tcp/*] succeeded!)
  ```
- **Compruebe los puertos**: `ss -tuln` (deben escuchar 12345, 10053, 5300).
- **Compruebe el cortafuegos**: asegúrese de que ufw o firewalld no bloquean sus nuevas reglas. Si SSH no funciona, desactive el redireccionamiento de todo el TCP.
- **Problemas comunes**: «Conectando pero sin respuesta»: compruebe el tipo de proxy (http-relay para HTTP). ¿Ciclo infinito? Asegúrese de que PROXY_IP esté excluido.

#### Parte 6. Guardar las reglas de iptables

La configuración de iptables se borra al reiniciar. Para que sea permanente, instale iptables-persistent.

```bash
sudo apt update
sudo apt install iptables-persistent
```

Durante la instalación, le preguntará si desea guardar las reglas actuales. Acepte. Si más adelante cambia las reglas, para guardarlas, ejecute:

```bash
sudo netfilter-persistent save
```

Para borrar:
`sudo iptables -t nat -F REDSOCKS; sudo iptables -t nat -X REDSOCKS; sudo iptables -t nat -D PREROUTING/OUTPUT ...`
(elimine las reglas específicas).

#### **Conclusión**

El proxy transparente con iptables es una herramienta increíblemente potente. Gracias a redsocks (o redsocks2), se puede configurar para que funcione con los proxies SOCKS5 modernos. Lo más importante es recordar la seguridad, evitar la interceptación de todo el tráfico TCP (filtrando los puertos), habilitar MASQUERADE para los gateways y siempre interceptar las solicitudes DNS para evitar fugas.

#### **Preguntas frecuentes**

- **¿No funciona la conexión?** Comprueba el proxy en los registros: «authentication failed» (autenticación fallida): nombre de usuario/contraseña incorrectos.
- **¿Ciclo infinito?** Asegúrate de que PROXY_IP está excluido.
- **¿En contenedores?** Redsocks requiere cap_net_admin; utiliza --privileged en Docker.
- **¿No funciona con mi proxy?** Si es HTTP, utiliza type = http-connect para compatibilidad con HTTPS.