Proxy para Transparent Proxy / iptables

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

Na maioria dos casos, quando falamos de proxy, estamos a referir-nos a um proxy «normal» ou «não transparente». Este requer uma configuração explícita em cada aplicação. Mas existe outra abordagem muito mais poderosa: o proxy transparente (Transparent Proxy).

Essa tecnologia intercepta e redireciona o tráfego de rede de forma imperceptível para o utilizador final e seus aplicativos. Os programas no computador do utilizador nem suspeitam que o tráfego está a passar pelo proxy.

**Analogia:**
Um proxy comum é como enviar uma encomenda por meio de um serviço de entrega que você mesmo escolheu e chamou.

Um proxy transparente é como se toda a agência dos correios, por padrão, embrulhasse todas as suas encomendas e as enviasse por uma rota especial, sem avisá-lo.

O mecanismo que torna isso possível no mundo Linux é chamado de iptables. Neste guia, vamos entender como isso funciona, para que serve e como configurar esse sistema na prática.

⛔️ **Aviso importante antes de começar**
Este guia é destinado a utilizadores avançados. Você trabalhará com o iptables e terá acesso root completo ao sistema. Um comando incorreto pode bloquear completamente o seu acesso à rede (incluindo SSH).

- **Teste em VM**: Sempre teste configurações como essa primeiro em uma máquina virtual.
- **Tenha um plano B**: Certifique-se de que tem acesso à consola do servidor (não SSH) para o caso de bloquear a sua rede.
- **Provedor confiável**: Você confia todo o seu tráfego ao servidor proxy. Certifique-se de usar um provedor confiável e comprovado. Não faça proxy de tráfego sensível (banca) sem encriptação end-to-end.
- **Compatibilidade**: Para novas distribuições (Ubuntu 22+, Fedora), verifique `iptables --version` — se for nft, mude para: `sudo update-alternatives --set iptables /usr/sbin/iptables-legacy`. Em contentores (Docker), o redsocks requer cap_net_admin; use --privileged.

#### **Parte 1. Por que precisa de um proxy transparente?**

O proxy transparente é o controlo total do tráfego ao nível da rede.

- **Redes corporativas e Wi-Fi**: para filtrar conteúdo, armazenar dados em cache e analisar a segurança de forma centralizada.
- **Gestão de dispositivos (IoT)**: pode fazer proxy do tráfego de dispositivos nos quais não é possível configurar o proxy manualmente (Smart TV, consolas de jogos, dispositivos IoT).
- **Contornar a censura para toda a rede**: em vez de configurar uma VPN em cada dispositivo, pode configurar uma vez o router, que encaminhará todo o tráfego através do proxy.

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

O iptables é uma ferramenta para gerenciar pacotes de rede no kernel Linux (Netfilter). Usaremos a tabela nat (Network Address Translation).

O ponto-chave é a escolha correta da cadeia para interceptação:

- **Cadeia PREROUTING**: Intercepta o tráfego que passa ATRAVÉS do seu servidor (tráfego de trânsito). Esta é a sua escolha se estiver a configurar um gateway ou router para outros dispositivos na rede.
- **Cadeia OUTPUT**: Intercepta o tráfego gerado pelo PRÓPRIO SERVIDOR (por exemplo, curl, apt-get ou scripts executados localmente).

#### **Parte 3. Implementação prática com redsocks**

O REDIRECT simples não funciona com proxies SOCKS5 remotos que exigem autenticação. Precisaremos do redsocks.

O redsocks é um daemon que recebe o tráfego redirecionado pelo iptables e, em seguida, estabelece uma ligação com o seu proxy remoto.

**Observação**: O redsocks original é bastante antigo (últimas atualizações ~2018). Recomendamos usar o fork redsocks2 (REDSOCKS2), que tem correções, novos recursos (redirecionamento automático sem lista negra, suporte a shadowsocks, IPv6) e está atualizado em 2025. Se a sua distribuição tiver o pacote redsocks2, use-o.
Caso contrário:
`git clone https://github.com/semigodking/redsocks && cd redsocks && make && sudo make install`
(ou um fork semelhante https://github.com/Intika-Linux-Proxy/Red-Socks-2).

##### **Passo 1: Recolha dos dados de autenticação do proxy**

O primeiro e mais importante passo é garantir que tem o conjunto completo de dados de autorização. Essas «chaves» permitirão que a sua aplicação ou navegador se conecte ao servidor proxy e encaminhe o tráfego através dele.

Certifique-se de preparar os seguintes dados:

* **Endereço IP** (servidor host)
* **Porta** para conexão
* **Login** e **senha** para autorização
* **Tipo de protocolo** (HTTP/HTTPS ou SOCKS5)

![](/media/mdeditor/proxies_info_pt_20251007053557394016.png)
*Fig. 1. Esta captura de ecrã mostra onde se encontram todos os campos necessários para se ligar ao servidor proxy na conta pessoal da **CyberYozh App**.*

##### **Passo 2. Instalação do redsocks**

```bash
sudo apt update
sudo apt install redsocks  # Para o original; para redsocks2 — veja acima
```

##### **Passo 3. Configurar o redsocks (TCP + DNS)**

Abra o ficheiro de configuração `sudo nano /etc/redsocks.conf`. Altere-o para o seguinte formato, substituindo os dados do seu proxy. Vamos configurar o redsocks para tráfego TCP, redudp para UDP/DNS e dnstc para TCP-DNS (para capturar solicitações TCP raras).

```bash
base {
    log_debug = off;
    log_info = on;
    log = “file:/var/log/redsocks.log”; // Caminho para os logs de depuração
    daemon = on;
    user = redsocks;
    group = redsocks;
    redirector = iptables;
}

// Secção para tráfego TCP (HTTP, HTTPS, etc.)
redsocks {
    local_ip = 0.0.0.0;
    local_port = 12345; // Porta que o redsocks irá escutar para TCP

ip = 51.77.190.247;        // Endereço IP do seu proxy SOCKS5 remoto
    port = 9595;         // Porta do seu proxy SOCKS5 remoto
    type = socks5;       // Usamos SOCKS5 (pode-se usar http-connect para proxy HTTP ou http-relay para HTTP puro)

// Secção para tráfego DNS (UDP)
redudp {
    local_ip = 0.0.0.0;
    local_port = 10053; // Porta que o redsocks irá escutar para DNS
    
    ip = 51.77.190.247;        // O mesmo IP do proxy SOCKS5
    port = 9595;         // O mesmo porta do proxy SOCKS5
    type = socks5;

// Secção para TCP-DNS (para capturar pedidos TCP raros)
dnstc {
    local_ip = 127.0.0.1;
    local_port = 5300;
}
```

##### **Passo 4. Configurar o iptables (o passo mais importante)**

Estas regras são o núcleo do nosso sistema. Elas impedirão fugas e ciclos infinitos.

**Importante:** o iptables não tem um “modo de edição” integrado como um editor de texto. As regras são armazenadas na memória do kernel e controladas através de comandos. Para visualizar, eliminar, inserir ou substituir, utilize os comandos do iptables. Para edições complexas, descarregue as regras para um ficheiro, edite-o e carregue-o novamente. Isto é especialmente útil com o iptables-persistent, onde as regras são guardadas em /etc/iptables/rules.v4.

##### Passo 1. Visualizar as regras atuais

Primeiro, veja as regras existentes para entender o que editar.

```bash
# Visualizar todas as regras na tabela nat com números de linha
sudo iptables -t nat -L -n -v --line-numbers
```

- `-t nat`: Tabela nat (para os nossos REDIRECT).
- `-L`: Lista de regras.
- `-n`: IP numéricos (sem DNS).
- `-v`: Detalhes (contadores de pacotes).
- `--line-numbers`: Números das regras (para remoção/inserção).

Exemplo de saída:
```
Chain PREROUTING (policy ACCEPT 0 packets, 0 bytes)
num   pkts bytes target     prot opt in     out     source               destination         
1        0     0 REDSOCKS   all  --  *      *       0.0.0.0/0            0.0.0.0/0           
```

##### Passo 2. Edição simples: remoção, inserção e substituição

Para pequenas alterações:
- **Remover regra por número**: Indique a cadeia e o número.
```bash
  # Remover regra n.º 1 em PREROUTING
  sudo iptables -t nat -D PREROUTING 1
  ```
- **Inserir nova regra na posição**: Use -I (insert).
  ```bash
  # Inserir na posição 1 em PREROUTING (por exemplo, com portas adicionais)
  sudo iptables -t nat -I PREROUTING 1 -p tcp -m multiport --dports 80,443,8080 -j REDSOCKS
  ```
- **Substituir regra**: Use -R (replace).
```bash
  # Substituir regra nº 1 em PREROUTING
  sudo iptables -t nat -R PREROUTING 1 -p tcp -m multiport --dports 80,443 -j REDSOCKS
  ```

##### Passo 3. Editar através do ficheiro (para alterações complexas)

Descarregue as regras para um ficheiro de texto, edite e carregue.
- **Descarregar regras**:
```bash
  sudo iptables-save > /tmp/iptables.rules  # Ficheiro temporário
  # Ou para persistente: sudo nano /etc/iptables/rules.v4
  ```
- **Editar o ficheiro**: Abra no nano ou vi. O ficheiro tem a seguinte aparência (exemplo):
```
  *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
  # ... restantes exceções
  -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
  ```
  Adicione/remova linhas com -A, -I, etc. Guarde o ficheiro.

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

Passo 4. Limpar as regras (se for necessário reiniciar)

- Limpar a cadeia: `sudo iptables -t nat -F REDSOCKS` (flush).
- Remover a cadeia: `sudo iptables -t nat -X REDSOCKS`.
- Limpeza completa do nat: `sudo iptables -t nat -F` (cuidado!).

**Dicas**: Após as alterações, verifique as regras (`iptables -t nat -L`) e teste o tráfego (curl, dig). Para IPv6, use `ip6tables`. Se o sistema estiver em nftables, edite /etc/nftables.conf e aplique `sudo nft -f /etc/nftables.conf`.

**Vamos começar a configurar o iptables:**
```bash
# IMPORTANTE: Indique o IP do seu proxy remoto
PROXY_IP="51.77.190.247"

# --- CONFIGURAÇÃO GERAL ---
# Limpar a cadeia REDSOCKS (se existir, para teste)
sudo iptables -t nat -F REDSOCKS || true
sudo iptables -t nat -X REDSOCKS || true

# Criar uma nova cadeia REDSOCKS para TCP
iptables -t nat -N REDSOCKS

# Excluímos o próprio servidor proxy para evitar um ciclo infinito
iptables -t nat -A REDSOCKS -d $PROXY_IP -j RETURN

# Ignoramos redes locais e 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

# --- CORREÇÃO: Redirecionamos apenas o tráfego WEB ---
# NÃO queremos interromper o SSH, FTP, etc. Redirecionamos apenas HTTP e HTTPS.
# Para e-mail (25,465) ou outras portas, adicione em --dports
iptables -t nat -A REDSOCKS -p tcp -m multiport --dports 80,443 -j REDIRECT --to-port 12345

# (Opcional) Se tiver a certeza de que deseja proxy TODO o tráfego TCP:
# iptables -t nat -A REDSOCKS -p tcp -j REDIRECT --to-port 12345

# --- ESCOLHA O SEU CENÁRIO ---

# === CENÁRIO A: Proxy para gateway (tráfego de OUTROS dispositivos) ===
# Os clientes devem usar o servidor como gateway padrão (via DHCP ou estaticamente)

# 1. Ativamos o encaminhamento de IP (permanente)
echo ‘net.ipv4.ip_forward=1’ | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# 2. Aplicamos regras ao tráfego de trânsito
iptables -t nat -A PREROUTING -j REDSOCKS

# 3. Interceptamos o tráfego DNS (UDP 53) e enviamos para 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. Ativamos MASQUERADE (CRITICAMENTE IMPORTANTE para o gateway)
# Substitua eth0 pela sua interface de rede EXTERNA
sudo iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# === CENÁRIO B: Proxy para o próprio servidor (tráfego LOCAL) ===

# 1. Aplicamos regras ao tráfego local
iptables -t nat -A OUTPUT -j REDSOCKS

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

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

**Importante**: Não aplique os dois cenários simultaneamente sem um conhecimento profundo. Escolha aquele que corresponde à sua tarefa.

##### **Passo 5. Iniciar o redsocks**

```bash
sudo systemctl start redsocks
# Verifique se o serviço está iniciado
sudo systemctl status redsocks
```

#### **Parte 4. Problemas e soluções avançadas**

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

Este guia resolve o problema interceptando as solicitações DNS por UDP (porta 53) e TCP com o dnstc. No entanto, se o proxy não suportar UDP-associate (para redudp), o DNS não passará — verifique os registos. Para proteção total, verifique em dnsleaktest.com.

##### **Problema com HTTPS e SSL**

O redsocks não tem esse problema. Ele funciona no nível de transporte (TCP) e não tenta descriptografar o seu tráfego HTTPS. Ele simplesmente pega o seu pacote HTTPS já criptografado e o “embrulha” inteiramente em SOCKS5. O proprietário do proxy não pode ler os seus dados.

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

O redsocks é uma ferramenta poderosa, mas bastante antiga. Em 2025, para novos sistemas, especialmente aqueles que usam nftables, alternativas mais modernas são frequentemente recomendadas, como ss-redir (do shadowsocks-libev) ou V2Ray/Xray, que realizam tarefas semelhantes com melhor desempenho e plug-ins. Para UDP sem redsocks, considere TPROXY em iptables/nftables. Se estiver em contentores ou em Android/routers (GL.iNet) — redsocks funciona, mas requer firmware personalizado.

#### **Parte 5. Teste e depuração**

Se algo não estiver a funcionar, eis a sua lista de verificação:

- **Verifique o IP**: `curl ifconfig.me` (deve mostrar o IP do seu proxy SOCKS5, não do servidor).
- **Verifique o DNS**: `dig google.com` ou `nslookup google.com`. Verifique o endereço IP que responde. Verifique se há fugas: abra browserleaks.com ou dnsleaktest.com.
- **Verifique os registos do redsocks**: este é o seu melhor amigo.
  ```bash
  tail -f /var/log/redsocks.log
  # Ou: journalctl -u redsocks
  ```
Procure mensagens de erro de ligação ou autenticação (por exemplo, «authentication failed» — login/password incorreto).
- **Verifique a disponibilidade do proxy**: Certifique-se de que o seu servidor consegue ligar-se ao servidor proxy:
```bash
  nc -zv 51.77.190.247 9595
  # (Resposta esperada: Connection to 51.77.190.247 9595 port [tcp/*] succeeded!)
  ```
- **Verifique as portas**: `ss -tuln` (devem estar a ouvir 12345, 10053, 5300).
- **Verifique a firewall**: Certifique-se de que o ufw ou o firewalld não estão a bloquear as suas novas regras. Se o SSH estiver avariado, desative o redirecionamento de todo o TCP.
- **Problemas comuns**: ‘Conectando, mas sem resposta’ — verifique o tipo de proxy (http-relay para HTTP). Ciclo infinito? Certifique-se de que PROXY_IP está excluído.

#### Parte 6. Salvando regras do iptables

As configurações do iptables são reiniciadas ao reiniciar. Para torná-las permanentes, instale o iptables-persistent.

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

Durante a instalação, ele perguntará se deseja guardar as regras atuais. Aceite. Se alterar as regras posteriormente, execute o seguinte para guardá-las:

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

Para limpar:
`sudo iptables -t nat -F REDSOCKS; sudo iptables -t nat -X REDSOCKS; sudo iptables -t nat -D PREROUTING/OUTPUT ...`
(apague regras específicas).

#### **Conclusão**

O proxy transparente com iptables é uma ferramenta incrivelmente poderosa. Graças ao redsocks (ou redsocks2), ele pode ser configurado para funcionar com proxies SOCKS5 modernos. O principal é lembrar-se da segurança, evitar a interceção de todo o tráfego TCP (filtrando portas), ativar o MASQUERADE para gateways e sempre interceptar consultas DNS para evitar fugas.

#### **Perguntas frequentes**

- **A ligação não está a funcionar?** Verifique o proxy nos registos: «authentication failed» — login/palavra-passe incorretos.
- **Ciclo infinito?** Certifique-se de que PROXY_IP está excluído.
- **Em contentores?** O Redsocks requer cap_net_admin; use --privileged no Docker.
- **Não funciona com o meu proxy?** Se for HTTP — use type = http-connect para compatibilidade com HTTPS.