Iptables Básico - Debian/RedHat

Resumo

Você pode encontrar uma versão mais fácil de ler aqui: 5dollarwhitebox.org

Muitas pessoas ficam assustadas com o IPTables e acham difícil de entender. No entanto, uma vez que você compreende, o básico é fácil. Este documento servirá como um guia básico sobre como usar iptables. Eu não sou de forma alguma um guru de iptables, mas tenho usado assim por um bom tempo. Se eu cometi algum erro, por favor, não hesite em me enviar um e-mail.

O Sistema

Debian Sarge 3.1 Kernel vanilla 2.6.12.4 do mirrors.kernel.org Utilitário de administração iptables versão 1.2.11-10

Preparação

Este How-To é realizado em uma máquina Debian Sarge 3.1, embora os comandos e a sintaxe devam funcionar para qualquer distribuição linux. Antes de você poder configurar o iptables, primeiro deve garantir que ele foi compilado no kernel e que você tem os utilitários de userland apropriados instalados.

Você deve ter um arquivo de configuração de quando o kernel foi compilado. Grepando-o por “CONFIG_IP_NF” deve produzir ‘=y’ ou ‘=m’ para a maioria das linhas/opções. Aqui você vê que “CONFIG_IP_NF_IPTABLES” foi compilado como um módulo do kernel.

# cat /boot/config-2.4.30 | grep -i “CONFIG_IP_NF”

CONFIG_IP_NF_CONNTRACK=m
CONFIG_IP_NF_FTP=m
CONFIG_IP_NF_AMANDA=m
CONFIG_IP_NF_TFTP=m
CONFIG_IP_NF_IRC=m
CONFIG_IP_NF_QUEUE=m
CONFIG_IP_NF_IPTABLES=m
CONFIG_IP_NF_MATCH_LIMIT=m
CONFIG_IP_NF_MATCH_MAC=m
CONFIG_IP_NF_MATCH_PKTTYPE=m
CONFIG_IP_NF_MATCH_MARK=m
CONFIG_IP_NF_MATCH_MULTIPORT=m
CONFIG_IP_NF_MATCH_TOS=m
CONFIG_IP_NF_MATCH_RECENT=m
CONFIG_IP_NF_MATCH_ECN=m
CONFIG_IP_NF_MATCH_DSCP=m
CONFIG_IP_NF_MATCH_AH_ESP=m
CONFIG_IP_NF_MATCH_LENGTH=m
CONFIG_IP_NF_MATCH_TTL=m
CONFIG_IP_NF_MATCH_TCPMSS=m
CONFIG_IP_NF_MATCH_HELPER=m
CONFIG_IP_NF_MATCH_STATE=m
CONFIG_IP_NF_MATCH_CONNTRACK=m
CONFIG_IP_NF_MATCH_UNCLEAN=m
CONFIG_IP_NF_MATCH_OWNER=m
CONFIG_IP_NF_FILTER=m
CONFIG_IP_NF_TARGET_REJECT=m
CONFIG_IP_NF_TARGET_MIRROR=m
CONFIG_IP_NF_NAT=m
CONFIG_IP_NF_NAT_NEEDED=y
CONFIG_IP_NF_TARGET_MASQUERADE=m
CONFIG_IP_NF_TARGET_REDIRECT=m
CONFIG_IP_NF_NAT_AMANDA=m
CONFIG_IP_NF_NAT_SNMP_BASIC=m
CONFIG_IP_NF_NAT_IRC=m
CONFIG_IP_NF_NAT_FTP=m
CONFIG_IP_NF_NAT_TFTP=m
CONFIG_IP_NF_MANGLE=m
CONFIG_IP_NF_TARGET_TOS=m
CONFIG_IP_NF_TARGET_ECN=m
CONFIG_IP_NF_TARGET_DSCP=m
CONFIG_IP_NF_TARGET_MARK=m
CONFIG_IP_NF_TARGET_LOG=m
CONFIG_IP_NF_TARGET_ULOG=m
CONFIG_IP_NF_TARGET_TCPMSS=m
CONFIG_IP_NF_ARPTABLES=m
CONFIG_IP_NF_ARPFILTER=m
CONFIG_IP_NF_ARP_MANGLE=m
CONFIG_IP_NF_COMPAT_IPCHAINS=m
CONFIG_IP_NF_NAT_NEEDED=y
CONFIG_IP_NF_COMPAT_IPFWADM=m
CONFIG_IP_NF_NAT_NEEDED=y*

Isso não é tão necessário, já que você descobrirá rapidamente se o iptables funciona ou não assim que tentarmos adicionar algumas regras.

Você pode verificar se você tem o utilitário de administração iptables instalado executando:

# dpkg -l iptables

iptables 1.2.11-10 Linux kernel 2.4+ administração de iptables para*

…ou para distribuições baseadas em rpm:

# rpm -qa | grep iptables

iptables-xxxxx

…ou você pode apenas ver se o binário está lá!

# which iptables

/sbin/iptables

Se o utilitário estiver ausente, você pode instalá-lo assim:

APT

# apt-get update && apt-get install iptables

RPM

# rpm -Uvh iptables-xxxx.rpm

Preparando ################################# [100%]

Os Arquivos Principais

Debian

/etc/init.d/iptables – Script INIT para iniciar|parar|reiniciar o serviço (e salvar conjuntos de regras). Este arquivo não é mais padrão a partir do Sarge, mas você ainda pode obtê-lo (eu vou te mostrar).
/var/lib/iptables – O lar do Debian para os arquivos de contagem ‘ativos’ e ‘inativos’ do iptables-save (ou seja, os conjuntos de regras salvos). No RedHat, você encontraria as regras salvas em ‘/etc/sysconfig/iptables’.
/var/lib/iptables/active – Contadores Ativos (mais sobre isso depois)
/var/lib/iptables/inactive – Contadores Inativos
/sbin/iptables – O utilitário/binário de administração.

RedHat

/etc/init.d/iptables – Script INIT para iniciar|parar|reiniciar o serviço (e salvar conjuntos de regras).
/etc/sysconfig/iptables – O arquivo do RedHat para os arquivos de contagem do iptables-save (ou seja, os conjuntos de regras salvos).
/sbin/iptables – O utilitário/binário de administração.

Um Pouco Sobre IPTables

Para ver quais conjuntos de regras temos atualmente em vigor, execute:

# iptables –list

*Chain INPUT (policy ACCEPT)
target prot opt source destination

Chain FORWARD (policy ACCEPT)
target prot opt source destination

Chain OUTPUT (policy ACCEPT)
target prot opt source destination*

Isso é o que você verá quando não há conjuntos de regras em vigor. Olhando para isso, vemos 3 ‘Chains’.

INPUT - Contém regras para o tráfego direcionado a este servidor.
FORWARD – Contém regras para o tráfego que será encaminhado para um IP atrás deste servidor (ou seja, se esta máquina serve como um firewall para outros servidores).
OUTPUT – Contém regras para o tráfego que está saindo deste servidor para a internet.

Principalmente, lidaremos com o tráfego direcionado a este servidor e emitiremos regras para a Chain INPUT. Quando o tráfego passa pelo kernel, ele determina um “TARGET” com base em se o pacote corresponde a uma regra ou não. Os alvos gerais são:

ACCEPT – O tráfego é aceito para entrega.
REJECT – O tráfego é rejeitado, enviando um pacote de volta para o host de origem.
DROP - O tráfego é descartado. Nada é enviado de volta para o host de origem.

Configurando Conjuntos de Regras

Então, vamos ao que interessa. É importante notar que a ordem em que as regras são adicionadas é muito importante. Por exemplo, se sua primeira regra é negar tudo… então, não importa o que você permita especificamente, será negado.

Além disso, é importante notar que nada do que você faz é salvo no disco até que você execute ‘iptables-save’ (ou use o script init para salvar). Todos os contadores/conjuntos de regras estão na memória. Uma vez que o servidor reinicia, ou você executa ‘iptables –flush’, tudo que você trabalhou se foi. Pessoalmente, trabalho a partir de um arquivo de script bash chamado ‘iptables-rules.sh’, que me permite manter tudo organizado e comentado. Se eu cometer um erro, não me preocupo se eu só quero limpar todas as regras, eu apenas volto para o meu script bash e começo a editar novamente, salvo e executo o script (isso, no entanto, não será executado na inicialização… isso será abordado na próxima seção).

É muito importante que, se você estiver trabalhando neste servidor remotamente através do ssh, que você faça todo o esforço para não se trancar para fora. Portanto, nossa primeira regra será garantir que, não importa o que aconteça, eu ainda possa acessar o ssh do meu endereço IP.

# iptables -A INPUT -s 192.168.1.10 -d 10.1.15.1 -p tcp –dport 22 -j ACCEPT

Vamos analisar isso:

-A => Diz ao iptables para ‘anexar’ esta regra à Chain INPUT
-s => Endereço de Origem. Esta regra se refere apenas ao tráfego vindo DE este IP. Substitua pelo endereço IP de onde você está fazendo SSH.
-d => Endereço de Destino. Esta regra se refere apenas ao tráfego indo PARA este IP. Substitua pelo IP deste servidor.
-p => Protocolo. Especificando tráfego que é TCP.
–dport => Porta de Destino. Especificando tráfego que é para a Porta TCP 22 (SSH)
-j => Jump. Se tudo nesta regra corresponder, então ‘salte’ para ACCEPT

Em seguida, queremos usar algumas regras padrão para tráfego de rede geral. Isso vai um pouco além do básico, no entanto, o iptables pode determinar o ‘estado’ em que um pacote está. Isso tem a ver com a comunicação TCP padrão. Por exemplo, o handshake de 3 vias entre dois hosts ao transmitir dados.

NEW => Servidor1 conecta-se ao Servidor2 emitindo um pacote SYN (Synchronize).
RELATED => Servidor 2 recebe o pacote SYN e então responde com um pacote SYN-ACK (Synchronize Acknowledgment).
ESTABLISHED => Servidor 1 recebe o pacote SYN-ACK e então responde com o pacote ACK final (Acknowledgment).

Após este handshake de 3 vias ser concluído, o tráfego agora está ESTABELECIDO. Para esse tipo de comunicação TCP, algo semelhante a estas três regras é necessário:

# iptables -A INPUT -m state –state RELATED,ESTABLISHED -j ACCEPT

Obviamente, a última regra permite qualquer tráfego que saia do servidor.

Agora que temos o básico configurado, vamos ver o que o iptables lista para nossos conjuntos de regras:

# iptables –list

*Chain INPUT (policy ACCEPT)
target prot opt source destination

ACCEPT tcp – 192.168.1.10 10.1.15.1 tcp dpt:ssh
ACCEPT all – anywhere anywhere state RELATED,ESTABLISHED

Chain FORWARD (policy ACCEPT)
target prot opt source destination
ACCEPT all – anywhere anywhere state RELATED,ESTABLISHED

Chain OUTPUT (policy ACCEPT)
target prot opt source destination
ACCEPT all – anywhere anywhere state NEW,RELATED,ESTABLISHED*

A partir daqui, você pode adicionar quaisquer regras que desejar. Se você estiver executando um servidor web básico, provavelmente precisará de algo semelhante a:

REJEIÇÕES INDIVIDUAIS PRIMEIRO:

MAUS CARACTERES (Bloquear Endereço IP de Origem):

# iptables -A INPUT -s 172.34.5.8 -j DROP

NÃO SPAMMERS (note o uso de FQDN):

# iptables -A INPUT -s mail.spammer.org -d 10.1.15.1 -p tcp –dport 25 -j REJECT

ENTÃO ABRA: ———————————————————————–
MYSQL (Permitir Acesso Remoto a um IP Particular):

SSH:

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 22 -j ACCEPT

Enviar mail/Postfix:

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 25 -j ACCEPT

FTP: (Note como você pode especificar um intervalo de portas 20-21)

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 20:21 -j ACCEPT

Portas FTP Passivas Talvez: (Novamente, especificando portas 50000 a 50050 em uma regra)

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 50000:50050 -j ACCEPT

HTTP/Apache

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 80 -j ACCEPT

SSL/Apache

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 443 -j ACCEPT

IMAP

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 143 -j ACCEPT

IMAPS

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 993 -j ACCEPT

POP3

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 110 -j ACCEPT

POP3S

# iptables -A INPUT -d 10.1.15.1 -p tcp –dport 995 -j ACCEPT

Qualquer Tráfego do Localhost:

# iptables -A INPUT -d 10.1.15.1 -s 127.0.0.1 -j ACCEPT

ICMP/Ping:

# iptables -A INPUT -d 10.1.15.1 -p icmp -j ACCEPT

REJEIÇÕES GLOBAIS POR ÚLTIMO:

Rejeitar tudo o mais para aquele IP:

# iptables -A INPUT -d 10.1.15.1 -j REJECT

Ou, rejeitar tudo o mais que venha para qualquer IP:

# iptables -A INPUT -j REJECT

Note que fazemos as linhas de REJEIÇÃO global por último! Estas devem ser as últimas.

Salvando Conjuntos de Regras

Com os scripts init, salvar conjuntos de regras é bastante fácil. Uma vez que você esteja satisfeito com sua configuração, basta fazer uma das seguintes:

O Jeito Debian

O script init do estilo antigo não está mais no Sarge por padrão, mas ainda está disponível para uso legado. Acredito que a nova maneira é usar ‘/etc/network/if-up.d’ e ‘/etc/network/if-down.d’ para scripts de iptables (mas eu não gosto disso).

Você pode pegar o script INIT legado desta maneira:

# gunzip /usr/share/doc/iptables/examples/oldinitdscript.gz -c > /etc/init.d/iptables

Agora que você tem o script no lugar, você pode fazer o necessário.

Regras Ativas

As regras Ativas são aquelas carregadas ao iniciar o iptables:

# /etc/init.d/iptables save active

Salvando conjunto de regras iptables: salvar “ativo” com contadores.

Isso salva suas regras em /var/lib/iptables/active

Regras Inativas

Você também pode configurar um segundo conjunto de regras para quando você parar o iptables chamado ‘inativo’. O iptables não “para” realmente, ele apenas limpa os conjuntos de regras que estão em vigor e então carrega as regras ‘inativas’.

# /etc/init.d/iptables stop

Carregando conjunto de regras iptables: carregar “inativo”

Portanto, você pode definir suas regras ‘inativas’ e então salvá-las com:

# /etc/init.d/iptables save inactive

Salvando conjunto de regras iptables: salvar “inativo” com contadores.

O Jeito RedHat

O script INIT do RedHat é muito semelhante. Você pode usá-lo para iniciar e parar o iptables, bem como salvar conjuntos de regras.

Para salvar suas regras ativas, execute o seguinte:

# /etc/init.d/iptables save

Isso salvará suas regras em ‘/etc/sysconfig/iptables’.

Quando você iniciar o iptables, as regras são lidas de ‘/etc/sysconfig/iptables’:

# /etc/init.d/iptables start

Iniciando iptables [OK]

E quando você parar o iptables, todas as regras são limpas:

# /etc/init.d/iptables stop

Parando iptables [OK]

Salvar e Restaurar Manualmente

Você também pode usar manualmente os utilitários iptables-save e iptables-restore assim:

Salvar as regras em um arquivo

# iptables-save > /root/iptables-save.out

Restaurar as regras

# iptables-restore -c /root/iptables-save.out

O -c diz ao iptables-restore que este arquivo foi criado usando iptables-save, que gera as regras como “contadores”.

Conclusão

E aí está, iptables em seu nível mais básico. Os usos do iptables são numerosos demais para realmente começar a fazer um howto sobre eles. No entanto, para segurança básica e compreensão do IPTables, espero que isso possa ter te ajudado. Se houver algo que eu possa adicionar, fique à vontade para me enviar um e-mail.

—
BJ Dierkes, RHCE4-LPIC1
wdierkes [at] 5dollarwhitebox [dot] org
Texas, EUA

Recursos

Netfilter/Iptables: http://www.netfilter.org/
Protocolo de Controle de Transmissão: http://www.rhyshaden.com/tcp.htm