Aula sobre Iptables

Caros leitores. Gostaria de compartilhar com vocês algum conteúdo sobre iptables, que estou montando aqui:
http://www.fix.inf.br/wiki/doku.php?id=iptables
É um pequeno tutorial/aula sobre iptables. Espero que seja útil. Sugiro que leiam o tutorial dentro da wiki acima, é bem melhor de visualizar e o conteúdo será atualizado. Ainda não encontrei uma boa forma de mostrar direto o conteúdo da página da wiki no wordpress. Caso alguém conheça, por favor me avise.

Table of Contents

Iptables – O que é:
Primeiro comando: Listar regras em uso.
Limpando o iptables
Comandos básicos
Tabelas
Chains
Sintaxe
Primeira Regra
Liberação de portas e protocolos
Liberar SSH
Liberar Porta 80
Bloqueando o restante
Liberando Loopback
Liberando de um ip específico
Deletando regras
Outras possibilidades
Salvando as regras
Referências

Iptables – O que é:

O Iptables é o firewall mais utilizado em todas as distribuições de linux.Outros sistemas utilizam outras implementações de firewall. Existem muitas informações na internet e a documentação do iptables/netfilter é muito grande, sendo ele uma das mais complexas (senão a mais) ferramentasde firewall. De um modo simples, o iptables pode ser utilizado com poucas regras para criar um bom e efetivo firewall para sua rede.

O sistema todo é composto de duas partes. O módulo do kernel netfilter e o aplicativo que controla as regras, chamado iptables. Quem realmente faz a função é o netfilter, mas é comum encontrar referências ao firewall como iptables, já que é o comando usado. Quando um pacote de rede passa pelo netfilter, ele compara as informações com as regras inseridas pelo iptables. Se alguma regra bater com o pacote, ele faz a ação indicada na regra (aceitar, negar, etc) .
Primeiro comando: Listar regras em uso.

Para ir se familiarizando com o iptables, utiliza o comando

iptables -L

Esta opção lista as regras atualmente em uso.

Caso não exista nenhuma regra, o que você deve ver é algo como isso:

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

Caso alguma regra apareça é porque:
1 – Você criou regras anteriores
2 – Sua distribuição de linux já vem com regras como padrão.
Limpando o iptables

No caso do debian/ubuntu, as regras do iptables vem vazias. No caso das distribuições baseadas em redhat como centos e scientific linux, o arquivo /etc/sysconfig/iptables já vem com algumas regras regras. Neste caso, precisamos começar desabilitando todas elas com os comandos:

iptables -F
iptables -X
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT

O comando iptables -F limpa todas as regras do iptables e a opção -X limpa todas as chains personalizadas. Utilizamos o mesmo comando para todas as outras tabelas (aqui, nat e mangle). Depois colocamos as políticas padrão para as chains INPUT, FORWARD e OUTPUT com a opção -P

Estes comandos limpam todas as regras do iptables, em sua tabela filter, mangle e nat. Cuidado, este comando pode eliminar regras necessárias para compartilhamento de internet e outros. Verifique suas regras e faça os testes em uma instalação nova.
Comandos básicos

O iptables aceita, dentre vários, estes comandos mais utilizados (direto do help)

-A – Append this rule to a rule chain. Valid chains for what we’re doing are INPUT, FORWARD and OUTPUT, but we mostly deal with INPUT in this tutorial, which affects only incoming traffic.\\
-L – List the current filter rules.\\
-m conntrack – Allow filter rules to match based on connection state. Permits the use of the –ctstate option.\\
–ctstate – Define the list of states for the rule to match on. Valid states are:\\
NEW – The connection has not yet been seen.\\
RELATED – The connection is new, but is related to another connection already permitted.\\
ESTABLISHED – The connection is already established.\\
INVALID – The traffic couldn’t be identified for some reason.\\
-m limit – Require the rule to match only a limited number of times. Allows the use of the –limit option. Useful for limiting logging rules.\\
–limit – The maximum matching rate, given as a number followed by “/second”, “/minute”, “/hour”, or “/day” depending on how often you want the rule to match. If this option is not used and -m limit is used, the default is “3/hour”.\\
-p – The connection protocol used.\\
–dport – The destination port(s) required for this rule. A single port may be given, or a range may be given as start:end, which will match all ports from start to end, inclusive.\\
-j – Jump to the specified target. By default, iptables allows four targets:\\
ACCEPT – Accept the packet and stop processing rules in this chain.\\
REJECT – Reject the packet and notify the sender that we did so, and stop processing rules in this chain.\\
DROP – Silently ignore the packet, and stop processing rules in this chain.\\
LOG – Log the packet, and continue processing more rules in this chain. Allows the use of the –log-prefix and –log-level options.\\
–log-prefix – When logging, put this text before the log message. Use double quotes around the text to use.\\
–log-level – Log using the specified syslog level. 7 is a good choice unless you specifically need something else.\\
-i – Only match if the packet is coming in on the specified interface.\\
-I – Inserts a rule. Takes two options, the chain to insert the rule into, and the rule number it should be.\\
-I INPUT 5 would insert the rule into the INPUT chain and make it the 5th rule in the list.\\
-v – Display more information in the output. Useful for if you have rules that look similar without using -v.\\
-s –source – address[/mask] source specification\\
-d –destination – address[/mask] destination specification\\
-o –out-interface – output name[+] network interface name ([+] for wildcard)\\

Tabelas

o Iptables trabalha com o conceito de tabelas, cada uma com funções diferentes, dependendo do que queremos fazer com o pacote de dados. As três mais comuns são:

FILTER
NAT
MANGLE
Lembrando que quanto não especificamos qual tabela do iptables iremos usar (com o -t) ele assume por padrão que é a filter. Quando limpas as regras anteriormente, tivemos que executar os comandos para várias tabelas, pois por padrão, ele só limpará a tabela FILTER Para que o iptables faça o papel de firewall, a tabela utilizada é a filter, que cuida justamente da filtragem dos pacotes recebidos.
Chains

Cada tabela possue algumas chains, que são associadas a algum tipo de tráfego de dados. Dentro desta tabela FILTER temos 3 chains principais:

INPUT
FORWARD
OUTPUT

Essas chains tratam justamente da entrada, encaminhamento e saida. Quando precisarmos lidar com um pacote, nós iremos verificar a origem e/ou destino dele e falar ao iptables para aplicar a função que queremos (ACCEPT, REJECT, DROP), aceitar ou negar o pacote.
Sintaxe

A sintaxe do iptables

# iptables -t TABLE -A CADEIA REGRAS -j ALVO Onde:

TABLE identifica a tabela (lembrando que se não for usada nenhuma, a FILTER é a padrão. O -t pode ser abstraído nesse caso) CADEIA identifica a cadeia (CHAIN usada, INPUT, OUTPUT) REGRAS compõe as regras de seleção de pacotes no qual o ALVO deve atuar (Se é protocolo TCP ou UDP ou todos, se é uma porta específica ou um grupo de portas, etc) ALVO ação a ser executada (Permitir, bloquear, recusar, registrar, etc)

Como você já deve ter visto também, o iptables assim como o Linux em geral, é case sensitive. Então, o que estiver em maiúsculo precisa estar em maiúsculo e não pode ser colocado em minúsculo.
Primeira Regra

Tendo isso em vista, a primeira coisa que preciamos é liberar no nosso firewall que quando tivermos conexões já estabelecidas, elas possam receber tráfego. Toda conexão no kernel do linux tem um estado. Ela pode ser NOVA, ESTABELECIDA, RELACIONADA, etc.

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

Com este comando, falamos ao iptables para adicionar uma nova regra (-A) dentro da chain INPUT (entrada), ativando a opção de verificação de estado da conexão (-m conntrack), com as seguintes opções de estado (–ctstate ESTABLISHED,RELATED) e que devemos aceitar essas conexões (ACCEPT)

Todas as conexões em nossa máquina tem um estado e a opção -m conntrack nos permite trabalhar com estes estados no iptables. As que utilizamos neste comando são a ESTABLISHED e a RELATED. A ESTABLISHED refere-se a todas as conexões já estabelecidas e a RELATED refere-se as conexões novas mas que são relacionadas a conexões já estabelecidas.

Assim, queremos dizer que todas as conexões que entrarem na nossa máquina que sejam respostas de conexões já estabelecidas ou conexões novas referentes a conexões já estabelecidas devem ser aceitas.
Liberação de portas e protocolos

A partir de agora, iremos começar a trabalhar em nossas regras. Por padrão, um firewall bom deve negar todas as conexões que não forem explicitamente permitidas. Não podemos negar uma por uma, seria impossível listas todas. Por isso, precisamos definir o que queremos liberar e depois bloquear tudo.
Liberar SSH

Começaremos então liberando o acesso a porta 22, que é a porta do servidor SSH, o servidor de acesso remoto. É sempre importante saber qual protocolo o aplicativo que queremos utiliza. Neste caso, é o protocolo TCP. Para descobrir isso é necessário pesquisar na internet ou procurar no manual de utilização do aplicativo.

Então, começaremos criando uma regre para liberar o nosso acesso a porta 22. O comando utilizado é o seguinte:

#iptables -A INPUT -p tcp -i eth0 –dport ssh -j ACCEPT

Explicando: chamamos aqui o iptables, dizendo que queremos adicionar uma regra (-A). Este regra é referente ao protocolo tcp (-p tcp), deve ser aplicada somente na interface eth0 (-i eth0) e tem como porta de destino a porta do ssh (–dport ssh) e finalmente falomos ao iptables que queremos aceitar esta regra (-j ACCEPT). Note que utilizamos a palavra “ssh” no lugar do número da porta do ssh. Se tivessemos colocado 22 teria funcionado também. O ipables aceita algumas palavras no lugar de portas. Você pode verificar quais no arquivo /etc/services
Liberar Porta 80

Ótimo! Agora nosso ssh já está liberado. Outras regras serão bem parecidas com essa. Vejamos o seguinte exemplo. Digamos que queremos agora permitir também o acesso a porta 80 pois temos um servidor web nela.

#iptables -A INPUT -p tcp -i eth0 –dport 80 -j ACCEPT

Bloqueando o restante

Pronto. Nosso firewall agora permite todo o acesso a porta 80 e a porta 22 de entrada. Agora, iremos bloquear todo o resto:

#iptables -A INPUT -j DROP

Com este comando, adicionamos uma regra nova na chain INPUT que nega o acesso a todas as conexões. O iptables uma vez que lê uma regra, obedece ela mesmo que outra regra modifique o comportamento. Uma vez configurada, ela não muda. Sendo assim, a nossa terceira regra vai bloquear todo o acesso de entrada em nosso computador, menos nas portas 80 e 22 porque já foram definidas antes. Digitando iptables -L podemos ver como ficou

# iptables -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
ACCEPT all — anywhere anywhere state RELATED,ESTABLISHED
ACCEPT tcp — anywhere anywhere tcp dpt:ssh
ACCEPT tcp — anywhere anywhere tcp dpt:www
DROP all — anywhere anywhere

Veja que bloqueamos todo o trafego de entrada, em qualquer interface de rede e permitimos o acesso a 80 e a 22 somente na eth0.Se tivessemos outra interface de rede, ela estaria com toda a sua entrada negada.
Liberando Loopback

Mas esta configuração de iptables tem um grande problema. Ele bloqueou o acesso a nossa interface de loopback também. Isso é ruim, pois muitos programas utilizam ela para suas conexões internas. Sendo assim precisamos adicionar uma regra que libere ela (ou especificar a interface no comando anterior). Mas se colocarmos a regra iptables -A INPUT -i lo – j ACCEPT, ela não teria efeito, pois uma regra anterior já tinha sido definida para ignorar todo o tráfego de rede de entrada e adicionar outra regra não vai mudar isso. Nossa regra precisa vir antes da regra de negar.
Utilizaremos então a opção -I (insert) no lugar da -A . A regra fica assim:

#iptables -I INPUT 4 -i lo -j ACCEPT

A única difereça é que utilizamos o -I e falamos em qual posição da lista queremos que ela fique, no caso, quarta posição. Um iptables -L mostra que a regra está na quarta posição, antes do bloqueio e por isso, efetiva.

iptables -L INPUT
Chain INPUT (policy ACCEPT)
target prot opt source destination
ACCEPT all — anywhere anywhere state RELATED,ESTABLISHED
ACCEPT tcp — anywhere anywhere tcp dpt:ssh
ACCEPT tcp — anywhere anywhere tcp dpt:www
ACCEPT all — anywhere anywhere
DROP all — anywhere anywhere

====Listando as regras com modo verbose====
Olhando a listagem, vemos que ficou um pouco difícil entender sobre qual interface a regra numero 4 se referencia. Daremos então um outro comando


iptables -L INPUT -v


iptables -L INPUT -v
Chain INPUT (policy ACCEPT 227 packets, 22599 bytes)
pkts bytes target prot opt in out source destination
56 3996 ACCEPT all -- any any anywhere anywhere ctstate RELATED,ESTABLISHED
0 0 ACCEPT tcp -- eth0 any anywhere anywhere tcp dpt:ssh
0 0 ACCEPT tcp -- eth0 any anywhere anywhere tcp dpt:http
0 0 ACCEPT all -- lo any anywhere anywhere
0 0 DROP all -- any any anywhere anywhere

Liberando de um ip específico

Agora vamos olhar outra regra, um pouco mais complexa. Aqui nós liberamos todo o tráfego de ssh de entrada. Mas digamos que temos uma máquina com ip fixo e só queremos utilizar este IP para acessar nosso servidor. Usaremos uma opção chamada -s (source, fonte) que nos fala de onde é a origem da conexão, de qual ip ela vem:

#iptables -A INPUT -p tcp -i eth0 -s 192.168.0.1 –dport ssh -j ACCEPT

O comando é igual ao de antes, mas com a adição da opção -s e um ip de origem (192.168.1.1). Poderia ter sido usado também uma rede inteira, com a opção -s 192.168.0.0/24, especificando a máscara 24.
Deletando regras

É possível também deletar uma regra do iptables se soubermos qual a ordem dela. O comando #iptables -L INPUT -n –line-numbers mostra a numeração das linhas das regras de INPUT do iptables.

iptables -L INPUT -n –line-numbers
Chain INPUT (policy ACCEPT)
num target prot opt source destination
1 ACCEPT all — 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED
2 ACCEPT tcp — 0.0.0.0/0 0.0.0.0/0 tcp dpt:22
3 ACCEPT tcp — 0.0.0.0/0 0.0.0.0/0 tcp dpt:80
4 ACCEPT all — 0.0.0.0/0 0.0.0.0/0
5 DROP all — 0.0.0.0/0 0.0.0.0/0

Sabendo o número, podemos deletar uma regra com a opção iptables -D INPUT «número». Claro que podemos sempre limpar todo o iptables com o -F, mas nem sempre queremos fazer isso. Tentaremos então deletar a regra que dá DROP em todos os pacotes. Ela é a regra de número 5. Então o comando é:

iptables -D INPUT 5
iptables -L
ACCEPT all — anywhere anywhere ctstate RELATED,ESTABLISHED
ACCEPT tcp — anywhere anywhere tcp dpt:ssh
ACCEPT tcp — anywhere anywhere tcp dpt:http
ACCEPT all — anywhere anywhere

Assim, a linha 5 foi deletada.
Outras possibilidades

Outras opções possíveis são: –sport (source port)porta de origem, caso conheçamos a porta de origem do que queremos bloquear
-p protocolos tcp, udp, icmp ou all para todos os protocolos
-s (source) fonte da conexão com ip ou rede
-d (destination) mesma coisa que o -s, mas com relação ao destino na conexão
-j Possíveis alvos da regra, como ACCEPT, DROP, REJECT. Tanto o DROP como o REJECT negam a coenxão, mas o REJECT manda um retorno avisando que a conexão foi negada, enquanto o DROP simplesmente ignora o pacote.
-i (input interface) interface de entrada
-o (output inteface) interface de saida
Salvando as regras

O iptables limpa suas regras toda vez que o computador é reiniciado. Para que as regras fiquem ativas durante todo o tempo, é preciso adicionar um script que as carregue durante a inicialização do sistema. O arquivo /etc/sysconfig/iptables é lido na inicialização dos sistemas baseados em redhat e o conteúdo do seu script de firewall pode ser adicionado lá.

Uma outra opção é o comando iptables-save. Ele salva as regras do iptables atual em um arquivos que você especificar (ou mostra na tela se não for especificado nada) com o comando #iptables-save > nomedoarquivo. E o comando iptables-restore pode ser utilizado para restaurar as configurações da seguinte forma, iptables-restore < nomedoarquivo. Quando executamos o iptables-save sozinho temos como saída algo parecido: # iptables-save # Generated by iptables-save v1.4.12 on Mon Nov 21 11:12:26 2011 *nat REROUTING ACCEPT [0:0] :INPUT ACCEPT [0:0] :OUTPUT ACCEPT [18:1099] OSTROUTING ACCEPT [18:1099] COMMIT # Completed on Mon Nov 21 11:12:26 2011 # Generated by iptables-save v1.4.12 on Mon Nov 21 11:12:26 2011 *mangle REROUTING ACCEPT [452:636466] :INPUT ACCEPT [452:636466] :FORWARD ACCEPT [0:0] :OUTPUT ACCEPT [441:100355] OSTROUTING ACCEPT [443:100419] COMMIT # Completed on Mon Nov 21 11:12:26 2011 # Generated by iptables-save v1.4.12 on Mon Nov 21 11:12:26 2011 *filter :INPUT ACCEPT [2:4832] :FORWARD ACCEPT [0:0] :OUTPUT ACCEPT [2:104] -A INPUT -s 192.168.0.1/32 -i eth0 -p tcp -m tcp –dport 22 -j ACCEPT COMMIT # Completed on Mon Nov 21 11:12:26 2011 Para salvarmos estas regras, é preciso direcionar a saída do iptables-save para um arquivo de texto com o comando iptables-save > nomedoarquivo. Será criado o arquivo no local onde você apontou.

Para restaurar as regras, é só rodar o programa ipables-restore. Ele aceita como entrada a saída do iptables-save

#iptables-restore < nomedoarquivo

Assim, é simples criar um script com suas regras personalizadas.
Referências

http://www.frozentux.net/iptables-tutorial/iptables-tutorial.html

https://help.ubuntu.com/community/IptablesHowTo

http://www.thegeekstuff.com/2011/02/iptables-add-rule/

http://ornellas.apanela.com/dokuwiki/pub:pt-br:linuxfwrt