Resumo das regras do Iptables

As regras do Iptables são muitas vezes um desafio até mesmo para os administradores mais experientes. Escrever regras de firewall é quase como aprender um novo dialeto. Existem muitas combinações possíveis entre os parâmetros disponíveis e “regras de
concordância”, que determinam o que funciona e o que não.

Aqui está um resumo dos parâmetros do Iptables, que vai ajudá-lo a escrever seus próprios scripts e entender melhor os scripts de exemplo que encontrar pela web:

-A INPUT: Especifica que a regra se aplica a pacotes de entrada, ou seja, pacotes recebidos pelo servidor, em qualquer interface.

-A OUTPUT: A regra se aplica a pacotes de saída, transmitidos pelo próprio servidor.

-A FORWARD: Este parâmetro é usado ao compartilhar a conexão com a Internet, permitindo que os micros da rede local acessem através do servidor. Os pacotes de outros micros, encaminhados pelo servidor, são tratados como “FORWARD”,
diferentemente dos pacotes transmitidos pelo próprio servidor, que são tratados como “OUTPUT”. Você pode definir regras diferentes para cada situação.

-p tcp: Especifica que a regra se aplica a pacotes TCP, o que é o mais comum.

-p udp: Alguns serviços usam também portas UDP. Um bom exemplo são os servidores DNS, que escutam tanto na porta 53 TCP, quanto na 53 UDP. Este parâmetro permite definir regras que se aplicam a estes casos, abrindo ou fechando as
portas UDP, como em:

iptables -A INPUT -p udp --dport 53 -j ACCEPT

A maioria das regras do Iptables exigem que você especifique o protocolo, fazendo com que você tenha que repetir a regra caso queira abrir uma porta simultaneamente para TCP e UDP. Ao executar algo como “iptables -A INPUT –dport 53 -j ACCEPT” (sem
especificar o protocolo), você receberá um erro como:

iptables v1.3.3: Unknown arg `--dport'
Try `iptables -h' or 'iptables --help' for more information.

Nesses casos, você pode usar o parâmetro “-p ALL”, que se aplica simultaneamente aos três protocolos (TCP, UDP e ICMP), sem que você precise incluir uma regra separada para cada um, como no exemplo da regra que bloqueia qualquer tipo de conexão
proveniente de um determinado endereço:

iptables -A INPUT -p ALL -s 88.191.79.206 -j DROP

Como as portas UDP também são usadas por alguns serviços, é muito comum bloquear as portas de 0 a 1023 UDP, autorizando apenas as portas que realmente devem ficar abertas, como em:

iptables -A INPUT -p udp --dport 53 -j ACCEPT
iptables -A INPUT -p udp --dport 0:1023 -j DROP

Note que você nunca deve fechar todas as portas UDP, pois as portas altas são usadas aleatoriamente para pacotes de resposta para DNS e diversos outros protocolos. Alguns administradores mais paranóicos fecham todas as portas UDP até a 32000, por
exemplo. Não existem muitos problemas em fechar uma faixa maior de portas, desde que você sempre deixe uma larga faixa de portas altas abertas, de forma a receber os pacotes de resposta.

Ao contrário do TCP, não é possível criar uma regra genérica para permitir todos os pacotes de resposta UDP (como a “iptables -A INPUT -p tcp –syn -j DROP”), pois no UDP não são abertas conexões. Os pacotes são simplesmente transmitidos diretamente,
sem aviso prévio.

-p icmp: Além do TCP e UDP, existe o protocolo ICMP, usado para pacotes de controle, pings e envio de mensagens. Um exemplo de uso é a regra para desativar a resposta a pings. Na verdade, ela atua bloqueando o pedido de ping antes que
ele seja repassado ao sistema:

iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

-i eth0: A opção “-i” permite definir a interface onde os pacotes devem ser recebidos ou enviados. Por exemplo, usar uma regra como:

iptables -A INPUT -p tcp -j REJECT

… simplesmente desconectaria seu micro da rede, pois bloquearia comunicações em qualquer interface. Porém, se você especificasse a interface, ele bloquearia apenas pacotes recebidos através dela, como em:

iptables -A INPUT -i eth2 -p tcp -j REJECT

O mesmo se aplica quando você quer permitir conexões em determinadas portas, mas apenas a partir da placa de rede local. Para permitir conexões via SSH apenas a partir da placa eth0, você poderia usar:

iptables -A INPUT -i eth0 -p tcp --dport 22 -j ACCEPT

-o eth0: É similar ao parâmetro “-i”, mas especifica uma interface de saída. Este parâmetro é menos usado, pois normalmente nos preocupamos em impedir que o firewall aceite conexões em determinadas portas, em vez de tentar interceptar
as respostas. Entretanto, esta opção pode ser útil em casos em que você precisa fechar uma porta de saída apenas para determinada interface. Este é um exemplo de uso, onde bloqueio pacotes de saída na porta 1863 apenas para a placa eth1:

iptables -A OUTPUT -p tcp -o eth1 --dport 1863 -j DROP

–dport ou –destination-port: Especifica uma porta. O uso mais comum para esta opção é para abrir portas de entrada (e depois aplicar uma regra que fecha as demais), como na regra que abre para conexões na porta 22,
que mostrei no exemplo anterior.

-s (source): O parâmetro “-s” permite especificar um endereço IP ou domínio de origem, de forma a aceitar ou recusar as conexões. Embora seja muito fácil forjar endereços IP dentro da rede local, as coisas são muito mais complicadas na
Internet. Permitir o acesso a determinadas portas (como a do SSH) apenas para determinados endereços, ou faixas de endereços, é uma medida de segurança interessante em muitas situações.

Este é um exemplo de regra, que abre a porta 631 apenas para hosts dentro da faixa e máscara especificada:

iptables -A INPUT -p tcp -s 72.232.35.0/255.255.255.248 --dport 631 -j ACCEPT

-d (destiny): Destinado ao endereço IP ou domínio citado. É muito usado ao bloquear o acesso a determinados sites a partir dos micros da rede local como, por exemplo:

iptables -A FORWARD -d torrentreactor.net -j REJECT

-m mac –mac-source 00:11:D8:76:59:2E: Esta é a regra que permite especificar endereços MAC dentro de regras do Iptables que vimos há pouco. Ela é uma forma de dificultar o uso de endereços IP falseados para ganhar acesso ao servidor,
pois permite relacionar o IP ao endereço MAC da placa instalada. Lembre-se, porém, que ela só pode ser usada em rede local e que os endereços MAC são quase tão fáceis de falsear quanto os endereços IP. Um exemplo de uso seria:

iptables -A INPUT --dport 22 -m mac --mac-source 00:11:D8:76:59:2E -j ACCEPT

–syn: Cria uma regra válida apenas para novas conexões, não impedindo que o outro micro responda a conexões iniciadas pelo servidor, como em:

iptables -A INPUT -p tcp --syn -j DROP

-j: É usado no final de cada regra, especificando uma ação, que pode ser:

-j ACCEPT : Aceita o pacote. Ele é encaminhado ao destino sem passar pelas demais regras.

-j REJECT : Rejeita educadamente o pacote, enviando um pacote de resposta ao emissor. Quando uma porta está fechada em modo reject, o emissor recebe rapidamente uma resposta como “connect to host 192.168.1.1 port 22: Connection
refused”.

-j DROP: O DROP é mais enfático. O pacote é simplesmente descartado, sem aviso. O emissor fica um longo tempo esperando, até que eventualmente recebe um erro de time-out.

-j LOG: Este último parâmetro permite logar conexões. É interessante usar esta regra principalmente em portas muito visadas, como a do SSH, pois assim você tem uma lista de todos os endereços que acessaram seu servidor na porta
especificada. Para ativar o log, você deve duplicar a regra que abre a porta, usando a opção “-j LOG” na primeira e “-j ACCEPT” na segunda, como em:

iptables -A INPUT -p tcp --dport 22 -j LOG
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

As mensagens são gravadas no arquivo “/var/log/messages” de forma bastante detalhada, incluindo a data e hora da conexão, o IP e MAC do micro que fez a conexão (SRC), além da porta (DPT). Você pode ver o mesmo log, porém com as entradas escritas de
forma resumida, usando o comando “dmesg”.

Não se assuste com o volume de informações, pois o log inclui todas as tentativas de conexão. O fato de um determinado IP ter aberto uma conexão com a porta 22 do seu servidor, não significa que o usuário realmente obteve acesso ao SSH. Ele pode ter
recebido o prompt para digitar a senha, mas isso não significa que ele realmente conseguiu fazer login.

Note que alterar a ordem das regras altera o resultado. Em caso de duas regras conflitantes, vale a que vem primeiro. Por exemplo, ao usar:

iptables -A INPUT -p tcp -j REJECT
iptables -A INPUT -p tcp --dport 22 -j ACCEPT

… a porta 22 permanecerá fechada, pois os pacotes serão descartados pela primeira regra, sem terem chance de serem autorizados pela segunda. É justamente por isso que é sempre necessário colocar as regras menos restritivas primeiro, declarando as
portas autorizadas, para só então fechar as demais.

O mesmo se aplica ao logar transmissões. Se você usar algo como:

iptables -A INPUT -p tcp --dport 22 -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j LOG

… o log não funcionará, pois os pacotes destinados à porta 22 serão aceitos pela primeira regra e não passarão pela segunda, que faz o log. As regras que fazem log devem sempre vir antes das regras que autorizam as conexões.