Proxy para Transparent Proxy / 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)

*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

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).

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)

    login = “pcobLdlPkt-res-any”;    // Login do proxy
    password = “PC_7CJ2WQqdHNm42dHWj”; // Senha do proxy
}

// 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;

    login = “pcobLdlPkt-res-any”;    // O mesmo login
    password = “PC_7CJ2WQqdHNm42dHWj”; // A mesma senha
}

// 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.

# 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.

  # Remover regra n.º 1 em PREROUTING
  sudo iptables -t nat -D PREROUTING 1

Inserir nova regra na posição: Use -I (insert).

# 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).

  # 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:

  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:

  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:

# 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

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.
```
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:

  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.

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:

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.