Como bloquear ataques DDoS na borda com eBPF e XDP

Por que o firewall tradicional sofre com ataques modernos?

Quando um servidor recebe milhões de requisições por segundo em um ataque de negação de serviço, o sistema operacional convencional começa a sofrer. Cada pacote de rede que chega à placa física precisa percorrer um caminho longo até a aplicação final, passando por várias camadas de software dentro do kernel. Na prática, isso significa que a CPU gasta preciosos ciclos apenas abrindo e fechando envelopes digitais de dados que, no fim, serão descartados. Em cenários extremos, o sistema fica sem memória e trava antes mesmo de registrar o que aconteceu.

Para resolver esse gargalo, engenheiros de redes vêm adotando tecnologias que interceptam o tráfego muito antes. Assim como detalhamos nas estratégias do guia sobre como bloquear ataques DDoS na camada 4 com iptables e hashlimit, a ideia central é colocar barreiras inteligentes no caminho dos dados. No entanto, ferramentas tradicionais ainda dependem de estruturas antigas que perdem eficiência quando o volume de pacotes atinge dezenas de gigabits por segundo. É justamente nesse cenário de alta pressão que o ecossistema de manipulação de pacotes no kernel se torna indispensável para manter os servidores online.

O que é eBPF e como ele revoluciona a segurança de redes

O eBPF, sigla para Extended Berkeley Packet Filter, é uma tecnologia revolucionária que permite executar pequenos programas personalizados diretamente dentro do núcleo do sistema operacional de forma segura. Pense nisso como um mecanismo que deixa você colocar um vigia treinado dentro da portaria principal de um prédio gigante, capaz de revistar cada encomenda antes que ela suba para os andares. Esse vigia passa por um rigoroso teste de segurança antes de começar a trabalhar, garantindo que ele nunca derrube o sistema inteiro por causa de um erro de programação.

Na prática, o eBPF transforma o kernel do Linux em uma plataforma programável. Em vez de depender de regras engessadas que vêm prontas de fábrica, os engenheiros podem escrever lógicas customizadas para inspecionar pacotes de rede, registrar métricas de desempenho ou bloquear tráfego suspeito. Como esse código roda logo na chegada dos dados, ele evita a criação de estruturas pesadas na memória RAM, poupando recursos vitais da máquina para manter os serviços legítimos funcionando sem lentidão.

Acelerando o bloqueio com XDP e manipulação no driver

O XDP, conhecido como eXpress Data Path, funciona como o braço direito do eBPF voltado especificamente para redes de altíssima velocidade. Quando a placa de rede recebe um sinal elétrico ou óptico, ela o transforma em um pacote bruto de dados e o armazena temporariamente na memória. O XDP agarra esse pacote exatamente no momento em que o driver da placa de rede acorda para recolhê-lo, muito antes de o sistema operacional criar qualquer representação interna para ele.

Nesse estágio inicial, o programa XDP pode tomar três decisões principais sobre o pacote: descartá-lo instantaneamente com um comando de negação, enviá-lo de volta por onde veio, ou passá-lo adiante para o fluxo normal do Linux. Se o pacote for um ataque evidente vindo de um IP malicioso já conhecido, o descarte ocorre em microssegundos. Para aprofundar a proteção da infraestrutura, vale a pena combinar essa abordagem com técnicas complementares de filtragem, como como bloquear varreduras de portas na borda com nftables para conter reconhecimento prévio de vulnerabilidades.

Construindo um filtro de pacotes de alta performance

Para colocar essa tecnologia para funcionar na prática, precisamos escrever um programa em linguagem C que será traduzido para um formato binário compreensível pelo kernel. Esse código examina os cabeçalhos Ethernet, IP e TCP de cada pacote que chega para identificar assinaturas típicas de tráfego malicioso. Abaixo está um exemplo básico de código eBPF com XDP 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/tcp.h>#include <bpf/bpf_helpers.h>SEC("xdp")int block_target_port(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 *iph = data + sizeof(*eth); if ((void *)(iph + 1) > data_end) return XDP_PASS; if (iph->protocol == IPPROTO_TCP) { struct tcphdr *tcph = (void *)iph + (iph->ihl * 4); if ((void *)(tcph + 1) > data_end) return XDP_PASS; if (tcph->dest == __constant_htons(80)) { return XDP_DROP; } } return XDP_PASS;}char _license[] <!-- SEC --> ("GPL");

Para carregar esse código na placa de rede do seu servidor Linux, você utiliza ferramentas modernas de gerenciamento como o utilitário iproute2. O comando a seguir anexa o programa compilado diretamente à interface de rede principal, ativando a barreira de proteção de forma imediata.

1. Compilar o código fonte em C gerando o arquivo binário objeto para o eBPF.
2. Identificar o nome exato da interface de rede principal do servidor de borda.
3. Carregar o programa no modo driver nativo usando o comando de configuração de rede.

clang -O2 -target bpf -c filter.c -o filter.oip link set dev eth0 xdp obj filter.o sec xdp

Monitorando e atualizando listas de bloqueio em tempo real

Uma das maiores vantagens de usar eBPF na borda é a capacidade de alterar regras de segurança sem precisar reiniciar o sistema operacional ou derrubar a placa de rede. Isso é feito através de estruturas chamadas mapas eBPF, que funcionam como pequenas tabelas de memória compartilhada entre o espaço do usuário e o espaço do kernel. Quando o sistema de monitoramento identifica um novo invasor, ele injeta o endereço IP indesejado no mapa.

O programa eBPF que roda na placa de rede consulta esse mapa em nanossegundos para cada pacote recebido, decidindo se o tráfego deve ser bloqueado ou liberado. Essa arquitetura garante flexibilidade operacional total, permitindo mitigar ameaças ativas de forma automatizada. Se você também administra acessos remotos na infraestrutura, assegure-se de blindar seus servidores contra invasões automatizadas aplicando tutoriais como como bloquear ataques de força bruta no SSH com Fail2Ban.

Considerações finais sobre resiliência na borda

Implementar filtros baseados em eBPF e XDP representa um salto quântico na capacidade de defesa de qualquer infraestrutura conectada à internet. Ao empurrar o processamento de pacotes maliciosos para o nível mais raso do driver da placa de rede, ganhamos uma margem de manobra imensa contra ataques volumétricos que derrubariam servidores comuns. Embora exija conhecimento técnico especializado para escrever e manter os programas em C, o retorno sobre o investimento em termos de estabilidade operacional e economia de hardware compensa cada esforço na jornada de engenharia.