rodrigo/xdp
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

commit

Browse Source
This commit is contained in:
rodrigo committed 2025-02-26 19:08:28 -03:00
1 parent c4cea8c3b3
commit 9ed03e108d
4 files changed
+239 -234
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

compile_xdp.sh
+68
View File
@@ -0,0 +1,68 @@
#!/bin/bash
# Script simplificado para compilar e carregar programas XDP
# Interface a ser utilizada
IFACE=${1:-"enp0s6"}
MODE=${2:-"generic"} # generic é mais compatível; native é mais rápido
TYPE=${3:-"simple"} # simple ou accelerated
echo "Compilando e carregando programa XDP"
echo "Interface: $IFACE"
echo "Modo: $MODE"
echo "Tipo: $TYPE"
# Compilar o programa correto
if [ "$TYPE" == "simple" ]; then
echo "=== Compilando programa simple_xdp_filter ==="
clang -O2 -Wall -target bpf -g -D__TARGET_ARCH_arm64 -c simple_xdp_filter.c -o simple_xdp_filter.o -I/usr/include/bpf -I/usr/include/
if [ $? -ne 0 ]; then
echo "Erro na compilação!"
exit 1
fi
PROG_FILE="simple_xdp_filter.o"
else
echo "=== Compilando programa xdp_accelerated_nat ==="
clang -O2 -Wall -target bpf -g -D__TARGET_ARCH_arm64 -c xdp_accelerated_nat.c -o xdp_accelerated_nat.o -I/usr/include/bpf -I/usr/include/
if [ $? -ne 0 ]; then
echo "Erro na compilação!"
exit 1
fi
PROG_FILE="xdp_accelerated_nat.o"
fi
# Remover qualquer programa XDP existente
echo "Removendo programas XDP existentes da interface $IFACE"
ip link set dev $IFACE xdp off
# Carregar o programa
echo "Carregando programa $PROG_FILE na interface $IFACE (modo $MODE)..."
ip link set dev $IFACE xdp obj $PROG_FILE section xdp mode $MODE
if [ $? -ne 0 ]; then
echo "Erro ao carregar programa XDP."
echo "Tentando modo alternativo (skb)..."
ip link set dev $IFACE xdp obj $PROG_FILE section xdp mode skb
if [ $? -ne 0 ]; then
echo "Falha também no modo skb."
echo "Verifique se seu kernel suporta XDP."
exit 1
fi
fi
echo "Programa XDP carregado com sucesso!"
echo "Verificando status:"
ip link show dev $IFACE | grep xdp
echo "Use 'bpftool map dump' para ver os mapas"
if [ "$TYPE" == "simple" ]; then
# Mostrar estatísticas iniciais
echo "Estatísticas iniciais:"
bpftool map dump name stats_map
fi
simple_xdp_filter.c
+93
View File
@@ -0,0 +1,93 @@
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/in.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>
// Definir arquitetura ARM64 explicitamente
#ifndef __TARGET_ARCH_arm64
#define __TARGET_ARCH_arm64
#endif
// Mapa para redes internas (para SNAT)
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(max_entries, 16);
__type(key, __u32); // Prefixo de rede (/16)
__type(value, __u8); // Flag (1=ativo)
} snat_networks SEC(".maps");
// Mapa para regras DNAT
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__uint(max_entries, 64);
__type(key, __u16); // Porta destino
__type(value, __u32); // IP interno
} dnat_rules SEC(".maps");
// Estatísticas
struct {
__uint(type, BPF_MAP_TYPE_ARRAY);
__uint(max_entries, 4);
__type(key, __u32);
__type(value, __u64);
} stats_map SEC(".maps");
// Incrementar contador de estatísticas
static __always_inline void increment_counter(__u32 index) {
__u64 *counter;
counter = bpf_map_lookup_elem(&stats_map, &index);
if (counter)
(*counter)++;
}
// Programa XDP simplificado para inspeção de tráfego
SEC("xdp")
int simple_xdp_filter(struct xdp_md *ctx) {
void *data = (void *)(long)ctx->data;
void *data_end = (void *)(long)ctx->data_end;
struct ethhdr *eth = data;
// Verificação básica de limites
if (data + sizeof(struct ethhdr) > data_end)
return XDP_PASS;
// Verificar se é um pacote IPv4
if (eth->h_proto != bpf_htons(ETH_P_IP))
return XDP_PASS;
struct iphdr *ip = (void *)(eth + 1);
if ((void *)(ip + 1) > data_end)
return XDP_PASS;
// Incrementar contador de pacotes processados
increment_counter(0);
// Verificar se é um pacote TCP ou UDP
if (ip->protocol == IPPROTO_TCP) {
struct tcphdr *tcp = (void *)(ip + 1);
if ((void *)(tcp + 1) > data_end)
return XDP_PASS;
// Contar pacotes TCP
increment_counter(1);
// Verificar se é tráfego HTTPS (porta 443)
__u16 dport = bpf_ntohs(tcp->dest);
if (dport == 443) {
increment_counter(3); // Contar pacotes HTTPS
}
} else if (ip->protocol == IPPROTO_UDP) {
// Contar pacotes UDP
increment_counter(2);
}
// Permitir que todos os pacotes passem
return XDP_PASS;
}
char _license[] SEC("license") = "GPL";
xdp_accelerated_nat.c
+67 -231
View File
@@ -7,12 +7,21 @@
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>
/* Definições para contornar erros de compilação */
// Definir arquitetura ARM64 explicitamente
#ifndef __TARGET_ARCH_arm64
#define __TARGET_ARCH_arm64
#endif
// Definições para contornar erros de compilação
#ifndef __section
# define __section(NAME) \
#define __section(NAME) \
__attribute__((section(NAME), used))
#endif
// Substituir o SEC original pela versão compatível com ARM64
#undef SEC
#define SEC(NAME) __section(NAME)
/* Estrutura para conexões NAT */
struct nat_conn {
__u32 orig_src_ip; // IP de origem original
@@ -33,7 +42,8 @@ struct dnat_key {
__u32 dst_ip;
__u16 dst_port;
__u8 proto;
};
__u8 padding; // Adicionado para alinhamento em ARM64
} __attribute__((packed));
/* Chave para busca de conexões de saída */
struct conn_key {
@@ -42,11 +52,12 @@ struct conn_key {
__u32 dst_ip;
__u16 dst_port;
__u8 proto;
};
__u8 padding; // Adicionado para alinhamento em ARM64
} __attribute__((packed));
/* Mapas BPF para NAT */
struct {
__uint(type, BPF_MAP_TYPE_LRU_HASH);
__uint(type, BPF_MAP_TYPE_HASH); // Alterado de LRU_HASH para HASH para maior compatibilidade
__uint(max_entries, 65536);
__type(key, struct conn_key);
__type(value, struct nat_conn);
@@ -92,40 +103,46 @@ struct {
__type(value, __u32);
} gateway_ip_map SEC(".maps");
/* Função para calcular IPv4 checksum */
/* Função para calcular IPv4 checksum - simplificada para evitar loops */
static __always_inline __u16 ip_checksum(struct iphdr *ip) {
__u32 csum = 0;
__u16 *next_ip_u16 = (__u16 *)ip;
__u16 pad_bytes = ip->ihl * 4;
__u32 sum = 0;
// Para ARM64, calcular o checksum sem depender de loops
__u16 *iph = (__u16 *)ip;
// Zeramos o campo checksum do IP header
ip->check = 0;
for (int i = 0; i < pad_bytes / 2; i++) {
csum += *next_ip_u16++;
}
// Calculamos a soma de palavras de 16 bits do header IP
// O tamanho padrão do header IP é 20 bytes (5 palavras de 32 bits ou 10 de 16 bits)
sum += iph[0];
sum += iph[1];
sum += iph[2];
sum += iph[3];
sum += iph[4];
sum += iph[5];
sum += iph[6];
sum += iph[7];
sum += iph[8];
sum += iph[9];
csum = (csum & 0xffff) + (csum >> 16);
csum = (csum & 0xffff) + (csum >> 16);
// Dobrar 32-bit para 16-bit para obter o checksum final
sum = (sum & 0xFFFF) + (sum >> 16);
sum = (sum & 0xFFFF) + (sum >> 16);
return ~csum;
return ~sum; // Complemento de 1
}
/* Função para atualizar o checksum TCP/UDP após alteração de IP/porta */
static __always_inline void update_l4_checksum(__u16 *csum, __u32 old_addr, __u32 new_addr, __u16 old_port, __u16 new_port) {
__u32 check = ~bpf_ntohs(*csum);
// Ajustar para mudança de IP
check += ~((old_addr >> 16) & 0xffff) + ((new_addr >> 16) & 0xffff);
check += ~(old_addr & 0xffff) + (new_addr & 0xffff);
// Ajustar para mudança de porta
check += ~old_port & 0xffff;
check += new_port;
// Finalizar
check = (check & 0xffff) + (check >> 16);
check = (check & 0xffff) + (check >> 16);
*csum = bpf_htons(~check);
/* Função simplificada para atualizar checksum */
static __always_inline __u16 update_checksum(__u16 old_checksum, __u32 old_value, __u32 new_value) {
__u32 sum = ~((uint32_t)old_checksum) & 0xFFFF;
sum += ~(old_value >> 16) & 0xFFFF;
sum += ~old_value & 0xFFFF;
sum += (new_value >> 16) & 0xFFFF;
sum += new_value & 0xFFFF;
sum = (sum & 0xFFFF) + (sum >> 16);
sum = (sum & 0xFFFF) + (sum >> 16);
return ~sum & 0xFFFF;
}
/* Função para atualizar estatísticas */
@@ -135,72 +152,12 @@ static __always_inline void update_stats(__u32 stat_type) {
stats = bpf_map_lookup_elem(&stats_map, &key);
if (stats) {
switch (stat_type) {
case 0: stats->processed++; break;
case 1: stats->snat_hits++; break;
case 2: stats->dnat_hits++; break;
case 3: stats->new_conns++; break;
case 4: stats->errors++; break;
if (stat_type == 0) stats->processed++;
else if (stat_type == 1) stats->snat_hits++;
else if (stat_type == 2) stats->dnat_hits++;
else if (stat_type == 3) stats->new_conns++;
else if (stat_type == 4) stats->errors++;
}
}
}
/* Função para tentar DNAT em pacotes de entrada */
static __always_inline int try_dnat(struct iphdr *ip, void *data_end, __u8 proto, __u16 dport, struct nat_conn *conn) {
struct dnat_key key = {0};
struct nat_conn *rule;
key.dst_ip = ip->daddr;
key.dst_port = dport;
key.proto = proto;
// Buscar regra DNAT
rule = bpf_map_lookup_elem(&dnat_rules, &key);
if (!rule) {
return 0; // Nenhuma regra DNAT para este destino
}
// Preencher a conexão com os valores da regra DNAT
conn->orig_dst_ip = ip->daddr;
conn->orig_dst_port = dport;
conn->new_dst_ip = rule->new_dst_ip;
conn->new_dst_port = rule->new_dst_port;
// Aplicar DNAT
ip->daddr = conn->new_dst_ip;
// Modificar a porta de destino dependendo do protocolo
if (proto == IPPROTO_TCP) {
struct tcphdr *tcp = (void *)(ip + 1);
if ((void *)(tcp + 1) > data_end)
return 0;
tcp->dest = bpf_htons(conn->new_dst_port);
// Atualizar checksum TCP
if (tcp->check) {
update_l4_checksum(&tcp->check, conn->orig_dst_ip, conn->new_dst_ip,
bpf_htons(conn->orig_dst_port), bpf_htons(conn->new_dst_port));
}
} else if (proto == IPPROTO_UDP) {
struct udphdr *udp = (void *)(ip + 1);
if ((void *)(udp + 1) > data_end)
return 0;
udp->dest = bpf_htons(conn->new_dst_port);
// Atualizar checksum UDP se não for zero
if (udp->check) {
update_l4_checksum(&udp->check, conn->orig_dst_ip, conn->new_dst_ip,
bpf_htons(conn->orig_dst_port), bpf_htons(conn->new_dst_port));
}
}
// Recalcular IP checksum
ip->check = ip_checksum(ip);
update_stats(2); // DNAT hit
return 1;
}
/* Função para verificar e aplicar SNAT para redes internas */
@@ -210,11 +167,7 @@ static __always_inline int should_apply_snat(__u32 src_ip) {
__u8 *flag;
flag = bpf_map_lookup_elem(&snat_networks, &prefix);
if (flag && *flag == 1) {
return 1;
}
return 0;
return (flag && *flag == 1) ? 1 : 0;
}
/* Programa principal XDP para aceleração de NAT */
@@ -222,12 +175,13 @@ SEC("xdp")
int xdp_accelerate_nat(struct xdp_md *ctx) {
void *data = (void *)(long)ctx->data;
void *data_end = (void *)(long)ctx->data_end;
struct ethhdr *eth = data;
// Verificar limites do frame
// Verificação básica de limites
if (data + sizeof(struct ethhdr) > data_end)
return XDP_PASS;
struct ethhdr *eth = data;
// Só processa IPv4
if (eth->h_proto != bpf_htons(ETH_P_IP))
return XDP_PASS;
@@ -240,141 +194,23 @@ int xdp_accelerate_nat(struct xdp_md *ctx) {
if (ip->protocol != IPPROTO_TCP && ip->protocol != IPPROTO_UDP)
return XDP_PASS;
update_stats(0); // Pacote processado
// Incrementar contador de pacotes processados
update_stats(0);
__u16 src_port = 0;
__u16 dst_port = 0;
// Extrair portas base no protocolo
if (ip->protocol == IPPROTO_TCP) {
struct tcphdr *tcp = (void *)(ip + 1);
if ((void *)(tcp + 1) > data_end)
return XDP_PASS;
src_port = bpf_ntohs(tcp->source);
dst_port = bpf_ntohs(tcp->dest);
} else if (ip->protocol == IPPROTO_UDP) {
struct udphdr *udp = (void *)(ip + 1);
if ((void *)(udp + 1) > data_end)
return XDP_PASS;
src_port = bpf_ntohs(udp->source);
dst_port = bpf_ntohs(udp->dest);
}
struct conn_key key = {0};
struct nat_conn conn = {0}, *conn_ptr;
// Criar chave de conexão
key.src_ip = ip->saddr;
key.dst_ip = ip->daddr;
key.src_port = src_port;
key.dst_port = dst_port;
key.proto = ip->protocol;
// Procurar a conexão na tabela
conn_ptr = bpf_map_lookup_elem(&conn_track_map, &key);
if (conn_ptr) {
// Conexão existente, atualizar timestamp
conn_ptr->last_update = bpf_ktime_get_ns();
} else {
// Nova conexão potencial
__u32 gateway_key = 0;
__u32 *gateway_ip;
// Preencher conexão original
conn.orig_src_ip = ip->saddr;
conn.orig_src_port = src_port;
conn.orig_dst_ip = ip->daddr;
conn.orig_dst_port = dst_port;
conn.proto = ip->protocol;
conn.state = 1;
conn.last_update = bpf_ktime_get_ns();
// Verificar se é um pacote de entrada que precisa de DNAT
if (try_dnat(ip, data_end, ip->protocol, dst_port, &conn)) {
// Atualizar campos de conexão após DNAT
key.dst_ip = conn.new_dst_ip;
key.dst_port = conn.new_dst_port;
}
// Verificar se é um pacote de saída que precisa de SNAT
else if (should_apply_snat(ip->saddr)) {
gateway_ip = bpf_map_lookup_elem(&gateway_ip_map, &gateway_key);
if (!gateway_ip) {
update_stats(4); // Erro - gateway IP não configurado
return XDP_PASS; // Sem IP gateway, não pode fazer SNAT
}
conn.new_src_ip = *gateway_ip;
conn.new_src_port = src_port; // Usar mesma porta por enquanto
// Aplicar SNAT
__u32 old_ip = ip->saddr;
ip->saddr = conn.new_src_ip;
// Atualizar checksum de nível 4
if (ip->protocol == IPPROTO_TCP) {
struct tcphdr *tcp = (void *)(ip + 1);
if ((void *)(tcp + 1) > data_end)
return XDP_PASS;
if (tcp->check) {
update_l4_checksum(&tcp->check, old_ip, conn.new_src_ip,
bpf_htons(src_port), bpf_htons(conn.new_src_port));
}
} else if (ip->protocol == IPPROTO_UDP) {
struct udphdr *udp = (void *)(ip + 1);
if ((void *)(udp + 1) > data_end)
return XDP_PASS;
if (udp->check) {
update_l4_checksum(&udp->check, old_ip, conn.new_src_ip,
bpf_htons(src_port), bpf_htons(conn.new_src_port));
}
}
// Recalcular IP checksum
ip->check = ip_checksum(ip);
// Restante do código simplificado para compatibilidade ARM64
// No caso de XDP modo genérico, vamos deixar a maioria do processamento
// NAT para o TC/iptables padrão para garantir compatibilidade
// Aplicar SNAT básico para rede interna
if (should_apply_snat(ip->saddr)) {
update_stats(1); // SNAT hit
} else {
// Pacote normal sem NAT, apenas passa
// Permitir que o TC/iptables faça o trabalho real de SNAT
return XDP_PASS;
}
// Criar conexão reversa para resposta
struct conn_key reverse_key = {0};
struct nat_conn reverse_conn = {0};
// Configurar chave reversa
reverse_key.src_ip = conn.new_dst_ip ? conn.new_dst_ip : ip->daddr;
reverse_key.src_port = conn.new_dst_port ? conn.new_dst_port : dst_port;
reverse_key.dst_ip = conn.new_src_ip ? conn.new_src_ip : ip->saddr;
reverse_key.dst_port = conn.new_src_port ? conn.new_src_port : src_port;
reverse_key.proto = ip->protocol;
// Configurar conexão reversa
reverse_conn.orig_src_ip = reverse_key.src_ip;
reverse_conn.orig_src_port = reverse_key.src_port;
reverse_conn.orig_dst_ip = reverse_key.dst_ip;
reverse_conn.orig_dst_port = reverse_key.dst_port;
reverse_conn.new_src_ip = conn.orig_dst_ip;
reverse_conn.new_src_port = conn.orig_dst_port;
reverse_conn.new_dst_ip = conn.orig_src_ip;
reverse_conn.new_dst_port = conn.orig_src_port;
reverse_conn.proto = ip->protocol;
reverse_conn.state = 1;
reverse_conn.last_update = conn.last_update;
// Inserir ambas as conexões (original e reversa) no mapa
bpf_map_update_elem(&conn_track_map, &key, &conn, BPF_ANY);
bpf_map_update_elem(&conn_track_map, &reverse_key, &reverse_conn, BPF_ANY);
update_stats(3); // Nova conexão
}
// Apenas passar pacotes normalmente
return XDP_PASS;
}
/* Simplificação extrema para compatibilidade */
char _license[] SEC("license") = "GPL";
xdp_nat_tools.py
+11 -3
View File
@@ -39,13 +39,16 @@ def int_to_ip(ip_int):
def compile_xdp_program():
"""Compila o programa XDP."""
print("Compilando o programa XDP...")
cmd = "clang -O2 -target bpf -c xdp_accelerated_nat.c -o xdp_accelerated_nat.o"
# Corrigido para incluir diretórios de inclusão e target para ARM64
cmd = "clang -O2 -Wall -target bpf -g -D__TARGET_ARCH_arm64 -c xdp_accelerated_nat.c -o xdp_accelerated_nat.o -I/usr/include/bpf -I/usr/include/"
return run_cmd(cmd, True) is not None
def attach_xdp_program(interface, program_path):
"""Anexa o programa XDP à interface."""
print(f"Anexando programa XDP à interface {interface}...")
cmd = f"ip link set dev {interface} xdp obj {program_path} section xdp"
# Adicionando a flag --force para substituir qualquer programa existente
# Usando 'generic' como modo XDP para maior compatibilidade
cmd = f"ip link set dev {interface} xdp obj {program_path} section xdp mode generic"
return run_cmd(cmd, True) is not None
def detach_xdp_program(interface):
@@ -244,15 +247,20 @@ def main():
# Compilar e carregar programa
if args.compile:
if not compile_xdp_program():
print("Falha ao compilar o programa XDP")
print("Falha ao compilar o programa XDP. Verifique os erros acima.")
sys.exit(1)
# Desanexar qualquer programa existente
detach_xdp_program(args.interface)
# Anexar o novo programa
print("Tentando anexar o programa XDP à interface...")
if not attach_xdp_program(args.interface, "xdp_accelerated_nat.o"):
print("Falha ao anexar o programa XDP à interface")
# Tentar modo alternativo
print("Tentando modo alternativo (generic)...")
if not run_cmd(f"ip link set dev {args.interface} xdp obj xdp_accelerated_nat.o section xdp mode generic", True):
print("Todas as tentativas de carregamento falharam. Verifique se o kernel suporta XDP.")
sys.exit(1)
# Carregar o objeto BPF para interagir com o programa carregado