iptables: Como configurar o firewall do Linux para proteger seu servidor

Principais recursos do iptables

O iptables é um software responsável por atuar como firewall ou firewall em nossa rede. É uma parte muito importante dos sistemas operacionais e foi projetada especificamente para permitir o acesso autorizado e bloquear o acesso não autorizado. Um firewall estabelece um ponto de controle, tanto de pacotes de entrada quanto de saída. Além disso, é muito importante indicar que um firewall protege do tráfego que cruza redes diferentes, mas não protege a rede local de ataques que ocorrem dentro da mesma sub-rede. .

iptables é o firewall incluído nos sistemas Linux desde a versão 2.4, portanto, é embutido por padrão em sistemas como Debian, Ubuntu, Linux Mint e muitos outros, embora atualmente nftables seja usado internamente, porque o iptables é considerado antigo, embora hoje o iptables seja ainda amplamente utilizado no mundo da administração de sistemas Linux e também no mundo da administração de redes.

Este firewall possui várias tabelas criadas por padrão, com o objetivo de facilitar muito a possibilidade de adicionar diferentes chains e regras. Um detalhe muito importante é que por padrão temos tudo configurado para “aceitar”, ou seja, todo tráfego é permitido, não existe uma regra para negar tráfego, portanto, a princípio esse firewall é permissivo, mas podemos alterar muito a política padrão facilmente e rapidamente.

Assim que conhecermos as principais características, mostraremos o funcionamento e a arquitetura deste firewall.

Operação e arquitetura

Este firewall é baseado em regras que iremos introduzir uma após a outra, seu funcionamento é baseado na aplicação de regras que o próprio firewall é responsável por executar. Embora o iptables possa parecer simples de usar no início, se você quiser fazer isso de uma forma avançada, é mais complicado. A seguir, você pode ver um esquema resumido de como o iptables funciona.

A estrutura do iptables é baseada em tabelas, muitas das quais já são criadas por padrão. Dentro das tabelas temos as strings, que também temos algumas criadas por padrão. Finalmente, dentro das cadeias temos as diferentes regras que podemos configurar. Na foto a seguir você pode ver um pequeno esquema de como seria a arquitetura do firewall:

Por padrão, temos um total de quatro tabelas:

• tabela de filtro : é a tabela padrão, se não definirmos uma tabela para adicionar uma regra, ela sempre irá para a tabela de filtros. Nesta tabela temos um total de três chains padrão, dependendo do que nos interessa, teremos que usar uma chain ou outra: INPUT (são os pacotes na direção de entrada, para o próprio firewall), OUTPUT (são os pacotes de saída, do servidor para fora) e FORWARD (usado para filtrar pacotes que vão de uma interface de rede para outra).
• Nat tabela: esta tabela é responsável por fazer o NAT, transformando o IP privado em público e vice-versa. Dentro do NAT temos três chains: PREROUTING (altera os pacotes antes de roteá-los, aqui é feito o encaminhamento de porta ou DNAT), POSTROUTING (altera os pacotes após roteá-los, aqui é feito o SNAT ou MASQUERADE) e OUTPUT (pacotes gerados pelo firewall que o configurado NAT irá percorrer).
• Calandra tabela: esta tabela é responsável por alterar os pacotes, é onde a QoS é configurada para qualidade de serviço, alterando cabeçalhos TCP, etc. Nesta tabela temos as cinco cadeias: PREROUTING, INPUT, FORWARD, OUTPUT, POSTROUTING.
• cru tabela – Esta tabela não é frequentemente usada porque os pacotes viajam sem estado de conexão. Temos a cadeia PREROUTING e OUTPUT.

Na imagem a seguir você pode ver um pequeno resumo das cadeias que temos nas diferentes tabelas:

A operação ao adicionar uma regra é a seguinte:

• As regras que adicionamos às cadeias sempre têm um alvo (-j na regra).
• Quando o firewall recebe um pacote, ele verifica se o pacote corresponde a uma regra que inscrevemos. Se corresponder, o comando de destino é executado, caso contrário, ele vai para a próxima regra até o final da cadeia.
• As regras são verificadas em ordem sequencial, da primeira à última regra. A ordem é muito importante, se bloquearmos tudo primeiro e depois permitirmos algo mais específico, bloquearemos todo o tráfego e a regra mais específica não será verificada.
• Caso nenhuma regra satisfaça o pacote, então a política da cadeia que temos (regra global) será usada.

Os objetivos das diferentes regras são os seguintes:

• ACEITAR: aceita o pacote e passa para o próximo nível, um servidor web, SSH, FTP etc.
• DROP: bloqueia o pacote e não o passa para o próximo nível.
• QUEUE: é um destino especial, que passa o pacote em uma fila destinada ao processamento do espaço do usuário. Isso pode ser usado para executar outros programas externos.
• RETURN: tem o mesmo efeito como se tivéssemos chegado ao final da cadeia. Se a regra estiver em uma das cadeias padrão, a política da cadeia será executada. Para uma regra que está em uma cadeia definida pelo usuário, ela é encerrada, continuando pela cadeia antes do salto, logo após a regra com a qual foi saltada.

Uma vez que saibamos como funciona e sua arquitetura, veremos diferentes comandos para realizar diferentes ações.

 

Comandos essenciais para usar o iptables

A primeira coisa que devemos levar em conta ao configurar este firewall é que precisamos de permissões de superusuário para realizar os diferentes pedidos. É absolutamente necessário que eles sejam executados, caso contrário não funcionará. Os comandos a seguir não possuem “sudo” porque assumimos que você já é superusuário (sudo su).

Nas versões mais recentes do Linux não é possível parar o serviço iptables, para permitir todo o tráfego de rede e deixar o firewall com os parâmetros padrão, temos que executar os seguintes comandos:

• sudo iptables-F
• sudo iptables-X
• sudo iptables -t nat -F
• sudo iptables -t nat -X
• sudo iptables -t mangle -F
• sudo iptables -t mangle -X
• sudo iptables -P ENTRADA ACEITAR
• sudo iptables -P FORWARD ACEITAR
• sudo iptables -P SAÍDA ACEITAR

Feito isso, teremos o firewall “reset” e permitiremos tudo. Agora que sabemos como redefini-lo, vamos ver os diferentes comandos.

 

Ver tabelas atuais

Se você quiser ver o conteúdo das diferentes cadeias e regras que temos em uma determinada tabela, você pode ver como elas seriam:

• iptables -t filtro –lista
• iptables -t mangle –lista
• iptables -t nat –lista
• iptables -t raw –lista

 

Principais argumentos e para que servem

• -t, –table table Selecione a tabela que queremos
• -A, –append chain rule-specification Adicionamos uma nova regra em uma determinada chain
• -C, –check chain rule-specification Verificamos se existe uma certa regra em uma certa chain
• -D, –delete chain rule-specification Excluímos a regra que colocamos em uma determinada chain
• -D, –delete chain rulenum Nós excluímos o número da regra X em uma certa chain
• -I, –insert chain [rulenum] especificação da regra Inserimos uma nova chain com um número em uma determinada tabela
• -R, –replace chain rulenum regra-especificação Substitui uma determinada chain em uma tabela, usada para mover o número.
• -L, –list [cadeia] Mostra a lista de regras de uma cadeia
• -F, –flush [cadeia] Libera todas as regras de uma determinada cadeia.
• -Z, –zero [chain [rulenum]] Define os contadores de uma determinada regra para 0.
• -N, –new-chain chain Criamos uma nova chain em uma determinada tabela
• -X, –delete-chain [cadeia] Excluímos uma certa cadeia (vazia) em uma determinada tabela
• -P, –policy chain target Aplicamos a política padrão, ela é cumprida quando nenhuma regra das chains é cumprida.
• -E, –rename-chain cadeia antiga cadeia nova Renomeia uma cadeia adicionada anteriormente
• -h, mostra ajuda
• -v, –verbose Saída usada em conjunto com –L, para exibir mais informações do que o comando –L fornece.
• -n, –numeric endereços IP e números de porta aparecerão como números. Por exemplo, se filtrarmos a porta 80, com o típico –L www aparecerá, e não 80.
• -x, –exact Mostra o valor exato do pacote e do contador de bytes, em vez de usar K, M ou G para os valores.
• –line-numbers Ao mostrar a lista de regras, mostrará o número exato da regra. Ideal para usar –D e o número (delete) ou –I para introduzir antes ou depois dessa regra.

 

Condições principais

• -p , –protocolo protocolo. Filtre o pacote por protocolo, o protocolo especificado pode ser: tcp, udp, Idplite, icmp, esp, ah, sctp.
• -s , –source address[/mask][,…] Endereço IP de origem do pacote. Podemos ter um IP ou uma sub-rede (indicando a máscara no formato CIDR). Também podemos colocar nomes de host (domínios, sites etc), mas é uma má ideia porque não é eficiente. Vários endereços de origem podem ser especificados (192.168.1.1,192.168.1.2), mas isso criará regras diferentes para satisfazê-los.
• -d , –destination address[/mask][,…] Endereço IP de destino do pacote. Ele se comporta exatamente como -s.
• -m , –match correspondência. Especifica se queremos chamar os módulos estendidos do iptables, para realizar certas ações como:
  • Coloque várias portas de origem e destino (módulo multiporta).
  • Conexões de controle (módulo conntrack).
  • Evite força bruta (módulo recente, ideal para SSH).
  • Limite o número de conexões (limite de módulo e connlimit).
  • Faixa de endereços IP (iprange).
• -j , –alvo de salto. Especifica o objetivo da regra, se queremos aceitar, negar e até mesmo encaminhar o pacote para outra cadeia para posterior tratamento. Sempre em qualquer regra teremos um -j para dizer o que queremos fazer. Se não adicionarmos um –j, a regra será adicionada e contará os pacotes, mas não fará nada. Se usarmos -j para encaminhar para outra cadeia, assim que a outra cadeia terminar, ela retornará ao original.
• -g , –goto cadeia. Ele é usado para encaminhar o tráfego para outra cadeia, mas ao contrário do salto, ele não voltará para a cadeia original de onde veio.
• -i , –nome da interface. Nome da interface através da qual um pacote é recebido. Funciona apenas para strings de entrada como INPUT, FORWARD e PREROUTING. Se colocarmos Significa tudo, menos essa interface. Se colocarmos um + no final do nome, qualquer interface com o início do nome o pegará para verificação. Vamos imaginar eth0, eth1 e eth2. Se quisermos colocar todos os três, basta colocar eth+.
• -o , –out-nome da interface. Nome da interface pela qual um pacote sai. É válido apenas para strings de saída como OUTPUT, FORWARD e POSTROUTING.

 

Condições somente se você usar TCP ou UDP

Se você usa o protocolo TCP ou UDP, pode querer filtrar por número de porta de origem e/ou destino, então você tem os dois argumentos que você pode usar:

• –esporte –porta de origem. Selecione as portas de origem para permitir ou negar. Se usarmos ! exclui.
• –dport –porta-destino. Selecione as portas de destino para permitir ou negar. Se usarmos ! exclui.

Existem muitas outras condições para uma configuração avançada do firewall, mas já listamos as elementares.

 

Defina a política padrão

As políticas são usadas para que, quando uma regra não for encontrada na cadeia, a política padrão seja executada. A política padrão para todas as cadeias é ACCEPT, mas há duas opções: ACCEPT ou DROP

-P, –destino da cadeia de políticas

Exemplos:

• iptables -P ENTRADA QUEDA
• iptables -P FORWARD DROP
• iptables -P SAÍDA DROP

Com isso vamos ficar sem internet, então a seguir devemos começar a criar regras permissivas.

Abaixo, você pode ver todas as políticas que temos nas diferentes tabelas:

• iptables -t filtro -P (INPUT | OUTPUT | FORWARD) (ACCEPT | DROP)
• iptables -P (ENTRADA | SAÍDA | FORWARD) (ACEITAR | DROP)
• iptables -t mangle -P (ENTRADA | SAÍDA | FORWARD | PREROUTING | POSTROUTING) (ACEITAR | DROP)

 

Visualizar o status do firewall

O parâmetro -L mostra as regras que configuramos. V permite que você receba mais informações sobre as conexões e N retorna os endereços IP e suas portas correspondentes sem passar por um DNS servidor.

• iptables -L -n -v

Este é um dos comandos mais importantes para ver o status do firewall.

 

Módulos (-m match) do iptables

 

multiporta

É uma extensão do iptables que nos dá a possibilidade de agrupar regras semelhantes com diferentes portas TCP e UDP em uma. Multiport permite que você coloque várias portas ignoradas, e também várias portas seguidas, o máximo são 15 argumentos de porta. Exemplo:

• iptables –A INPUT –p tcp –m multiporta –dports 80,81,1000:1200 –j ACEITAR

Graças a este módulo, temos a possibilidade de utilizar várias portas na mesma regra.

 

Intervalo de IP

O iprange nos permite colocar vários endereços IP de origem ou destino de uma só vez, sem a necessidade de colocar dezenas de regras. Também permite colocar IP de origem e de destino, a sintaxe é a seguinte:

• [!]–ip-ip-src-range
• [!]–ip-ip-intervalo dst

O funcionamento desta regra é bastante simples, basta colocarmos o IP inicial e o IP final.

 

Limitar

O módulo connlimit é responsável por restringir o número de conexões simultâneas feitas por um endereço IP, é ideal para limitar o número de conexões para evitar DoS.

• –connlimit-upto n . Verificamos se o número de conexões é igual ou menor que N (então podemos permitir ou negar).
• –connlimit-acima de n . Verificamos se o número de conexões é maior que N (então podemos permitir ou negar).
• –connlimit-mask prefix_length . Marcamos por intervalo de sub-rede (é o mesmo que um host fazendo 2 conexões, dois hosts na mesma sub-rede fazendo 1 conexão cada).
• –connlimit-saddr . Aplique a limitação ao grupo de origem, é o padrão se nada for especificado.
• –connlimit-daddr . Aplica a limitação ao grupo-alvo.

Por exemplo, digamos que queremos permitir apenas duas conexões SSH por cliente:

• iptables -A INPUT -p tcp –dport 22 -m connlimit –connlimit-acima 2 -j DROP

Porém, podemos fazer a regra complementar, colocando um aceite de até 2 conexões.

 

conntrack

Este módulo é usado para rastrear as conexões, é usado para gerenciar a entrada e saída de pacotes antes e depois do estabelecimento da conexão. Dentro deste módulo existem várias opções, mas a mais importante é -ctstate que nos permite aceitar ou negar diferentes tipos de pacotes. Dentro do ctstate temos vários estados, destacando-se os seguintes:

• INVÁLIDO: O pacote recebido é inválido e não pertence a nenhuma conexão.
• NOVO: Novas conexões que são feitas ou que estão associadas a uma conexão que ainda não é bidirecional.
• ESTABELECIDO: Conexões estabelecidas, eles passam por NOVO primeiro desde que tiveram uma resposta
• RELATED: Um pacote que está relacionado, mas não faz parte de uma conexão existente, como FTP passivo.

Vamos imaginar que queremos acessar qualquer site, porém, não queremos que absolutamente ninguém nos acesse.

• iptables –P ENTRADA QUEDA
• iptables -A INPUT -m conntrack –ctstate ESTABLISHED, RELATED -j ACCEPT

 

Limitar

O módulo limit nos permite limitar o tráfego e o número de logs a serem gravados no syslog como tentativas de conexão. Tem dois argumentos principais:

• –limite N. Este argumento especifica o número máximo de correspondências médias por segundo (N/s), minuto (N/m), hora (N/h) ou dia (N/d) para permitir. N especifica o número
• –limit-burst N . Indica a rajada mais longa que pode ocorrer antes de verificar o limite –limit.

O valor padrão se nada for especificado é 3 correspondências por hora, em rajadas de 5. Imagine a seguinte regra: “iptables -A INPUT -m limit -j LOG”, a operação é a seguinte:

• A primeira vez que esta regra é atingida, os primeiros cinco pacotes são registrados.
• Depois, serão vinte minutos até que um pacote seja registrado novamente com esta regra (3 partidas entre 60 minutos equivalem a 20 minutos, pois é MÉDIA).
• Além disso, a cada vinte minutos sem que um pacote alcance a regra, a rajada recuperará um pacote.
• Se nada acontecer por 100 minutos, a rajada será totalmente recarregada; em seguida, de volta à situação inicial.

 

Recentes

O módulo recente é usado para limitar o número de conexões por segundo no nível de IP, isso é ideal para nos proteger de ataques na porta SSH porque um invasor tentará várias senhas. Por exemplo, se quisermos proteger nosso SSH, podemos executar a seguinte regra:

• iptables -A INPUT -p tcp –dport 22 -m conntrack –ctstate NEW -m recente –set –name ssh –rsource
• iptables -A INPUT -p tcp –dport 22 -m state –state NEW -m recente –rcheck –seconds 60 –hitcount 4 –name ssh –rsource -j DROP

Esta regra permite apenas quatro tentativas de conexão em 60 segundos, é uma janela “deslizante”.

 

NAT

Este firewall também é responsável pelo NAT de nossa conexão. Para fazer o NAT do nosso IP público (ou interface que possui esse IP público), devemos colocar:

• SNAT estático: iptables -t nat -A POSTROUTING -s 192.168.1.0/24 –o eth1 -j SNAT –to IP_eth1
• SNAT dinâmico: iptables -t nat -A POSTROUTING -s 192.168.1.0/24 -o eth1 -j MASQUERADE

O normal é usar MASQUERADE para fazer NAT independente do endereço IP que a interface física ou lógica tenha.

Para abrir portas temos que adicionar uma regra na cadeia PREROUTING da tabela NAT.

• iptables -t nat -A PREROUTING -i eth1 -p tcp –dport 22 -j DNAT –to-destination 192.168.1.1

A tabela PREROUTING também nos permite modificar as portas em tempo real, para que, se recebermos pacotes na porta 2121, possamos transformá-la em 21.

• iptables -t nat -A PREROUTING -i eth1 -p tcp –dport 2121 -j DNAT –to-destination 192.168.1.1:21

Assim que conhecermos detalhadamente esse firewall, veremos os exemplos básicos de uso e também os mais avançados.

 

Exemplos básicos de uso

Este firewall é muito completo e temos centenas de comandos que podemos executar para realizar diferentes ações. Neste artigo, daremos alguns exemplos fáceis de entender para uma primeira abordagem desse firewall.

Bloqueie o endereço IP 192.168.1.10 de fazer qualquer comunicação com nosso servidor:

• iptables -A INPUT –s 192.168.1.10 –j DROP

Bloqueie os endereços IP 192.168.1.20, 192.168.1.30, 192.168.1.40, 192.168.1.50 de fazer qualquer comunicação com nosso servidor:

• iptables -A INPUT –s 192.168.1.20,192.168.1.30,192.168.1.40,192.168.1.50 –j DROP

Bloqueie toda a sub-rede 192.168.2.0/24 de fazer qualquer comunicação com nosso servidor, exceto o endereço IP 192.168.2.20, que seria permitido:

• iptables –A INPUT –s 192.168.2.20 –j ACEITAR
• iptables –A INPUT –s 192.168.2.0/24 –j DROP

Bloqueie o endereço IP 192.168.4.50 para que não possamos fazer nenhuma comunicação:

• iptables –A SAÍDA –d 192.168.4.50 –j DROP

Bloqueie os endereços IP 192.168.4.51 e 192.168.4.52 para que não possamos fazer nenhuma comunicação:

• iptables –A SAÍDA –d 192.168.4.51,192.168.4.52 –j DROP

Bloqueie o acesso a www.google.es do iptables:

• iptables –A SAÍDA –d www.google.es –j DROP

Queremos bloquear o acesso ao nosso servidor do MAC 00:01:02:03:04:05, e o resto permite tudo:

• iptables -A INPUT -m mac –mac-source 00:01:02:03:04:05 -j DROP

Queremos permitir o acesso ao nosso servidor para o endereço MAC MAC 00:01:02:03:04:06, e o resto nega tudo:

• iptables -A INPUT -m mac –mac-source 00:01:02:03:04:05 -j ACEITAR
  iptables -A INPUT -j DROP

Bloqueie o endereço IP 192.168.1.10 para ping do nosso servidor:

• iptables -A INPUT -s 192.168.1.10 -p icmp -j DROP

Bloqueie os endereços IP 192.168.1.20, 192.168.1.30, 192.168.1.40, 192.168.1.50 do PING do nosso servidor (em uma única regra):

• iptables -A INPUT -s 192.168.1.20,192.168.1.30,192.168.1.40,192.168.1.50 -p icmp -j DROP

Bloqueie toda a sub-rede 192.168.2.0/24 para que não façam PING em nosso servidor, exceto para o endereço IP 192.168.2.20, que seria permitido:

• iptables -A INPUT -s 192.168.2.20 -p icmp -j ACEITAR
  iptables -A INPUT -s 192.168.2.0/24 -p icmp -j DROP

Bloqueie o endereço IP 192.168.4.50 para que não possamos pingar.

• iptables -A SAÍDA -d 192.168.4.50 -p icmp -j DROP

Bloqueie os endereços IP 192.168.4.51 e 192.168.4.52 para que não possamos pingar.

• iptables -A SAÍDA -d 192.168.4.51,192.168.4.52 -p icmp -j DROP

Bloqueie o acesso a www.google.es do iptables.

• iptables -A OUTPUT -d www.google.es -p icmp -j DROP

Como você pode ver, a operação é bastante simples com as regras baseadas em IP com origem e destino. Também poderíamos usar o módulo iprange para configurar um intervalo de IPs:

Bloqueie um intervalo de endereços IP de 192.168.5.1 a 192.168.5.50 para que não possa executar ping em nosso servidor.

• iptables -A OUTPUT -m iprange –dst-range 192.168.5.1-192.168.5.50 -p icmp -j DROP

Também podemos filtrar o protocolo ICMP de maneira mais avançada. Vamos imaginar que temos um usuário que quer fazer ping em qualquer host, mas não quer que NINGUÉM consiga fazer ping nele. Como podemos fazer isso com o iptables se o próprio PING tem comunicação bidirecional?

• iptables -A INPUT -s IP -p icmp –icmp-type eco-request -j DROP

Bloqueie qualquer acesso de entrada através da interface eth0 (somente), permitindo assim o acesso eth1.

• iptables -A INPUT -i eth0 -j DROP
• iptables -A ENTRADA -i eth1 -j ACEITAR

Bloqueie o tráfego de saída na interface eth0 (somente), permitindo assim o acesso eth1.

• iptables -A SAÍDA -o eth0 -j DROP
• iptables -A OUTPUT -o eth1 -j ACEITAR

Permita qualquer tráfego de entrada e saída em eth0 e negue qualquer tráfego de entrada ou saída em eth1.

• iptables -A ENTRADA -i eth0 -j ACEITAR
• iptables -A OUTPUT -o eth0 -j ACEITAR
• iptables -A INPUT -i eth1 -j DROP
• iptables -A SAÍDA -o eth1 -j DROP

Se você quiser começar a ver como funciona o protocolo TCP e UDP, aqui estão alguns exemplos:

Bloqueie o acesso da web a www.google.es e permita todo o resto (ping), por exemplo.

• iptables -A OUTPUT -d www.google.es -p tcp –dport 80 -j DROP

Bloqueie o acesso FTP a qualquer IP ou domínio e permita todo o resto.

• iptables -A SAÍDA -p tcp –dport 21 -j DROP

Bloqueie o acesso SSH ao IP 192.168.1.50 e permita todo o resto.

• iptables -A OUTPUT -d 192.168.1.50 -p tcp –dport 22 -j DROP

Bloqueie o acesso Telnet à sub-rede 192.168.2.0 e permita todo o resto.

• iptables -A OUTPUT -d 192.168.2.0/24 -p tcp –dport 23 -j DROP

Bloqueie o acesso 192.168.1.50 ao nosso servidor web.

• iptables -A INPUT -s 192.168.1.50 -p tcp –dport 80 -j DROP

Bloqueie o acesso 192.168.1.150 e 192.168.1.151 ao nosso servidor SSH.

• iptables -A INPUT -s 192.168.1.150,192.168.1.151 -p tcp –dport 22 -j DROP

Bloqueie o acesso de toda a sub-rede 192.168.2.0/24 ao nosso serviço de telnet

• iptables -A INPUT -s 192.168.2.0/24 -p tcp –dport 23 -j DROP

Bloqueie o acesso de todos ao servidor OpenVPN, exceto o endereço IP 77.77.77.77 que é permitido.

• iptables -A INPUT -s 77.77.77.77 -p tcp –dport 1194 -j ACEITAR
• iptables -A INPUT -p tcp –dport 1194 -j DROP

Bloqueie o acesso DNS ao 8.8.8.8 e permita todo o resto (ping), por exemplo.

• iptables -A OUTPUT -d 8.8.8.8 -p tcp –dport 53 -j DROP
• iptables -A OUTPUT -d 8.8.8.8 -p udp –dport 53 -j DROP

Bloqueie o acesso à porta 1194 para qualquer IP ou domínio e permita todo o resto.

• iptables -A INPUT -p udp –dport 1194 -j DROP

Temos um servidor DNS em nosso servidor. Queremos que apenas computadores na sub-rede 192.168.1.0/24 possam se comunicar com ela e bloqueiem todos os outros acessos.

• iptables -A INPUT -s 192.168.1.0/24 -p tcp –dport 53 -j ACEITAR
• iptables -A INPUT -s 192.168.1.0/24 -p udp –dport 53 -j ACEITAR
• iptables -A INPUT -p tcp –dport 53 -j DROP
• iptables -A INPUT -p udp –dport 53 -j DROP

Bloqueie o acesso ao nosso servidor web, da faixa de IP 192.168.100.0/24, vindo da interface eth0.

• iptables -A INPUT -s 192.168.100.0/24 -i eth0 -p tcp –dport 80 -j DROP

Bloqueie o acesso ao nosso servidor ssh, da faixa de IP 192.168.100.0/24, vindo da interface eth1.

• iptables -A INPUT -s 192.168.100.0/24 -i eth1 -p tcp –dport 22 -j DROP

 

Exemplos de uso avançado

Se você quiser aprender mais sobre iptables, aqui estão alguns exemplos onde usamos o módulo connlimit.

Permita apenas 10 conexões Telnet por cliente.

• iptables -A INPUT -p tcp –dport 23 -m connlimit –connlimit-above 10 –connlimit-mask 32 -j DROP

Negar até a conexão número 5 na web feita por um cliente (não faz muito sentido mas é um exemplo).

• iptables -A INPUT -p tcp –dport 80 -m connlimit –connlimit-upto 5 –connlimit-mask 32 -j DROP

Permita apenas 10 conexões Telnet por cliente (faça diferente do que acima).

• iptables -A INPUT -p tcp –dport 23 -m connlimit –connlimit-upto 10 –connlimit-mask 32 -j ACEITAR
• iptables -A INPUT -p tcp –dport 23 -j DROP

Permita apenas 10 conexões da Web no intervalo de IP 10.0.0.0/8 e negue se exceder esse número.

• iptables -A INPUT -s 10.0.0.0/8 -p tcp –dport 80 -m connlimit –connlimit-acima 10 –connlimit-mask 8 -j DROP

Permitir apenas 20 conexões HTTP para cada cliente, assim que for excedido enviamos um TCP Reset.

• iptables -A INPUT -p tcp –dport 80 -m connlimit –connlimit-acima de 20 –connlimit-mask 32 -j REJECT –reject-with tcp-reset

Ou assim:

• iptables -A INPUT -p tcp –syn –dport 80 -m connlimit –connlimit-acima de 20 –connlimit-mask 32 -j REJECT –reject-with tcp-reset

Como você pode ver, este firewall é realmente completo e podemos fazer muitas configurações muito avançadas, para controlar detalhadamente todas as conexões de entrada e saída.