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

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:

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?”.

 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

A política padrão determina o que acontecerá com um pacote quando ele chegar ao final das regras contidas em um chain. A política padrão do iptables é "ACCEPT" mas isto pode ser alterado com o comando:

iptables [-t tabela] [-P chain] [ACCEPT/DROP]

Onde:

A política padrão de um chain é mostrada com o comando iptables -L:

# iptables -L INPUT

Chain INPUT (policy ACCEPT)
target     prot opt source               destination         
DROP       icmp --  anywhere             localhost

No exemplo acima, a política 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 a política padrão deste chain usamos o comando:

 iptables -t filter -P INPUT DROP

NOTA: As políticas de acesso PERMISSIVASS (ACCEPT) normalmente são usadas em conjunto com regras restritivas no chain correspondentes (tudo é bloqueado e o que sobrar é liberado) e políticas RESTRITIVAS (DROP) são usadas em conjunto com regras permissivas no chain correspondente (tudo é liberado e o que sobrar é bloqueado pela política padrão).