Este capítulo documenta o funcionamento do firewall iptables que
acompanha a série do kernel 2.4, opções usadas, e aponta alguns pontos
fundamentais para iniciar a configuração e construção de bons sistemas de
firewall.
O Firewall é um programa que como objetivo proteger a máquina contra
acessos indesejados, tráfego indesejado, proteger serviços que estejam rodando
na máquina e bloquear a passagem de coisas que você não deseja receber (como
conexões vindas da Internet para sua segura rede local, evitando acesso aos
dados corporativos de uma empresa ou a seus dados pessoais). No kernel do
Linux 2.4, foi introduzido o firewall iptables (também chamado de
netfilter) que substitui o ipchains dos kernels da série 2.2.
Este novo firewall tem como vantagem ser muito estável (assim como o
ipchains e ipfwadm), confiável, permitir muita
flexibilidade na programação de regras pelo administrador do sistema, mais
opções disponíveis ao administrador para controle de tráfego, controle
independente do tráfego da rede local/entre redes/interfaces devido a nova
organização das etapas de roteamento de pacotes.
O iptables é um firewall em nível de pacotes e funciona baseado no
endereço/porta de origem/destino do pacote, prioridade, etc. Ele funciona
através da comparação de regras para saber se um pacote tem ou não permissão
para passar. Em firewalls mais restritivos, o pacote é bloqueado e registrado
para que o administrador do sistema tenha conhecimento sobre o que está
acontecendo em seu sistema.
Ele também pode ser usado para modificar e monitorar o tráfego da rede, fazer
NAT (masquerading, source nat, destination nat), redirecionamento de pacotes,
marcação de pacotes, modificar a prioridade de pacotes que chegam/saem do seu
sistema, contagem de bytes, dividir tráfego entre máquinas, criar proteções
anti-spoofing, contra syn flood, DoS, etc. O tráfego vindo de máquinas
desconhecidas da rede pode também ser bloqueado/registrado através do uso de
simples regras. As possibilidades oferecidas pelos recursos de filtragem
iptables como todas as ferramentas UNIX maduras dependem de sua
imaginação, pois ele garante uma grande flexibilidade na manipulação das regras
de acesso ao sistema, precisando apenas conhecer quais interfaces o sistema
possui, o que deseja bloquear, o que tem acesso garantido, quais serviços devem
estar acessíveis para cada rede, e iniciar a construção de seu firewall.
O iptables ainda tem a vantagem de ser modularizável, funções
podem ser adicionadas ao firewall ampliando as possibilidades oferecidas. Usei
por 2 anos o ipchains e afirmo que este é um firewall que tem
possibilidades de gerenciar tanto a segurança em máquinas isoladas como
roteamento em grandes organizações, onde a passagem de tráfego entre redes deve
ser minuciosamente controlada.
Um firewall não funciona de forma automática (instalando e esperar que ele faça as coisas por você), é necessário pelo menos conhecimentos básicos de rede tcp/ip, roteamento e portas para criar as regras que farão a segurança de seu sistema. A segurança do sistema depende do controle das regras que serão criadas por você, as falhas humanas são garantia de mais de 95% de sucesso nas invasões.
Enfim o iptables é um firewall que agradará tanto a pessoas que
desejam uma segurança básica em seu sistema, quando administradores de grandes
redes que querem ter um controle minucioso sobre o tráfego que passam entre
suas interfaces de rede (controlando tudo o que pode passar de uma rede a
outra), controlar o uso de tráfego, monitoração, etc.
É assumido que esteja usando a versão 1.2.3 do iptables e baseadas
nas opções do kernel 2.4.16 (sem o uso de módulos experimentais). As
explicações contidas aqui podem funcionar para versões posteriores, mas é
recomendável que leia a documentação sobre modificações no programa (changelog)
em busca de mudanças que alterem o sentido das explicações fornecidas aqui.
O iptables é um código de firewall das versões 2.4 do kernel, que
substituiu o ipchains (presente nas séries 2.2 do kernel). Ele
foi incluído no kernel da série 2.4 em meados de Junho/Julho de 1999.
A história do desenvolvimento (desde o porte do ipfw do
BSD para o Linux até o iptables (que é a
quarta geração de firewalls do kernel) está disponível no documento,
Netfilter-howto.
syslog sobre o tráfego
aceito/bloqueado.
Pacote: iptables
iptables-save.
É necessário que o seu kernel tenha sido compilado com suporte ao
iptables (veja Habilitando o suporte ao
iptables no kernel, Seção 10.1.15. O requerimento mínimo de memória
necessária para a execução do iptables é o mesmo do kernel 2.4
(4MB). Dependendo do tráfego que será manipulado pela(s) interface(s) do
firewall ele poderá ser executado com folga em uma máquina 386 SX com 4MB de
RAM.
Como as configurações residem no kernel não é necessário espaço extra em disco rígido para a execução deste utilitário.
Todo tráfego que for registrado pelo iptables é registrado por
padrão no arquivo /var/log/kern.log.
apt-get install iptables
O pacote iptables contém o utilitário iptables (e
ip6tables para redes ipv6) necessários para inserir suas regras no
kernel. Se você não sabe o que é ipv6, não precisará se preocupar com o
utilitário ip6tables por enquanto.
A página principal do projeto é http://netfilter.filewatcher.org.
Sugestões podem ser enviadas para a lista de desenvolvimento oficial do
iptables: http://lists.samba.org.
ipchains e ipfwadm?
O iptables faz parte da nova geração de firewalls que acompanha o
kernel 2.4, mas o suporte ao ipchains e ipfwadm ainda
será mantido através de módulos de compatibilidade do kernel até 2004. Seria
uma grande falta de consideração retirar o suporte a estes firewalls do kernel
como forma de obrigar a "aprenderem" o iptables (mesmo o
suporte sendo removido após este período, acredito que criarão patches
"externos" para futuros kernels que não trarão mais este suporte).
Se precisa do suporte a estes firewalls antes de passar em definitivo para o
iptables leia Habilitando o suporte ao
iptables no kernel, Seção 10.1.15.
Se você é um administrador que gosta de explorar todos os recursos de um
firewall, usa todos os recursos que ele oferece ou mantém uma complexa rede
corporativa, tenho certeza que gostará do iptables.
Existem basicamente dois tipos de firewalls:
squid, são um exemplo
deste tipo de firewall.
iptables é um
excelente firewall que se encaixa nesta categoria.
Firewall em nível de pacotes é o assunto explicado nesta seção do guia mas será
apresentada uma explicação breve sobre o funcionamento de análise de strings do
iptables.
Os dois tipos de firewalls podem ser usados em conjunto para fornecer uma camada dupla de segurança no acesso as suas máquinas/máquinas clientes.
Antes de iniciar a construção do firewall é bom pensar nos seguintes pontos:
A configuração do firewall ajuda a prevenir isso, mesmo se um serviço estiver mal configurado e tentando enviar seus pacotes para fora, será impedido. Da mesma forma se uma máquina Windows de sua rede for infectada por um trojan não haverá pânico: o firewall poderá estar configurado para bloquear qualquer tentativa de conexão vinda da internet (cracker) para as máquinas de sua rede.
Para cópia de arquivos via rede insegura (como através da Internet), é recomendado o uso de serviços que utilizam criptografia para login e transferência de arquivos (veja Servidor ssh, Capítulo 15) ou a configuração de uma VPN.
A análise destes pontos pode determinar a complexidade do firewall, custos de implementação, prazo de desenvolvimento e tempo de maturidade do código para implementação. Existem muitos outros pontos que podem entrar na questão de desenvolvimento de um sistema de firewall, eles dependem do tipo de firewall que está desenvolvendo e das políticas de segurança de sua rede.
As regras são como comandos passados ao iptables para que ele
realize uma determinada ação (como bloquear ou deixar passar um pacote) de
acordo com o endereço/porta de origem/destino, interface de origem/destino,
etc. As regras são armazenadas dentro dos chains e processadas na ordem que
são inseridas.
As regras são armazenadas no kernel, o que significa que quando o computador for reiniciado tudo o que fez será perdido. Por este motivo elas deverão ser gravadas em um arquivo para serem carregadas a cada inicialização.
Um exemplo de regra: iptables -A INPUT -s 123.123.123.1 -j DROP.
Os Chains são locais onde as regras do firewall definidas pelo usuário são armazenadas para operação do firewall. Existem dois tipos de chains: os embutidos (como os chains INPUT, OUTPUT e FORWARD) e os criados pelo usuário. Os nomes dos chains embutidos devem ser especificados sempre em maiúsculas (note que os nomes dos chains são case-sensitive, ou seja, o chain input é completamente diferente de INPUT).
Tabelas são os locais usados para armazenar os chains e conjunto de regras com
uma determinada característica em comum. As tabelas podem ser referenciadas
com a opção -t tabela e existem 3 tabelas disponíveis no
iptables:
Os chains INPUT e OUTPUT somente são atravessados por conexões indo/se originando de localhost.
OBS: Para conexões locais, somente os chains INPUT e OUTPUT são consultados na tabela filter.
Veja A tabela mangle, Seção 10.5 para mais detalhes sobre a tabela mangle.
Para usar toda a funcionalidade do firewall iptables, permitindo
fazer o controle do que tem ou não permissão de acessar sua máquina, fazer
Masquerading/NAT em sua rede, etc., você precisará dos seguintes componentes
compilados em seu kernel (os módulos experimentais fora ignorados
intencionalmente):
*
* Network Options:
*
Network packet filtering (replaces ipchains) [Y/m/n/?]
Network packet filtering debugging [Y/m/n/?]
e na Subseção:
*
* IP: Netfilter Configuration
*
Connection tracking (required for masq/NAT) (CONFIG_IP_NF_CONNTRACK) [M/n/y/?]
FTP protocol support (CONFIG_IP_NF_FTP) [M/n/?]
IRC protocol support (CONFIG_IP_NF_IRC) [M/n/?]
IP tables support (required for filtering/masq/NAT) (CONFIG_IP_NF_IPTABLES) [Y/m/n/?]
limit match support (CONFIG_IP_NF_MATCH_LIMIT) [Y/m/n/?]
MAC address match support (CONFIG_IP_NF_MATCH_MAC) [M/n/y/?]
netfilter MARK match support (CONFIG_IP_NF_MATCH_MARK) [M/n/y/?]
Multiple port match support (CONFIG_IP_NF_MATCH_MULTIPORT) [M/n/y/?]
TOS match support (CONFIG_IP_NF_MATCH_TOS) [M/n/y/?]
LENGTH match support (CONFIG_IP_NF_MATCH_LENGTH) [M/n/y/?]
TTL match support (CONFIG_IP_NF_TTL) [M/n/y/?]
tcpmss match support (CONFIG_IP_NF_MATCH_TCPMSS) [M/n/y/?]
Connection state match support (CONFIG_IP_NF_MATCH_STATE) [M/n/?]
Packet filtering (CONFIG_IP_NF_FILTER) [M/n/y/?]
REJECT target support (CONFIG_IP_NF_TARGET_REJECT) [M/n/?]
Full NAT (CONFIG_IP_NF_NAT) [M/n/?]
MASQUERADE target support (CONFIG_IP_NF_TARGET_MASQUERADE) [M/n/?]
REDIRECT target support (CONFIG_IP_NF_TARGET_REDIRECT) [M/n/?]
Packet mangling (CONFIG_IP_NF_MANGLE) [M/n/y/?]
TOS target support (CONFIG_IP_NF_TARGET_TOS) [M/n/?]
MARK target support (CONFIG_IP_NF_TARGET_MARK) [M/n/?]
LOG target support (CONFIG_IP_NF_TARGET_LOG) [M/n/y/?]
TCPMSS target support (CONFIG_IP_NF_TARGET_TCPMSS) [M/n/y/?]
Esta configuração permite que você não tenha problemas para iniciar o uso e
configuração do seu firewall iptables, ela ativa os módulos necessários para
utilização de todos os recursos do firewall iptables. Quando
conhecer a função de cada um dos parâmetros acima (durante o decorrer do
texto), você poderá eliminar muitas das opções desnecessárias para seu estilo
de firewall ou continuar fazendo uso de todas ;-)
OBS1: A configuração acima leva em consideração que você NÃO
executará os códigos antigos de firewall ipfwadm e
ipchains. Caso deseje utilizar o ipchains ou o
ipfwadm, será preciso responder com "M" a questão
"IP tables support (required for filtering/masq/NAT)
(CONFIG_IP_NF_IPTABLES)". Será necessário carregar manualmente o módulo
correspondente ao firewall que deseja utilizar (modprobe
iptables_filter.o no caso do iptables).
Não execute mais de um tipo de firewall ao mesmo tempo!!!
OBS2: É recomendável ativar o daemon kmod para
carga automática de módulos, caso contrário será necessário compilar todas as
partes necessárias embutidas no kernel, carregar os módulos necessários
manualmente ou pelo iptables (através da opção
--modprobe=módulo).
Se a sua intenção (como da maioria dos usuários) é conectar sua rede interna a Internet de forma rápida e simples, leia Fazendo IP masquerading (para os apressados), Seção 10.4.2 ou Fazendo SNAT, Seção 10.4.3. Um exemplo prático de configuração de Masquerading deste tipo é encontrado em Conectando sua rede interna a Internet, Seção 10.8.3.
Após configurar o masquerading, você só precisará especificar o endereço IP da
máquina masquerading (servidor) como Gateway da rede. No
Windows 9x/NT/2000 isto é feito no Painel de
Controle/Rede/Propriedades de Tcp/IP. No Linux pode ser feito com
route add default gw IP_do_Servidor.
O iptables trabalha com uma tabela de regras que é analisada uma a
uma até que a última seja processada. Por padrão, se uma regra tiver qualquer
erro, uma mensagem será mostrada e ela descartada. O pacote não conferirá e a
ação final (se ele vai ser aceito ou rejeitado) dependerá das regras seguintes.
As opções passadas ao iptables usadas para manipular os chains são
SEMPRE em maiúsculas. As seguintes operações podem ser
realizadas:
Como exemplo vamos criar uma regra que bloqueia o acesso a nosso própria máquina (127.0.0.1 - loopback). Primeiro daremos um ping para verificar seu funcionamento:
#ping 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
64 bytes from 127.0.0.1: icmp_seq=0 ttl=255 time=0.6 ms
64 bytes from 127.0.0.1: icmp_seq=1 ttl=255 time=0.5 ms
--- 127.0.0.1 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.5/0.5/0.6 ms
Ok, a máquina responde, agora vamos incluir uma regra no chain INPUT (-A INPUT) que bloqueie (-j DROP) qualquer acesso indo ao endereço 127.0.0.1 (-d 127.0.0.1):
iptables -t filter -A INPUT -d 127.0.0.1 -j DROP
Agora verificamos um novo ping:
#ping 127.0.0.1
PING 127.0.0.1 (127.0.0.1): 56 data bytes
--- 127.0.0.1 ping statistics ---
2 packets transmitted, 0 packets received, 100% packet loss
Desta vez a máquina 127.0.0.1 não respondeu, pois todos os pacotes com o destino 127.0.0.1 (-d 127.0.0.1) são rejeitados (-j DROP). A opção -A é usada para adicionar novas regras no final do chain. Além de -j DROP que serve para rejeitar os pacotes, podemos também usar -j ACCEPT para aceitar pacotes. A opção -j é chamada de alvo da regra ou somente alvo pois define o destino do pacote que atravessa a regra (veja Especificando um alvo, Seção 10.3.6). Bem vindo a base de um sistema de firewall :-)
OBS1: - O acesso a interface loopback não deve ser de forma alguma bloqueado, pois muitos aplicativos utilizam soquetes tcp para realizarem conexões, mesmo que você não possua uma rede interna.
OBS2: - A tabela filter será usada como padrão caso nenhuma tabela seja especificada através da opção -t.
A seguinte sintaxe é usada para listar as regras criadas:
iptables [-t tabela] -L [chain] [opções]
Onde:
iptables. Se a tabela não for
especificada, a tabela filter será usada como padrão. Veja O que são tabelas?, Seção
10.1.14 para detalhes.
/etc/services. A resolução
de nomes pode tomar muito tempo dependendo da quantidade de regras que suas
tabelas possuem e velocidade de sua conexão.
Para listar a regra criada anteriormente usamos o comando:
#iptables -t filter -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP all -- anywhere localhost
O comando iptables -L INPUT -n tem o mesmo efeito, a diferença é que são mostrados números ao invés de nomes:
#iptables -L INPUT -n
Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP all -- 0.0.0.0/0 127.0.0.1
#iptables -L INPUT -n --line-numbers
Chain INPUT (policy ACCEPT)
num target prot opt source destination
1 DROP all -- 0.0.0.0/0 127.0.0.1
#iptables -L INPUT -n -v
Chain INPUT (policy ACCEPT 78 packets, 5820 bytes)
pkts bytes target prot opt in out source destination
2 194 DROP icmp -- * * 0.0.0.0/0 127.0.0.1
Os campos assim possuem o seguinte significado:
Para apagar um chain, existem duas alternativas:
iptables -t filter -D INPUT 1
Esta opção não é boa quando temos um firewall complexo com um grande número de regras por chains, neste caso a segunda opção é a mais apropriada.
iptables -t filter -D INPUT -d 127.0.0.1 -j DROP
Então a regra correspondentes no chain INPUT será automaticamente apagada (confira listando o chain com a opção "-L"). Caso o chain possua várias regras semelhantes, somente a primeira será apagada.
OBS: Não é possível apagar os chains defaults do
iptables (INPUT, OUTPUT...).
Precisamos que o tráfego vindo de 192.168.1.15 não seja rejeitado
pelo nosso firewall. Não podemos adicionar uma nova regra (-A) pois esta seria
incluída no final do chain e o tráfego seria rejeitado pela primeira regra
(nunca atingindo a segunda). A solução é inserir a nova regra antes da regra
que bloqueia todo o tráfego ao endereço 127.0.0.1 na posição 1:
iptables -t filter -I INPUT 1 -s 192.168.1.15 -d 127.0.0.1 -j ACCEPT
Após este comando, temos a regra inserida na primeira posição do chain (repare no número 1 após INPUT) e a antiga regra número 1 passa a ser a número 2. Desta forma a regra acima será consultada, se a máquina de origem for 192.168.1.15 então o tráfego estará garantido, caso contrário o tráfego com o destino 127.0.0.1 será bloqueado na regra seguinte.
Após criar nossa regra, percebemos que a nossa intenção era somente bloquear os
pings com o destino 127.0.0.1 (pacotes ICMP) e não havia
necessidade de bloquear todo o tráfego da máquina. Existem duas alternativas:
apagar a regra e inserir uma nova no lugar ou modificar diretamente a regra já
criada sem afetar outras regras existentes e mantendo a sua ordem no chain
(isso é muito importante). Use o seguinte comando:
iptables -R INPUT 2 -d 127.0.0.1 -p icmp -j DROP
O número 2 é o número da regra que será substituída no chain
INPUT, e deve ser especificado. O comando acima substituirá a regra 2 do chain
INPUT (-R INPUT 2) bloqueando (-j DROP) qualquer pacote icmp (-p icmp) com o
destino 127.0.0.1 (-d 127.0.0.1).
Em firewalls organizados com um grande número de regras, é interessante criar chains individuais para organizar regras de um mesmo tipo ou que tenha por objetivo analisar um tráfego de uma mesma categoria (interface, endereço de origem, destino, protocolo, etc) pois podem consumir muitas linhas e tornar o gerenciamento do firewall confuso (e conseqüentemente causar sérios riscos de segurança). O tamanho máximo de um nome de chain é de 31 caracteres e podem conter tanto letras maiúsculas quanto minúsculas.
iptables [-t tabela] [-N novochain]
Para criar o chain internet (que pode ser usado para agrupar as regras de internet) usamos o seguinte comando:
iptables -t filter -N internet
Para inserir regras no chain internet basta especifica-lo após a opção -A:
iptables -t filter -A internet -s 200.200.200.200 -j DROP
E então criamos um pulo (-j) do chain INPUT para o chain internet:
iptables -t filter -A INPUT -j internet
OBS: O chain criando pelo usuário pode ter seu nome tanto em maiúsculas como minúsculas.
Se uma máquina do endereço 200.200.200.200 tentar acessar sua máquina, o
iptables consultará as seguintes regras:
`INPUT' `internet'
---------------------------- -----------------------------
| Regra1: -s 192.168.1.15 | | Regra1: -s 200.200.200.200|
|--------------------------| |---------------------------|
| Regra2: -s 192.168.1.1 | | Regra2: -d 192.168.1.1 |
|--------------------------| -----------------------------
| Regra3: -j DROP |
----------------------------
O pacote tem o endereço de origem
200.200.200.200, ele passa pela
primeira e segunda regras do chain
INPUT, a terceira regra direciona
para o chain internet
_______________________________________
v / v
/-------------------------|-\ / /-------------------------------------|-\
| Regra1: -s 192.168.1.15 | | / | Regra1: -s 200.200.200.200 -j DROP \_____\
|-------------------------|-| / |---------------------------------------| /
| Regra2: -s 192.168.1.1 | | / | Regra2: -d 200.200.200.202 -j DROP |
|-------------------------|-|/ \---------------------------------------/
| Regra3: -j internet /|
|---------------------------| No chain internet, a primeira regra confere
| Regra4: -j DROP | com o endereço de origem 200.200.200.200 e
\---------------------------/ o pacote é bloqueado.
Se uma máquina com o endereço de origem 200.200.200.201 tentar acessar a máquina,
então as regra consultadas serão as seguintes:
O pacote tem o endereço de origem
200.200.200.201, ele passa pela
primeira e segunda regras do chain
INPUT, a terceira regra direciona
para o chain internet ______________________________________
v / v
/-------------------------|-\ / /-------------------------------------|-\
| Regra1: -s 192.168.1.15 | | / | Regra1: -s 200.200.200.200 -j DROP | |
|-------------------------|-| / |-------------------------------------|-|
| Regra2: -s 192.168.1.1 | | / | Regra2: -s 200.200.200.202 -j DROP | |
|-------------------------|-|/ \-------------------------------------|-/
| Regra3: -j internet /| v
|---------------------------| /
| Regra4: -j DROP --+-------------------------------------------
\------------------------/-/ O pacote passa pelas regras 1 e 2 do chain
| internet, como ele não confere com nenhuma
v das 2 regras ele retorna ao chain INPUT e é
Esta regra é a número 4 analisado pela regra seguinte.
que diz para rejeitar o
pacote.
Se por algum motivo precisar renomear um chain criado por você na tabela
filter, nat ou mangle, isto poderá ser feito usando
a opção -E do iptables:
iptables -t filter -E chain-antigo novo-chain
Note que não é possível renomear os chains defaults do iptables.
Use o comando cat /proc/net/ip_tables_names para fazer isto. É
interessante dar uma olhada nos arquivos dentro do diretório
/proc/net, pois os arquivos existentes podem lhe interessar para
outras finalidades.
Para limpar todas as regras de um chain, use a seguinte sintaxe:
iptables [-t tabela] [-F chain]
Onde:
iptables -t filter -F INPUT
iptables -t filter -F
Para apagarmos um chain criado pelo usuário, usamos a seguinte sintaxe:
iptables [-t tabela] [-X chain]
Onde:
OBS: - Chains embutidos nas tabelas não podem ser apagados pelo usuário. Veja os nomes destes chains em O que são tabelas?, Seção 10.1.14.
iptables -t filter -X internet
iptables -X
Este comando zera o campo pkts e bytes de uma regra do
iptables. Estes campos podem ser visualizados com o comando
iptables -L -v. A seguinte sintaxe é usada:
iptables [-t tabela] [-Z chain] [-L]
Onde:
iptables -t filter -Z INPUT
O policiamento padrão determina o que acontecerá com um pacote quando ele
chegar ao final das regras contidas em um chain. O policiamento padrão do
iptables é "ACCEPT" mas isto pode ser alterado com o
comando:
iptables [-t tabela] [-P chain] [ACCEPT/DROP]
Onde:
O policiamento padrão de um chain é mostrado com o comando iptables
-L:
# iptables -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
DROP icmp -- anywhere localhost
No exemplo acima, o policiamento padrão de INPUT é ACCEPT (policy ACCEPT), o que significa que qualquer pacote que não seja rejeitado pela regra do chain, será aceito. Para alterar o policiamento padrão deste chain usamos o comando:
iptables -t filter -P INPUT DROP
NOTA: Os policiamentos PERMISSIVOS (ACCEPT) normalmente são usados em conjunto com regras restritivas no chain correspondentes (tudo é bloqueado e o que sobrar é liberado) e policiamentos RESTRITIVOS (DROP) são usados em conjunto com regras permissivas no chain correspondente (tudo é liberado e o que sobrar é bloqueado pelo policiamento padrão).
As opções -s (ou --src/--source)e -d (ou --dst/--destination) servem para especificar endereços de origem e destino respectivamente. É permitido usar um endereço IP completo (como 192.168.1.1), um hostname (debian), um endereço fqdn (www.debian.org) ou um par rede/máscara (como 200.200.200.0/255.255.255.0 ou 200.200.200.0/24).
Caso um endereço/máscara não sejam especificados, é assumido 0/0 como padrão (todos as máquinas de todas as redes). A interpretação dos endereços de origem/destino dependem do chain que está sendo especificado (como INPUT e OUTPUT por exemplo).
OBS: Caso seja especificado um endereço fqdn e este resolver mais de um endereço IP, serão criadas várias regras, cada uma se aplicando a este endereço IP específico. É recomendável sempre que possível a especificação de endereços IP's nas regras, pois além de serem muito rápidos (pois não precisar de resolução DNS) são mais seguros para evitar que nosso firewall seja enganado por um ataque de IP spoofing.
# Bloqueia o tráfego vindo da rede 200.200.200.*:
iptables -A INPUT -s 200.200.200.0/24 -j DROP
# Bloqueia conexões com o destino 10.1.2.3:
iptables -A OUTPUT -d 10.1.2.3 -j DROP
# Bloqueia o tráfego da máquina www.dominio.teste.org a rede 210.21.1.3
# nossa máquina possui o endereço 210.21.1.3
iptables -A INPUT -s www.dominio.teste.org -d 210.21.1.3 -j DROP
As opções -i (ou --in-interface) e -o (ou --out-interface) especificam as interfaces de origem/destino de pacotes. Nem todos as chains aceitam as interfaces de origem/destino simultaneamente, a interface de entrada (-i) nunca poderá ser especificada em um chain OUTPUT e a interface de saída (-o) nunca poderá ser especificada em um chain INPUT. Abaixo uma rápida referência:
+---------------------+--------------------------------+
TABELA | CHAIN | INTERFACE |
| +----------------+---------------+
| | ENTRADA (-i) | SAÍDA (-o) |
+---------+---------------------+----------------+---------------+
| | INPUT | SIM | NÃO |
| filter | OUTPUT | NÃO | SIM |
| | FORWARD | SIM | SIM |
+---------+---------------------+----------------+---------------+
| | PREROUTING | SIM | NÃO |
| nat | OUTPUT | NÃO | SIM |
| | POSTROUTING | NÃO | SIM |
+---------+---------------------+----------------+---------------+
| | PREROUTING | SIM | NÃO |
| mangle | | | |
| | OUTPUT | NÃO | SIM |
+---------+---------------------+----------------+---------------+
O caminho do pacote na interface será determinado pelo tipo da interface e pela posição dos chains nas etapas de seu roteamento. O chain OUTPUT da tabela filter somente poderá conter a interface de saída (veja a tabela acima). O chain FORWARD da tabela filter é o único que aceita a especificação de ambas as interfaces, este é um ótimo chain para controlar o tráfego que passa entre interfaces do firewall.
Por exemplo para bloquear o acesso do tráfego de qualquer máquina com o endereço 200.123.123.10 vinda da interface ppp0 (uma placa de fax-modem):
iptables -A INPUT -s 200.123.123.10 -i ppp0 -j DROP
A mesma regra pode ser especificada como
iptables -A INPUT -s 200.123.123.10 -i ppp+ -j DROP
O sinal de "+" funciona como um coringa, assim a regra terá efeito em
qualquer interface de ppp0 a ppp9. As interfaces ativas no momento podem ser
listadas com o comando ifconfig, mas é permitido especificar uma
regra que faz referência a uma interface que ainda não existe, isto é
interessante para conexões intermitentes como o PPP. Para bloquear qualquer
tráfego local para a Internet:
iptables -A OUTPUT -o ppp+ -j DROP
Para bloquear a passagem de tráfego da interface ppp0 para a interface eth1 (de uma de nossas redes internas):
iptables -A FORWARD -i ppp0 -o eth1 -j DROP
A opção -p (ou --protocol) é usada para especificar protocolos no
iptables. Podem ser especificados os protocolos tcp,
udp e icmp. Por exemplo, para rejeitar todos os pacotes UDP
vindos de 200.200.200.200:
iptables -A INPUT -s 200.200.200.200 -p udp -j DROP
OBS1: Tanto faz especificar os nomes de protocolos em maiúsculas ou minúsculas.
As portas de origem/destino devem ser especificadas após o protocolo e podem ser precedidas por uma das seguintes opções:
Uma faixa de portas pode ser especificada através de PortaOrigem:PortaDestino:
# Bloqueia qualquer pacote indo para 200.200.200.200 na faixa de
# portas 0 a 1023
iptables -A OUTPUT -d 200.200.200.200 -p tcp --dport :1023 -j DROP
Caso a PortaOrigem de uma faixa de portas não seja especificada, 0 é assumida como padrão, caso a Porta Destino não seja especificada, 65535 é assumida como padrão. Caso precise especificar diversas regras que envolvam o tratamento de portas diferentes, recomendo da uma olhada em Especificando múltiplas portas de origem/destino, Seção 10.6.6, antes de criar um grande número de regras.
O protocolo ICMP não possui portas, mas é possível fazer um controle maior sobre o tráfego ICMP que entra/sai da rede através da especificação dos tipos de mensagens ICMP. Os tipos de mensagens devem ser especificados com a opção "--icmp-type CódigoICMP" logo após a especificação do protocolo icmp:
iptables -A INPUT -s 200.123.123.10 -p icmp --icmp-type time-exceeded -i ppp+ -j DROP
A regra acima rejeitará mensagens ICMP do tipo "time-exceeded" (tempo de requisição excedido) que venham do endereço 200.123.123.10 através da interface ppp+.
Alguns tipos de mensagens ICMP são classificados por categoria (como o próprio "time-exceeded"), caso a categoria "time-exceeded" seja especificada, todas as mensagens daquela categoria (como "ttl-zero-during-transit", "ttl-zero-during-reassembly") conferirão na regra especificada.Os tipos de mensagens ICMP podem ser obtidos com o comando iptables -p icmp -h:
echo-reply (pong)
destination-unreachable
network-unreachable
host-unreachable
protocol-unreachable
port-unreachable
fragmentation-needed
source-route-failed
network-unknown
host-unknown
network-prohibited
host-prohibited
TOS-network-unreachable
TOS-host-unreachable
communication-prohibited
host-precedence-violation
precedence-cutoff
source-quench
redirect
network-redirect
host-redirect
TOS-network-redirect
TOS-host-redirect
echo-request (ping)
router-advertisement
router-solicitation
time-exceeded (ttl-exceeded)
ttl-zero-during-transit
ttl-zero-during-reassembly
parameter-problem
ip-header-bad
required-option-missing
timestamp-request
timestamp-reply
address-mask-request
address-mask-reply
OBS1: Não bloqueie mensagens do tipo "host-unreachable" e "source-quench", pois terá sérios problemas no controle de suas conexões. A primeira diz que o destino está inalcançavel e a segunda que o host está sobrecarregado, assim os pacotes devem ser enviados mais lentamente.
Pacotes syn são usados para iniciarem uma conexão, o uso da opção --syn serve para especificar estes tipos de pacotes. Desta maneira é possível bloquear somente os pacotes que iniciam uma conexão, sem afetar os pacotes restantes. Para que uma conexão ocorra é necessário que a máquina obtenha a resposta a pacotes syn enviados, caso ele seja bloqueado a resposta nunca será retornada e a conexão não será estabelecida.
iptables -A INPUT -p tcp --syn --dport 23 -i ppp+ -j DROP
A regra acima bloqueia (-j DROP) qualquer tentativa de conexão (--syn) vindas da interface ppp+ ao telnet (--dport 23) da máquina local, conexões já efetuadas ão são afetadas por esta regra. A opção --syn somente pode ser especificada para o protocolo tcp.
ATENÇÃO: - A situação de passagem de pacotes durante deve ser levada em conta durante a inicialização do firewall, bloqueando a passagem de pacotes durante o processo de configuração, criando regras que bloqueiam a passagem de pacotes (exceto para a interface loopback) até que a configuração do firewall esteja completa, pode ser uma solução eficiente.
Outra alternativa segura é configurar as regras de firewall antes das
interfaces de rede se tornarem ativas (usando a opção "pre-up
comando_firewall" no arquivo de configuração
/etc/network/interfaces em sistemas Debian.
A opção "-f" (ou --fragment) permite especificar regras que confiram com fragmentos. Fragmentos são simplesmente um pacote maior dividido em pedaços para poder ser transmitido via rede TCP/IP para remontagem do pacote pela máquina de destino.
Somente o primeiro fragmento possui detalhes de cabeçalho para ser processado, os segundos e seguintes somente possuem alguns cabeçalhos necessários para dar continuidade ao processo de remontagem do pacote no destino.
Uma regra como
iptables -A INPUT -s 200.200.200.1 -f -j DROP
derrubará os fragmentos de 200.200.200.1 derrubará o segundo pacote e pacotes seguintes enviados por 200.200.200.1 até nós.
OBS1: Note que se o cabeçalho do pacote não tiver detalhes
suficientes para checagem de regras no iptables, a regra
simplesmente não ira conferir.
OBS2: Não é preciso especificar a opção "-f" para conexões NAT, pois os pacotes são remontados antes de entrarem no código de filtragem.
OBS3: A opção "-f" também pode ser usada para evitar o flood por fragmentos (bomba de fragmentos) que, dependendo da intensidade, podem até travar a máquina.
Muitos parâmetros (como o endereço de origem/destino, protocolo, porta, mensagens ICMP, fragmentos, etc) podem ser precedidos pelo sinal "!" que significa exceção. Por exemplo:
iptables -t filter -A INPUT ! -s 200.200.200.10 -j DROP
Diz para rejeitar todos os pacotes EXCETO os que vem do endereço
200.200.200.10.
iptables -A INPUT -p tcp ! --syn -s 200.200.200.10 ! -i eth0 -j DROP
Diz para bloquear todos os pacotes EXCETO os que iniciam conexões (! --syn), EXCETO para pacotes vindos pela interface eth0 (! -i eth0).
iptables -A INPUT -s 200.200.200.10 ! -p tcp -j DROP
Bloqueia todos os pacotes vindos de 200.200.200.10, EXCETO os do protocolo tcp.
O alvo (-j) é o destino que um pacote terá quando conferir com as condições de
uma regra, um alvo pode dizer para bloquear a passagem do pacote (-j DROP),
aceitar a passagem do pacote (-j ACCEPT), registrar o pacote no sistema de log
(-j LOG), rejeitar o pacote (-j REJECT), redirecionar um pacote -j REDIRECT,
retornar ao chain anterior sem completar o processamento no chain atual (-j
RETURN), passar para processamento de programas externos (-j QUEUE), fazer
source nat (-j SNAT), destination nat (-j DNAT), etc. Podem existir mais
alvos, pois o iptables é modularizável, e módulos que acrescentam
mais funções podem ser carregados em adição aos já existentes no kernel.
Nos exemplos anteriores vimos o uso de diversos alvos como o DROP e o ACCEPT. Apenas farei uma breve referência sobre os alvos mais usados em operações comuns dos chains. Os alvos REDIRECT, SNAT e DNAT serão explicados em uma seção seguinte:
iptables e também pode ser especificado no policiamento padrão das
regras do firewall (veja Especificando o policiamento
padrão de um chain - P, Seção 10.2.12).
iptables e também pode ser especificado no policiamento padrão das
regras do firewall (veja Especificando o policiamento
padrão de um chain - P, Seção 10.2.12).
syslog caso a regra confira, o
processamento continua normalmente para a próxima regra (o pacote não é nem
considerado ACEITO ou REJEITADO).
Para ser usado, o módulo ipt_REJECT deve ser compilado no kernel
ou como módulo. Este alvo rejeita o pacote (como o DROP) e envia uma
mensagem ICMP do tipo "icmp-port-unreachable" como padrão para a
máquina de origem.
É um alvo interessante para bloqueio de portas TCP, pois em alguns casos da a impressão que a máquina não dispõe de um sistema de firewall (o alvo DROP causa uma parada de muito tempo em alguns portscanners e tentativas de conexão de serviços, revelando imediatamente o uso de um sistema de firewall pela máquina). O alvo REJECT vem dos tempos do ipchains e somente pode ser usado na tabela filter. Quando um pacote confere, ele é rejeitado com a mensagem ICMP do tipo "port unreachable", é possível especificar outro tipo de mensagem ICMP com a opção --reject-with tipo_icmp.
OBS: REJECT pode ser usado somente como alvo na tabela filter
e não é possível especifica-lo como policiamento padrão do chain filter (como
acontecia no ipchains. Uma forma alternativa é inserir como
última regra uma que pegue todos os pacotes restantes daquele chain e tenha
como alvo REJECT (como iptables -A INPUT -j REJECT), desta forma
ele nunca atingirá o policiamento padrão do chain.
# Rejeita pacotes vindos de 200.200.200.1 pela interface ppp0:
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Este alvo é usado para registrar a passagem de pacotes no syslog
do sistema. É um alvo muito interessante para ser usado para regras que
bloqueiam determinados tráfegos no sistema (para que o administrador tome
conhecimento sobre tais tentativas), para regras de fim de chain (quando você
tem um grande conjunto de regras em um firewall restritivo e não sabe onde suas
regras estão sendo bloqueadas), para satisfazer sua curiosidade, etc.
# Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface ppp0
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j LOG
# Para efetuar o bloqueio
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Note que no exemplo anterior a regra que registra o pacote (-j LOG) deve aparecer antes da regra que REJEITA (-j REJECT), caso contrário a regra de LOG nunca funcionará. A regra que REJEITA poderia também ser trocada por uma regra que ACEITA, caso queira registrar um pacote que deve ser aceito (se o policiamento padrão do seu firewall for restritivo (-P DROP). A única coisa que muda nas regras de log é o alvo da regra, isto facilita a implementação de grandes conjuntos de regras de firewall.
A regra acima mostrará a seguinte saída no syslog do sistema:
Aug 25 10:08:01 debian kernel: IN=ppp0 OUT= MAC=10:20:30:40:50:60:70:80:90:00:00:00:08:00 SRC=200.200.200.1 DST=200.210.10.10 LEN=61 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=UDP SPT=1031 DPT=53 LEN=41
Os campos possuem o seguinte significado:
iptables faz parte do
próprio kernel.
O log acima mostra uma consulta DNS (porta destino 53) para nossa máquina (INPUT) de 200.200.200.1 para 200.210.10.10.
O problema é que em um grande número de regras será difícil saber qual regra conferiu (pois teríamos que analisar o endereço/porta origem/destino) e o destino do pacote (se ele foi ACEITO ou BLOQUEADO) pois você pode ter regras para ambas as situações. Por este motivo existem algumas opções úteis que podemos usar com o alvo LOG:
syslog.
OBS1:Lembre-se que estas opções são referentes ao alvo LOG e devem ser usadas após este, caso contrário você terá um pouco de trabalho para analisar e consertar erros em suas regras do firewall.
OBS2:Caso esteja usando o firewall em um servidor público, recomendo associar um limite a regra de log, pois um ataque poderia causar um DoS enchendo sua partição. Leia mais sobre isso em Limitando o número de vezes que a regra confere, Seção 10.6.2.
# Complementando o exemplo anterior:
# Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface ppp0
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j LOG --log-prefix "FIREWALL: Derrubado "
# Para efetuar o bloqueio
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Retornará a seguinte mensagem no syslog:
Aug 25 10:08:01 debian kernel: FIREWALL: Derrubado IN=ppp0 OUT= MAC=10:20:30:40:50:60:70:80:90:00:00:00:08:00 SRC=200.200.200.1 DST=200.210.10.10 LEN=61 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=UDP SPT=1031 DPT=53 LEN=41
Agora você sabe o que aconteceu com o pacote (Rejeitado). A padronização de mensagens de firewall é também importante para a criação de scripts de análise que poderão fazer a análise dos logs do seu firewall (para criação de estatísticas que podem servir como base para a criação de novas regras de firewall ou eliminação de outras).
OBS: Se você sente falta da função "-l" do
ipchains que combina o alvo e log na mesma regra você pode criar
um alvo como o seguinte:
iptables -N log-drop
iptables -A log-drop -j LOG
iptables -A log-drop -j DROP
E usar "log-drop" como alvo em suas regras. Mesmo assim esta solução
é "limitada" em relação a "-l" do ipchains
porque o iptables não inclui detalhes de qual chain bloqueou o
pacote/qual pacote foi bloqueado, assim é necessário a especificação da opção
--log-prefix para as mensagens se tornarem mais compreensíveis. Esta
limitação pode ser contornada utilizando um firewall feito em linguagem shell
script, desta forma você terá um controle maior sobre o seu programa usando
funções e integração com outros utilitários.
O alvo RETURN diz ao iptables interromper o processamento no chain
atual e retornar o processamento ao chain anterior. Ele é útil quando criamos
um chain que faz um determinado tratamento de pacotes, por exemplo bloquear
conexões vindas da internet para portas baixas, exceto para um endereço IP
específico. Como segue:
1-) iptables -t filter -A INPUT -i ppp0 -j internet
2-) iptables -t filter -j ACCEPT
3-) iptables -t filter -N internet
4-) iptables -t filter -A internet -s www.debian.org -p tcp --dport 80 -j RETURN
5-) iptables -t filter -A internet -p tcp --dport 21 -j DROP
6-) iptables -t filter -A internet -p tcp --dport 23 -j DROP
7-) iptables -t filter -A internet -p tcp --dport 25 -j DROP
8-) iptables -t filter -A internet -p tcp --dport 80 -j DROP
Quando um pacote com o endereço www.debian.org tentando acessar a
porta www (80) de nossa máquina através da internet (via interface ppp0), o
chain número 1 confere, então o processamento continua no chain número 4, o
chain número 4 confere então o processamento volta para a regra número 2, que
diz para aceitar o pacote.
Agora se um pacote vem com o endereço www.dominio.com.br tentando
acessar a porta www *80) de nossa máquina através da internet (via interface
ppp0), o chain número 1 confere, então o processamento continua no chain número
4, que não confere. O mesmo acontece com os chains 5, 6 e 7. O chain número 8
confere, então o acesso é bloqueado.
Como pode notou, o alvo RETURN facilita bastante a construção das regras do seu firewall, caso existam máquinas/redes que sejam exceções as suas regras. Se ela não existisse, seria necessário especificar diversas opções -s, -d, etc para poder garantir o acesso livre a determinadas máquinas.
As regras que você está trabalhosamente criando e testando manualmente enquanto
manipula o iptables podem ser salvas de 2 formas; uma delas é
escrevendo um shell script que tenha todos os comandos, um por linha. Isto é
recomendado quando tem um firewall grande e que exige uma boa padronização de
regras, bem como sua leitura, comentários. O script shell também permite o uso
de funções presente no interpretador de comando, portanto se você é uma pessoa
que gosta de interagir com as funções do shell e deixar as coisas mais
flexíveis, prefira esta opção.
A outra forma é usando as ferramentas iptables-save e
iptables-restore baseada na idéia do ipchains-save e
ipchains-restore. O iptables-save deve ser usado
sempre que modificar regras no firewall iptables da seguinte forma:
iptables-save >/dir/iptables-regras
Uma das vantagens do uso do iptables-save é ele também salvar os
contadores de chains, ou seja, a quantidade de pacotes que conferiram com a
regra. Isto também pode ser feito com algumas regras adicionais em seu shell
script, caso tenha interesse nesses contadores para estatísticas ou outros
tipos de relatórios.
Para restaurar as regras salvas, utilize o comando:
iptables-restore </dir/iptables-regras
A tabela nat serve para controlar a tradução dos endereços que
atravessam o código de roteamento da máquina Linux. Existem 3
chains na tabela nat: PREROUTING, OUTPUT e
POSTROUTING (veja O que são tabelas?, Seção
10.1.14 para maiores detalhes).
A tradução de endereços tem inúmeras utilidades, uma delas é o Masquerading,
onde máquinas de uma rede interna podem acessar a Internet através de uma
máquina Linux, redirecionamento de porta, proxy transparente, etc.
Esta seção abordará os tipos de NAT, exemplos de como criar rapidamente uma
conexão IP masquerading e entender como a tradução de endereços funciona no
iptables.
Se sua intenção é ligar sua rede a Internet existem duas opções:
O procedimento para criação de um novo chain nesta tabela é o mesmo descrito em Criando um novo chain - N, Seção 10.2.6 será necessário somente especificar a tabela nat (-t nat) para que o novo chain não seja criado na tabela padrão (-t filter).
iptables -t nat -N intra-inter
Que criará o chain chamado intra-inter na tabela nat. Para inserir regras neste chain será necessário especificar a opção "-t nat".
Você precisará de um kernel com suporte ao iptables (veja Habilitando o suporte ao
iptables no kernel, Seção 10.1.15 e ip_forward e então digitar
os dois comandos abaixo para habilitar o masquerading para todas as máquinas da
rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE
echo "1" >/proc/sys/net/ipv4/ip_forward
A configuração do servidor Linux está completa, agora os clientes
da rede precisarão ser configurados para usar o endereço IP do servidor
Linux como gateway. É recomendável instalar um servidor proxy e
DNS na máquina Linux para acelerar o desempenho das
requisições/resolução de nomes das máquinas em rede. A utilização de bits TOS
também pode trazer um grande aumento de velocidade para os diferentes serviços
da rede (veja Especificando o tipo de
serviço, Seção 10.5.1).
SNAT (source nat - nat no endereço de origem) consiste em modificar o endereço de origem das máquinas clientes antes dos pacotes serem enviados. A máquina roteadora é inteligente o bastante para lembrar dos pacotes modificados e reescrever os endereços assim que obter a resposta da máquina de destino, direcionando os pacotes ao destino correto. Toda operação de SNAT é feita no chain POSTROUTING.
É permitido especificar endereços de origem/destino, protocolos, portas de origem/destino, interface de entrada/saída (dependendo do chain), alvos, etc. É desnecessário especificar fragmentos na tabela nat, pois eles serão remontados antes de entrar no código de roteamento.
O SNAT é a solução quando você tem acesso a internet através de um único IP e
deseja fazer que sua rede tenha acesso a Internet através da máquina
Linux. Nenhuma máquina da Internet poderá ter acesso direto as
máquinas de sua rede interna via SNAT.
OBS: A observação acima não leva em conta o controle de acesso
externo configurado na máquina que estiver configurando o
iptables, uma configuração mau realizada pode expor sua máquina a
acessos externos indesejados e comprometer sua rede interna caso alguém consiga
acesso direto ao servidor.
É necessário especificar SNAT como alvo (-j SNAT) quando desejar que as
máquinas de sua rede interna tenha acesso a Internet através do IP fixo da
máquina Linux (para conexões intermitentes como PPP, veja Fazendo IP
Masquerading, Seção 10.4.3.1). O parâmetro --to IP:portas
deve ser usado após o alvo SNAT. Ele serve para especificar um endereço IP,
faixa de endereços e opcionalmente uma porta ou faixa de portas que será
substituída. Toda a operação de SNAT é realizada através do chain POSTROUTING:
# Modifica o endereço IP dos pacotes vindos da máquina 192.168.1.2 da rede interna
# que tem como destino a interface eth1 para 200.200.217.40 (que é o nosso endereço
# IP da interface ligada a Internet).
iptables -t nat -A POSTROUTING -s 192.168.1.2 -o eth1 -j SNAT --to 200.200.217.40
Os pacotes indo para a Internet (nossa conexão é feita via eth1, nossa
interface externa) vindo do endereço 192.168.1.2, são substituídos por
200.241.200.40 e enviados para fora. Quando a resposta a requisição é
retornada, a máquina com iptables recebe os pacotes e faz a
operação inversa, modificando o endereço 200.241.200.40 novamente para
192.168.1.2 e enviando a resposta a máquina de nossa rede interna. Após
definir suas regras de NAT, execute o comando echo "1"
>/proc/sys/net/ipv4/ip_forward para habilitar o suporte a
redirecionamento de pacotes no kernel.
Também é possível especificar faixas de endereços e portas que serão substituídas:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50
Modifica o endereço IP de origem de todas as máquinas da rede 192.168.1.0/24 que tem o destino a interface eth0 para 200.241.200.40 a 200.241.200.50. O endereço IP selecionado é escolhido de acordo com o último IP alocado.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50:1-1023
Idêntico ao anterior, mas faz somente substituições na faixa de portas de origem de 1 a 1023.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50 --to 200.200.217.70-200.200.217.73
Faz o mapeamento para a faixa de portas 200.200.217.40 a 200.200.217.50 e de 200.200.217.70 a 200.200.217.73.
OBS1: Se por algum motivo não for possível mapear uma conexão NAT, ela será derrubada.
OBS2: Tenha certeza que as respostas podem chegar até a máquina que fez o NAT. Se estiver fazendo SNAT em um endereço livre em sua rede (como 200.200.217.73).
OBS3: Como notou acima, o SNAT é usado quando temos uma conexão externa com um ou mais IP's fixos. O Masquerading é uma forma especial de SNAT usada para funcionar em conexões que recebem endereços IP aleatórios (PPP).
OBS4: Não se esqueça de habilitar o redirecionamento de pacotes após fazer suas regra de NAT com o comando: echo "1" >/proc/sys/net/ipv4/ip_forward, caso contrário o redirecionamento de pacotes não funcionará.
O IP Masquerading é um tipo especial de SNAT usado para conectar a sua rede interna a internet quando você recebe um IP dinâmico de seu provedor (como em conexões ppp). Todas as operações de IP Masquerading são realizadas no chain POSTROUTING. Se você tem um IP fixo, deve ler Fazendo SNAT, Seção 10.4.3.
Para fazer IP Masquerading de uma máquina com o IP 192.168.1.2 para ter acesso a Internet, use o comando:
iptables -t nat -A POSTROUTING -s 192.168.1.2/32 -o ppp0 -j MASQUERADE
A diferença é que o alvo é -j MASQUERADE. O comando acima faz IP Masquerading de todo o tráfego de 192.168.1.2 indo para a interface ppp0: O endereço IP dos pacotes vindos de 192.168.1.2 são substituídos pelo IP oferecido pelo seu provedor de acesso no momento da conexão, quando a resposta é retornada a operação inversa é realizada para garantir que a resposta chegue ao destino. Nenhuma máquina da internet poderá ter acesso direto a sua máquina conectava via Masquerading.
Para fazer o IP Masquerading de todas as máquinas da rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o ppp0 -j MASQUERADE
Após definir a regra para fazer Masquerading (SNAT), execute o comando echo "1" >/proc/sys/net/ipv4/ip_forward para habilitar o suporte a redirecionamento de pacotes no kernel.
DNAT (Destination nat - nat no endereço de destino) consiste em modificar o endereço de destino das máquinas clientes. O destination nat é muito usado para fazer redirecionamento de pacotes, proxyes transparentes e balanceamento de carga.
Toda operação de DNAT é feita no chain PREROUTING. As demais opções e observações do SNAT são também válidas para DNAT (com exceção que s
>--log-tcp-sequence
OBS1:Lembre-se que estas opções são referentes ao alvo LOG e devem ser usadas após este, caso contrário você terá um pouco de trabalho para analisar e consertar erros em suas regras do firewall.
OBS2:Caso esteja usando o firewall em um servidor público, recomendo associar um limite a regra de log, pois um ataque poderia causar um DoS enchendo sua partição. Leia mais sobre isso em Limitando o número de vezes que a regra confere, Seção 10.6.2.
# Complementando o exemplo anterior:
# Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface ppp0
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j LOG --log-prefix "FIREWALL: Derrubado "
# Para efetuar o bloqueio
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Retornará a seguinte mensagem no syslog:
Aug 25 10:08:01 debian kernel: FIREWALL: Derrubado IN=ppp0 OUT= MAC=10:20:30:40:50:60:70:80:90:00:00:00:08:00 SRC=200.200.200.1 DST=200.210.10.10 LEN=61 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=UDP SPT=1031 DPT=53 LEN=41
Agora você sabe o que aconteceu com o pacote (Rejeitado). A padronização de mensagens de firewall é também importante para a criação de scripts de análise que poderão fazer a análise dos logs do seu firewall (para criação de estatísticas que podem servir como base para a criação de novas regras de firewall ou eliminação de outras).
OBS: Se você sente falta da função "-l" do
ipchains que combina o alvo e log na mesma regra você pode criar
um alvo como o seguinte:
iptables -N log-drop
iptables -A log-drop -j LOG
iptables -A log-drop -j DROP
E usar "log-drop" como alvo em suas regras. Mesmo assim esta solução
é "limitada" em relação a "-l" do ipchains
porque o iptables não inclui detalhes de qual chain bloqueou o
pacote/qual pacote foi bloqueado, assim é necessário a especificação da opção
--log-prefix para as mensagens se tornarem mais compreensíveis. Esta
limitação pode ser contornada utilizando um firewall feito em linguagem shell
script, desta forma você terá um controle maior sobre o seu programa usando
funções e integração com outros utilitários.
O alvo RETURN diz ao iptables interromper o processamento no chain
atual e retornar o processamento ao chain anterior. Ele é útil quando criamos
um chain que faz um determinado tratamento de pacotes, por exemplo bloquear
conexões vindas da internet para portas baixas, exceto para um endereço IP
específico. Como segue:
1-) iptables -t filter -A INPUT -i ppp0 -j internet
2-) iptables -t filter -j ACCEPT
3-) iptables -t filter -N internet
4-) iptables -t filter -A internet -s www.debian.org -p tcp --dport 80 -j RETURN
5-) iptables -t filter -A internet -p tcp --dport 21 -j DROP
6-) iptables -t filter -A internet -p tcp --dport 23 -j DROP
7-) iptables -t filter -A internet -p tcp --dport 25 -j DROP
8-) iptables -t filter -A internet -p tcp --dport 80 -j DROP
Quando um pacote com o endereço www.debian.org tentando acessar a
porta www (80) de nossa máquina através da internet (via interface ppp0), o
chain número 1 confere, então o processamento continua no chain número 4, o
chain número 4 confere então o processamento volta para a regra número 2, que
diz para aceitar o pacote.
Agora se um pacote vem com o endereço www.dominio.com.br tentando
acessar a porta www *80) de nossa máquina através da internet (via interface
ppp0), o chain número 1 confere, então o processamento continua no chain número
4, que não confere. O mesmo acontece com os chains 5, 6 e 7. O chain número 8
confere, então o acesso é bloqueado.
Como pode notou, o alvo RETURN facilita bastante a construção das regras do seu firewall, caso existam máquinas/redes que sejam exceções as suas regras. Se ela não existisse, seria necessário especificar diversas opções -s, -d, etc para poder garantir o acesso livre a determinadas máquinas.
As regras que você está trabalhosamente criando e testando manualmente enquanto
manipula o iptables podem ser salvas de 2 formas; uma delas é
escrevendo um shell script que tenha todos os comandos, um por linha. Isto é
recomendado quando tem um firewall grande e que exige uma boa padronização de
regras, bem como sua leitura, comentários. O script shell também permite o uso
de funções presente no interpretador de comando, portanto se você é uma pessoa
que gosta de interagir com as funções do shell e deixar as coisas mais
flexíveis, prefira esta opção.
A outra forma é usando as ferramentas iptables-save e
iptables-restore baseada na idéia do ipchains-save e
ipchains-restore. O iptables-save deve ser usado
sempre que modificar regras no firewall iptables da seguinte forma:
iptables-save >/dir/iptables-regras
Uma das vantagens do uso do iptables-save é ele também salvar os
contadores de chains, ou seja, a quantidade de pacotes que conferiram com a
regra. Isto também pode ser feito com algumas regras adicionais em seu shell
script, caso tenha interesse nesses contadores para estatísticas ou outros
tipos de relatórios.
Para restaurar as regras salvas, utilize o comando:
iptables-restore </dir/iptables-regras
A tabela nat serve para controlar a tradução dos endereços que
atravessam o código de roteamento da máquina Linux. Existem 3
chains na tabela nat: PREROUTING, OUTPUT e
POSTROUTING (veja O que são tabelas?, Seção
10.1.14 para maiores detalhes).
A tradução de endereços tem inúmeras utilidades, uma delas é o Masquerading,
onde máquinas de uma rede interna podem acessar a Internet através de uma
máquina Linux, redirecionamento de porta, proxy transparente, etc.
Esta seção abordará os tipos de NAT, exemplos de como criar rapidamente uma
conexão IP masquerading e entender como a tradução de endereços funciona no
iptables.
Se sua intenção é ligar sua rede a Internet existem duas opções:
O procedimento para criação de um novo chain nesta tabela é o mesmo descrito em Criando um novo chain - N, Seção 10.2.6 será necessário somente especificar a tabela nat (-t nat) para que o novo chain não seja criado na tabela padrão (-t filter).
iptables -t nat -N intra-inter
Que criará o chain chamado intra-inter na tabela nat. Para inserir regras neste chain será necessário especificar a opção "-t nat".
Você precisará de um kernel com suporte ao iptables (veja Habilitando o suporte ao
iptables no kernel, Seção 10.1.15 e ip_forward e então digitar
os dois comandos abaixo para habilitar o masquerading para todas as máquinas da
rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE
echo "1" >/proc/sys/net/ipv4/ip_forward
A configuração do servidor Linux está completa, agora os clientes
da rede precisarão ser configurados para usar o endereço IP do servidor
Linux como gateway. É recomendável instalar um servidor proxy e
DNS na máquina Linux para acelerar o desempenho das
requisições/resolução de nomes das máquinas em rede. A utilização de bits TOS
também pode trazer um grande aumento de velocidade para os diferentes serviços
da rede (veja Especificando o tipo de
serviço, Seção 10.5.1).
SNAT (source nat - nat no endereço de origem) consiste em modificar o endereço de origem das máquinas clientes antes dos pacotes serem enviados. A máquina roteadora é inteligente o bastante para lembrar dos pacotes modificados e reescrever os endereços assim que obter a resposta da máquina de destino, direcionando os pacotes ao destino correto. Toda operação de SNAT é feita no chain POSTROUTING.
É permitido especificar endereços de origem/destino, protocolos, portas de origem/destino, interface de entrada/saída (dependendo do chain), alvos, etc. É desnecessário especificar fragmentos na tabela nat, pois eles serão remontados antes de entrar no código de roteamento.
O SNAT é a solução quando você tem acesso a internet através de um único IP e
deseja fazer que sua rede tenha acesso a Internet através da máquina
Linux. Nenhuma máquina da Internet poderá ter acesso direto as
máquinas de sua rede interna via SNAT.
OBS: A observação acima não leva em conta o controle de acesso
externo configurado na máquina que estiver configurando o
iptables, uma configuração mau realizada pode expor sua máquina a
acessos externos indesejados e comprometer sua rede interna caso alguém consiga
acesso direto ao servidor.
É necessário especificar SNAT como alvo (-j SNAT) quando desejar que as
máquinas de sua rede interna tenha acesso a Internet através do IP fixo da
máquina Linux (para conexões intermitentes como PPP, veja Fazendo IP
Masquerading, Seção 10.4.3.1). O parâmetro --to IP:portas
deve ser usado após o alvo SNAT. Ele serve para especificar um endereço IP,
faixa de endereços e opcionalmente uma porta ou faixa de portas que será
substituída. Toda a operação de SNAT é realizada através do chain POSTROUTING:
# Modifica o endereço IP dos pacotes vindos da máquina 192.168.1.2 da rede interna
# que tem como destino a interface eth1 para 200.200.217.40 (que é o nosso endereço
# IP da interface ligada a Internet).
iptables -t nat -A POSTROUTING -s 192.168.1.2 -o eth1 -j SNAT --to 200.200.217.40
Os pacotes indo para a Internet (nossa conexão é feita via eth1, nossa
interface externa) vindo do endereço 192.168.1.2, são substituídos por
200.241.200.40 e enviados para fora. Quando a resposta a requisição é
retornada, a máquina com iptables recebe os pacotes e faz a
operação inversa, modificando o endereço 200.241.200.40 novamente para
192.168.1.2 e enviando a resposta a máquina de nossa rede interna. Após
definir suas regras de NAT, execute o comando echo "1"
>/proc/sys/net/ipv4/ip_forward para habilitar o suporte a
redirecionamento de pacotes no kernel.
Também é possível especificar faixas de endereços e portas que serão substituídas:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50
Modifica o endereço IP de origem de todas as máquinas da rede 192.168.1.0/24 que tem o destino a interface eth0 para 200.241.200.40 a 200.241.200.50. O endereço IP selecionado é escolhido de acordo com o último IP alocado.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50:1-1023
Idêntico ao anterior, mas faz somente substituições na faixa de portas de origem de 1 a 1023.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50 --to 200.200.217.70-200.200.217.73
Faz o mapeamento para a faixa de portas 200.200.217.40 a 200.200.217.50 e de 200.200.217.70 a 200.200.217.73.
OBS1: Se por algum motivo não for possível mapear uma conexão NAT, ela será derrubada.
OBS2: Tenha certeza que as respostas podem chegar até a máquina que fez o NAT. Se estiver fazendo SNAT em um endereço livre em sua rede (como 200.200.217.73).
OBS3: Como notou acima, o SNAT é usado quando temos uma conexão externa com um ou mais IP's fixos. O Masquerading é uma forma especial de SNAT usada para funcionar em conexões que recebem endereços IP aleatórios (PPP).
OBS4: Não se esqueça de habilitar o redirecionamento de pacotes após fazer suas regra de NAT com o comando: echo "1" >/proc/sys/net/ipv4/ip_forward, caso contrário o redirecionamento de pacotes não funcionará.
O IP Masquerading é um tipo especial de SNAT usado para conectar a sua rede interna a internet quando você recebe um IP dinâmico de seu provedor (como em conexões ppp). Todas as operações de IP Masquerading são realizadas no chain POSTROUTING. Se você tem um IP fixo, deve ler Fazendo SNAT, Seção 10.4.3.
Para fazer IP Masquerading de uma máquina com o IP 192.168.1.2 para ter acesso a Internet, use o comando:
iptables -t nat -A POSTROUTING -s 192.168.1.2/32 -o ppp0 -j MASQUERADE
A diferença é que o alvo é -j MASQUERADE. O comando acima faz IP Masquerading de todo o tráfego de 192.168.1.2 indo para a interface ppp0: O endereço IP dos pacotes vindos de 192.168.1.2 são substituídos pelo IP oferecido pelo seu provedor de acesso no momento da conexão, quando a resposta é retornada a operação inversa é realizada para garantir que a resposta chegue ao destino. Nenhuma máquina da internet poderá ter acesso direto a sua máquina conectava via Masquerading.
Para fazer o IP Masquerading de todas as máquinas da rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o ppp0 -j MASQUERADE
Após definir a regra para fazer Masquerading (SNAT), execute o comando echo "1" >/proc/sys/net/ipv4/ip_forward para habilitar o suporte a redirecionamento de pacotes no kernel.
DNAT (Destination nat - nat no endereço de destino) consiste em modificar o endereço de destino das máquinas clientes. O destination nat é muito usado para fazer redirecionamento de pacotes, proxyes transparentes e balanceamento de carga.
Toda operação de DNAT é feita no chain PREROUTING. As demais opções e observações do SNAT são também válidas para DNAT (com exceção que s
>--log-tcp-sequence
OBS1:Lembre-se que estas opções são referentes ao alvo LOG e devem ser usadas após este, caso contrário você terá um pouco de trabalho para analisar e consertar erros em suas regras do firewall.
OBS2:Caso esteja usando o firewall em um servidor público, recomendo associar um limite a regra de log, pois um ataque poderia causar um DoS enchendo sua partição. Leia mais sobre isso em Limitando o número de vezes que a regra confere, Seção 10.6.2.
# Complementando o exemplo anterior:
# Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface ppp0
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j LOG --log-prefix "FIREWALL: Derrubado "
# Para efetuar o bloqueio
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Retornará a seguinte mensagem no syslog:
Aug 25 10:08:01 debian kernel: FIREWALL: Derrubado IN=ppp0 OUT= MAC=10:20:30:40:50:60:70:80:90:00:00:00:08:00 SRC=200.200.200.1 DST=200.210.10.10 LEN=61 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=UDP SPT=1031 DPT=53 LEN=41
Agora você sabe o que aconteceu com o pacote (Rejeitado). A padronização de mensagens de firewall é também importante para a criação de scripts de análise que poderão fazer a análise dos logs do seu firewall (para criação de estatísticas que podem servir como base para a criação de novas regras de firewall ou eliminação de outras).
OBS: Se você sente falta da função "-l" do
ipchains que combina o alvo e log na mesma regra você pode criar
um alvo como o seguinte:
iptables -N log-drop
iptables -A log-drop -j LOG
iptables -A log-drop -j DROP
E usar "log-drop" como alvo em suas regras. Mesmo assim esta solução
é "limitada" em relação a "-l" do ipchains
porque o iptables não inclui detalhes de qual chain bloqueou o
pacote/qual pacote foi bloqueado, assim é necessário a especificação da opção
--log-prefix para as mensagens se tornarem mais compreensíveis. Esta
limitação pode ser contornada utilizando um firewall feito em linguagem shell
script, desta forma você terá um controle maior sobre o seu programa usando
funções e integração com outros utilitários.
O alvo RETURN diz ao iptables interromper o processamento no chain
atual e retornar o processamento ao chain anterior. Ele é útil quando criamos
um chain que faz um determinado tratamento de pacotes, por exemplo bloquear
conexões vindas da internet para portas baixas, exceto para um endereço IP
específico. Como segue:
1-) iptables -t filter -A INPUT -i ppp0 -j internet
2-) iptables -t filter -j ACCEPT
3-) iptables -t filter -N internet
4-) iptables -t filter -A internet -s www.debian.org -p tcp --dport 80 -j RETURN
5-) iptables -t filter -A internet -p tcp --dport 21 -j DROP
6-) iptables -t filter -A internet -p tcp --dport 23 -j DROP
7-) iptables -t filter -A internet -p tcp --dport 25 -j DROP
8-) iptables -t filter -A internet -p tcp --dport 80 -j DROP
Quando um pacote com o endereço www.debian.org tentando acessar a
porta www (80) de nossa máquina através da internet (via interface ppp0), o
chain número 1 confere, então o processamento continua no chain número 4, o
chain número 4 confere então o processamento volta para a regra número 2, que
diz para aceitar o pacote.
Agora se um pacote vem com o endereço www.dominio.com.br tentando
acessar a porta www *80) de nossa máquina através da internet (via interface
ppp0), o chain número 1 confere, então o processamento continua no chain número
4, que não confere. O mesmo acontece com os chains 5, 6 e 7. O chain número 8
confere, então o acesso é bloqueado.
Como pode notou, o alvo RETURN facilita bastante a construção das regras do seu firewall, caso existam máquinas/redes que sejam exceções as suas regras. Se ela não existisse, seria necessário especificar diversas opções -s, -d, etc para poder garantir o acesso livre a determinadas máquinas.
As regras que você está trabalhosamente criando e testando manualmente enquanto
manipula o iptables podem ser salvas de 2 formas; uma delas é
escrevendo um shell script que tenha todos os comandos, um por linha. Isto é
recomendado quando tem um firewall grande e que exige uma boa padronização de
regras, bem como sua leitura, comentários. O script shell também permite o uso
de funções presente no interpretador de comando, portanto se você é uma pessoa
que gosta de interagir com as funções do shell e deixar as coisas mais
flexíveis, prefira esta opção.
A outra forma é usando as ferramentas iptables-save e
iptables-restore baseada na idéia do ipchains-save e
ipchains-restore. O iptables-save deve ser usado
sempre que modificar regras no firewall iptables da seguinte forma:
iptables-save >/dir/iptables-regras
Uma das vantagens do uso do iptables-save é ele também salvar os
contadores de chains, ou seja, a quantidade de pacotes que conferiram com a
regra. Isto também pode ser feito com algumas regras adicionais em seu shell
script, caso tenha interesse nesses contadores para estatísticas ou outros
tipos de relatórios.
Para restaurar as regras salvas, utilize o comando:
iptables-restore </dir/iptables-regras
A tabela nat serve para controlar a tradução dos endereços que
atravessam o código de roteamento da máquina Linux. Existem 3
chains na tabela nat: PREROUTING, OUTPUT e
POSTROUTING (veja O que são tabelas?, Seção
10.1.14 para maiores detalhes).
A tradução de endereços tem inúmeras utilidades, uma delas é o Masquerading,
onde máquinas de uma rede interna podem acessar a Internet através de uma
máquina Linux, redirecionamento de porta, proxy transparente, etc.
Esta seção abordará os tipos de NAT, exemplos de como criar rapidamente uma
conexão IP masquerading e entender como a tradução de endereços funciona no
iptables.
Se sua intenção é ligar sua rede a Internet existem duas opções:
O procedimento para criação de um novo chain nesta tabela é o mesmo descrito em Criando um novo chain - N, Seção 10.2.6 será necessário somente especificar a tabela nat (-t nat) para que o novo chain não seja criado na tabela padrão (-t filter).
iptables -t nat -N intra-inter
Que criará o chain chamado intra-inter na tabela nat. Para inserir regras neste chain será necessário especificar a opção "-t nat".
Você precisará de um kernel com suporte ao iptables (veja Habilitando o suporte ao
iptables no kernel, Seção 10.1.15 e ip_forward e então digitar
os dois comandos abaixo para habilitar o masquerading para todas as máquinas da
rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE
echo "1" >/proc/sys/net/ipv4/ip_forward
A configuração do servidor Linux está completa, agora os clientes
da rede precisarão ser configurados para usar o endereço IP do servidor
Linux como gateway. É recomendável instalar um servidor proxy e
DNS na máquina Linux para acelerar o desempenho das
requisições/resolução de nomes das máquinas em rede. A utilização de bits TOS
também pode trazer um grande aumento de velocidade para os diferentes serviços
da rede (veja Especificando o tipo de
serviço, Seção 10.5.1).
SNAT (source nat - nat no endereço de origem) consiste em modificar o endereço de origem das máquinas clientes antes dos pacotes serem enviados. A máquina roteadora é inteligente o bastante para lembrar dos pacotes modificados e reescrever os endereços assim que obter a resposta da máquina de destino, direcionando os pacotes ao destino correto. Toda operação de SNAT é feita no chain POSTROUTING.
É permitido especificar endereços de origem/destino, protocolos, portas de origem/destino, interface de entrada/saída (dependendo do chain), alvos, etc. É desnecessário especificar fragmentos na tabela nat, pois eles serão remontados antes de entrar no código de roteamento.
O SNAT é a solução quando você tem acesso a internet através de um único IP e
deseja fazer que sua rede tenha acesso a Internet através da máquina
Linux. Nenhuma máquina da Internet poderá ter acesso direto as
máquinas de sua rede interna via SNAT.
OBS: A observação acima não leva em conta o controle de acesso
externo configurado na máquina que estiver configurando o
iptables, uma configuração mau realizada pode expor sua máquina a
acessos externos indesejados e comprometer sua rede interna caso alguém consiga
acesso direto ao servidor.
É necessário especificar SNAT como alvo (-j SNAT) quando desejar que as
máquinas de sua rede interna tenha acesso a Internet através do IP fixo da
máquina Linux (para conexões intermitentes como PPP, veja Fazendo IP
Masquerading, Seção 10.4.3.1). O parâmetro --to IP:portas
deve ser usado após o alvo SNAT. Ele serve para especificar um endereço IP,
faixa de endereços e opcionalmente uma porta ou faixa de portas que será
substituída. Toda a operação de SNAT é realizada através do chain POSTROUTING:
# Modifica o endereço IP dos pacotes vindos da máquina 192.168.1.2 da rede interna
# que tem como destino a interface eth1 para 200.200.217.40 (que é o nosso endereço
# IP da interface ligada a Internet).
iptables -t nat -A POSTROUTING -s 192.168.1.2 -o eth1 -j SNAT --to 200.200.217.40
Os pacotes indo para a Internet (nossa conexão é feita via eth1, nossa
interface externa) vindo do endereço 192.168.1.2, são substituídos por
200.241.200.40 e enviados para fora. Quando a resposta a requisição é
retornada, a máquina com iptables recebe os pacotes e faz a
operação inversa, modificando o endereço 200.241.200.40 novamente para
192.168.1.2 e enviando a resposta a máquina de nossa rede interna. Após
definir suas regras de NAT, execute o comando echo "1"
>/proc/sys/net/ipv4/ip_forward para habilitar o suporte a
redirecionamento de pacotes no kernel.
Também é possível especificar faixas de endereços e portas que serão substituídas:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50
Modifica o endereço IP de origem de todas as máquinas da rede 192.168.1.0/24 que tem o destino a interface eth0 para 200.241.200.40 a 200.241.200.50. O endereço IP selecionado é escolhido de acordo com o último IP alocado.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50:1-1023
Idêntico ao anterior, mas faz somente substituições na faixa de portas de origem de 1 a 1023.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50 --to 200.200.217.70-200.200.217.73
Faz o mapeamento para a faixa de portas 200.200.217.40 a 200.200.217.50 e de 200.200.217.70 a 200.200.217.73.
OBS1: Se por algum motivo não for possível mapear uma conexão NAT, ela será derrubada.
OBS2: Tenha certeza que as respostas podem chegar até a máquina que fez o NAT. Se estiver fazendo SNAT em um endereço livre em sua rede (como 200.200.217.73).
OBS3: Como notou acima, o SNAT é usado quando temos uma conexão externa com um ou mais IP's fixos. O Masquerading é uma forma especial de SNAT usada para funcionar em conexões que recebem endereços IP aleatórios (PPP).
OBS4: Não se esqueça de habilitar o redirecionamento de pacotes após fazer suas regra de NAT com o comando: echo "1" >/proc/sys/net/ipv4/ip_forward, caso contrário o redirecionamento de pacotes não funcionará.
O IP Masquerading é um tipo especial de SNAT usado para conectar a sua rede interna a internet quando você recebe um IP dinâmico de seu provedor (como em conexões ppp). Todas as operações de IP Masquerading são realizadas no chain POSTROUTING. Se você tem um IP fixo, deve ler Fazendo SNAT, Seção 10.4.3.
Para fazer IP Masquerading de uma máquina com o IP 192.168.1.2 para ter acesso a Internet, use o comando:
iptables -t nat -A POSTROUTING -s 192.168.1.2/32 -o ppp0 -j MASQUERADE
A diferença é que o alvo é -j MASQUERADE. O comando acima faz IP Masquerading de todo o tráfego de 192.168.1.2 indo para a interface ppp0: O endereço IP dos pacotes vindos de 192.168.1.2 são substituídos pelo IP oferecido pelo seu provedor de acesso no momento da conexão, quando a resposta é retornada a operação inversa é realizada para garantir que a resposta chegue ao destino. Nenhuma máquina da internet poderá ter acesso direto a sua máquina conectava via Masquerading.
Para fazer o IP Masquerading de todas as máquinas da rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o ppp0 -j MASQUERADE
Após definir a regra para fazer Masquerading (SNAT), execute o comando echo "1" >/proc/sys/net/ipv4/ip_forward para habilitar o suporte a redirecionamento de pacotes no kernel.
DNAT (Destination nat - nat no endereço de destino) consiste em modificar o endereço de destino das máquinas clientes. O destination nat é muito usado para fazer redirecionamento de pacotes, proxyes transparentes e balanceamento de carga.
Toda operação de DNAT é feita no chain PREROUTING. As demais opções e observações do SNAT são também válidas para DNAT (com exceção que s
>--log-tcp-sequence
OBS1:Lembre-se que estas opções são referentes ao alvo LOG e devem ser usadas após este, caso contrário você terá um pouco de trabalho para analisar e consertar erros em suas regras do firewall.
OBS2:Caso esteja usando o firewall em um servidor público, recomendo associar um limite a regra de log, pois um ataque poderia causar um DoS enchendo sua partição. Leia mais sobre isso em Limitando o número de vezes que a regra confere, Seção 10.6.2.
# Complementando o exemplo anterior:
# Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface ppp0
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j LOG --log-prefix "FIREWALL: Derrubado "
# Para efetuar o bloqueio
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Retornará a seguinte mensagem no syslog:
Aug 25 10:08:01 debian kernel: FIREWALL: Derrubado IN=ppp0 OUT= MAC=10:20:30:40:50:60:70:80:90:00:00:00:08:00 SRC=200.200.200.1 DST=200.210.10.10 LEN=61 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=UDP SPT=1031 DPT=53 LEN=41
Agora você sabe o que aconteceu com o pacote (Rejeitado). A padronização de mensagens de firewall é também importante para a criação de scripts de análise que poderão fazer a análise dos logs do seu firewall (para criação de estatísticas que podem servir como base para a criação de novas regras de firewall ou eliminação de outras).
OBS: Se você sente falta da função "-l" do
ipchains que combina o alvo e log na mesma regra você pode criar
um alvo como o seguinte:
iptables -N log-drop
iptables -A log-drop -j LOG
iptables -A log-drop -j DROP
E usar "log-drop" como alvo em suas regras. Mesmo assim esta solução
é "limitada" em relação a "-l" do ipchains
porque o iptables não inclui detalhes de qual chain bloqueou o
pacote/qual pacote foi bloqueado, assim é necessário a especificação da opção
--log-prefix para as mensagens se tornarem mais compreensíveis. Esta
limitação pode ser contornada utilizando um firewall feito em linguagem shell
script, desta forma você terá um controle maior sobre o seu programa usando
funções e integração com outros utilitários.
O alvo RETURN diz ao iptables interromper o processamento no chain
atual e retornar o processamento ao chain anterior. Ele é útil quando criamos
um chain que faz um determinado tratamento de pacotes, por exemplo bloquear
conexões vindas da internet para portas baixas, exceto para um endereço IP
específico. Como segue:
1-) iptables -t filter -A INPUT -i ppp0 -j internet
2-) iptables -t filter -j ACCEPT
3-) iptables -t filter -N internet
4-) iptables -t filter -A internet -s www.debian.org -p tcp --dport 80 -j RETURN
5-) iptables -t filter -A internet -p tcp --dport 21 -j DROP
6-) iptables -t filter -A internet -p tcp --dport 23 -j DROP
7-) iptables -t filter -A internet -p tcp --dport 25 -j DROP
8-) iptables -t filter -A internet -p tcp --dport 80 -j DROP
Quando um pacote com o endereço www.debian.org tentando acessar a
porta www (80) de nossa máquina através da internet (via interface ppp0), o
chain número 1 confere, então o processamento continua no chain número 4, o
chain número 4 confere então o processamento volta para a regra número 2, que
diz para aceitar o pacote.
Agora se um pacote vem com o endereço www.dominio.com.br tentando
acessar a porta www *80) de nossa máquina através da internet (via interface
ppp0), o chain número 1 confere, então o processamento continua no chain número
4, que não confere. O mesmo acontece com os chains 5, 6 e 7. O chain número 8
confere, então o acesso é bloqueado.
Como pode notou, o alvo RETURN facilita bastante a construção das regras do seu firewall, caso existam máquinas/redes que sejam exceções as suas regras. Se ela não existisse, seria necessário especificar diversas opções -s, -d, etc para poder garantir o acesso livre a determinadas máquinas.
As regras que você está trabalhosamente criando e testando manualmente enquanto
manipula o iptables podem ser salvas de 2 formas; uma delas é
escrevendo um shell script que tenha todos os comandos, um por linha. Isto é
recomendado quando tem um firewall grande e que exige uma boa padronização de
regras, bem como sua leitura, comentários. O script shell também permite o uso
de funções presente no interpretador de comando, portanto se você é uma pessoa
que gosta de interagir com as funções do shell e deixar as coisas mais
flexíveis, prefira esta opção.
A outra forma é usando as ferramentas iptables-save e
iptables-restore baseada na idéia do ipchains-save e
ipchains-restore. O iptables-save deve ser usado
sempre que modificar regras no firewall iptables da seguinte forma:
iptables-save >/dir/iptables-regras
Uma das vantagens do uso do iptables-save é ele também salvar os
contadores de chains, ou seja, a quantidade de pacotes que conferiram com a
regra. Isto também pode ser feito com algumas regras adicionais em seu shell
script, caso tenha interesse nesses contadores para estatísticas ou outros
tipos de relatórios.
Para restaurar as regras salvas, utilize o comando:
iptables-restore </dir/iptables-regras
A tabela nat serve para controlar a tradução dos endereços que
atravessam o código de roteamento da máquina Linux. Existem 3
chains na tabela nat: PREROUTING, OUTPUT e
POSTROUTING (veja O que são tabelas?, Seção
10.1.14 para maiores detalhes).
A tradução de endereços tem inúmeras utilidades, uma delas é o Masquerading,
onde máquinas de uma rede interna podem acessar a Internet através de uma
máquina Linux, redirecionamento de porta, proxy transparente, etc.
Esta seção abordará os tipos de NAT, exemplos de como criar rapidamente uma
conexão IP masquerading e entender como a tradução de endereços funciona no
iptables.
Se sua intenção é ligar sua rede a Internet existem duas opções:
O procedimento para criação de um novo chain nesta tabela é o mesmo descrito em Criando um novo chain - N, Seção 10.2.6 será necessário somente especificar a tabela nat (-t nat) para que o novo chain não seja criado na tabela padrão (-t filter).
iptables -t nat -N intra-inter
Que criará o chain chamado intra-inter na tabela nat. Para inserir regras neste chain será necessário especificar a opção "-t nat".
Você precisará de um kernel com suporte ao iptables (veja Habilitando o suporte ao
iptables no kernel, Seção 10.1.15 e ip_forward e então digitar
os dois comandos abaixo para habilitar o masquerading para todas as máquinas da
rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE
echo "1" >/proc/sys/net/ipv4/ip_forward
A configuração do servidor Linux está completa, agora os clientes
da rede precisarão ser configurados para usar o endereço IP do servidor
Linux como gateway. É recomendável instalar um servidor proxy e
DNS na máquina Linux para acelerar o desempenho das
requisições/resolução de nomes das máquinas em rede. A utilização de bits TOS
também pode trazer um grande aumento de velocidade para os diferentes serviços
da rede (veja Especificando o tipo de
serviço, Seção 10.5.1).
SNAT (source nat - nat no endereço de origem) consiste em modificar o endereço de origem das máquinas clientes antes dos pacotes serem enviados. A máquina roteadora é inteligente o bastante para lembrar dos pacotes modificados e reescrever os endereços assim que obter a resposta da máquina de destino, direcionando os pacotes ao destino correto. Toda operação de SNAT é feita no chain POSTROUTING.
É permitido especificar endereços de origem/destino, protocolos, portas de origem/destino, interface de entrada/saída (dependendo do chain), alvos, etc. É desnecessário especificar fragmentos na tabela nat, pois eles serão remontados antes de entrar no código de roteamento.
O SNAT é a solução quando você tem acesso a internet através de um único IP e
deseja fazer que sua rede tenha acesso a Internet através da máquina
Linux. Nenhuma máquina da Internet poderá ter acesso direto as
máquinas de sua rede interna via SNAT.
OBS: A observação acima não leva em conta o controle de acesso
externo configurado na máquina que estiver configurando o
iptables, uma configuração mau realizada pode expor sua máquina a
acessos externos indesejados e comprometer sua rede interna caso alguém consiga
acesso direto ao servidor.
É necessário especificar SNAT como alvo (-j SNAT) quando desejar que as
máquinas de sua rede interna tenha acesso a Internet através do IP fixo da
máquina Linux (para conexões intermitentes como PPP, veja Fazendo IP
Masquerading, Seção 10.4.3.1). O parâmetro --to IP:portas
deve ser usado após o alvo SNAT. Ele serve para especificar um endereço IP,
faixa de endereços e opcionalmente uma porta ou faixa de portas que será
substituída. Toda a operação de SNAT é realizada através do chain POSTROUTING:
# Modifica o endereço IP dos pacotes vindos da máquina 192.168.1.2 da rede interna
# que tem como destino a interface eth1 para 200.200.217.40 (que é o nosso endereço
# IP da interface ligada a Internet).
iptables -t nat -A POSTROUTING -s 192.168.1.2 -o eth1 -j SNAT --to 200.200.217.40
Os pacotes indo para a Internet (nossa conexão é feita via eth1, nossa
interface externa) vindo do endereço 192.168.1.2, são substituídos por
200.241.200.40 e enviados para fora. Quando a resposta a requisição é
retornada, a máquina com iptables recebe os pacotes e faz a
operação inversa, modificando o endereço 200.241.200.40 novamente para
192.168.1.2 e enviando a resposta a máquina de nossa rede interna. Após
definir suas regras de NAT, execute o comando echo "1"
>/proc/sys/net/ipv4/ip_forward para habilitar o suporte a
redirecionamento de pacotes no kernel.
Também é possível especificar faixas de endereços e portas que serão substituídas:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50
Modifica o endereço IP de origem de todas as máquinas da rede 192.168.1.0/24 que tem o destino a interface eth0 para 200.241.200.40 a 200.241.200.50. O endereço IP selecionado é escolhido de acordo com o último IP alocado.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50:1-1023
Idêntico ao anterior, mas faz somente substituições na faixa de portas de origem de 1 a 1023.
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth0 -j SNAT --to 200.200.217.40-200.200.217.50 --to 200.200.217.70-200.200.217.73
Faz o mapeamento para a faixa de portas 200.200.217.40 a 200.200.217.50 e de 200.200.217.70 a 200.200.217.73.
OBS1: Se por algum motivo não for possível mapear uma conexão NAT, ela será derrubada.
OBS2: Tenha certeza que as respostas podem chegar até a máquina que fez o NAT. Se estiver fazendo SNAT em um endereço livre em sua rede (como 200.200.217.73).
OBS3: Como notou acima, o SNAT é usado quando temos uma conexão externa com um ou mais IP's fixos. O Masquerading é uma forma especial de SNAT usada para funcionar em conexões que recebem endereços IP aleatórios (PPP).
OBS4: Não se esqueça de habilitar o redirecionamento de pacotes após fazer suas regra de NAT com o comando: echo "1" >/proc/sys/net/ipv4/ip_forward, caso contrário o redirecionamento de pacotes não funcionará.
O IP Masquerading é um tipo especial de SNAT usado para conectar a sua rede interna a internet quando você recebe um IP dinâmico de seu provedor (como em conexões ppp). Todas as operações de IP Masquerading são realizadas no chain POSTROUTING. Se você tem um IP fixo, deve ler Fazendo SNAT, Seção 10.4.3.
Para fazer IP Masquerading de uma máquina com o IP 192.168.1.2 para ter acesso a Internet, use o comando:
iptables -t nat -A POSTROUTING -s 192.168.1.2/32 -o ppp0 -j MASQUERADE
A diferença é que o alvo é -j MASQUERADE. O comando acima faz IP Masquerading de todo o tráfego de 192.168.1.2 indo para a interface ppp0: O endereço IP dos pacotes vindos de 192.168.1.2 são substituídos pelo IP oferecido pelo seu provedor de acesso no momento da conexão, quando a resposta é retornada a operação inversa é realizada para garantir que a resposta chegue ao destino. Nenhuma máquina da internet poderá ter acesso direto a sua máquina conectava via Masquerading.
Para fazer o IP Masquerading de todas as máquinas da rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o ppp0 -j MASQUERADE
Após definir a regra para fazer Masquerading (SNAT), execute o comando echo "1" >/proc/sys/net/ipv4/ip_forward para habilitar o suporte a redirecionamento de pacotes no kernel.
DNAT (Destination nat - nat no endereço de destino) consiste em modificar o endereço de destino das máquinas clientes. O destination nat é muito usado para fazer redirecionamento de pacotes, proxyes transparentes e balanceamento de carga.
Toda operação de DNAT é feita no chain PREROUTING. As demais opções e observações do SNAT são também válidas para DNAT (com exceção que s
>--log-tcp-sequence
OBS1:Lembre-se que estas opções são referentes ao alvo LOG e devem ser usadas após este, caso contrário você terá um pouco de trabalho para analisar e consertar erros em suas regras do firewall.
OBS2:Caso esteja usando o firewall em um servidor público, recomendo associar um limite a regra de log, pois um ataque poderia causar um DoS enchendo sua partição. Leia mais sobre isso em Limitando o número de vezes que a regra confere, Seção 10.6.2.
# Complementando o exemplo anterior:
# Para registrar o bloqueio de pacotes vindos de 200.200.200.1 pela interface ppp0
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j LOG --log-prefix "FIREWALL: Derrubado "
# Para efetuar o bloqueio
iptables -A INPUT -s 200.200.200.1 -i ppp+ -j REJECT
Retornará a seguinte mensagem no syslog:
Aug 25 10:08:01 debian kernel: FIREWALL: Derrubado IN=ppp0 OUT= MAC=10:20:30:40:50:60:70:80:90:00:00:00:08:00 SRC=200.200.200.1 DST=200.210.10.10 LEN=61 TOS=0x00 PREC=0x00 TTL=64 ID=0 DF PROTO=UDP SPT=1031 DPT=53 LEN=41
Agora você sabe o que aconteceu com o pacote (Rejeitado). A padronização de mensagens de firewall é também importante para a criação de scripts de análise que poderão fazer a análise dos logs do seu firewall (para criação de estatísticas que podem servir como base para a criação de novas regras de firewall ou eliminação de outras).
OBS: Se você sente falta da função "-l" do
ipchains que combina o alvo e log na mesma regra você pode criar
um alvo como o seguinte:
iptables -N log-drop
iptables -A log-drop -j LOG
iptables -A log-drop -j DROP
E usar "log-drop" como alvo em suas regras. Mesmo assim esta solução
é "limitada" em relação a "-l" do ipchains
porque o iptables não inclui detalhes de qual chain bloqueou o
pacote/qual pacote foi bloqueado, assim é necessário a especificação da opção
--log-prefix para as mensagens se tornarem mais compreensíveis. Esta
limitação pode ser contornada utilizando um firewall feito em linguagem shell
script, desta forma você terá um controle maior sobre o seu programa usando
funções e integração com outros utilitários.
O alvo RETURN diz ao iptables interromper o processamento no chain
atual e retornar o processamento ao chain anterior. Ele é útil quando criamos
um chain que faz um determinado tratamento de pacotes, por exemplo bloquear
conexões vindas da internet para portas baixas, exceto para um endereço IP
específico. Como segue:
1-) iptables -t filter -A INPUT -i ppp0 -j internet
2-) iptables -t filter -j ACCEPT
3-) iptables -t filter -N internet
4-) iptables -t filter -A internet -s www.debian.org -p tcp --dport 80 -j RETURN
5-) iptables -t filter -A internet -p tcp --dport 21 -j DROP
6-) iptables -t filter -A internet -p tcp --dport 23 -j DROP
7-) iptables -t filter -A internet -p tcp --dport 25 -j DROP
8-) iptables -t filter -A internet -p tcp --dport 80 -j DROP
Quando um pacote com o endereço www.debian.org tentando acessar a
porta www (80) de nossa máquina através da internet (via interface ppp0), o
chain número 1 confere, então o processamento continua no chain número 4, o
chain número 4 confere então o processamento volta para a regra número 2, que
diz para aceitar o pacote.
Agora se um pacote vem com o endereço www.dominio.com.br tentando
acessar a porta www *80) de nossa máquina através da internet (via interface
ppp0), o chain número 1 confere, então o processamento continua no chain número
4, que não confere. O mesmo acontece com os chains 5, 6 e 7. O chain número 8
confere, então o acesso é bloqueado.
Como pode notou, o alvo RETURN facilita bastante a construção das regras do seu firewall, caso existam máquinas/redes que sejam exceções as suas regras. Se ela não existisse, seria necessário especificar diversas opções -s, -d, etc para poder garantir o acesso livre a determinadas máquinas.
As regras que você está trabalhosamente criando e testando manualmente enquanto
manipula o iptables podem ser salvas de 2 formas; uma delas é
escrevendo um shell script que tenha todos os comandos, um por linha. Isto é
recomendado quando tem um firewall grande e que exige uma boa padronização de
regras, bem como sua leitura, comentários. O script shell também permite o uso
de funções presente no interpretador de comando, portanto se você é uma pessoa
que gosta de interagir com as funções do shell e deixar as coisas mais
flexíveis, prefira esta opção.
A outra forma é usando as ferramentas iptables-save e
iptables-restore baseada na idéia do ipchains-save e
ipchains-restore. O iptables-save deve ser usado
sempre que modificar regras no firewall iptables da seguinte forma:
iptables-save >/dir/iptables-regras
Uma das vantagens do uso do iptables-save é ele também salvar os
contadores de chains, ou seja, a quantidade de pacotes que conferiram com a
regra. Isto também pode ser feito com algumas regras adicionais em seu shell
script, caso tenha interesse nesses contadores para estatísticas ou outros
tipos de relatórios.
Para restaurar as regras salvas, utilize o comando:
iptables-restore </dir/iptables-regras
A tabela nat serve para controlar a tradução dos endereços que
atravessam o código de roteamento da máquina Linux. Existem 3
chains na tabela nat: PREROUTING, OUTPUT e
POSTROUTING (veja O que são tabelas?, Seção
10.1.14 para maiores detalhes).
A tradução de endereços tem inúmeras utilidades, uma delas é o Masquerading,
onde máquinas de uma rede interna podem acessar a Internet através de uma
máquina Linux, redirecionamento de porta, proxy transparente, etc.
Esta seção abordará os tipos de NAT, exemplos de como criar rapidamente uma
conexão IP masquerading e entender como a tradução de endereços funciona no
iptables.
Se sua intenção é ligar sua rede a Internet existem duas opções:
O procedimento para criação de um novo chain nesta tabela é o mesmo descrito em Criando um novo chain - N, Seção 10.2.6 será necessário somente especificar a tabela nat (-t nat) para que o novo chain não seja criado na tabela padrão (-t filter).
iptables -t nat -N intra-inter
Que criará o chain chamado intra-inter na tabela nat. Para inserir regras neste chain será necessário especificar a opção "-t nat".
Você precisará de um kernel com suporte ao iptables (veja Habilitando o suporte ao
iptables no kernel, Seção 10.1.15 e ip_forward e então digitar
os dois comandos abaixo para habilitar o masquerading para todas as máquinas da
rede 192.168.1.*:
iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -j MASQUERADE
echo "1" >/proc/sys/net/ipv4/ip_forward
A configuração do servidor Linux está completa, agora os clientes
da rede precisarão ser configurados para usar o endereço IP do servidor
Linux como gateway. É recomendável instalar um servidor proxy e
DNS na máquina Linux para acelerar o desempenho das
requisições/resolução de nomes das máquinas em rede. A utilização de bits TOS
também pode trazer um grande aumento de velocidade para os diferentes serviços
da rede (veja Especificando o tipo de
serviço, Seção 10.5.1).
SNAT (source nat - nat no endereço de origem) consiste em modificar o endereço de origem das máquinas clientes antes dos pacotes serem enviados. A máquina roteadora é inteligente o bastante para lembrar dos pacotes modificados e reescrever os endereços assim que obter a resposta da máquina de destino, direcionando os pacotes ao destino correto. Toda operação de SNAT é feita no chain POSTROUTING.
É permitido especificar endereços de origem/destino, protocolos, portas de origem/destino, interface de entrada/saída (dependendo do chain), alvos, etc. É desnecessário especificar fragmentos na tabela nat, pois eles serão remontados antes de entrar no código de roteamento.
O SNAT é a solução quando você tem acesso a internet através de um único IP e
deseja fazer que sua rede tenha acesso a Internet através da máquina
Linux. Nenhuma máquina da Internet poderá ter acesso direto as
máquinas de sua rede interna via SNAT.
OBS: A observação acima não leva em conta o controle de acesso
externo configurado na máquina que estiver configurando o
iptables, uma configuração mau realizada pode expor sua máquina a
acessos externos indesejados e comprometer sua rede interna caso alguém consiga
acesso direto ao servidor.
É necessário especificar SNAT como alvo (-j SNAT) quando desejar que as
máquinas de sua rede interna tenha acesso a Internet através do IP fixo da
máquina Linux (para conexões intermitentes como PPP, veja Fazendo IP
Masquerading, Seção 10.4.3.1). O parâmetro --to IP:portas
deve ser usado após o alvo SNAT. Ele serve para especificar um endereço IP,
faixa de endereços e opcionalmente uma porta ou faixa de portas que será
substituída. Toda a operação de SNAT é realizada através do chain POSTROUTING:
# Modifica o endereço IP dos pacotes vindos da máquina 192.168.1.2 da rede interna
# que tem como destino a interface eth1 para 200.200.217.40 (que é o nosso endereço
# IP da interface ligada a Internet).
iptables -t nat -A POSTROUTING -s 192.168.1.2 -o eth1 -j SNAT --to 200.200.217.40
Os pacotes indo para a Internet (nossa conexão é feita via eth1, nossa
interface externa) vindo do endereço 192.168.1.2, são substituídos por
200.241.200.40 e enviados para fora. Quando a resposta a requisição é
retornada, a máquina com iptables recebe os pacotes e faz a
operação inversa, modificando o endereço 200.241.200.40 novamente para
192.168.1.2 e enviando a resposta a máquina de nossa rede interna. Após
definir suas regras de NAT, execute o comando echo "1"
>/proc/sys/net/ipv4/ip_forward para habilitar o suporte a
redirecionamento de pacotes no kernel.
Também é possível especificar faixas de en