Como bloquear DDoS na borda usando iptables e eBPF no Linux

O desafio de proteger a borda contra ataques volumétricos

Quando um servidor sofre um ataque de negação de serviço distribuído, conhecido como DDoS, o volume de dados que chega à placa de rede pode esgotar os recursos do sistema operacional em poucos segundos. Historicamente, administradores confiam no iptables, a ferramenta clássica de firewall do Linux, para filtrar pacotes indesejados. Contudo, quando milhões de pacotes por segundo atingem a interface, o próprio mecanismo de processamento de pacotes do kernel consome toda a CPU.

Na prática, isso significa que antes mesmo de uma regra de iptables decidir descartar um pacote malicioso, o sistema já gastou ciclos de processamento valiosos para recebê-lo e enfileirá-lo. Para superar essa limitação, a engenharia moderna de redes adotou o eBPF, ou Extended Berkeley Packet Filter, uma tecnologia que permite executar programas em formato de bytecode diretamente dentro do espaço do kernel do Linux com segurança extrema.

O que é eBPF e como o XDP muda o jogo na rede

O eBPF funciona como uma máquina virtual leve que roda código personalizado no kernel sem precisar compilar módulos novos ou reiniciar o sistema operacional. Dentro desse ecossistema, o XDP, abreviação de eXpress Data Path, atua na camada mais baixa possível do driver da placa de rede, interceptando o pacote assim que ele chega fisicamente à interface física.

Quando combinamos essa tecnologia com o ecossistema de redes, conseguimos tomar decisões instantâneas sobre o tráfego. Para quem já gerencia infraestruturas complexas, usar essa abordagem é tão essencial quanto eliminar perda de pacotes e jitter em enlaces críticos para manter a estabilidade do sistema sob estresse severo. O programa XDP pode retornar instruções diretas como XDP_DROP para descartar o lixo digital imediatamente, poupando recursos vitais.

Escrevendo um filtro de alta performance com XDP

Para colocar a teoria em prática, precisamos criar um programa em C restrito que será compilado para bytecode e injetado na interface de rede. Este código inspeciona os cabeçalhos Ethernet, IP e TCP ou UDP de cada pacote recebido, identificando padrões típicos de tráfego malicioso ou inundações de pacotes vazios.

O código abaixo exemplifica um filtro XDP básico que rejeita pacotes destinados a uma porta específica sob ataque:

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <bpf/bpf_helpers.h>

SEC("xdp")
int block_udp_flood(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
    struct ethhdr *eth = data;
    
    if ((void *)(eth + 1) > data_end) return XDP_PASS;
    if (eth->h_proto != __constant_htons(ETH_P_IP)) return XDP_PASS;
    
    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return XDP_PASS;
    
    if (ip->protocol == IPPROTO_UDP) {
        struct udphdr *udp = (void *)(ip + 1);
        if ((void *)(udp + 1) > data_end) return XDP_PASS;
        
        if (udp->dest == __constant_htons(80)) {
            return XDP_DROP;
        }
    }
    return XDP_PASS;
}

Esse script roda diretamente no driver, garantindo que o descarte ocorra nanossegundos após a chegada do pacote físico. Se o tráfego for legítimo, ele simplesmente retorna XDP_PASS, permitindo que o fluxo normal prossiga para o restante da pilha de rede do Linux.

O papel complementar do iptables na defesa em profundidade

Embora o XDP e o eBPF brilhem na eliminação de ataques volumétricos brutos na camada de driver, eles operam sem manter o estado das conexões de rede de forma complexa. É exatamente aqui que o iptables e o seu sucessor moderno, o nftables, continuam indispensáveis para a estratégia de segurança da infraestrutura.

Enquanto o eBPF barra o ruído em massa na porta de entrada, o iptables gerencia regras contextuais, como limitar taxas de conexões stateful para portas SSH ou aplicar políticas de NAT. Integrar ambas as ferramentas cria uma defesa em camadas robusta, onde cada camada atua exatamente onde possui maior eficiência operacional.

Passo a passo para carregar e testar o filtro XDP

Para colocar essa arquitetura em produção, siga a sequência correta de comandos na sua estação de trabalho Linux com suporte a eBPF habilitado no kernel.

1. Instale as ferramentas de desenvolvimento e os compiladores necessários executando sudo apt install clang llvm libelf-dev libpcap-dev build-essential no terminal.
2. Compile o código C do filtro XDP em bytecode executando clang -O2 -target bpf -c ddos_filter.c -o ddos_filter.o para gerar o objeto binário compatível com o kernel.
3. Carregue o programa diretamente na interface de rede principal usando o comando sudo ip link set dev eth0 xdpgeneric obj ddos_filter.o sec xdp para iniciar a filtragem imediata.

Após carregar o filtro, verifique se a interface está processando os pacotes corretamente utilizando ferramentas de monitoramento de tráfego. Essa verificação garante que nenhum serviço legítimo seja afetado acidentalmente pelas novas regras de bloqueio na borda. Para complementar essa implementação em produção, vale conferir também nossas análises técnicas sobre Multímetro travou? Como rastrear curtos em placas com segurança e Alerta falso no Zabbix? Como tunar triggers e reduzir ruído.

Considerações finais sobre mitigação moderna de ataques

Implementar filtragem com eBPF e XDP combinada ao iptables transforma radicalmente a capacidade de resiliência de qualquer infraestrutura exposta à internet. Ao mover a lógica de bloqueio para o mais próximo possível do hardware, ganhamos tempo de CPU valioso e impedimos que ataques volumétricos derrubem aplicações críticas.

Manter essa arquitetura atualizada exige monitoramento constante, testes regulares de estresse e ajustes finos nas regras de inspeção de pacotes. Com planejamento adequado, sua borda de rede estará preparada para absorver picos anômalos de tráfego com estabilidade e eficiência incomparáveis.