Ubuntu nftables

O nftables é o firewall que vive dentro do kernel Linux. Ele decide, pacote por pacote, o que entra, o que sai e o que passa pela máquina. O ufw, que você viu em Firewall (ufw), é uma camada simples por cima dele. Nesta aula você vai falar direto com o nftables usando o comando nft.

Os exemplos acontecem na máquina fictícia servidor, com a usuária ana. Todos os comandos do nft exigem sudo.

Antes do comando: quem é quem

No Linux existem várias ferramentas de firewall, e isso confunde. Na verdade há um só motor no kernel, chamado netfilter. As ferramentas são formas diferentes de dar ordens a ele:

Você confere isso na sua máquina:

$ iptables --version
iptables v1.8.11 (nf_tables)                 « o iptables grava no nftables
$ readlink -f /usr/sbin/iptables
/usr/sbin/xtables-nft-multi
$ systemctl is-active ufw nftables
active                                       « ufw ligado
inactive                                     « serviço nftables desligado

Tabelas, cadeias e regras

O nftables organiza tudo em três níveis, como pastas dentro de pastas:

1. Tabela (table): uma caixa com nome e família. A família diz que tipo de tráfego ela vê: ip (IPv4), ip6 (IPv6) ou inet (os dois). Use inet quase sempre.
2. Cadeia (chain): uma lista de regras ligada a um ponto do caminho do pacote, o hook. input = pacotes chegando para esta máquina; output = saindo dela; forward = passando por ela rumo a outra.
3. Regra (rule): uma condição e uma ação. "Se for TCP na porta 22, aceite."

Cada cadeia tem uma política (policy): o que fazer com um pacote que não bateu em nenhuma regra. accept deixa passar; drop descarta em silêncio.

Ler as regras atuais: nft list ruleset

sudo

O nftables só responde ao administrador.

nft

O programa que conversa com o nftables.

list ruleset

"Liste o conjunto de regras": mostra todas as tabelas, cadeias e regras ativas.

$ sudo nft list ruleset
[sudo: authenticate] Senha:
table inet filter {                                         « tabela "filter", família inet
	chain input {                                           « cadeia ligada à entrada
		type filter hook input priority filter; policy accept;
	}
	chain forward {
		type filter hook forward priority filter; policy accept;
	}
	chain output {
		type filter hook output priority filter; policy accept;
	}
}

Essa é a tabela vazia de exemplo que o Ubuntu traz em /etc/nftables.conf. Nenhuma cadeia tem regra e todas as políticas são accept: nada é bloqueado. Com o ufw ativo, a saída é bem maior e cheia de cadeias chamadas ufw-….

O que o comando devolve

Sem sudo, o nft não consegue nem ler as regras e devolve código 1:

$ nft list ruleset
Operation not permitted (you must be root)
netlink: Error: cache initialization failed: Operation not permitted
$ echo $?
1

Uma regra, parte por parte

Vamos adicionar uma regra à cadeia input que aceita conexões SSH (porta 22):

sudo nft

O programa, como administrador.

add rule

Adiciona uma regra no fim da cadeia. insert rule põe no começo.

inet filter input

Onde: família inet, tabela filter, cadeia input.

tcp dport 22

A condição: protocolo TCP com porta de destino (destination port) 22.

accept

A ação: deixar passar.

$ sudo nft add rule inet filter input tcp dport 22 accept
$ sudo nft list chain inet filter input
table inet filter {
	chain input {
		type filter hook input priority filter; policy accept;
		tcp dport 22 accept                              « a regra nova
	}
}

De novo, silêncio é sucesso. O list chain mostra só uma cadeia, o que é mais fácil de ler que o list ruleset inteiro.

Apagar uma regra: o número handle

Para apagar uma regra, você precisa do número dela, o handle ("alça"). A opção -a mostra esses números:

$ sudo nft -a list chain inet filter input
table inet filter {
	chain input { # handle 1
		type filter hook input priority filter; policy accept;
		tcp dport 22 accept # handle 4                   « o número da regra
	}
}
$ sudo nft delete rule inet filter input handle 4

Um firewall completo em /etc/nftables.conf

O jeito profissional é descrever todas as regras num arquivo e carregar o arquivo inteiro de uma vez. Este exemplo libera SSH, HTTP e HTTPS, aceita respostas de conexões que o próprio servidor abriu e descarta todo o resto:

#!/usr/sbin/nft -f

# Apaga todas as regras antigas antes de carregar as novas
flush ruleset

table inet filter {
    chain input {
        # Tudo o que não for aceito abaixo é descartado
        type filter hook input priority filter; policy drop;

        # Respostas de conexões já abertas (ex.: o apt baixando pacotes)
        ct state established,related accept
        # Pacotes sem sentido
        ct state invalid drop

        # A interface "lo" é a própria máquina conversando com ela mesma
        iif "lo" accept

        # ping e mensagens de controle do IPv4 e IPv6
        meta l4proto { icmp, ipv6-icmp } accept

        # SSH, com limite contra tentativas em massa
        tcp dport 22 ct state new limit rate 15/minute accept

        # Site: HTTP e HTTPS
        tcp dport { 80, 443 } accept
    }

    chain forward {
        # Este servidor não é roteador: não repassa nada
        type filter hook forward priority filter; policy drop;
    }

    chain output {
        # O servidor pode iniciar qualquer conexão de saída
        type filter hook output priority filter; policy accept;
    }
}

Os pontos que mais confundem:

Verificar, carregar e tornar permanente

sudo nft

O programa, como administrador.

-c

Check: só confere a sintaxe, sem aplicar nada.

-f /etc/nftables.conf

File: lê as regras deste arquivo.

$ sudo nft -c -f /etc/nftables.conf
$ echo $?
0                                                    « sintaxe correta
$ sudo nft -f /etc/nftables.conf                     « aplica agora
$ sudo systemctl enable nftables                     « carrega o arquivo em todo boot
Created symlink '/etc/systemd/system/sysinit.target.wants/nftables.service' → '/usr/lib/systemd/system/nftables.service'.

Testar sem medo: a "rede de segurança"

A ideia é agendar a volta das regras antigas para daqui a 5 minutos, aplicar as novas e, se tudo estiver bem, cancelar a volta. Se você perder o acesso, basta esperar: as regras antigas voltam sozinhas.

1. Guarde as regras atuais num arquivo:

   $ sudo nft list ruleset | sudo tee /root/regras-antigas.nft > /dev/null

2. Agende a restauração para daqui a 5 minutos com um timer temporário do systemd:

   $ sudo systemd-run --on-active=5min /usr/sbin/nft -f /root/regras-antigas.nft
   Running timer as unit: run-r3f1c2b9a.timer
   Will run service as unit: run-r3f1c2b9a.service

3. Aplique as regras novas:

   $ sudo nft -f /etc/nftables.conf

4. Abra uma segunda janela e faça um SSH novo para o servidor. Se entrar, as regras estão boas. Cancele a restauração:

   $ sudo systemctl stop run-r3f1c2b9a.timer

Se a nova conexão não entrar, não faça nada: em 5 minutos o timer recarrega as regras antigas.

Formas diferentes de fazer

Quando não funciona

$ sudo nft -c -f /etc/nftables.conf
/etc/nftables.conf:21:31-31: Error: syntax error, unexpected newline
        tcp dport 22 acept
                          ^

$ sudo nft list ruleset | grep -c ufw
84                                                  « o ufw também está ativo

Referência

Condições mais usadas

Ações: accept (aceita), drop (descarta em silêncio), reject (recusa avisando o remetente), log prefix "texto " (registra no log e segue para a próxima regra).

Exercícios

Resumo

• Há um só motor de firewall no kernel; ufw, iptables e nft são formas de configurá-lo. Use um só.
• Tabela (família inet) → cadeia (input, forward, output) → regras (condição + ação).
• policy drop + ct state established,related accept + portas liberadas = firewall "negar por padrão".
• Regras permanentes vão em /etc/nftables.conf; confira com nft -c -f e ative com systemctl enable nftables.
• Em servidor remoto, agende a volta das regras antigas antes de aplicar as novas.