{"id":6484,"date":"2017-08-24T10:16:21","date_gmt":"2017-08-24T13:16:21","guid":{"rendered":"https:\/\/blog.hostinger.io\/br-tutoriais\/?p=6484"},"modified":"2026-09-01T18:09:49","modified_gmt":"2026-09-01T11:09:49","slug":"tutorial-iptables","status":"publish","type":"post","link":"\/br\/tutoriais\/tutorial-iptables\/","title":{"rendered":"Tutorial de iptables: protegendo um VPS com o firewall do Linux"},"content":{"rendered":"

O iptables é uma ferramenta de firewall do Linux que permite controlar o tráfego que chega ao seu VPS por meio de regras para permitir, bloquear, encaminhar e filtrar pacotes.<\/p>

O iptables funciona por meio do netfilter, integrado ao kernel do Linux, e continua sendo uma das soluções de firewall mais usadas em servidores Linux.<\/p>

O iptables organiza as regras em tabelas, cadeias, critérios de correspondência e alvos. Para configurar o firewall com segurança, primeiro permita o SSH e as conexões já estabelecidas e só depois aplique as regras DROP. As regras precisam ser salvas explicitamente para continuar válidas após uma reinicialização.<\/p>

Tanto o UFW quanto o nftables são alternativas viáveis, dependendo das suas necessidades.<\/p>

Os principais passos para configurar o iptables são:<\/p>

    \n
  1. Verifique e instale o iptables.<\/li>\n\n\n\n
  2. Liste as regras existentes.<\/li>\n\n\n\n
  3. Permita o SSH antes de aplicar regras restritivas.<\/li>\n\n\n\n
  4. Adicione regras básicas de firewall.<\/li>\n\n\n\n
  5. Abra as portas de serviços comuns.<\/li>\n\n\n\n
  6. Exclua ou limpe regras.<\/li>\n\n\n\n
  7. Salve as regras permanentemente.<\/li>\n<\/ol>

    O que é o iptables?<\/h2>

    O iptables é uma ferramenta de firewall de linha de comando que gerencia as regras de firewall do Linux por meio do netfilter, um sistema de filtragem de pacotes integrado diretamente ao kernel do Linux. Todo pacote que entra ou sai do seu servidor passa pelo netfilter, e o iptables define as regras que determinam o que acontece com ele.<\/p>

    O iptables gerencia o tráfego IPv4. Para o tráfego IPv6, é necessário usar o ip6tables, que segue a mesma sintaxe, mas trabalha com um conjunto de regras separado.<\/p>

    Para entender o iptables, comece por cinco conceitos básicos:<\/p>

    Conceito<\/strong><\/th>O que é<\/strong><\/th><\/tr><\/thead>
    Tabela<\/strong><\/td>Uma coleção de cadeias agrupadas por finalidade. As principais tabelas são filter<\/strong>, nat<\/strong> e mangle<\/strong>.<\/td><\/tr>
    Cadeia<\/strong><\/td>Uma lista de regras dentro de uma tabela. As cadeias integradas incluem INPUT<\/strong>, OUTPUT<\/strong> e FORWARD<\/strong>.<\/td><\/tr>
    Regra<\/strong><\/td>Uma condição usada para verificar um pacote. Se houver correspondência, o iptables aplica o alvo<\/strong>.<\/td><\/tr>
    Correspondência<\/strong><\/td>Os critérios usados para avaliar um pacote, como IP de origem, porta de destino, protocolo e assim por diante.<\/td><\/tr>
    Alvo<\/strong><\/td>A ação executada quando um pacote corresponde a uma regra: ACCEPT<\/strong>, DROP<\/strong>, RETURN<\/strong> ou REJECT<\/strong>.<\/td><\/tr><\/tbody><\/table><\/figure>

    A maioria das configurações básicas de segurança para VPS<\/a> usa a tabela filter<\/strong>, que contém três cadeias padrão. A INPUT<\/strong> processa os pacotes que chegam ao servidor, a OUTPUT<\/strong> processa os pacotes que saem dele e a FORWARD<\/strong> processa os pacotes roteados para um destino diferente do próprio servidor.<\/p>

    Como funciona o iptables?<\/h3>

    O iptables verifica cada pacote em relação às regras de uma cadeia, de cima para baixo. A primeira regra que corresponder ao pacote é aplicada, e o iptables para de verificar o restante daquela cadeia. A ordem das regras é importante porque uma regra anterior pode permitir ou bloquear o tráfego antes que qualquer regra posterior seja avaliada.<\/p>

    Existem duas maneiras de adicionar regras: a opção -A<\/strong> adiciona uma regra ao final de uma cadeia, enquanto a opção -I<\/strong> insere uma regra em uma posição específica. Isso é útil quando uma regra precisa ser avaliada antes das que já existem. Se você adicionar uma regra DROP abrangente antes da regra que permite o SSH, perderá o acesso ao servidor. Por isso, é importante adicionar as regras na ordem correta.<\/p>

    Sempre adicione as regras essenciais de permissão, especialmente para SSH, antes de qualquer regra que bloqueie ou descarte o tráfego.<\/p>

    Qual é a diferença entre iptables, ip6tables e nftables?<\/h3>

    O iptables gerencia regras de firewall para IPv4. Já o ip6tables gerencia regras para IPv6 usando a mesma sintaxe de comandos. No entanto, os dois conjuntos de regras são totalmente separados: uma regra do iptables não afeta o tráfego IPv6 e vice-versa.<\/p>

    O nftables é o framework de firewall mais recente do Linux e substitui tanto o iptables quanto o ip6tables. Ele gerencia IPv4 e IPv6 em um único conjunto de regras e usa uma sintaxe mais simples. Nas versões mais recentes do Ubuntu, os comandos do iptables podem usar o nftables como backend sem que isso seja perceptível. Nesse caso, as regras do iptables são armazenadas e processadas pelo nftables.<\/p>

    Para quem quer um gerenciamento mais simples do firewall no Ubuntu, sem precisar escrever regras do iptables diretamente, o UFW é abordado mais adiante neste guia.<\/p>

    Como configurar o iptables em um VPS com Ubuntu<\/h2>

    A maneira mais segura de configurar o firewall de um VPS<\/a> com iptables é seguir uma ordem específica: primeiro, verifique as regras existentes. Depois, permita o SSH, as conexões já estabelecidas e as portas de serviço necessárias antes de bloquear qualquer tráfego.<\/p>

    Aplique as regras DROP por último. Se essa ordem não for seguida, os administradores podem perder o acesso ao servidor.<\/p>

    1. Verifique e instale o iptables<\/h3>

    O iptables já vem pré-instalado na maioria das distribuições Linux. Este tutorial usa um VPS com Ubuntu como exemplo principal. Para verificar se o iptables já está disponível no seu sistema, execute:<\/p>

    iptables --version<\/pre>
    Se o comando retornar um número de versão, o iptables já está instalado. Nas versões mais recentes do Ubuntu, a saída pode fazer referência ao backend nftables. Isso significa que os comandos do iptables são processados pelo nftables, mas a sintaxe permanece a mesma.<\/p>
    Se o iptables não estiver instalado, execute:<\/p>
    sudo apt update\n\nsudo apt install iptables<\/pre>
    2. Liste as regras existentes do iptables<\/h3>
    Verifique as regras existentes antes de adicionar novas. Uma regra pode já permitir ou bloquear o tráfego que você pretende configurar, e adicionar regras duplicadas ou conflitantes pode causar um comportamento imprevisível.<\/p>
    Liste todas as regras atuais com informações detalhadas e números de linha:<\/p>
    sudo iptables -L -v -n --line-numbers<\/pre>
    A opção -n<\/strong> exibe os endereços IP e números de porta em formato numérico, em vez de resolvê-los para nomes de host. Isso torna a saída mais rápida e fácil de ler. Os números de linha identificam a posição de cada regra na cadeia, e você precisará deles para excluir ou inserir regras em posições específicas.<\/p>
    Os contadores de pacotes e bytes na saída mostram se o tráfego realmente corresponde a cada regra, o que ajuda na solução de problemas.<\/p>
    3. Permita o SSH antes de alterar as regras do firewall<\/h3>
    \n\n\n    
    \n        \n            \n                \n            <\/svg>\n            Warning        <\/span>\n        
    \n            Aviso! <\/strong>Aplicar regras restritivas de firewall antes de permitir o SSH fará com que você perca o acesso ao VPS. Nenhuma mensagem de erro será exibida, a conexão simplesmente será interrompida e você perderá o acesso.        <\/p>\n    <\/div>\n\n    \n\n\n\n<\/p>
    Permita o SSH antes de adicionar qualquer regra DROP ou REJECT. A porta padrão do SSH é a 22:<\/p>
    sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT<\/pre>
    Se você já alterou a porta SSH do seu VPS<\/a>, substitua 22<\/strong> pelo número da porta configurada. Se não tiver certeza, verifique a configuração do servidor abrindo este arquivo:<\/p>
    sudo nano \/etc\/ssh\/sshd_config<\/pre>
    As senhas são o método mais comum de autenticação via SSH, mas configurar chaves SSH<\/a> é mais seguro e é recomendável fazer isso antes de restringir o firewall.<\/p>
    Depois de adicionar a regra de SSH, mantenha a sessão atual aberta e teste o acesso em uma segunda janela do terminal antes de salvar qualquer regra restritiva. Se a segunda conexão funcionar, é seguro continuar.<\/p>
    4. Adicione regras básicas de firewall do iptables<\/h3>
    As regras restantes configuram seu firewall por ordem de prioridade. Adicione-as na sequência abaixo para evitar bloquear o tráfego de que você precisa.<\/p>
    Permita o tráfego do localhost<\/strong><\/p>
    O tráfego na interface de loopback fica restrito ao próprio servidor. Bloqueá-lo interrompe a comunicação interna entre serviços em execução na mesma máquina, como uma aplicação web que se conecta a um banco de dados local:<\/p>
    sudo iptables -A INPUT -i lo -j ACCEPT<\/pre>
    Permita conexões estabelecidas e relacionadas<\/strong><\/p>
    Essa regra permite o tráfego associado a conexões que o servidor já iniciou ou aceitou. Sem ela, as respostas às solicitações de saída são bloqueadas:<\/p>
    sudo iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT<\/pre>
    Permita HTTP e HTTPS<\/strong><\/p>
    Abra as portas 80 e 443 para permitir o tráfego da web:<\/p>
    sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT\nsudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT<\/pre>
    Bloqueie um endereço IP específico<\/strong><\/p>
    Para bloquear todo o tráfego proveniente de um único endereço IP:<\/p>
    sudo iptables -A INPUT -s 192.0.2.1 -j DROP<\/pre>
    Bloqueie um intervalo de endereços IP<\/strong><\/p>
    Use o módulo iprange<\/strong> para descartar o tráfego proveniente de um intervalo de endereços:<\/p>
    sudo iptables -A INPUT -m iprange --src-range 192.0.2.1-192.0.2.254 -j DROP<\/pre>
    Descarte pacotes inválidos<\/strong><\/p>
    Pacotes inválidos não pertencem a nenhuma conexão conhecida e costumam ser usados em ataques de rede. Descarte-os antes que cheguem aos seus serviços:<\/p>
    sudo iptables -A INPUT -m conntrack --ctstate INVALID -j DROP<\/pre>
    Descarte todo o tráfego de entrada restante<\/strong><\/p>
    Adicione essa regra por último. Ela descarta todo o tráfego de entrada que não tenha correspondido a uma regra ACCEPT anterior. Se você adicioná-la antes das regras de permissão, todo o tráfego será bloqueado, inclusive o SSH:<\/p>
    sudo iptables -A INPUT -j DROP<\/pre>
    5. Abra as portas de serviços comuns com o iptables<\/h3>
    Cada serviço em execução no seu VPS usa uma porta específica, e o iptables precisa de uma regra explícita para permitir o tráfego nessa porta:<\/p>
    Serviço<\/strong><\/th>Protocolo<\/strong><\/th>Porta<\/strong><\/th>Observações<\/strong><\/th><\/tr><\/thead>
    SSH<\/strong><\/td>TCP<\/td>22<\/td>Altere a porta padrão, se possível<\/td><\/tr>
    HTTP<\/strong><\/td>TCP<\/td>80<\/td>Necessária para tráfego web não criptografado<\/td><\/tr>
    HTTPS<\/strong><\/td>TCP<\/td>443<\/td>Necessária para tráfego web criptografado<\/td><\/tr>
    MySQL<\/strong><\/td>TCP<\/td>3306<\/td>Restrinja o acesso apenas a IPs confiáveis<\/td><\/tr>
    PostgreSQL<\/strong><\/td>TCP<\/td>5432<\/td>Restrinja o acesso apenas a IPs confiáveis<\/td><\/tr>
    SMTP<\/strong><\/td>TCP<\/td>25<\/td>Apenas se você tiver um servidor de e-mail em execução<\/td><\/tr>
    IMAP<\/strong><\/td>TCP<\/td>993<\/td>Apenas se você tiver um servidor de e-mail em execução<\/td><\/tr><\/tbody><\/table><\/figure>
    Portas de banco de dados como 3306 e 5432 nunca devem ser abertas para a internet pública. Em vez disso, restrinja-as a um endereço IP confiável ou a uma interface de rede privada:<\/p>
    sudo iptables -A INPUT -p tcp --dport 3306 -s 192.0.2.1 -j ACCEPT<\/pre>
    Substitua 192.0.2.1<\/strong> pelo endereço IP da máquina que precisa acessar o banco de dados.<\/p>
    6. Exclua ou limpe as regras do iptables<\/h3>
    Excluir uma regra específica não afeta o restante da configuração. Já a limpeza remove todas as regras de uma só vez.<\/p>
    Exclua uma regra específica<\/strong><\/p>
    Para remover uma regra sem afetar as demais, use o número da linha dela. Primeiro, liste as regras com os números das linhas:<\/p>
    sudo iptables -L INPUT --line-numbers<\/pre>
    Em seguida, exclua a regra na posição que você quer remover. Para excluir a regra número 3 da cadeia INPUT:<\/p>
    sudo iptables -D INPUT 3<\/pre>
    Limpe todas as regras<\/strong><\/p>
    Para remover todas as regras de uma só vez, use a opção -F<\/strong>:<\/p>
    sudo iptables -F<\/pre>
    \n\n\n    
    \n        \n            \n                \n            <\/svg>\n            Warning        <\/span>\n        
    \n            Aviso!<\/strong> Limpar as regras de um VPS remoto remove todas as regras de permissão e bloqueio. Se a política padrão da cadeia for DROP, você perderá o acesso ao servidor. Se a política padrão for ACCEPT, todas as portas ficarão expostas. Verifique a política padrão antes de limpar as regras.        <\/p>\n    <\/div>\n\n    \n\n\n\n<\/p>
    DROP x REJECT<\/strong><\/p>
    Ao bloquear o tráfego, você tem duas opções. O alvo DROP descarta o pacote silenciosamente: o remetente não recebe nenhuma resposta e a conexão acaba expirando. Já o alvo REJECT descarta o pacote e envia uma resposta de erro ao remetente. Isso facilita a solução de problemas, mas também confirma que a porta existe.<\/p>
    Use DROP para regras voltadas ao público, nas quais você não quer revelar informações sobre o servidor. Use REJECT em ambientes internos ou de desenvolvimento, onde um feedback mais rápido é útil.<\/p>
    7. Salve as regras do iptables permanentemente<\/h3>
    As regras do iptables ficam na memória e, por padrão, não sobrevivem a uma reinicialização. Para manter suas regras depois de reiniciar o VPS, salve-as em um arquivo.<\/p>
    Instale o iptables-persistent<\/strong><\/p>
    O pacote iptables-persistent<\/strong> salva e carrega as regras automaticamente. No Ubuntu, a instalação também inclui o netfilter-persistent<\/strong>, serviço responsável por carregar as regras salvas durante a inicialização:<\/p>
    sudo apt install iptables-persistent<\/pre>
    Durante a instalação, você verá uma mensagem solicitando que salve as regras atuais de IPv4 e IPv6. Escolha Sim<\/strong> para ambas.<\/p>
    Salve as regras manualmente<\/strong><\/p>
    Se você instalou o iptables-persistent<\/strong>, o diretório \/etc\/iptables\/<\/strong> já existe. Depois de adicionar ou alterar regras, salve-as para que permaneçam após as reinicializações:<\/p>
    sudo netfilter-persistent save<\/pre>
    Esse comando grava as regras de IPv4 e IPv6 em \/etc\/iptables\/rules.v4<\/strong> e \/etc\/iptables\/rules.v6<\/strong>, respectivamente.<\/p>
    Restaure as regras manualmente<\/strong><\/p>
    Se você precisar recarregar as regras salvas sem reiniciar o sistema:<\/p>
    sudo iptables-restore < \/etc\/iptables\/rules.v4\n\nsudo ip6tables-restore < \/etc\/iptables\/rules.v6<\/pre>
    Verifique após reiniciar<\/strong><\/p>
    Depois de reiniciar seu VPS, verifique se as regras foram carregadas corretamente:<\/p>
    sudo iptables -L -v -n<\/pre>
    A saída deve corresponder às regras que você salvou antes de reiniciar o VPS.<\/p>
    Como configurar NAT e encaminhamento de portas com o iptables<\/h2>
    O NAT e o encaminhamento de portas são usados quando o VPS funciona como gateway, roteador, endpoint de VPN<\/a> ou encaminhador de tráfego para rotear pacotes entre redes ou redirecionar o tráfego de uma porta para outra. Essas regras usam a tabela nat<\/strong>, em vez da tabela filter<\/strong> usada nas etapas anteriores.<\/p>
    O encaminhamento de portas também exige que o encaminhamento de IP esteja habilitado no kernel. Para habilitá-lo temporariamente:<\/p>
    sudo sysctl -w net.ipv4.ip_forward=1<\/pre>
    Para tornar a configuração permanente, adicione a seguinte linha ao arquivo \/etc\/sysctl.conf<\/strong>:<\/p>
    net.ipv4.ip_forward=1<\/pre>
    Depois, aplique a alteração:<\/p>
    sudo sysctl -p<\/pre>
    Para encaminhar o tráfego que chega pela porta 80 para outro host na sua rede:<\/p>
    sudo iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 192.0.2.1:80\n\nsudo iptables -t nat -A POSTROUTING -j MASQUERADE<\/pre>
    Se a política da cadeia FORWARD<\/strong> estiver definida como DROP<\/strong>, você também precisará permitir explicitamente o tráfego encaminhado:<\/p>
    sudo iptables -A FORWARD -p tcp -d 192.0.2.1 --dport 80 -j ACCEPT<\/pre>
    iptables x UFW: qual ferramenta de firewall você deve usar?<\/h2>
    O iptables oferece controle direto sobre todos os aspectos do firewall, como ordem das regras, NAT, encaminhamento de portas, cadeias personalizadas e compatibilidade com scripts existentes. Em contrapartida, a sintaxe é extensa, a ordem das regras não permite erros e uma configuração incorreta em um VPS remoto pode fazer você perder o acesso imediatamente.<\/p>
    O UFW (Uncomplicated Firewall) é uma interface para o iptables que simplifica tarefas comuns de firewall no Ubuntu. Se você só precisa permitir SSH, HTTP e HTTPS, pode configurar um firewall no Ubuntu usando o UFW<\/a> com apenas alguns comandos, sem o risco de cometer erros na ordem das regras.<\/p>
    O nftables é a alternativa mais moderna para substituir o iptables a longo prazo. Ele gerencia IPv4 e IPv6 em um único conjunto de regras e usa uma sintaxe mais simples, mas exige aprender um novo framework do zero.<\/p>
    A ferramenta certa depende do que você precisa:<\/p>