Você está na página 1de 72
Administração de redes Firewall - Iptables Firewall podem ser dispositivos formados por componentes de hardware comohttp://www.netfilter.o rg/ e instalar a última versão a partir do código fonte do programa baixando o arquivo .tar.bz2 ou em distribuições como Debian e Fedora utilizar os comandos apt-get e yum. Debian # apt-get install iptables Fedora # yum install iptables 1 " id="pdf-obj-0-2" src="pdf-obj-0-2.jpg">

Administração de redes

Firewall - Iptables

Administração de redes Firewall - Iptables Firewall podem ser dispositivos formados por componentes de hardware comohttp://www.netfilter.o rg/ e instalar a última versão a partir do código fonte do programa baixando o arquivo .tar.bz2 ou em distribuições como Debian e Fedora utilizar os comandos apt-get e yum. Debian # apt-get install iptables Fedora # yum install iptables 1 " id="pdf-obj-0-8" src="pdf-obj-0-8.jpg">

Firewall podem ser dispositivos formados por componentes de hardware como roteadores, modens ADSL e ponto de acesso (Access Point) ou através um computador configurado como roteador e firewall que são capazes de fazer a filtragem de pacotes e controlar o tráfego de pacotes entre uma rede local (LAN) e a rede externa (Internet).

Um computador com Linux configurado como roteador e firewall é responsável pelo roteamento de pacotes e filtragem dos pacotes, onde analisa o cabeçalho dos pacotes e faz a decisão o que pode entrar e sair pela rede local.

No Linux o programa atual Iptables (kernel 2.4.x e 2.6.x - em versões anteriores ipchains 2.2.x e ipfwadm 2.0.x) é responsável por fazer a filtragem desses pacotes, fornecendo em linha de comandos a possibilidade do administrador manipular as regras dos pacotes do kernel do Linux.

Em todas distribuições Linux o pacote iptables já vem instalação por padrão, caso você não tenha instalado o pacote iptables, você pode instalar a partir do site http://www.netfilter.org/ e instalar a última versão a partir do código fonte do programa baixando o arquivo .tar.bz2 ou em distribuições como Debian e Fedora utilizar os comandos apt-get e yum.

  • Debian

# apt-get install iptables

  • Fedora

# yum install iptables

Nesta capítulo será mostrado como exemplo o computador firewall.dominio.com.br onde serão implementadas regras de iptables com
Nesta capítulo será mostrado como exemplo o computador firewall.dominio.com.br onde serão implementadas regras de iptables com

Nesta capítulo será mostrado como exemplo o computador firewall.dominio.com.br onde serão implementadas regras de iptables com NAT para redirecionar as requisições externas da internet para servidores da rede local DMZ (Veja a aula do Roteador NAT para mais detalhes) com mostra a imagem abaixo.

Nesta capítulo será mostrado como exemplo o computador firewall.dominio.com.br onde serão implementadas regras de iptables com
Este computador configurado como firewall tem o endereço IP mais baixo da nossa rede local DMZ
Este computador configurado como firewall tem o endereço IP mais baixo da nossa rede local DMZ

Este computador configurado como firewall tem o endereço IP mais baixo da nossa rede local DMZ 192.168.0.1 (eth1) e da rede local 192.168.1.1 (eth2) que está com 3 placas de rede:

eth0 - 200.000.000.100 (conexão com a internet IP fixo (eth0) ou dinâmico

(ppp0))

eth1 (conexão rede local DMZ – servidores) eth2 (conexão rede local - computadores Desktop)

* Obs: Para a configuração do DNS é necessário adquirir mais endereços IP fixo com sua
* Obs: Para a configuração do DNS é necessário adquirir mais endereços IP fixo com sua

* Obs: Para a configuração do DNS é necessário adquirir mais endereços IP fixo com sua operadora ou seu provedor.

Configuração dos endereços IP do firewall

Abaixo segue a configuração das interfaces de rede baseado no Debian e Red Hat / Fedora que pode ser implementado em outras distribuições Linux facilmente.

Hostname

firewall

Domínio

dominio.com.br

DNS primário

192.168.1.30

DNS secundário

192.168.1.20

Endereço IP eth0(IP fixo) ou ppp0(IP dinâmico)

200.204.143.80

Máscara de rede

255.255.255.192

Gateway

200.204.143.65

Endereço IP eth1 (rede DMZ)

192.168.0.1

máscara de rede

255.255.255.0

Endereço de rede

192.168.0.0

Endereço IP eth2 (rede local)

192.168.1.1

Máscara de rede

255.255.255.0

Endereço de rede

192.168.1.0

* Obs: Para a configuração do DNS é necessário adquirir mais endereços IP fixo com sua

Em distribuições Debian acesse as configurações de rede através do arquivo /etc/network/interfaces e faça as seguintes:

/etc/network/interfaces /etc/network/interfaces # The loopback network interface auto lo iface lo inet loopback # IP FIXO

/etc/network/interfaces

/etc/network/interfaces /etc/network/interfaces # The loopback network interface auto lo iface lo inet loopback # IP FIXO

/etc/network/interfaces

# The loopback network interface

auto lo iface lo inet loopback

# IP FIXO auto eth0

iface eth0 inet static address 200.204.143.80 netmask 255.255.255.192 gateway 200.204.143.65

# IP DINÂMICO PPPoE auto ppp0 iface ppp0 inet dhcp

# IP da rede DMZ auto eth1 iface eth1 inet static address 192.168.0.1

netmask 255.255.255.0 network .168.0.0

# IP da rede local auto eth2 iface eth2 inet static address 192.168.1.1

netmask 255.255.255.0 netmask 192.168.1.0

  • No Red Hat / Fedora edite o arquivo os arquivos

/etc/sysconfig/network-scripts/ifcfg-eth0,

/etc/sysconfig/network-scripts/ifcfg-ppp0,

/etc/sysconfig/network-scripts/ifcfg-eth1 e

/etc/sysconfig/network-scripts/ifcfg-eth2.

Configuração IP fixo estático:

# placa de rede da rede externa # /etc/sysconfig/network-scripts/ifcfg-eth0 DEVICE = eth0 ONBOOT = yes BOOTPROTO = static IPADDR = 200.204.143.80 (IP fixo fornecido pelo provedor) NETMASK = 255.255.255.192 (máscara de rede fornecida pela provedor)

GATEWAY = 200.204.143.65 (gateway fornecido do provedor)
GATEWAY = 200.204.143.65 (gateway fornecido do provedor)

GATEWAY = 200.204.143.65 (gateway fornecido do provedor)

Configuração IP fixo dinâmico DHCP:

# placa de rede da rede externa

# /etc/sysconfig/network-scripts/ifcfg-eth0 DEVICE = eth0 ONBOOT = yes BOOTPROTO = dhcp

Configuração IP dinâmico ADSL PPPOE:

# placa de rede da rede externa

# /etc/sysconfig/network-scripts/ifcfg-ppp0 DEVICE = ppp0 ONBOOT = yes BOOTPROTO = dhcp

# placa de rede da rede DMZ

# /etc/sysconfig/network-scripts/ifcfg-eth1 DEVICE = eth1 ONBOOT = yes BOOTPROTO = static IPADDR =192.168.0.1 NETMASK = 255.255.255.0 NETWORK = 192.168.0.0

# placa de rede da rede local

# /etc/sysconfig/network-scripts/ifcfg-eth2 DEVICE = eth2 ONBOOT = yes BOOTPROTO = static IPADDR =192.168.1.1 NETMASK = 255.255.255.0 NETWORK = 192.168.1.0

Configure o nome do host no arquivos /etc/hostname

# /etc/hostname firewall Especifique os endereços e nome de host no arquivo /etc/hosts # /etc/hosts 127.0.0.1
# /etc/hostname firewall Especifique os endereços e nome de host no arquivo /etc/hosts # /etc/hosts 127.0.0.1

# /etc/hostname

firewall

Especifique os endereços e nome de host no arquivo /etc/hosts

# /etc/hosts 127.0.0.1 localhost localhost.localdomain 192.168.0.1 firewall firewall.dominio.com.br # interface eth1 – rede DMZ 192.168.1.1 firewall firewall.dominio.com.br # interface eth2 – rede local

Especifique as redes no arquivo /etc/networks

# /etc/networks

default 0.0.0.0 loopback 127.0.0.0 link-local 169.254.0.0

rede-DMZ 192.168.0.0 # rede DMZ

rede-local 192.168.1.0 # rede local

Edite o arquivo de configuração de resolução de nomes DNS /etc/host.conf

# /etc/host.conf

order hosts,bind

multi on

Especifique os endereços de DNS no arquivo /etc/resolv.conf

# /etc/resolv.conf # servidores DNS da rede local DMZ

nameserver 192.168.1.30

nameserver 192.168.1.20

Ativando o roteamento Para ativar o roteamento edite o arquivo /etc/sysctl.conf e altere a linha Debian

Ativando o roteamento

Ativando o roteamento Para ativar o roteamento edite o arquivo /etc/sysctl.conf e altere a linha Debian

Para ativar o roteamento edite o arquivo /etc/sysctl.conf e altere a linha

Debian

net.ipv4.conf.default.forwarding=1

para

net.ipv4.conf.default.forwarding=0

Red Hat / Fedora

net.ipv4.ip_forwarding=1

para

net.ipv4.ip_forwarding=0

Ou você pode adicionar o seguinte comando como root em seu arquivo de Firewall

# echo 1 > /proc/sys/net/ipv4/ip_forward

Ativando o mascaramento de IP

Agora compartilhe a internet habilitando o mascaramento de IP com seguinte comando:

conexão IP fixo em eth0

# iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

conexão discada ou ADSL IP dinâmico em ppp0

# iptables -t nat -A POSTROUTING -o ppp0 -j MASQUERADE

Configurando as rotas

Para configurar as rotas para a rede DMZ (eth1 - 192.168.0.0) e a rede local (eth2 - 192.168.1.0) use o comando route e adicione os comandos no script do firewall para

ativar na inicialização do Linux. *Obs - (Mais detalhes sobre rotas veja a aula de configuração

ativar na inicialização do Linux.

ativar na inicialização do Linux. *Obs - (Mais detalhes sobre rotas veja a aula de configuração

*Obs - (Mais detalhes sobre rotas veja a aula de configuração do roteador)

Adicionando as rotas

# route add -net 192.168.0.0 netmask 255.255.255.0 gw 192.168.0.1 dev eth1 # route add -net 192.168.1.0 netmask 255.255.255.0 gw 192.168.1.1 dev eth2

Exibindo as rotas

# route -n

Destino Roteador MáscaraGen. Opções Métrica Ref Uso Iface 200.204.210.226 0.0.0.0 255.255.255.255 UH 0 0 0 ppp0

  • 192.168.0.0 192.168.0.1 255.255.255.0 UG 0 0 0 eth1

  • 192.168.1.0 192.168.1.1 255.255.255.0 UG 0 0 0 eth2

0.0.0.0 0.0.0.0 0.0.0.0 U 0 0 0 ppp0

Pronto, agora que os endereços IP e os arquivos de configuração da rede estão configurados, o roteamento e o mascaramento de IP ativados e as rotas configuradas, podemos criar nosso script de configuração básica do nosso firewall, onde veremos a explicação mais detalhada dos comandos e opções do iptables em seguida.

Para ativar as configurações após reiniciar o computador crie um script geralmente em /etc/init.d/ com os comandos acima e torne-o executável e adicione-o no arquivo de inicialização /etc/rc.local.

# /etc/init.d/firewall # apaga todas as regras

/sbin/iptables -F

# ativa o roteamento

echo 1 > /proc/sys/net/ipv4/ip_forward

# habilita o mascaramento de IP

/sbin/iptables -t nat -A POSTROUTING -o eth0 -j MASQUERADE

# configurando as rotas

/sbin/route add -net 192.168.0.0 netmask 255.255.255.0 gw 192.168.0.1 dev eth1

/sbin/route add -net 192.168.1.0 netmask 255.255.255.0 gw 192.168.1.1 dev eth2

Para visualizar as regras adicionadas executa o comando abaixo

# iptables -L -t nat -v

Mude as permissões para torna-lo executável # chmod +x /etc/init.d/firewall Adicione-o na inicialização no arquivo /etc/rc.local

Mude as permissões para torna-lo executável

# chmod +x /etc/init.d/firewall

Mude as permissões para torna-lo executável # chmod +x /etc/init.d/firewall Adicione-o na inicialização no arquivo /etc/rc.local

Adicione-o na inicialização no arquivo /etc/rc.local

# /etc/rc.local

/etc/init.d/firewall

Agora reinicie a rede ou reinicie o computador e execute o script do firewall

# /etc/init.d/networking restart # /etc/init.d/firewall

# /sbin/service network restart # /etc/init.d/firewall

Iptables

Iptables é o programa no Linux em linha de comando responsável pelo filtro de pacotes nas versões do kernel 2.4.x e 2.6.x que funciona através de regras determinadas na inicialização do sistema, onde os pacotes que entram no kernel são analisados pelas cadeias (chains) que são situações que podem ocorrer dentro do kernel.

Em uma conexão quando um pacote entra no firewall, o kernel do Linux faz o roteamento do pacote determinando o destino e qual cadeia irá analisar esse pacote. As cadeias irão depender do tipo de tabela, que são divididas em 3 tipos:

filter, nat e mangle.

Para inicializar o programa iptables abra um terminal e execute o comando iptables -h para exibir as opções que são muitas, comece exibindo a versão do iptables (iptables -V).

# iptables -V iptables v1.3.6
# iptables -V
iptables v1.3.6

A sintaxe do comando iptables é da seguinte forma:

Vamos analisar resumidamente o funcionamento do iptables, como base no diagrama da imagem abaixo onde é
Vamos analisar resumidamente o funcionamento do iptables, como base no diagrama da imagem abaixo onde é

Vamos analisar resumidamente o funcionamento do iptables, como base no diagrama da imagem abaixo onde é mostrado um pacote passando pelo firewall.

  • 1. O pacote entra na interface de rede de entrada.

  • 2. As regras de PREROUNTING (pré-roteamento) da tabela NAT são aplicadas.

  • 3. O pacote passa por uma decisão de roteamento onde é desviado para a cadeia INPUT (entrada) caso o destino seja a interface de rede do próprio firewall, caso contrário é encaminhado para a cadeia FORWARD (indo e vindo).

  • 4. O pacote passa por um processo local de verificação para determinar se é aceito ou rejeitado.

  • 5. Caso o pacote seja aceito, é encaminhado para a cadeia OUTPUT (saída) da tabela NAT ou Filter.

  • 6. O pacote é encaminhado para a cadeia POSTROUTING (pós-roteamento) da tabela NAT.

  • 7. As regras de POSTROUTING da tabela NAT são aplicadas.

  • 8. E finalmente o pacote sai da interface de rede saída até seu destino.

Tabelas São utilizadas para especificar os tipos de cadeias(chains) que serão utilizadas. tabela Significado filter Essa

Tabelas

Tabelas São utilizadas para especificar os tipos de cadeias(chains) que serão utilizadas. tabela Significado filter Essa

São utilizadas para especificar os tipos de cadeias(chains) que serão utilizadas.

tabela

Significado

filter

Essa é a tabela padrão utilizada, caso nenhuma tabela for determinada, é utilizada quando existe tráfego de dados normal, sem utilização de regras com NAT. Essa tabela utilizada as cadeias (chains) INPUT, OUTPUT e FORWARD.

nat

É usada quando tem NAT, e quando ocorre o tráfego de pacotes entre a rede local e a internet. Essa tabela utilizada as cadeias (chains) PREROUTING, POSTROUTING e OUTPUT.

 

Possui 2 cadeias (chains) padrões: PREROUTING e OUTPUT, é usada para fazer alterações especiais em pacotes para o tratamento do tráfego que atravessa os cadeias chains (como alterar o tipo de serviço (TOS) e usa as cinco cadeias (chains) PREROUTING, POSTROUTING, INPUT, OUTPUT e FORWARD.

mangle

Cada uma destas cadeias são processadas antes da cadeia correspondente na tabela filter e nat para determinar opções especiais para o tráfego dos pacotes (por exemplo, a cadeia PREROUTING da tabela mangle é processada antes da PREROUTING da tabela nat e assim por diante).

Para exibir as tabelas atuais utilizadas pelo comando iptables pelo firewall, execute o comando:

$ cat /proc/net/ip_tables_names

Comandos

Os comandos servem para permitir que o iptables execute determinadas ações como: estabelecer uma política de analise dos pacotes, adicionar uma regra ou cadeia, apagar e exibir as regras e cadeias.

Comando

Significado

-P

Determina uma política de analise dos pacotes em uma cadeia

-A

Adiciona um regra em uma cadeia

-I

Insere uma regra em uma cadeia

-R Renomeia uma regra em uma cadeia -D Exclui uma regra ou uma cadeia -F Excluir
-R Renomeia uma regra em uma cadeia -D Exclui uma regra ou uma cadeia -F Excluir

-R

Renomeia uma regra em uma cadeia

-D

Exclui uma regra ou uma cadeia

-F

Excluir todas as regras de uma cadeia ou de todas as cadeias

-Z

Zera contadores de uma cadeia ou de todas as cadeias

-N

Cria uma nova cadeia definida pelo usuário

-E

Renomeia uma cadeia definida pelo usuário

-X

Exclui uma cadeia definida pelo usuário

-L

Exibe as regras de uma cadeia

-

h

ou

Exibe ajuda do iptables

--help

Cadeias (Chains)

As cadeias servem para determinar se um pacote irá entrar, sair ou ser redirecionado pelo iptables.

Cadeia

Significado

INPUT

Analisa os pacotes que estão entrando na rede interna.

OUTPUT

Analisa os pacotes que estão saindo na rede interna.

FORWARD

Analisa os pacotes que estão trafegando pela rede, tanto da rede externa (Internet) para rede interna (LAN) e vice-versa.

PREROUTING

Analisa pacotes que estão entrando pelo firewall e que são aplicadas regras de NAT, onde é determinado o destino dos pacotes (DNAT – Destination NAT – Destino NAT).

POSTROUTING

Analisa pacotes que estão saindo pelo firewall e que são aplicadas regras de NAT, onde é determinado a origem dos pacotes (SNAT – Source NAT – Origem NAT).

Para exibir as cadeias execute os comandos:

# iptables -L -n

# iptables -L -t nat

Opções Opção Significado -p ou -- protocol Especifica o protocolo que pode ser TCP, UDP, ICMP

Opções

Opções Opção Significado -p ou -- protocol Especifica o protocolo que pode ser TCP, UDP, ICMP

Opção

Significado

-p ou --protocol

Especifica o protocolo que pode ser TCP, UDP, ICMP ou ALL (todos). *Obs - pode ser usados outros protocolos especificados em /etc/protocols.

-s, --src ou --source

Especifica os pacotes de origem da rede (192.168.0.0/255.255.255.0) ou computador local

(192.168.0.2)

-d,

-

- dst

ou

Especifica os pacotes de destino da rede

(192.168.0.2)

--destination

(192.168.0.0/255.255.255.0) ou computador local

-i ou --in-interface

Determina a placa de rede de entrada, onde não pode ser utilizada pela cadeia OUTPUT

-o ou --out-interface

Determina a placa de rede de saída, onde não pode ser utilizada pela cadeia INPUT

  • - sport

-

ou

Determinada o porta de origem, onde só pode ser

--source-port

utilizada com as opções -p tcp e -p udp.

dport

  • - o

-

u

Determinada o porta de destino, onde só pode ser

--destination-port

utilizada com as opções -p tcp e -p udp.

--syn

Essa opção só deve ser usada em pacotes que utilizam o protocolo TCP que tenham o bit SYN ativado e os bits ACK e FIN desativados no início de uma conexão TCP. Por exemplo, quando se bloqueia esses pacotes vindos de uma placa de rede, a conexão de entrada TCP será recusada, mas a conexão de saída não.

-j ou --jump

Especifica o destino da regra

Para exibir as opções e parâmetros execute o comando:

# iptables -L -n -v

*OBS – Antes da opções e parâmetros pode ser utilizado a exclamação “ ! “ que veremos mais a frente, que significa não (NOT) e inverte o sentido fazendo uma exceção.

Destino O destino é o que será determinado para os pacotes, se eles serão aceitos, rejeitados,

Destino

Destino O destino é o que será determinado para os pacotes, se eles serão aceitos, rejeitados,

O destino é o que será determinado para os pacotes, se eles serão aceitos, rejeitados, excluídos, redirecionados e etc.

Destino

Significado

ACCEPT

Especifica que os pacotes serão aceitos e poderão passar pelo firewall

 

Especifica que os pacotes serão rejeitados e não poderão passar pelo firewall, em caso de pacotes ICMP, como o comando ping,

REJECT

retornará uma mensagem de porta inalcançável “port-unreachable”.

 

Especifica também que os pacotes serão rejeitados e não

DROP

poderão passar pelo firewall, em caso de pacotes ICMP, como o comando ping, não retornará uma mensagem de porta inalcançável “port-unreachable”.

LOG

Determina que as regras serão gravadas em log pelo daemon syslog em /var/log/syslog.

SNAT

Utilizada para fazer mascaramento de origem e deve ser utilizada com a cadeia POSTROUTING

DNAT

Utilizada com as cadeias PREROUTING e OUTPUT para fazer o redirecionamento de portas e servidores, balanceamento de carga e proxy transparente, onde caso a porta de destino não seja determinada, será utilizada a porta de origem.

*Obs: a porta que estiver sendo redirecionada não pode estar sendo usada no momento por algum serviço.

--to

Utilizada para especificar o endereço IP e a porta de destino, depois de determinado o destino com DNAT ou após determinado a origem com SNAT.

MASQUERADE

Faz o mascaramento de IP na saída de pacotes em uma interface de rede ppp0, eth0, etc.

REDIRECT

Utilizada para fazer redirecionamento de conexões para uma porta do firewall

--to-port

Determina a porta de destino, após o redirecionamento com REDIRECT

RETURN

 
Determina que regras sejam executadas até que ocorra algum erro em uma delas, onde é usada
Determina que regras sejam executadas até que ocorra algum erro em uma delas, onde é usada
 

Determina que regras sejam executadas até que ocorra algum erro em uma delas, onde é usada em linhas seqüenciais no firewall, onde retorna o resultado da cadeia anterior sem executar o restante do cadeia atual.

Para exibir os destinos das tabelas filter, nat e mangle execute o comando:

# iptables -L -n -t filter

# iptables -L -n -t nat

# iptables -L -n -t mangle

ou

$ cat /proc/net/ip_tables_targets

Extensões

O iptables e o kernel do Linux podem ser extendidos para novas funcionalidades o que os tornam extensíveis, as extensões do kernel estão localizadas no diretório de módulos do kernel em /lib/modules/2.6.x/kernel/net/ipv4/netfilter/ (onde 2.6.x é versão do kernel instalado). E as extensões do programa iptables são bibliotecas compartilhadas e geralmente ficam localizadas em /usr/lib/iptables ou /lib/iptables.

Esses módulos podem ser carregados e utilizados pelo iptables através do comando modprobe .Por exemplo, para carregar algum módulo listado em /lib/modules/2.6.x/kernel/net/ipv4/netfilter/ ficaria da seguinte forma:

# modprobe ipt_tos

# modprobe ipt_LOG

As extensões permite o uso de filtros especiais dos pacotes, que podem ser usadas para implementação
As extensões permite o uso de filtros especiais dos pacotes, que podem ser usadas para implementação

As extensões permite o uso de filtros especiais dos pacotes, que podem ser usadas para implementação de segurança mais avançada.

As extensões podem ser utilizadas da seguinte forma na linha de comando com iptables com a opção -p ou -m ou –match :

-p (protocolo) [extensão (opção) ]

ou

-m [ módulo (extensão) ]

Para saber informações sobre um protocolo que pode ser tcp, udp ou icmp, podemos executar o comando iptables -p protocolo -h.

# iptables -p tcp -h

ou

# iptables -p tcp --help

Para saber informações sobre algum módulo que pode ser mac, limit, multiport, mark, owner, state, tos e unclean, podemos executar o comando iptables -m modulo -h.

# iptables -m multiport -h

ou

# iptables -m multiport –help

ou

# iptables --match multiport -h Para exibir os módulos atuais usados pelo comando iptables, execute o

# iptables --match multiport -h

# iptables --match multiport -h Para exibir os módulos atuais usados pelo comando iptables, execute o

Para exibir os módulos atuais usados pelo comando iptables, execute o comando:

$ cat /proc/net/ip_tables_matches

Usando o iptables

Usando as cadeias (chains)

O iptables utilizada regras (que estão em letras MAÍSCULAS) que são analisadas uma por uma até que a última seja analisada, caso alguma regra esteja com erro, por padrão será exibida mensagem de erro e ela não será aplicada. Assim os pacotes não serão verificados e dependerá das regras posteriores se os pacotes serão aceitos ou rejeitados.

Criando regras ( -A )

A nossa primeira regra irá bloquear seu próprio computador, onde será testado com o comando ping no endereço local de loopback 127.0.0.1 ou localhost.

Execute o comando ping com a opção -c 3, onde será enviados apenas 3 pacotes e veja que está que o computador está respondendo pelo pacotes ICMP

$ ping 127.0.0.1

ou

$ ping localhost

$ ping -c 3 127.0.0.1

PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.

64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.079 ms

64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.073 ms 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.074 ms
64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.073 ms 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.074 ms
  • 64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.073 ms

  • 64 bytes from 127.0.0.1: icmp_seq=3 ttl=64 time=0.074 ms

--- 127.0.0.1 ping statistics ---

3 packets transmitted, 3 received, 0% packet loss, time 2013ms

rtt min/avg/max/mdev = 0.073/0.075/0.079/0.00

Agora adicione um regra na cadeia (chain) INPUT (-A INPUT) utilizando o protocolo ICMP (-p icmp) que bloqueia (-j DROP) o endereço de loopback 127.0.0.1 (-d

127.0.0.1).

# iptables -A INPUT -p icmp -d 127.0.0.1 -j DROP

Para exibir a nova regra criada execute o comando abaixo e veja o que o destino (target) está como DROP (rejeitado), que o protocolo é icmp e não tem opções – (opt), que a origem (source) é qualquer endereço IP 0.0.0.0/0 e o destino (destination) é 127.0.0.1.

# iptables -L -n

Chain INPUT (policy ACCEPT)

target prot opt source destination

DROP cmp -- 0.0.0.0/0 127.0.0.1

Agora execute o comando ping novamente e verifique o IP 127.0.0.1 de destino (-d 127.0.0.1) está bloqueado e não obtêm nenhuma resposta, pois os pacotes ICMP foram rejeitados pelo destino (-j DROP).

$ ping -c 3 127.0.0.1

Para voltar a aceitar pacotes ICMP e voltar a obtêm resposta do comando ping no endereço
Para voltar a aceitar pacotes ICMP e voltar a obtêm resposta do comando ping no endereço

Para voltar a aceitar pacotes ICMP e voltar a obtêm resposta do comando ping no endereço loopback 127.0.0.1, devemos excluir a regra anterior, que pode ser feito de duas formas:

Primeiramente devemos exibir as numeração das regras com o comando abaixo com a opção --line-numbers.

# iptables -L -n --line-numbers

Chain INPUT (policy ACCEPT)

num target prot opt source destination

1 DROP icmp -- 0.0.0.0/0 127.0.0.1

Repare que exibe a linha número 1 da cadeia INPUT, onde podemos excluí-la da seguinte forma:

# iptables -D INPUT 1

ou executando a regra novamente especificando o comando -D ao invés de -A

# iptables -D INPUT -p icmp -d 127.0.0.1 -j DROP

Agora você pode executar ping novamente e obterá resposta, pois não tem nenhuma regra bloqueando os pacotes.

$ ping -c 3 127.0.0.1

Você pode criar a mesma regra para aceitar os pacotes ao invés de rejeitar apenas alterando o destino -j DROP para -j ACCEPT

# iptables -A INPUT -p icmp -d 127.0.0.1 -j ACCEPT Exibindo regras ( -L ) Para
# iptables -A INPUT -p icmp -d 127.0.0.1 -j ACCEPT Exibindo regras ( -L ) Para

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

Exibindo regras ( -L )

Para exibir regras utilize a seguinte sintaxe:

iptables -t tabela -L cadeia opções

-t tabela - podemos especificar a tabela que pode ser filter, nat ou mangle.

-L exibe a cadeia (chain) que pode ser INPUT, OUTPUT, FORWARD, PREROUTING ou POSTROUTING.

E as opções utilizadas para exibir as regras que podem ser:

-v – exibe mais detalhes das regras criadas. -n – exibe endereços IP e portas ao invés de fazer a resolução de nomes DNS para serem exibidos, o que torna mais lento para ser exibidas as regras das tabelas. -x – exibe números exatos ao invés de números arredondados e exibe uma faixa de portas de uma regra. --line-numbers – exibe a numeração de linhas das regras na primeira coluna da tabela

Para exibir as regras das tabelas filter, nat ou mangle execute os comandos especificando as opções:

# iptables -t filter -L -n

# iptables -t nat -L -n -v

# iptables -t mangle -L -n -v --line-numbers

Para exibir as regras da cadeia INPUT, OUTPUT ou FORWARD execute os comandos especificando as opções:

# iptables -L OUTPUT -n -v # iptables -L FORWARD -n -v --line-numbers Por exemplo: #
# iptables -L OUTPUT -n -v # iptables -L FORWARD -n -v --line-numbers Por exemplo: #

# iptables -L OUTPUT -n -v

# iptables -L FORWARD -n -v --line-numbers

Por exemplo:

# iptables -L INPUT -n -v --line-numbers

Chain INPUT (policy ACCEPT 5026K packets, 1075M bytes)

num pkts bytes target prot opt in out source destination

1 0 0 DROP cmp -- * * 0.0.0.0/0 127.0.0.1

Exibindo as regras acima usando as opções -n, -v e --line-numbers temos os seguintes campos:

Chain INPUT (policy ACCEPT 5026K packets, 1075M bytes) - Exibe o nome da cadeia (chain) e a política padrão da cadeia (ACCEPT) onde são exibidos a quantidade e o tamanho dos pacotes. num - exibe a numeração linhas nas cadeias. pkts - especifica a quantidade de pacotes que trafegam pela regra. bytes - especifica a quantidade de bytes que trafegam pela regra. target - especifica o destino da regra, que pode ser DROP, ACCEPT, REJECT ou outro destino. prot - especifica o protocolo usado pela regra, que pode ser tcp, udp, icmp ou all opt - especifica opções extras como exceções ! “ ou fragmentos “ -f “. in - especifica a interface de rede de entrada, de onde dos pacotes vem. out - especifica a interface de rede de saída, para onde os pacotes dos vão. source - especifica o endereço de origem. destination - especifica o endereço de destino.

Apagando regras ( -D )

Primeiramente devemos exibir as numeração das regras com o comando abaixo com a opção --line-numbers.

Chain INPUT (policy ACCEPT) num target prot opt source destination 1 DROP icmp -- 0.0.0.0/0 127.0.0.1
Chain INPUT (policy ACCEPT) num target prot opt source destination 1 DROP icmp -- 0.0.0.0/0 127.0.0.1

Chain INPUT (policy ACCEPT)

num target prot opt source destination

1 DROP icmp -- 0.0.0.0/0 127.0.0.1

Repare que exibe a linha número 1 da cadeia INPUT, onde podemos excluí-la da seguinte forma:

# iptables -D INPUT 1

A opção acima não é útil quando temos um firewall mais complexo com muitas linhas de regras, então devemos executar a regra novamente especificando o comando -D ao invés de -A.

# iptables -D INPUT -p icmp -d 127.0.0.1 -j DROP

Inserindo regras ( -I )

Para inserir uma nova regra é utilizada opção -I, por exemplo, suponha que seu firewall tem uma regra que está bloqueando o endereço de loopback 127.0.0.1 na linha 1 da cadeia (chain) INPUT e você deseja inserir uma nova regra que libera o acesso antes da regra de bloqueio, neste caso a nova regra passa a estar na linha 1 e a regra de bloqueio na linha 2.

Neste caso não poderíamos inserir uma nova regra (-A INPUT) pois seria adicionada no final da cadeia INPUT e o tráfego de pacotes seria rejeitado pela primeira regra (linha 1) e nunca atingindo a segunda regra (linha 2).

Esta regra bloqueia ping no endereço 127.0.0.1, onde a regra está na linha 1 da cadeia INPUT.

# iptables -A INPUT -p icmp -d 127.0.0.1 -j DROP

# iptables -L INPUT -n --line-numbers Chain INPUT (policy ACCEPT) num target prot opt source destination
# iptables -L INPUT -n --line-numbers Chain INPUT (policy ACCEPT) num target prot opt source destination

# iptables -L INPUT -n --line-numbers

Chain INPUT (policy ACCEPT)

num target prot opt source destination

  • 1 DROP icmp -- 0.0.0.0/0 127.0.0.1

Exibindo regra anterior repare que a regra de bloqueio está na linha 1 da cadeia INPUT, e que executando o comando ping verifique que não obtêm resposta.

$ ping -c 3 127.0.0.1

Agora podemos inserir uma nova regra na linha 1 que aceite tráfego de pacotes e a regra de bloqueio passa para a linha 2, repare o número 1 depois da cadeia INPUT especifica a linha 1 da cadeia INPUT.

# iptables -D INPUT 1 -p icmp -d 127.0.0.1 -j DROP

# iptables -L INPUT -n --line-numbers

Chain INPUT (policy ACCEPT)

num target prot opt source destination

  • 1 ACCEPT icmp -- 0.0.0.0/0 127.0.0.1

  • 2 DROP icmp -- 0.0.0.0/0 127.0.0.1

$ ping -c 3 127.0.0.1

Agora executando o comando ping obtemos resposta, pois a linha número 1 está aceitando tráfego de pacotes e descartando a linha 2 de bloqueio DROP.

Substituindo regras ( -R ) Para substituir uma regra é utilizada a opção -R , por

Substituindo regras ( -R )

Substituindo regras ( -R ) Para substituir uma regra é utilizada a opção -R , por

Para substituir uma regra é utilizada a opção -R, por exemplo para substituir as regras anteriores, basta colocar o número da linha após a cadeia e a opção -R, como mostra o exemplo abaixo:

# iptables -R INPUT 2 -p tcp -d 127.0.0.1 -j ACCEPT

Repare abaixo que a linha 2 foi substituído destino DROP por ACCEPT e o protocolo icmp por tcp.

# iptables -L INPUT -n --line-numbers

Chain INPUT (policy ACCEPT)

num target prot opt source destination

  • 1 ACCEPT icmp -- 0.0.0.0/0 127.0.0.1

  • 2 ACCEPT tcp -- 0.0.0.0/0 127.0.0.1

Criando uma nova cadeia (chain) ( -N )

O tamanho de uma nova cadeia pode ter até 31 caracteres e pode ser usado letras maiúsculas ou minúsculas. Quando se tem muitas linhas de regras, a criação de uma nova cadeia ajuda organizar e facilitar o gerenciamento do firewall para um determinado objetivo analisando o tráfego de um mesmo tipo de interface de rede, protocolo, endereço de origem, destino e etc.

Para criar uma nova cadeia (chain) na tabela filter execute o comando :

# iptables -t filter -N Minha-Chain

E para inserir regras na nova cadeia use a opção -A antes da nova regra.

# iptables -t filter -A Minha-Chain -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 -- dport
# iptables -t filter -A Minha-Chain -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 -- dport

# iptables -t filter -A Minha-Chain -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 --dport 22 -j DROP

Agora inserimos a cadeia INPUT que tem como destino a nova cadeia Minha-Chain.

# iptables -t filter -A INPUT -j Minha-Chain

Exibindo a nova cadeia criada onde foi adicionada na cadeia INPUT.

# iptables -t filter -L -n

Chain INPUT (policy ACCEPT)

target prot opt source destination

Minha-Chain 0 -- 0.0.0.0/0 0.0.0.0/0

Chain Minha-Chain (1 references)

target prot opt source destination

DROP tcp -- 192.168.0.0/24 192.168.0.1

Renomeando uma cadeia criada ( -E )

Para renomear uma nova cadeia criada nas tabelas filter, nat ou mangle, use a opção -E antes da nova cadeia criada.

# iptables -t filter -E Minha-Chain Outra-Chain

Acima a cadeia Minha-Chain foi renomeada para Outra-Chain, como mostra o comando abaixo:

# iptables -t filter -L Outra-Chain -n Chain Outra-Chain (1 references) target prot opt source destination
# iptables -t filter -L Outra-Chain -n Chain Outra-Chain (1 references) target prot opt source destination

# iptables -t filter -L Outra-Chain -n

Chain Outra-Chain (1 references)

target prot opt source destination

DROP tcp -- 192.168.0.0/24 192.168.0.1

Excluindo cadeia (chains) criadas ( -X )

Para excluir uma cadeia (chain) criada em uma tabela, use a opção -X antes do nome da cadeia a ser excluída, caso você não especifique a cadeia a ser apagada, todas as novas cadeias criadas serão excluídas.

Exclui da nova cadeia Outra-Chain

# iptables -t filter -X Outra-Chain

Exclui todas as novas cadeias criadas

# iptables -X

Limpando regras de uma cadeia (chain) ( -F )

Para excluir uma regras criada em uma cadeia (chain), use a opção -F antes do nome da cadeia a ser limpa ou depois da tabela, caso você não especifique a cadeia ou tabela a ser limpada, todas as regras das cadeias ou tabelas serão limpas.

Limpa as regras da cadeia INPUT

# iptables -t filter -F INPUT

Limpa todas as regras da tabela filter

# iptables -t filter -F

Limpa todas as regras de todas as tabela filter, nat e mangle. # iptables -F Limpando
Limpa todas as regras de todas as tabela filter, nat e mangle. # iptables -F Limpando

Limpa todas as regras de todas as tabela filter, nat e mangle.

# iptables -F

Limpando contador de pacotes e bytes das cadeias (chains) ( -Z )

A opção -Z serve para limpar os contadores de pacotes e bytes dos campos pkts (pacotes) e bytes de uma regra, onde devemos especificar a tabela e a cadeia a ser limpo os contadores, caso não especifique, todos os contadores serão limpos.

Os contadores podem ser exibidos pela opção -v do comando iptables como mostra o comando abaixo.

# iptables -t nat -L -n -v

Chain POSTROUTING (policy ACCEPT 96 packets, 7378 bytes)

pkts bytes target prot opt in out source destination

832 50143 MASQUERADE 0 -- * eth0 0.0.0.0/0 0.0.0.0/0

Repare que no campo pkts temos 832 pacotes e no campo bytes 50143 bytes, e agora podemos zera-los usado a opção -Z em conjunto com as opções -L e -v, onde a opção -Z zera os pacotes e os bytes evitando o tráfego de pacotes durante a exibição e ao mesmo tempo exibe os campos zerados com as opções -L e -v.

# iptables -t nat -Z POSTROUTING -L -v

Chain POSTROUTING (policy ACCEPT 0 packets, 0 bytes)

pkts bytes target prot opt in out source destination

0 0 MASQUERADE 0 -- any wlan0 anywhere anywhere

Política de uma cadeia (chain) ( -P )

A política padrão do iptables é ACCEPT , e serve para especificar o destino de um
A política padrão do iptables é ACCEPT , e serve para especificar o destino de um

A política padrão do iptables é ACCEPT, e serve para especificar o destino de um pacote quando ele atingir o final das regras de uma cadeia. Essa política pode alterada através da opção -P do comando iptables como mostra a sintaxe abaixo.

iptables -t tabela -P cadeia ACCEPT/DROP

As duas políticas que podem ser usadas são: ACCEPT (bloqueia e depois aceita pacotes) e DROP (aceita e depois rejeita pacotes).

ACCEPT – essa política é utilizada junta com regras de restritivas (DROP e REJECT) na mesma cadeia (chain), ou seja, primeiro tudo é bloqueado e o resto é aceito.

DROP – essa política é utilizada junta com regras de permissivas (ACCEPT) na mesma cadeia (chain), ou seja, primeiro tudo é aceito e o resto é bloqueado.

Para exibir as políticas das cadeias execute o comando iptables -L.

# iptables -L

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

Repare a política padrão das cadeias (chains) INPUT, FORWARD e OUTPUT é ACCEPT , onde podemos
Repare a política padrão das cadeias (chains) INPUT, FORWARD e OUTPUT é ACCEPT , onde podemos

Repare a política padrão das cadeias (chains) INPUT, FORWARD e OUTPUT é ACCEPT, onde podemos alterar com a opção -P do comando iptables como mostra o exemplo abaixo:

# iptables -P INPUT DROP

Agora exibindo novamente a política INPUT, veja que a política ACCEPT foi alterada para DROP.

# iptables -L INPUT

Chain INPUT (policy DROP)

target prot opt source destination

Agora iremos criar duas regras utilizando a política DROP criada acima, onde primeiramente cria-se as regras que serão aceitas e depois no final as que bloqueia.

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

# iptables -A INPUT -p tcp -d 127.0.0.1 --dport 22 -j DROP

Acima foram criadas duas regras:

A primeira regra aceita pacotes ICMP do comando ping que tem como destino o endereço IP 127.0.0.1 e como destino ACCEPT (aceitar pacotes). A segunda regra bloqueia a porta 22 do ssh que tem como destino o endereço IP 127.0.0.1 e como destino DROP (rejeitar pacotes).

Agora execute o comando ping e veja que na primeira regra você consegue obter resposta, já na segunda regra não, pois a porta 22 está bloqueada para aceitar conexões TCP.

$ ping -c 2 127.0.0.1 PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data. 64 bytes from 127.0.0.1:
$ ping -c 2 127.0.0.1 PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data. 64 bytes from 127.0.0.1:

$ ping -c 2 127.0.0.1

PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.

  • 64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.072 ms

  • 64 bytes from 127.0.0.1: icmp_seq=2 ttl=64 time=0.079 ms

--- 127.0.0.1 ping statistics ---

2 packets transmitted, 2 received, 0% packet loss, time 1007ms

rtt min/avg/max/mdev = 0.072/0.075/0.079/0.009 ms

Repare que os comandos abaixo não obtêm resposta, por que a segunda regra está rejeitando pacotes na porta 22.

$ ssh -l usuario 127.0.0.1

ou

$ telnet 127.0.0.1 22

*Obs – Para comando ssh funcionar o servidor ssh, deve estar sendo executado, para isso execute o comando /etc/init.d/ssh start em distribuições Debian.

# /etc/init.d/ssh start

Agora mudando a política DROP para o padrão ACCEPT novamente e substituindo as regras anteriores alterando o destino onde está ACCEPT pra DROP e vice-versa, o comando ping estará bloqueado para aceitas pacotes ICMP e a porta 22 aceitando conexões TCP.

Alterando a política de DROP para ACCEPT

# iptables -P INPUT ACCEPT

Substituindo a primeira regra na linha 1 alterando o destino ACCEPT para DROP # iptables -R
Substituindo a primeira regra na linha 1 alterando o destino ACCEPT para DROP # iptables -R

Substituindo a primeira regra na linha 1 alterando o destino ACCEPT para DROP

# iptables -R INPUT 1 -p icmp -d 127.0.0.1 -j DROP

Substituindo a primeira regra na linha 1 alterando o destino ACCEPT para DROP

# iptables -R INPUT 2 -p tcp -d 127.0.0.1 --dport 22 -j ACCEPT

Especificando opções iptables

Endereço de origem e destino

A opção -s que também pode ser usado --src ou --source serve para especificar a origem dos pacotes e -d onde pode ser usado --dst ou –destination especifica o destino dos pacotes. Nessa opções é permitido usar um endereço IP (192.168.0.1), um host (pc1), um host completo FQDN (pc1.dominio.com.br) ou uma rede que pode ser usado máscara de rede padrão (192.168.0.0/255.255.255.0) ou máscara de rede CIDR (Veja a aula de endereço IP) 192.168.0.0/24. Caso não seja especificado um endereço IP ou rede, será atribuído o valor 0/0 que significa todos os computadores e todas as redes.

Exemplos:

Aceita todos os pacotes tcp na interface de rede eth0 que tem como origem a rede 192.168.0.0/24 e destino o computador 192.168.0.1

# iptables -A INPUT -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 -j ACCEPT

Bloqueia os pacotes tcp na interface de rede eth0 que tem como origem a rede 192.168.0.0/255.255.255.0 e destino o host pc1

# iptables -A INPUT -p tcp -i eth0 --src 192.168.0.0/255.255.255.0 --dst pc1 -j DROP

Bloqueia os pacotes tcp da porta 22 na interface de rede eth0 que tem como origem a rede 192.168.0.0/24 e destino o host pc1.dominio.com.br.

# iptables -A INPUT -p tcp -i eth0 -- source 192.168.0.0/24 -- destination pc1.dominio.com.br -- dport
# iptables -A INPUT -p tcp -i eth0 -- source 192.168.0.0/24 -- destination pc1.dominio.com.br -- dport

# iptables -A INPUT -p tcp -i eth0 --source 192.168.0.0/24 --destination pc1.dominio.com.br --dport 22 -j DROP

Bloqueia os pacotes tcp da porta 22 na interface de rede eth0 que tem como origem todos os computadores e todas as redes todos e destino o computador 192.168.0.1.

# iptables -A INPUT -p tcp -i eth0 -d 192.168.0.1 --dport 22 -j DROP

Interface de origem e destino

A opção -i (in - entrada) que pode ser usada também --in-interface serve para especificar a interface de rede de entrada de origem e destino dos pacotes e a opção -o (out - saída) que pode ser usado --out-interface serve para especificar a interface de rede de saída de origem e destino dos pacotes.

A interface de entrada -i nunca pode ser usada com uma cadeia (chain) de saída OUTPUT e POSTROUTING, e a interface de saída -o nunca pode ser usada com uma cadeia (chain) de entrada INPUT e PREROUTING. A cadeia (chain) FORWARD pode ser usada tanto para entrada -i como para saída -o, pois nessa cadeia trafega tanto pacotes de entrada como de saída.

As interfaces de rede geralmente são especificadas como ppp0, eth0, eth1,

... também podemos utilizar a interface lo de loopback para o endereço localhost ou

e

127.0.0.1. No caso especificar mais de uma interface do mesmo tipo como eth0,

eth1, ...

podemos usar o sinal de + (eth+) como mostra os exemplos abaixo.

Exemplos:

Para exibir as interfaces de entrada no campo in e saída no campo out, use a opção -v do comando iptables junto com as opções -L -n.

# iptables -L -n -v

Chain FORWARD (policy ACCEPT 2400 packets, 344K bytes)

pkts bytes target prot opt in out source destination 0 0 DROP tcp -- eth0 eth1
pkts bytes target prot opt in out source destination 0 0 DROP tcp -- eth0 eth1

pkts bytes target prot opt in out source destination

0 0 DROP tcp -- eth0 eth1 0.0.0.0/0 0.0.0.0/0

Aceita conexões tcp na interface ppp0

# iptables -A INPUT -i ppp0 -p tcp -j ACCEPT

Aceita conexões tcp na interface lo que tem como origem e destino o endereço

127.0.0.1

# iptables -A INPUT -i lo -p tcp -s 127.0.0.1 -d 127.0.0.1 -j ACCEPT

Aceita conexões tcp em todas interfaces que começam em eth0, eth1, eth2, tem como origem o endereço IP 192.168.0.1

...

que

# iptables -A INPUT -i eth+ -p tcp -d 192.168.0.1 -j ACCEPT

Bloqueia o tráfego de entrada (-A INPUT) de pacotes TCP na interface de rede eth1 (-i eth1)

# iptables -A INPUT -i eth1 -p tcp -d 192.168.0.1 -j DROP

Para aumentar a segurança dos usuários locais, você pode bloquear o tráfego de conexões que saem dos computadores da rede local para a internet, especificando a interface de rede conectada a rede local.

# iptables -A OUTPUT -o eth1 -p tcp -j DROP

Bloqueia o tráfego de entrada e saída pacotes TCP da interface de entrada -i eth0 para a interface de saída -o eth1

# iptables -A FORWARD -p tcp -i eth0 -o eth1 -j DROP

Protocolos

A opção -p que pode ser usada a opção -- protocol (protocolo) serve para especificar o
A opção -p que pode ser usada a opção -- protocol (protocolo) serve para especificar o

A opção -p que pode ser usada a opção --protocol (protocolo) serve para especificar o protocolo usado que pode ser tcp, udp e icmp.

Exemplos:

Bloqueia pacotes TCP para a porta 22 do SSH na interface de rede eth0 que tem como destino o endereço IP 192.168.0.1

# iptables -A INPUT -p tcp -i eth0 -d 192.168.0.1 --dport 22 -j DROP

Bloqueia pacotes UDP para a porta 53 do DNS na interface de rede eth0 que tem como destino o endereço IP 192.168.0.1

# iptables -A INPUT -p udp -i eth0 -d 192.168.0.1 --dport 53 -j DROP

Bloqueia pacotes ICMP usado pelo comando ping na interface de rede eth0 que tem como destino o endereço IP 192.168.0.1

# iptables -A INPUT -p icmp -i eth0 -d 192.168.0.1 -j DROP

Portas de origem e destino

A opção --sport que pode ser usada também --source-port serve para especificar a porta de origem e a opção - -dport que pode ser usada também --destination-port serve para especificar a porta de destino.

Exemplos:

Bloqueia as conexões tcp da porta 22 na interface eth0 que tem como origem a rede 192.168.0.0/24 e destino o computador 192.168.0.1. A opção –sport veremos mais a frente no redirecionamento de portas com DNAT e SNAT.

# iptables -A INPUT -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 --dport 22 -j DROP

Para especifica um intervalo de portas utilize dois pontos (21:81). # iptables -A INPUT -p tcp
Para especifica um intervalo de portas utilize dois pontos (21:81). # iptables -A INPUT -p tcp

Para especifica um intervalo de portas utilize dois pontos (21:81).

# iptables -A INPUT -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 --dport 21:81 -j DROP

Este exemplo rejeita conexões TCP na interface eth0 nas portas altas do firewall acima da porta 1024 até 65535.

# iptables -A INPUT -p tcp -i eth0 --dport 1024:65535 -j DROP

Para especificar várias portas é necessário utilizar o módulo multiport, onde as portas devem ser separadas por vírgula (21, 22, 80).

# iptables -A INPUT -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 -m multiport --dport 21, 22, 80 -j DROP

Mensagens do protocolo ICMP

Com o protocolo ICMP não possui portas, controle sobre o tráfego dos pacotes são feitos pelos tipos de mensagens ICMP que são exibidas pelo comando iptables -p icmp –help.

# iptables -p icmp --help

ou

# iptables -p icmp -h

Por exemplo observando as mensagens temos as mensagens echo-reply (pong) responsável pelo resposta de ping e echo-request (ping) responsável pelo

requisição de ping, onde podemos bloqueá-las e assim bloqueando o comando

ping.

# iptables -A INPUT -i eth0 -p icmp --icmp-type echo-request -j DROP

Pacotes syn A opção --syn especifica pacotes syn que são usados para iniciar uma conexão usando

Pacotes syn

Pacotes syn A opção --syn especifica pacotes syn que são usados para iniciar uma conexão usando

A opção --syn especifica pacotes syn que são usados para iniciar uma conexão usando o protocolo TCP, bloqueando esses pacotes o computador que enviou os pacotes syn, nunca obterá uma resposta, pois a conexão não será realizada, apenas as conexões já estabelecidas não serão bloqueadas.

A regra abaixo bloqueia qualquer tentativa de conexão que venha da interface de rede eth0, e em seguida aceita apenas conexões para o computador local no endereço de loopback 127.0.0.1 tanto na origem como no destino.

# iptables -A INPUT -p tcp -i eth0 --syn -j DROP

# iptables -A INPUT -p tcp -i eth0 --syn -s 127.0.0.1 -d 127.0.0.1 -j ACCEPT

Essa opção --syn pode ser invertida se precedida por “ ! “, o que significa rejeitar qualquer pacote (ACK,FIN,RST,URG,PSH) exceto os que iniciam conexões SYN.

# iptables -A INPUT -p tcp -i eth0 ! --syn -j DROP

Flags tcp (--tcp-flags)

O cabeçalho TCP identifica um pacote TCP que está sendo enviado por flags de bits(Urg, Ack, Psh, Rst, Syn e Fin). As flags Urg e Psh dificilmente são utilizadas, abaixo segue as combinações de flags usadas pelo TCP.

Combinações

Descrição

de flags

SYN

É o primeiro pacote a ser enviado em uma conexão entre a origem e o destino

SYN ACK

O destino responde ao pacote SYN, confirmando sua mensagem original e enviando SYN como resposta

ACK

Cada pacote utilizado em uma conexão estabelecida possui um bit ACK ativado para confirmar os pacotes recebidos anteriormente

FIN No momento em que uma conexão estiver sendo fechada, será enviado um pacote FIN para
FIN No momento em que uma conexão estiver sendo fechada, será enviado um pacote FIN para

FIN

No momento em que uma conexão estiver sendo fechada, será enviado um pacote FIN para o outro

FIN ACK

Este tipo de combinação é utilizada para confirmar o primeiro pacote FIN e completar o encerramento da conexão

RST

Quando um pacote é enviado de forma inesperada é enviado um pacote reset(RST), por exemplo, em uma conexão se for recebido um pacote SYN ACK sem ter enviado um pacote SYN será enviado um pacote RST

As vezes é necessário permitir conexões TCP em uma única direção e não nas duas direções. Por exemplo, temos um servidor HTTP externo onde é permitido fazer requisições de conexões e não conexões vindas deste servidor.

A solução seria bloquear os pacotes TCP vindos do servidor, mas as conexões TCP precisam de pacotes bidirecionais (indo e vindo) para estabelecer a conexão. Então a solução é bloquear os pacotes SYN (com as flags SYN ativadas e as flags RST e ACK desativadas, mas dizemos pacotes SYN como atalho) que são utilizados para iniciar uma conexão, onde rejeitando esses pacotes a conexão será bloqueada.

O protocolo TCP também possui as flags SYN, ACK, FIN, RST, URG e PSH, onde podemos especificar todas as flags com a opção ALL, nenhuma com a opção NONE e utilizar o uso de exceções com “ ! “ na primeira opção depois da opção --tcp-flags.

A opção --tcp-flags permite você filtrar flags TCP especificas. A primeira opção depois de --tcp-flags especifica as flags que são analisadas, e a segunda opção especifica as flags que são ajustadas para serem rejeitadas ou aceitas.

É possível fazer combinações de flags na primeira opção e na segunda após a opção --tcp-flags, como por exemplo:

Opção --tcp-flags

1ª opção

2ª opção

--tcp-flags

ALL

ALL

--tcp-flags

ALL

NONE

--tcp-flags

ALL

SYN,ACK

-- tcp-flags SYN,RST,ACK SYN -- tcp-flags SYN,ACK,FIN,RST,URG,PSH SYN,ACK,FIN,RST,URG,PSH -- tcp-flags ! SYN,ACK,RST SYN,ACK Para fazer testes
-- tcp-flags SYN,RST,ACK SYN -- tcp-flags SYN,ACK,FIN,RST,URG,PSH SYN,ACK,FIN,RST,URG,PSH -- tcp-flags ! SYN,ACK,RST SYN,ACK Para fazer testes

--tcp-flags

SYN,RST,ACK

SYN

--tcp-flags

SYN,ACK,FIN,RST,URG,PSH

SYN,ACK,FIN,RST,URG,PSH

--tcp-flags

! SYN,ACK,RST

SYN,ACK

Para fazer testes de conexão, use o comando ssh que usa pacotes TCP que possui as flags tcp.

$ ssh -l aluno1 192.168.0.1

Exemplos:

Analisa todas as flags na primeira opção ALL, e na segunda opção especifica a flag SYN onde será rejeitada qualquer tentativa de conexão.

# iptables -A INPUT -p tcp -i eth0 --tcp-flags ALL SYN -j DROP

Analisa todas as flags na primeira opção ALL, e na segunda opção NONE não especifica nenhuma flag a ser rejeitada.

# iptables -A INPUT -p tcp -i eth0 --tcp-flags ALL NONE -j DROP

Analisa todas as flags na primeira opção ALL, e na segunda opção ALL especifica todas as flags a serem rejeitadas.

# iptables -A INPUT -p tcp -i eth0 --tcp-flags ALL ALL -j DROP

Analisa as flags na primeira opção ACK e RST com exceção da flag SYN ( ! SYN ), e na segunda opção rejeita as flags ACK e RST.

# iptables -A INPUT -p tcp -i eth0 --tcp-flags ! SYN,ACK,RST ACK,RST -j DROP

Analisa as flags na primeira opção SYN e FIN, e na segunda opção rejeita ambas as flags.

# iptables -A INPUT -p tcp -i eth0 --tcp-flags SYN,FIN SYN,FIN -j DROP

Analisa as flags na primeira opção ACK e FIN, e na segunda opção rejeita a flag FIN sem o acompanhamento da flag ACK.

# iptables -A INPUT -p tcp -i eth0 -- tcp-flags ACK,FIN FIN -j DROP
# iptables -A INPUT -p tcp -i eth0 -- tcp-flags ACK,FIN FIN -j DROP

# iptables -A INPUT -p tcp -i eth0 --tcp-flags ACK,FIN FIN -j DROP

Fragmentos ( -f )

Quando um pacote TCP é muito grande para ser enviado de uma única vez, então o pacote é dividido em pedaços menores que são chamados de fragmentos que são transmitidos como múltiplos pacotes através de um computador de origem para ser reconstituído em um computador destino.

Para especificar fragmentos em regras podemos utilizar a opção -f ou --fragment, para conexões com NAT, todos os fragmentos serão reconstituídos antes de atingirem o código do filtro de pacotes, então você não precisa se preocupar com fragmentos.

Este exemplo bloqueia qualquer fragmento saído da interface eth0 que tenha como destino o computador 192.168.0.1

# iptables -A OUTPUT -p tcp -o eth0 -f -d 192.168.0.1 -j DROP

Exceções ( ! )

As exceções representada por uma exclamação ! podem ser aplicadas em endereços IP ou de rede de origem e destino, protocolos, portas e etc.

Por exemplo:

# iptables -A INPUT -p tcp -i eth0 -s ! 192.168.0.2 -d 192.168.0.1 --destination-port 22 -j DROP

Essa regra bloqueia a porta 22 para qualquer computador, exceto para o computador 192.168.1.2 ( ! 192.168.1.2) que utiliza o protocolo tcp, na interface de rede eth0, que tenha como origem qualquer computador e como destino o computador 192.168.0.1.

# iptables -A INPUT -p tcp ! --syn -i eth0 -s 192.168.0.0/24 -d 192.168.0.2 -j DROP
# iptables -A INPUT -p tcp ! --syn -i eth0 -s 192.168.0.0/24 -d 192.168.0.2 -j DROP

# iptables -A INPUT -p tcp ! --syn -i eth0 -s 192.168.0.0/24 -d 192.168.0.2 -j DROP

Essa regra bloqueia a todos os pacotes, exceto os pacotes que tentam iniciar conexões syn ( ! --syn) que utiliza o protocolo tcp, na interface de rede eth0, que tem como origem a rede 192.168.0.0/24 e o destino o computador 192.168.0.2. As conexões já efetuadas não são atingidas por esta regra, e somente pode ser aplicada em conexões TCP.

# iptables -A INPUT -p tcp -i eth0 -s 192.168.0.0/24 -d 192.168.0.1 -m multiport --dport ! 22, 21, 80 -j DROP

Essa regra que utiliza o módulo multiport (para especificar várias portas) bloqueia todas as portas para a rede 192.168.0.0/24, exceto as portas 21, 22 e 80 ( ! 22, 21, 80) que utiliza o protocolo tcp, na interface de rede eth0, que tenha como destino o computador 192.168.0.1.

Destino

O destino de um pacote em uma regra é representado pela letra -j que pode ser -j ACCEPT (aceitar pacotes), -j DROP (rejeitar pacotes), -j LOG (gravar em logs), -j REDIRECT (redireciona pacotes), -j SNAT (redirecionamento de origem), -j DNAT (redirecionamento de destino), -j RETURN (retorna o resultado da cadeia anterior sem executar o restante do cadeia atual).

Nos exemplos acima vimos os destinos ACCEPT e DROP, veremos agora os destinos REJECT, LOG e RETURN e mais adiante REDIRECT, SNAT e DNAT na seção de redirecionamento de portas e endereços de origem e destino.

REJECT

O destino REJECT rejeita pacotes assim como o destino DROP, pode ser usado apenas na tabela filter e não pode ser utilizado como política padrão assim como ACCEPT e DROP, e tem como diferença que ele envia uma mensagem ICMP "port-unreachable" “porta inalcançável” e o destino DROP não.

As vezes é melhor usar REJECT do que DROP para bloquear portas, pois dá uma impressão que o computador está sem firewall e além do mais DROP gasta mais

tempo nas repostas de portas de serviços, portscanners e sniffers com nmap e netcat diminuindo assim
tempo nas repostas de portas de serviços, portscanners e sniffers com nmap e netcat diminuindo assim

tempo nas repostas de portas de serviços, portscanners e sniffers com nmap e netcat diminuindo assim os recursos da máquina.

Exemplo:

Rejeita conexões de pacotes icmp na interface de loopback 127.0.0.1

# iptables -A INPUT -p icmp -d 127.0.0.1 -j REJECT

# iptables -L INPUT -n

Chain INPUT (policy ACCEPT)

target prot opt source destination

REJECT icmp -- 0.0.0.0/0 127.0.0.1 reject-with icmp-port-unreachable

$ ping -c 2 127.0.0.1

Rejeita conexões de pacotes tcp na porta 22 do SSH na interface de rede eth0 que tem como destino o computador 192.168.0.1. Para isso devemos ter o SSH instalado e executando o serviço e o portscanner nmap (caso não tenha instalado use o comando:

# apt-get install nmap

Iniciando o serviço ssh

# /etc/init.d/ssh start

Utilizando o portscanner nmap abaixo, veja que a porta do ssh está aberta.

# nmap -sS localhost Starting Nmap 4.11 ( http://www.insecure.org/nmap/ ) at 2008-04-01 00:50 BRT Interesting ports
# nmap -sS localhost Starting Nmap 4.11 ( http://www.insecure.org/nmap/ ) at 2008-04-01 00:50 BRT Interesting ports

# nmap -sS localhost

Starting Nmap 4.11 ( http://www.insecure.org/nmap/ ) at 2008-04-01 00:50 BRT

Interesting ports on localhost (127.0.0.1):

Not shown: 1677 closed ports

PORT STATE SERVICE

22/tcp open ssh

80/tcp open http

113/tcp open auth

Agora rejeite conexões na porta 22 do ssh

# iptables -A INPUT -p tcp -i eth0 -d 192.168.0.1 --dport 22 -j REJECT

Execute o comando nmap novamente, e veja que agora está filtrada onde obtêm-se também usando DROP.

# nmap -sS localhost

Starting Nmap 4.11 ( http://www.insecure.org/nmap/ ) at 2008-04-01 00:50 BRT

Interesting ports on localhost (127.0.0.1):

Not shown: 1677 closed ports

PORT STATE SERVICE

22/tcp filtered ssh

80/tcp open http

113/tcp open auth

LOG

Este destino grava mensagens de log do tráfego de pacotes nos arquivos /var/log/syslog (Debian) ou /var/log/messages (Red Hat / Fedora) do daemon syslog do sistema.

O destino LOG serve para gravar logs de uma determinada regra em seu firewall, onde geralmente
O destino LOG serve para gravar logs de uma determinada regra em seu firewall, onde geralmente

O destino LOG serve para gravar logs de uma determinada regra em seu firewall, onde geralmente deve ser aplicada no final de uma cadeia (chain) para posterior análise das tentativas de conexões, facilitando assim o conhecimento das regras que estão sendo aceitas ou bloqueadas.

No iptables não é possível gravar em log e especificar o destino na mesma regra, para gravar mensagens de log de uma regra, primeiramente deve-se gravar em log as tentativas de conexões e depois especificar a regra de destino, onde aceitará os pacotes (-j ACCEPT) ou rejeitará (-j DROP ou REJECT), caso contrário não funcionará a regra de LOG.

Vale lembrar que para política padrão -P ACCEPT (permissiva) deve-se primeiro bloquear tudo (-j DROP ou REJECT) e depois aceitar (-j ACCEPT) o que você quer no final, para a política -P DROP (restritiva) é o contrário.

Exemplo:

Grava em log todas as conexões tcp vindas da interface eth0 do computador

192.168.1.30

# iptables -A INPUT -p tcp -i eth0 -s 192.168.1.30 -j LOG

# iptables -A INPUT -p tcp -i eth0 -s 192.168.1.30 -j REJECT

Exiba as regras com o comando iptables -L -n -v

# iptables -L -n

Chain INPUT (policy ACCEPT)

target prot opt source destination

LOG tcp -- 192.168.1.30 0.0.0.0/0 LOG flags 0 level 4

REJECT tcp -- 192.168.1.30 0.0.0.0/0 reject-with icmp-port-unreachable
REJECT tcp -- 192.168.1.30 0.0.0.0/0 reject-with icmp-port-unreachable

REJECT tcp -- 192.168.1.30 0.0.0.0/0 reject-with icmp-port-unreachable

A partir de um computador da rede local (192.168.1.30), tente acessar um serviço que usa o protocolo TCP como o SSH e observe a saída do comando abaixo que a conexão estará recusada.

$ ssh -l aluno1 192.168.1.1

ssh: connect to host 192.168.1.1 port 22: Connection refused

Agora no computador com o firewall, observe no log do syslog as mensagens enviadas das tentativas de conexões com os comandos tail -f /var/log/syslog ou dmesg

# tail -f /var/log/syslog

ou

# dmesg

Apr 1 20:25:09 firewall kernel: IN=eth0 OUT= MAC=00:11:2f:90:a6:75:00:c0:df:22:d7:dc:08:00 SRC=192.168.1.30 DST=192.168.1.1 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=63356 DF PROTO=TCP SPT=38316 DPT=22 WINDOW=5840 RES=0x00 ACK SYN URGP=0

Analisando as mensagem de log acima temos os seguintes campos:

Apr 1 20:25:09 - Exibe o mês, o dia e a hora

firewall - Nome do computador local que gravou o log

kernel - Nome de daemon que registrou a mensagem, o iptables utilizada o próprio do kernel

IN - Interface de entrada de origem do pacote

OUT - Interface de saída de destino do pacote

MAC - Endereço MAC da interface de rede local e da interface de rede remota

SRC - Endereço IP de origem

DST - Endereço IP de destino LEN - Tamamho do pacote em bytes TOS - Prioridade

DST - Endereço IP de destino

LEN - Tamamho do pacote em bytes

TOS - Prioridade do pacote

PREC - Prioridade do pacote

TTL - Tempo de vida do pacote

DST - Endereço IP de destino LEN - Tamamho do pacote em bytes TOS - Prioridade

ID - Identificação do pacote que é usado por fragmentos posteriores desse pacote

DF - (DF - Don't Fragment) - Esta opção diz para não fragmentar pacotes pequenos.

PROTO - Especifica o tipo do protocolo podendo ser TCP, UDP ou ICMP.

SPT - Especifica a porta de origem do pacote

DPT - Especifica a porta de destino do pacote

ACK SYN - Especifica flags TCP

Acima temos um log na porta 22 (DPT) que tem com origem o computador 192.168.1.30 (SRC) e destino o computador 192.168.1.1 (DST). Quando temos muitas regras fica complicado conferir os endereços de origem e destino e suas respectivas portas com as regras de acesso (ACCEPT) ou bloqueio (DROP ou REJECT).

Para isso o destino LOG tem opções que permite especificar uma descrição do log para facilitar a análise.

--log-prefix “Descrição” - Especifica uma descrição de até 29 caracteres da regra a ser gravada em log para melhor identificação.

--log-level nível - Determina o nível da mensagem no syslog que pode ser debug, info, notice, warning, err, crit, alert and emerg, que corresponde aos números de 7 até 0. Para mais detalhes veja a aula mensagens do sistema do curso de Linux Intermediário.

Para especificar uma descrição para nosso exemplo acima, acrescente a opção --log-prefix a nossa regra abaixo,
Para especificar uma descrição para nosso exemplo acima, acrescente a opção --log-prefix a nossa regra abaixo,

Para especificar uma descrição para nosso exemplo acima, acrescente a opção --log-prefix a nossa regra abaixo, deixe um espaço no final da linha onde tem a descrição, para para a próxima opção do log.

# iptables -A INPUT -p tcp -i eth0 -s 192.168.1.30 -j LOG --log-prefix "Firewall:

porta 22 REJEITADA "

# iptables -A INPUT -p tcp -i eth0 -s 192.168.1.30 -j REJECT

Agora observe as mensagens de log com dmesg ou tail -f /var/log/syslog, e veja a descrição Firewall: porta 22 REJEITADA

# tail -f /var/log/syslog

Apr 1 22:45:55 firewall kernel: Firewall: porta 22 REJEITADA IN=eth0 OUT= MAC=00:11:2f:90:a6:75:00:90:f5:63:33:ee:08:00 SRC=192.168.1.20 DST=192.168.1.10 LEN=60 TOS=0x00 PREC=0x00 TTL=64 ID=22535 DF PROTO=TCP SPT=54952 DPT=22 WINDOW=5840 RES=0x00 SYN URGP=0

RETURN

O destino RETURN serve para interromper a execução de uma regra atual e retornar para a regra anterior ou posterior. Funciona semelhante aos comandos IF(SE) e ELSE (SENÃO) em linguagens de programação como C, Perl, Shell Script, Php etc, algo somo:

IF regra anterior for verdadeira

execute a regra anterior

ELSE

execute a regra posterior

Quando uma regra contêm o destino RETURN ela será analisada, e caso encontre informações contidas na regra anterior então é executada a regra anterior, caso contrário executada a regra posterior e caso não encontre informações na regra

posterior, então a política padrão da cadeia (ACCEPT – bloqueia tudo e aceita o resto) ou
posterior, então a política padrão da cadeia (ACCEPT – bloqueia tudo e aceita o resto) ou

posterior, então a política padrão da cadeia (ACCEPT – bloqueia tudo e aceita o resto) ou (DROP – aceita tudo e rejeita o resto) é utilizada para definir o destino do pacote.

Tendo em mente agora a política padrão das cadeias ACCEPT e DROP, iremos utilizar como exemplo um computador com o firewall 192.168.1.10 e dois computadores da rede 192.168.1.20 e 192.168.1.30, onde serão rejeitados pacotes ICMP do comando ping para o computador 192.168.1.20 e para o computador

  • 192.168.1.30 não.

Essa é a primeira regra onde rejeitada pacotes ICMP para o computador de origem

192.168.1.20

# iptables -A INPUT -p icmp -i eth0 -s 192.168.1.20 -j DROP

Essa é regra que contém o destino RETURN que analisará as informações da regra anterior, caso as informações sejam verdadeiras então interrompe a execução e retorna para a regra anterior, onde rejeitará o pacotes (-j DROP), caso contrário será analisadas as regras posteriores onde poderá aceitar (ACCEPT) ou rejeitar (REJECT ou DROP) o pacote.

# iptables -A INPUT -p icmp -i eth0 -s 192.168.1.20 -j RETURN

Agora adicione as regras posteriores onde aceitará os pacotes ACCEPT para os dois computadores 192.168.1.20 e 192.168.1.30

# iptables -A INPUT -p icmp -i eth0 -s 192.168.1.20 -j ACCEPT

# iptables -A INPUT -p icmp -i eth0 -s 192.168.1.30 -j ACCEPT

Exiba as regras com o comando iptables -L INPUT -n --line-numbers

Chain INPUT ( policy ACCEPT ) num target prot opt source destination 1 DROP icmp --
Chain INPUT ( policy ACCEPT ) num target prot opt source destination 1 DROP icmp --

Chain INPUT (policy ACCEPT)

num target prot opt source destination

  • 1 DROP icmp -- 192.168.1.20 0.0.0.0/0

  • 2 RETURN icmp -- 192.168.1.20 0.0.0.0/0

  • 3 ACCEPT icmp -- 192.168.1.20 0.0.0.0/0

  • 4 ACCEPT icmp -- 192.168.1.30 0.0.0.0/0

Agora a partir do computador 192.168.1.20, execute o comando ping:

$ ping 192.168.1.10

E não obtêm resposta, pois na (linha 2) onde está o destino RETURN, contém informações sobre endereço IP 192.168.1.20 e então diz para voltar para a regra anterior (linha 1) que rejeita o pacote (-j DROP) para o endereço IP 192.168.1.20.

Agora a partir do computador 192.168.1.30, execute o comando ping:

$ ping 192.168.1.10

PING 192.168.1.10 (192.168.1.10) 56(84) bytes of data.

64 bytes from 192.168.1.10: icmp_seq=1 ttl=64 time=0.092 ms

E obtêm resposta, pois na (linha 2) onde está o destino RETURN, não contém informações sobre o endereço IP 192.168.1.30 e então diz para continuar a execução da regra posterior (linha 3) que também não tem informações sobre o endereço IP 192.168.1.30 e finalmente na (linha 4) encontra informações sobre o endereço IP 192.168.1.30 onde aceita o pacote (-j ACCEPT).

Caso não encontrasse informações sobre o endereço IP 192.168.1.30 na última linha, então seria aplicada a política padrão da cadeia que neste caso é ACCEPT (-j ACCEPT) e aceitaria o pacote e se fosse DROP (-j DROP) rejeitaria.

Salvando e restaurando as regras Podemos salvar e recuperar as regras de duas maneiras: • A

Salvando e restaurando as regras

Salvando e restaurando as regras Podemos salvar e recuperar as regras de duas maneiras: • A

Podemos salvar e recuperar as regras de duas maneiras:

A primeira é criar um shell script como foi mostrado acima no começo deste capítulo (que é o correto) com todos os comandos executados onde você pode personalizar seu script de firewall. A segunda é usar os comandos iptables-save (para salvar as regras) e iptables-restore (para restaurar as regras).

A sintaxe dos comandos é da seguinte forma:

Para salvar as regras

# iptables-save > /diretorio/regras

Para restaurar as regras

# iptables-restore < /diretorio/regras

Tabela NAT

A tabela NAT (Network Address Translation – Tradução de endereço de rede) serve para controlar o tráfego da tradução de endereços, onde é feito o masquerading (mascaramento) que é uma técnica que consiste em reescrever os endereços IP (Ex:192.168.0.10) de origem de um pacote de que passam sobre um roteador, gateway ou firewall (Ex:192.168.0.1) de maneira que um computador de uma rede interna (Ex: 192.168.0.0) tenha acesso ao exterior (Ex:200.204.0.100 - rede pública – Internet).

Nesta tabela podemos fazer o masquerading (mascaramento) de IP quando se deseja compartilha a conexão com a internet para os demais computadores da rede e podemos SNAT(endereço de origem) e DNAT(endereço de destino) onde podemos redirecionar as conexões para um servidor da nossa rede local, como foi mostrado no capítulo Configurando o roteador.

Para monitorar as conexões na tabela nat use o comando cat /proc/net/ip_conntrack.

$ cat /proc/net/ip_conntrack

Criando uma cadeia na tabela NAT

Para criar uma nova cadeia (chain) na tabela nat é a mesma sintaxe onde criamos uma nova cadeia acima, apenas deve ser especificado a opção -t nat para não ser criada na tabela padrão filter.

# iptables -t nat -N Minha-Cadeia Para adicionar regras na nova cadeia da tabela NAT, deve

# iptables -t nat -N Minha-Cadeia

# iptables -t nat -N Minha-Cadeia Para adicionar regras na nova cadeia da tabela NAT, deve

Para adicionar regras na nova cadeia da tabela NAT, deve ser especificado a opção

-t nat

# iptables -t nat -A Minha-Cadeia -p tcp --dport 22 -j DROP

E para exibir as regras também deve ser especificado a opção -t nat

# iptables -t nat -L -n

Chain Minha-Cadeia (0 references)

target prot opt source destination

DROP tcp -- 0.0.0.0/0 0.0.0.0/0 tcp dpt:22

Mascaramento de IP (Masquerading)

Para habilitar o mascaramento de IP no Linux e compartilhar a conexão com a internet para todos os computadores da rede local 192.168.0.0/24. O IP Masquerading que utiliza o destino -j MASQUERADE é um tipo especial de SNAT (que veremos logo em seguida abaixo) e que utiliza sempre a cadeia POSTROUTING.

O IP Masquerading é feito da seguinte forma:

Os endereços privados da rede local (192.168.0.2, 192.168.0.2,

) se conecta ao

... roteador ou firewall, onde os endereços IP são substituídos pelo IP válido na internet

fornecido pelo provedor que pode ser fixo ou dinâmico (200.xxx.xxx.xxx), permitindo assim que os computadores acessarem a internet, e depois de a conexão conseguir ser estabelecida a operação é invertida.

Veja a seqüencia abaixo:

Computadores rede local

Roteador / Firewall

Internet

192.168.0.2, 192.168.0.3 ... =>

<=> 192.168.0.1 <=>

=> 200.000.000.100

Internet

Roteador / Firewall

Computadores rede local

200.000.000.100 =>

<=> 192.168.0.1 <=>

<= 192.168.0.2,

192.168.0.3 ...

Para ativar o roteamento de pacotes do kernel digite o comando: # echo "1" >/proc/sys/net/ipv4/ip_forward E(ppp 0) pelo navegador acessando o endereço IP do firewall http://200.0.0.10 0 com um amigo de uma LAN HOUSE pelo amsn, ou fazer os testes localmente da rede local de um computador (192.168.1.2) que esta sendo redirecionado nas regras de DNAT e SNAT, acessando no navegador web o 52 " id="pdf-obj-51-2" src="pdf-obj-51-2.jpg">
Para ativar o roteamento de pacotes do kernel digite o comando: # echo "1" >/proc/sys/net/ipv4/ip_forward E(ppp 0) pelo navegador acessando o endereço IP do firewall http://200.0.0.10 0 com um amigo de uma LAN HOUSE pelo amsn, ou fazer os testes localmente da rede local de um computador (192.168.1.2) que esta sendo redirecionado nas regras de DNAT e SNAT, acessando no navegador web o 52 " id="pdf-obj-51-4" src="pdf-obj-51-4.jpg">

Para ativar o roteamento de pacotes do kernel digite o comando:

# echo "1" >/proc/sys/net/ipv4/ip_forward

E habilite o mascaramento de IP com o comando:

# iptables -t nat -A POSTROUTING -s 192.168.0.0/24 -j MASQUERADE

Agora configure os computadores da sua rede colocando como gateway o endereço IP do servidor Linux 192.168.0.1 que está como roteador ou firewall da rede compartilhando a conexão com a internet.

Endereço de destino (DNAT) e endereço de origem (SNAT)

O recurso DNAT (Destination Nat – Endereço de destino NAT) é uma técnica que modifica os endereços IP dos computadores de destino, onde é bastante utilizado para redirecionamento de IP e portas, proxy transparente e balanceamento de carga.

Este recurso sempre e que utiliza a cadeia PREROUNTING e as mesma especificações de SNAT podem ser especificadas.

O recurso SNAT (Source Nat – Endereço de origem NAT) é uma técnica que modifica os endereços IP dos computadores de origem antes que os pacotes sejam enviados.

Este recurso sempre e que utiliza a cadeia POSTROUTING e funciona da mesma forma como foi mostrado acima no IP Masquerading (Máscaramento de IP) onde permite um ou mais computadores da sua rede acessar a internet através de um roteador ou firewall que tem um único endereço IP válido na internet.

Para fazer os testes de DNAT e SNAT é necessário que para cada regra com DNAT tenha outra regra correspondente com SNAT. Por exemplo:

# iptables -t nat -A PREROUTING -d 200.000.000.100 -j DNAT --to 192.168.1.2

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -j SNAT --to 200.000.000.100

Obs: Não se esqueça habilitar o roteamento de pacotes com o comando :

echo "1" >/proc/sys/net/ipv4/ip_forward

Você pode fazer testes externos utilizando o endereço um IP fixo(eth0) ou dinâmico(ppp0) pelo navegador acessando o endereço IP do firewall http://200.0.0.100 com um amigo de uma LAN HOUSE pelo amsn, ou fazer os testes localmente da rede local de um computador (192.168.1.2) que esta sendo redirecionado nas regras de DNAT e SNAT, acessando no navegador web o

endereço IP virtual <a href=http://10.0.0.1 criado com IP Aliasing como mostra o exemplo abaixo: # atribuindo vários endereços IP na mesma placa de rede com IP Aliasing /sbin/ifconfig eth0:0 10.0.0.1 netmask 255.0.0.0 /sbin/ifconfig eth0:1 10.0.0.2 netmask 255.0.0.0 /sbin/route add -host 10.0.0.1 dev eth0:0 /sbin/route add -host 10.0.0.2 dev eth0:1 Agora a partir de um computador da rede local teste com o comando ping os Ips criados $ ping 10.0.0.1 Exemplos: O exemplo abaixo redireciona as conexões TCP externas com DNAT vindas do IP válido conectado a internet 200.000.000.100 para o endereço IP da rede local 192.168.1.2 que utiliza a interface de rede eth0 . E quando a resposta da requisição da conexão é efetuada, é invertida a operação utilizando a regra com SNAT, onde é alterado a cadeia PREROUTING por POSTROUTING e a especificação da interface rede de entrada -i eth0 para saída -o eth0 . # iptables -t nat -A PREROUTING -p tcp -i eth0 -d 200.000.000.100 -j DNAT -- to 192.168.1.2 # iptables -t nat -A POSTROUTING -p tcp -o eth0 -s 192.168.1.2 -j SNAT -- to 200.000.000.100 ou para teste na rede local # iptables -t nat -A PREROUTING -p tcp -i eth1 -d 10.0.0.1 -j DNAT -- to 192.168.1.2 # iptables -t nat -A POSTROUTING -p tcp -o eth1 -s 192.168.1.2 -j SNAT -- to 10.0.0.1 Este exemplo faz um balanceamento entres os servidores 192.168.1.2 e 192.168.1.3 e redireciona as conexões com DNAT do endereço IP externo 200.000.000.100 conectado a interface da rede eth0 que tem como destino o intervalo de endereços IP entre 192.168.1.2 a 192.168.1.3 (sendo que poderia ser mais endereços como 192.168.1.4, 192.168.1.5, ... ) e depois a operação é invertida com SNAT . # iptables -t nat -A PREROUTING -d 200.000.000.100 -i eth0 -j DNAT -- to 192.168.1.1-192.168.1.2 53 " id="pdf-obj-52-2" src="pdf-obj-52-2.jpg">
endereço IP virtual <a href=http://10.0.0.1 criado com IP Aliasing como mostra o exemplo abaixo: # atribuindo vários endereços IP na mesma placa de rede com IP Aliasing /sbin/ifconfig eth0:0 10.0.0.1 netmask 255.0.0.0 /sbin/ifconfig eth0:1 10.0.0.2 netmask 255.0.0.0 /sbin/route add -host 10.0.0.1 dev eth0:0 /sbin/route add -host 10.0.0.2 dev eth0:1 Agora a partir de um computador da rede local teste com o comando ping os Ips criados $ ping 10.0.0.1 Exemplos: O exemplo abaixo redireciona as conexões TCP externas com DNAT vindas do IP válido conectado a internet 200.000.000.100 para o endereço IP da rede local 192.168.1.2 que utiliza a interface de rede eth0 . E quando a resposta da requisição da conexão é efetuada, é invertida a operação utilizando a regra com SNAT, onde é alterado a cadeia PREROUTING por POSTROUTING e a especificação da interface rede de entrada -i eth0 para saída -o eth0 . # iptables -t nat -A PREROUTING -p tcp -i eth0 -d 200.000.000.100 -j DNAT -- to 192.168.1.2 # iptables -t nat -A POSTROUTING -p tcp -o eth0 -s 192.168.1.2 -j SNAT -- to 200.000.000.100 ou para teste na rede local # iptables -t nat -A PREROUTING -p tcp -i eth1 -d 10.0.0.1 -j DNAT -- to 192.168.1.2 # iptables -t nat -A POSTROUTING -p tcp -o eth1 -s 192.168.1.2 -j SNAT -- to 10.0.0.1 Este exemplo faz um balanceamento entres os servidores 192.168.1.2 e 192.168.1.3 e redireciona as conexões com DNAT do endereço IP externo 200.000.000.100 conectado a interface da rede eth0 que tem como destino o intervalo de endereços IP entre 192.168.1.2 a 192.168.1.3 (sendo que poderia ser mais endereços como 192.168.1.4, 192.168.1.5, ... ) e depois a operação é invertida com SNAT . # iptables -t nat -A PREROUTING -d 200.000.000.100 -i eth0 -j DNAT -- to 192.168.1.1-192.168.1.2 53 " id="pdf-obj-52-4" src="pdf-obj-52-4.jpg">

endereço IP virtual http://10.0.0.1 criado com IP Aliasing como mostra o exemplo abaixo:

# atribuindo vários endereços IP na mesma placa de rede com IP Aliasing

/sbin/ifconfig eth0:0 10.0.0.1 netmask 255.0.0.0 /sbin/ifconfig eth0:1 10.0.0.2 netmask 255.0.0.0 /sbin/route add -host 10.0.0.1 dev eth0:0 /sbin/route add -host 10.0.0.2 dev eth0:1

Agora a partir de um computador da rede local teste com o comando ping os Ips criados

$ ping 10.0.0.1

Exemplos:

O exemplo abaixo redireciona as conexões TCP externas com DNAT vindas do IP válido conectado a internet 200.000.000.100 para o endereço IP da rede local

  • 192.168.1.2 que utiliza a interface de rede eth0. E quando a resposta da requisição

da conexão é efetuada, é invertida a operação utilizando a regra com SNAT, onde é

alterado a cadeia PREROUTING por POSTROUTING e a especificação da interface rede de entrada -i eth0 para saída -o eth0.

# iptables -t nat -A PREROUTING -p tcp -i eth0 -d 200.000.000.100 -j DNAT --to

192.168.1.2

# iptables -t nat -A POSTROUTING -p tcp -o eth0 -s 192.168.1.2 -j SNAT --to

200.000.000.100

ou para teste na rede local

# iptables -t nat -A PREROUTING -p tcp -i eth1 -d 10.0.0.1 -j DNAT --to

192.168.1.2

# iptables -t nat -A POSTROUTING -p tcp -o eth1 -s 192.168.1.2 -j SNAT --to

10.0.0.1

Este exemplo faz um balanceamento entres os servidores 192.168.1.2 e 192.168.1.3

e redireciona as conexões com DNAT do endereço IP externo 200.000.000.100 conectado a interface da rede eth0 que tem como destino o intervalo de endereços IP entre 192.168.1.2 a 192.168.1.3 (sendo que poderia ser mais endereços como

192.168.1.4, 192.168.1.5,

...

) e depois a operação é invertida com SNAT.

# iptables -t nat -A PREROUTING -d 200.000.000.100 -i eth0 -j DNAT --to

192.168.1.1-192.168.1.2

# iptables -t nat -A POSTROUTING -s 192.168.1.1 -p tcp -o eth0 -j SNAT -- to
# iptables -t nat -A POSTROUTING -s 192.168.1.1 -p tcp -o eth0 -j SNAT -- to

# iptables -t nat -A POSTROUTING -s 192.168.1.1 -p tcp -o eth0 -j SNAT --to 200.000.000.100

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -p tcp -o eth0 -j SNAT --to 200.000.000.100

ou para teste na rede local

# iptables -t nat -A PREROUTING -d 10.0.0.1 -i eth0 -j DNAT --to 192.168.1.1-192.168.1.2

# iptables -t nat -A POSTROUTING -s 192.168.1.1 -p tcp -o eth0 -j SNAT --to 10.0.0.1

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -p tcp -o eth0 -j SNAT --to 10.0.0.1

Este exemplo é idêntico ao exemplo acima, apenas foi especificado a porta :80 no final dos endereços IP

# iptables -t nat -A PREROUTING -d 200.000.000.100 -i eth0 -j DNAT - - t o

192.168.1.1-192.168.1.3:80

# iptables -t nat -A POSTROUTING -s 192.168.1.1 -p tcp -o eth0 -j SNAT --to 200.000.000.100:80

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -p tcp -o eth0 -j SNAT --to 200.000.000.100:80

ou para teste na rede local

# iptables -t nat -A PREROUTING -d 10.0.0.1 -i eth0 -j DNAT --to 192.168.1.1-192.168.1.3:80

# iptables -t nat -A POSTROUTING -s 192.168.1.1 -p tcp -o eth0 -j SNAT --to 10.0.0.1:80

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -p tcp -o eth0 -j SNAT --to 10.0.0.1:80

Este exemplo redireciona as conexões com DNAT do endereço IP externo 200.000.000.100 conectado a interface da rede eth0 utilizando o protocolo TCP conectado a interface da rede eth0 que tem como destino o endereço IP 192.168.1.2 e o intervalo de portas entre 21 a 80 e depois a operação é invertida com SNAT.

# iptables -t nat -A PREROUTING -d 200.000.000.100 -p tcp -i eth0 -j DNAT - - to

192.168.1.2:21-80

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -p tcp -o eth0 -j SNAT --to

200.000.000.100:21-80

ou para teste na rede local # iptables -t nat -A PREROUTING -d 10.0.0.1 -p tcp
ou para teste na rede local # iptables -t nat -A PREROUTING -d 10.0.0.1 -p tcp

ou para teste na rede local

# iptables -t nat -A PREROUTING -d 10.0.0.1 -p tcp -i eth0 -j DNAT --to 192.168.1.2:21-80

# iptables -t nat -A POSTROUTING -s 192.168.1.2 -p tcp -o eth0 -j SNAT --to 10.0.0.1:21-80

Exibindo as regras

# iptables -t nat -L -n

Chain PREROUTING (policy ACCEPT)

target prot opt source destination

DNAT tcp -- 0.0.0.0/0 10.0.0.1 to:192.168.1.2:21-80

Chain POSTROUTING (policy ACCEPT)

target prot opt source destination

MASQUERADE 0 -- 0.0.0.0/0 0.0.0.0/0

SNAT tcp -- 192.168.1.2 0.0.0.0/0 to:10.0.0.1:21-80

Redirecionamento de portas

O redirecionamento de portas que utilizada o destino REDIRECT, permite redirecionar conexões de uma porta para outra na mesma máquina que está o firewall. Este método é um tipo de DNAT e que utiliza sempre a cadeia PREROUNTING e OUTPUT da tabela nat onde é aplicado para fazer proxy transparente no servidor Squid.

O exemplo abaixo redireciona as conexões tcp vindas da interface eth1 da rede local para a porta 80 de acesso a intenet para a porta do squid 3128 usando a opção --to-port.

# iptables -t nat -A PREROUTING -i eth1 -p tcp --dport 80 -j REDIRECT --to-port

3128

Podemos também redirecionar portas usando DNAT e SNAT para portas de outros computadores da rede localhttp://www.site1.com.br => <= IP externo 200.0.0.100 => <= IP interno 192.168.1.2 56 " id="pdf-obj-55-2" src="pdf-obj-55-2.jpg">
Podemos também redirecionar portas usando DNAT e SNAT para portas de outros computadores da rede localhttp://www.site1.com.br => <= IP externo 200.0.0.100 => <= IP interno 192.168.1.2 56 " id="pdf-obj-55-4" src="pdf-obj-55-4.jpg">

Podemos também redirecionar portas usando DNAT e SNAT para portas de outros computadores da rede local onde esteja servidores http (porta 80), dns (porta 53), ftp (porta 21), smtp (porta 25), ssh (porta 22), mysql (porta 3306).

Exemplos:

Este exemplo redireciona uma porta que não esta em uso, geralmente portas altas acima de 1024, onde será feito o redirecionamento da porta 8181 do firewall para a porta 80 no servidor web 192.168.1.2.

Pronto agora quando alguém externamente da internet acessar o seu navegador web na porta 8181 do firewall com a url http://200.0.0.100:8181 e quem irá responder é o servidor web 192.168.1.2 na porta 80.

# iptables -t nat -A PREROUTING -p tcp --dport 8181 -d 200.0.0.100 -j DNAT --to

192.168.1.2:80

# iptables -t nat -A POSTROUTING -p tcp --sport 8181 -d 192.168.1.2 -j SNAT --to 200.0.0.100:80

Neste exemplo abaixo a primeira regra redireciona as conexões vindas da internet na porta 80 do firewall com endereço externo 200.0.0.100 para a porta 80 do servidor HTTP 192.168.1.2 onde é utilizando a tabela nat com DNAT.

Depois na segunda regra é invertido, onde as conexões que saem do servidor HTTP 192.168.1.2 na porta 80 são redirecionadas usando a tabela nat com SNAT para a porta 80 do firewall com o endereço externo 200.0.0.100.

INTERNET

FIREWALL

SERVIDOR REDE LOCAL

<= IP externo 200.0.0.100 =>

<= IP interno 192.168.1.2

# iptables -t nat -A PREROUTING -p tcp -- dport 80 - d 200.0.0.100 -j DNAT
# iptables -t nat -A PREROUTING -p tcp -- dport 80 - d 200.0.0.100 -j DNAT

# iptables -t nat -A PREROUTING -p tcp --dport 80 -d 200.0.0.100 -j DNAT --to

192.168.1.2:80

# iptables -t nat -A POSTROUTING -p tcp --sport 80 -s 192.168.1.2 -j SNAT --to

200.0.0.100:80

Exibindo a tabela nat com as regras:

# iptables -t nat -L -n

Chain PREROUTING (policy ACCEPT)

target prot opt source destination

DNAT tcp -- 200.0.0.100 200.0.0.100 tcp dpt:80 to:192.168.1.2:80

Chain POSTROUTING (policy ACCEPT)

target prot opt source destination

MASQUERADE 0 -- 0.0.0.0/0 0.0.0.0/0

SNAT tcp -- 200.0.0.100 192.168.1.2 tcp spt:80 to:200.0.0.100:80

Pronto agora quando alguém da internet solicitar um site hospedado no servidor HTTP da rede local, o firewall com o endereço 200.000.000.100 irá redirecionar para a porta 80 do servidor HTTP da rede local 192.168.1.2, que irá responder pelas requisições e exibir a página.

Esse mesmo exemplo serve para outros servidores como dns (porta 53), ftp (porta 21), smtp (porta 25), ssh (porta 22), mysql (porta 3306) basta alterar o endereço IP e a porta.

Tabela MANGLE

A tabela mangle serve para fazer algum tipo de ação para tratar um pacote que trafega
A tabela mangle serve para fazer algum tipo de ação para tratar um pacote que trafega

A tabela mangle serve para fazer algum tipo de ação para tratar um pacote que trafega pelas cadeias, como por exemplo especificar o tipo de serviço (TOS), e utiliza cinco cadeias PREROUNTING, POSTROUTING, INPUT, OUTPUT e FORWARD. Cada uma dessas cadeias são executadas antes das suas cadeias correspondentes na tabela filter e nat, onde são determinadas as ações a ser aplicadas no tráfego dos pacotes.

Por exemplo a cadeia PREROUNTING da tabela mangle é executada antes da cadeia PREROUNTING da tabela nat, a cadeia OUTPUT da tabela mangle é executada antes da cadeia OUTPUT da tabela nat e cadeia OUTPUT da tabela filter.

Veja a tabela abaixo:

Tabela mangle

Tabela nat

Tabela filter

PREROUNTING =>

PREROUNTING

 

OUTPUT =>

OUTPUT =>

OUTPUT

Na tabela mangle podemos especificar o tipo de serviço (Type Of Service - TOS) aplicado ao pacote para ordenar a prioridade aumentando ou diminuindo a velocidade do tráfego dos pacotes em tempo real. As cadeias da tabela mangle continuam ativas mesmo depois que a conexão estiver estabelecida, determinando que as opções de tipo serviço aplicado sejam mantidos.

Tipos de serviço

O tipo de serviço é um campo da cabeçalho de pacotes do protocolo IP (ipv4), que possibilita o kernel determinar a ordem de prioridade de uma pacote.

Especificando o tipo de serviço é possível dar prioridade ou não para programas de mensagens como amsn, msn, xchat, gaim, kopette e etc ou programas p2p como ktorrent, gtk-gnutella, amule, emule e etc. Mesmo se estiver sendo feito algum download na rede consumindo toda largura de banda, a prioridade do tráfego especificada no tipo de serviço será mantida e aumentando o desempenho dos serviços do servidor.

Para especificar, alterar e priorizar o tipo de serviço dos pacotes é usado o destino -j
Para especificar, alterar e priorizar o tipo de serviço dos pacotes é usado o destino -j

Para especificar, alterar e priorizar o tipo de serviço dos pacotes é usado o destino -j TOS com a opção --set-tos TOS, onde os valores ou bits permitidos no campo TOS após a opção --set-tos são:

16 ou 0x10 – (Prioridade de atraso mínimo – Minimize-Delay) 8 ou 0x08 – (Prioridade de processamento máximo – Maximize-Throughput) 4 ou 0x04 – (Prioridade de confiabilidade máxima – Maximize-Reliability) 2 ou 0x02 – (Prioridade de custo mínimo – Minimize-Cost) 0 ou 0x00 – (Prioridade de serviço normal – Normal-Service)

Por padrão os pacotes vem com a prioridade de serviço normal (0 ou 0x00) e a Prioridade de atraso mínimo tem a prioridade máxima (16 ou 0x10).

Tráfego de saída TOS

Esse tipo de serviço TOS determinada a prioridade do tráfego de saída de pacotes do firewall para a internet, onde são utilizadas as cadeias OUTPUT e POSTROUTING e a opção -o para especificar a interface de rede e --dport para especificar a porta.

Vale lembrar que os bits do tipo de serviço dos pacotes são apenas modificados e não rejeitados.

Exemplos:

Esta regra determina a prioridade máxima 16 para o tráfego de pacotes TCP saindo da rede local 192.168.1.0/24 para a internet através apenas da interface ppp0 na porta 80.

# iptables -t mangle -A OUTPUT -p tcp -o ppp0 -s 192.168.1.0/24 --dport 80 -j TOS --set-tos 16

Determina a prioridade mínima 2 para o tráfego de pacotes TCP do programa AMSN na porta 1683 saindo do com

59

# iptables -t mangle -A OUTPUT -p tcp -o eth0 -s 192.168.1.2 -- dport 1683 -j
# iptables -t mangle -A OUTPUT -p tcp -o eth0 -s 192.168.1.2 -- dport 1683 -j

# iptables -t mangle -A OUTPUT -p tcp -o eth0 -s 192.168.1.2 --dport 1683 -j TOS --set-tos 2

Determina a prioridade de processamento máximo 8 para o tráfego de pacotes TCP

saindo da rede local, passando pelo firewall e indo para interface ppp0 na porta

3128.

# iptables -t mangle -A OUTPUT -p tcp -o ppp0 --dport 3128 -j TOS --set-tos 8

Exibindo a tabela mangle com os TOS ajustados e as portas onde foram ajustados os bits

# iptables -t mangle -L -n

Chain OUTPUT (policy ACCEPT)

target prot opt source destination

TOS tcp -- 192.168.1.0/24 0.0.0.0/0 tcp dpt:80 TOS set 0x10

TOS tcp -- 192.168.1.2 0.0.0.0/0 tcp dpt:1683 TOS set 0x02

TOS tcp -- 0.0.0.0/0 0.0.0.0/0 tcp dpt:3128 TOS set 0x08

Tráfego de entrada TOS

Esse tipo de serviço TOS determinada a prioridade do tráfego de entrada de pacotes vindos da internet para o firewall, onde são utilizadas as cadeias INPUT e PREROUNTING e a opção -i para especificar a interface de rede e --sport para especificar a porta.

Os mesmos exemplos de saída TOS podem ser aplicados para a entrada, apenas mudando a cadeia OUTPUT para INPUT, a opção -o por -i e --dport por --sport.

Exemplos:

Esta regra determina a prioridade máxima 16 para o tráfego de pacotes TCP vindos da internet
Esta regra determina a prioridade máxima 16 para o tráfego de pacotes TCP vindos da internet

Esta regra determina a prioridade máxima 16 para o tráfego de pacotes TCP vindos da internet através da interface ppp0 na porta 80.

# iptables -t mangle -A INPUT -p tcp -i ppp0 --sport 80 -j TOS --set-tos 16

Determina a prioridade de processamento máximo 8 para o tráfego de pacotes TCP vindos da internet através da interface eth0 na porta 53.

# iptables -t mangle -A INPUT -p tcp -i eth0 --sport 53 -j TOS --set-tos 8

Exibindo a tabela mangle com os TOS ajustados e as portas onde foram ajustados os bits

# iptables -t mangle -L -n

Chain INPUT (policy ACCEPT)

target prot opt source destination

TOS tcp -- 0.0.0.0/0 0.0.0.0/0 tcp spt:80 TOS set 0x10

TOS tcp -- 0.0.0.0/0 0.0.0.0/0 tcp spt:53 TOS set 0x08

Módulos do iptables

Os módulos do iptables especificados pela opção -m ou --match permitem extender as funcionalidades do iptables através de novos recursos de filtragem de pacotes, como limitar a análise de regras do iptables.

Analisando pacotes conforme a conexão

O módulo ip_conntrack permite determinar regras conforme o estado da conexão de um pacote usando a opção --state (estado) onde são permitidos as seguintes opções:

Podemos exibir o módulo ip_conntrack com comando lsmod e carregá-lo com modprobe. $ lsmod | grep
Podemos exibir o módulo ip_conntrack com comando lsmod e carregá-lo com modprobe. $ lsmod | grep

Podemos exibir o módulo ip_conntrack com comando lsmod e carregá-lo com modprobe.

$ lsmod | grep ip_conntrack

ip_conntrack 49088 3 ipt_MASQUERADE,iptable_nat,ip_nat nfnetlink 6680 2 ip_nat,ip_conntrack

# modprobe ip_conntrack

NEW (novo) – Verifica pacotes que criam novas conexões ESTABLISHED (estabelecido) – Verifica conexões já estabelecidas RELATED (estabelecido) – Verifica pacotes relacionados com a conexão como as mensagens de erro ICMP (echo-request – ping) INVALID (estabelecido) – Verifica pacotes que não puderam ser analisados

Exemplos:

Rejeita novas conexões TCP vindas da interface de rede conectada a internet ppp0

# iptables -A INPUT -p tcp -i ppp0 -m state --state NEW -j DROP

Você pode especificar mais de um estado separando por vírgula

# iptables -A INPUT -p tcp -i ppp0 -m state --state NEW,RELATED,INVALID -j DROP

Limitando o número de vezes que uma regra é verificada

O módulo -m limit é um recurso do iptables que permite verificar a quantidade de vezes que uma regra é verificado depois de outras condições forem atendidas.

O valor padrão de verificação é 3 por hora (3/h), mas pode ser alterada pela opção
O valor padrão de verificação é 3 por hora (3/h), mas pode ser alterada pela opção

O valor padrão de verificação é 3 por hora (3/h), mas pode ser alterada pela opção limit onde podemos especificar as seguintes opções:

A sua sintaxe de verificação é:

limit número / tempo – onde número é a quantidade de vezes e o tempo que pode ser em:

s – segundo m – segundo h – hora d – dia

Podemos também utilizar a opção limit-burst para especificar o valor máximo de pacotes que serão verificados, aumentando de 1 até atingir o valor limite padrão 5.

Por exemplo, a regra abaixo grava logs usando o valor padrão 3 vezes por hora

(3/h).

# iptables -A INPUT -p tcp -i eth0 -m limit -j LOG

Exiba a regra criada e veja o padrão 3 vezes por hora (3/h).

# iptables -L -n

Chain INPUT (policy ACCEPT)

target prot opt source destination

LOG tcp -- 0.0.0.0/0 0.0.0.0/0 limit: avg 3/hour burst 5 LOG flags 0 level 4

Nessa regra abaixo os pacotes ICMP echo-request do comando ping são gravados em LOG e depois em seguida são rejeitados na interface de rede eth0 e na regra posterior são verificados 2 vezes por minuto (2/m) e gravados em log.