Firewall - Iptables 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 1
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. 2
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 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 3
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 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 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 4
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) 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: 5
# 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 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 6
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 net.ipv4.conf.default.forwarding=1 para net.ipv4.conf.default.forwarding=0 7
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 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 8
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 9
# /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 A sintaxe do comando iptables é da seguinte forma: iptables -t tabela comando cadeias (chains) opções parâmetros destino 10
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. 11
Tabelas São utilizadas para especificar os tipos de cadeias(chains) que serão utilizadas. tabela filter nat mangle Significado 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. É 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. 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 12
-I Insere uma regra em uma cadeia -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 o u --help Cadeias (Chains) Exibe ajuda do iptables As cadeias servem para determinar se um pacote irá entrar, sair ou ser redirecionado pelo iptables. Cadeia INPUT OUTPUT FORWARD PREROUTING POSTROUTING Significado Analisa os pacotes que estão entrando na rede interna. Analisa os pacotes que estão saindo na rede interna. Analisa os pacotes que estão trafegando pela rede, tanto da rede externa (Internet) para rede interna (LAN) e vice-versa. 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). 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 13
# iptables -L -t nat Opções Opção -p ou --protocol -s, --src ou --source - d, - - d s t o u --destination -i ou --in-interface -o ou --out-interface - - s p o r t o u --source-port - - d p o r t o u --destination-port --syn Significado Especifica o protocolo que pode ser TCP, UDP, ICMP ou ALL (todos). *Obs - pode ser usados outros protocolos especificados em /etc/protocols. Especifica os pacotes de origem da rede (192.168.0.0/255.255.255.0) ou computador local (192.168.0.2) Especifica os pacotes de destino da rede (192.168.0.0/255.255.255.0) ou computador local (192.168.0.2) Determina a placa de rede de entrada, onde não pode ser utilizada pela cadeia OUTPUT Determina a placa de rede de saída, onde não pode ser utilizada pela cadeia INPUT Determinada o porta de origem, onde só pode ser utilizada com as opções -p tcp e -p udp. Determinada o porta de destino, onde só pode ser utilizada com as opções -p tcp e -p udp. 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 14
*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, excluídos, redirecionados e etc. Destino ACCEPT REJECT DROP LOG SNAT DNAT --to MASQUERADE Significado 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, retornará uma mensagem de porta inalcançável port-unreachable. Especifica também que os pacotes serão rejeitados e não 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. Determina que as regras serão gravadas em log pelo daemon syslog em /var/log/syslog. Utilizada para fazer mascaramento de origem e deve ser utilizada com a cadeia POSTROUTING 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. 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. Faz o mascaramento de IP na saída de pacotes em uma interface de rede ppp0, eth0, etc. 15
REDIRECT --to-port RETURN Utilizada para fazer redirecionamento de conexões para uma porta do firewall Determina a porta de destino, após o redirecionamento com REDIRECT 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: 16
# modprobe ipt_tos # modprobe ipt_log 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 17
ou # iptables -m multiport help ou # iptables --match multiport -h 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 18
$ 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 --- 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 19
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 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 20
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 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: 21
# 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 INPUT -n # 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. 22
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. # 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 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 23
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 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 24
# 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 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 25
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 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 26
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 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 27
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 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. 28
# 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 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 é 29
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 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. 30
# 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: 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 --- 31
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 INPUT 1 -p icmp -d 127.0.0.1 -j DROP Substituindo a primeira regra na linha 1 alterando o destino ACCEPT para DROP 32
# 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 22 -j DROP 33
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,... e também podemos utilizar a interface lo de loopback para o endereço localhost ou 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 34
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,... que tem como origem o endereço IP 192.168.0.1 # 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 35
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 36
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 37
Pacotes syn 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 de flags SYN SYN ACK Descrição É o primeiro pacote a ser enviado em uma conexão entre a origem e o destino O destino responde ao pacote SYN, confirmando sua mensagem original e enviando SYN como resposta 38
ACK FIN FIN ACK RST Cada pacote utilizado em uma conexão estabelecida possui um bit ACK ativado para confirmar os pacotes recebidos anteriormente No momento em que uma conexão estiver sendo fechada, será enviado um pacote FIN para o outro Este tipo de combinação é utilizada para confirmar o primeiro pacote FIN e completar o encerramento da conexão 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: 39
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 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. 40
# 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 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: 41
# 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 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. 42
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 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: 43
# 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 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 44
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 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 45
# 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 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: 46