XDP：在网卡驱动层就把包丢掉

# 加载 XDP 程序到 eth0（native 模式是默认的）
ip link set dev eth0 xdp obj xdp_prog.o sec xdp

# 卸载到网卡硬件执行
ip link set dev eth0 xdpoffload obj xdp_prog.o sec xdp

# 强制使用 generic 模式（任何网卡都支持）
ip link set dev eth0 xdpgeneric obj xdp_prog.o sec xdp

# 检查你的网卡是否支持 XDP
ethtool -i eth0 | grep driver
ip link show eth0  # 看 xdp 字段

// XDP 程序的基本骨架
SEC("xdp")
int xdp_prog(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_ABORTED;  // 包太短，异常丢弃

    // 只处理 IPv4
    if (eth->h_proto != htons(ETH_P_IP))
        return XDP_PASS;  // 非 IPv4 直接放行

    // ... 你的过滤逻辑 ...

    return XDP_PASS;  // 默认放行
}

// xdp_firewall.c -- XDP 黑名单防火墙
// 编译：clang -O2 -g -target bpf -c xdp_firewall.c -o xdp_firewall.o

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

// 黑名单 Map：key 是 IPv4 地址（u32），value 是丢包计数器（u64）
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10240);
    __type(key, __u32);      // IPv4 源地址
    __type(value, __u64);    // 该 IP 被丢弃的包计数
} blacklist SEC(".maps");

SEC("xdp")
int xdp_firewall_prog(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_ABORTED;

    // 只处理 IPv4 流量，其他协议直接放行
    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    // 第二步：解析 IP 头部
    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_ABORTED;

    // 第三步：查黑名单
    __u32 src_ip = ip->saddr;
    __u64 *blocked = bpf_map_lookup_elem(&blacklist, &src_ip);

    if (blocked) {
        (*blocked)++;          // 更新丢包计数
        return XDP_DROP;       // 直接丢，不进协议栈
    }

    return XDP_PASS;
}

char _license[] SEC("license") = "GPL";

// xdp_fw_manager.c -- 用户态黑名单管理（核心逻辑）
// 编译：gcc -o xdp_fw_manager xdp_fw_manager.c -lbpf
#include <stdio.h>
#include <string.h>
#include <arpa/inet.h>
#include <bpf/bpf.h>

// 通过 pinned map 路径获取 fd
// XDP 程序加载后，map 会被 pin 到 /sys/fs/bpf/ 下
static int get_map_fd(const char *name)
{
    char path[256];
    snprintf(path, sizeof(path), "/sys/fs/bpf/%s", name);
    return bpf_obj_get(path);
}

// 添加 IP 到黑名单
static int cmd_add(const char *ip_str)
{
    int fd = get_map_fd("blacklist");
    struct in_addr addr;
    inet_pton(AF_INET, ip_str, &addr);
    __u64 count = 0;
    bpf_map_update_elem(fd, &addr.s_addr, &count, BPF_ANY);
    printf("已添加 %s 到黑名单\n", ip_str);
    return 0;
}

// 遍历并打印所有黑名单条目
static int cmd_list(void)
{
    int fd = get_map_fd("blacklist");
    __u32 key = 0, next_key;
    __u64 value;
    char ip_str[INET_ADDRSTRLEN];
    printf("%-18s %s\n", "IP 地址", "丢包计数");
    while (bpf_map_get_next_key(fd, &key, &next_key) == 0) {
        bpf_map_lookup_elem(fd, &next_key, &value);
        inet_ntop(AF_INET, &next_key, ip_str, sizeof(ip_str));
        printf("%-18s %llu\n", ip_str, value);
        key = next_key;
    }
    return 0;
}

int main(int argc, char **argv)
{
    if (argc >= 3 && strcmp(argv[1], "add") == 0)
        return cmd_add(argv[2]);
    if (argc >= 3 && strcmp(argv[1], "del") == 0) {
        // 类似 add，调用 bpf_map_delete_elem
        int fd = get_map_fd("blacklist");
        struct in_addr addr;
        inet_pton(AF_INET, argv[2], &addr);
        bpf_map_delete_elem(fd, &addr.s_addr);
        printf("已移除 %s\n", argv[2]);
        return 0;
    }
    if (argc >= 2 && strcmp(argv[1], "list") == 0)
        return cmd_list();
    fprintf(stderr, "用法: %s add|del|list [IP]\n", argv[0]);
    return 1;
}

# 1. 安装依赖
sudo apt install clang llvm libbpf-dev linux-headers-$(uname -r)

# 2. 编译 XDP 内核态程序
clang -O2 -g -target bpf -D__TARGET_ARCH_x86 \
    -I/usr/include/x86_64-linux-gnu \
    -c xdp_firewall.c -o xdp_firewall.o

# 3. 编译用户态管理工具
gcc -O2 -o xdp_fw_manager xdp_fw_manager.c -lbpf

# 4. 加载 XDP 程序并 pin maps（用户态工具通过 pin 路径访问 Map）
sudo bpftool prog load xdp_firewall.o /sys/fs/bpf/xdp_firewall \
    pinmaps /sys/fs/bpf/

# 5. 附加到网卡（native 模式）
sudo bpftool net attach xdp pinned /sys/fs/bpf/xdp_firewall dev eth0

# 6. 验证
sudo bpftool prog list | grep xdp
ip link show eth0  # 看 xdp 字段

# 7. 测试黑名单
sudo ./xdp_fw_manager add 192.168.1.100
sudo ./xdp_fw_manager list
# 从 192.168.1.100 发 ping——应该无回复；其他 IP 正常

# 8. 卸载
sudo bpftool net detach xdp dev eth0
sudo rm -rf /sys/fs/bpf/xdp_firewall /sys/fs/bpf/blacklist

// xdp_reflect.c -- 交换 MAC 地址后从同一网卡发回
SEC("xdp")
int xdp_reflect_prog(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_ABORTED;

    // 交换源和目的 MAC 地址
    __u8 tmp[ETH_ALEN];
    __builtin_memcpy(tmp, eth->h_dest, ETH_ALEN);
    __builtin_memcpy(eth->h_dest, eth->h_source, ETH_ALEN);
    __builtin_memcpy(eth->h_source, tmp, ETH_ALEN);

    return XDP_TX;  // 从同一个网卡发回
}

SEC("xdp")
int xdp_nat_prog(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 != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    // 如果目的 IP 是虚拟 IP 10.0.0.1，改成真实后端 10.0.0.100
    __u32 vip = bpf_htonl(0x0A000001);       // 10.0.0.1
    __u32 backend = bpf_htonl(0x0A000064);   // 10.0.0.100

    if (ip->daddr == vip) {
        // 增量更新校验和——只修改变化的字段，不用重算整个头
        __u32 old_addr = ip->daddr;
        ip->daddr = backend;
        __u32 sum = (~ip->check & 0xFFFF) +
                    (~old_addr & 0xFFFF) + (~(old_addr >> 16) & 0xFFFF) +
                    (backend & 0xFFFF) + ((backend >> 16) & 0xFFFF);
        sum = (sum & 0xFFFF) + (sum >> 16);
        ip->check = ~((sum & 0xFFFF) + (sum >> 16));

        // 修改目的 MAC（实际应从 Map 查，这里硬编码演示）
        __u8 backend_mac[] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55};
        __builtin_memcpy(eth->h_dest, backend_mac, ETH_ALEN);

        return XDP_TX;
    }

    return XDP_PASS;
}

// 正确的增量校验和更新——修改 IPv4 地址时使用
// 适用于 IP 头部校验和和 TCP/UDP 校验和
static __always_inline void update_csum_l3(struct iphdr *ip,
                                            __be32 old_addr,
                                            __be32 new_addr)
{
    __u32 sum;
    // RFC 1624: HC' = ~(~HC + ~m + m')
    // 把 32 位地址拆成两个 16 位 word 处理
    sum  = (~ntohs(ip->check)) & 0xFFFF;
    sum += (~(old_addr & 0xFFFF)) & 0xFFFF;       // 减去旧值低 16 位
    sum += (~((old_addr >> 16) & 0xFFFF)) & 0xFFFF; // 减去旧值高 16 位
    sum += (new_addr & 0xFFFF);                     // 加上新值低 16 位
    sum += ((new_addr >> 16) & 0xFFFF);             // 加上新值高 16 位

    // 进位回卷：把超过 16 位的高位加回来，可能需要两次
    sum = (sum & 0xFFFF) + (sum >> 16);
    sum = (sum & 0xFFFF) + (sum >> 16);

    ip->check = htons(~sum & 0xFFFF);
}

// TCP/UDP 校验和也需要更新（它们包含伪头部中的 IP 地址）
static __always_inline void update_csum_l4(struct tcphdr *tcp,
                                            __be32 old_addr,
                                            __be32 new_addr)
{
    __u32 sum;
    sum  = (~ntohs(tcp->check)) & 0xFFFF;
    sum += (~(old_addr & 0xFFFF)) & 0xFFFF;
    sum += (~((old_addr >> 16) & 0xFFFF)) & 0xFFFF;
    sum += (new_addr & 0xFFFF);
    sum += ((new_addr >> 16) & 0xFFFF);
    sum = (sum & 0xFFFF) + (sum >> 16);
    sum = (sum & 0xFFFF) + (sum >> 16);
    tcp->check = htons(~sum & 0xFFFF);
}

// ❌ 错误：只做了一次进位回卷
// 当中间结果的高位部分再次产生进位时，校验和会错
static __always_inline void update_csum_BUGGY(struct iphdr *ip,
                                               __be32 old_addr,
                                               __be32 new_addr)
{
    __u32 sum;
    sum = (~ip->check & 0xFFFF) +
          (~old_addr & 0xFFFF) + (~(old_addr >> 16) & 0xFFFF) +
          (new_addr & 0xFFFF) + ((new_addr >> 16) & 0xFFFF);
    // BUG: 只回卷一次——如果 (sum & 0xFFFF) + (sum >> 16) > 0xFFFF，
    //      结果会多出 1，导致校验和错误
    //      概率不高（大约 1/65536），但流量大了一定会遇到
    ip->check = ~((sum & 0xFFFF) + (sum >> 16));
}

// 最安全的方式：用 bpf_csum_diff helper
__be32 old_addr = ip->daddr;
ip->daddr = new_addr;
// bpf_csum_diff 计算旧值和新值的校验和差异
ip->check = bpf_csum_diff(&old_addr, 4, &new_addr, 4, ~ip->check);

// devmap_redirect.c -- 跨多网卡 XDP 转发示例
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>

// 设备映射：支持按 ifindex 哈希查找，比 DEVMAP 更灵活
struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP_HASH);
    __uint(max_entries, 64);
    __type(key, __u32);    // 目标 ifindex
    __type(value, struct bpf_devmap_val);
} tx_port_map SEC(".maps");

// Per-CPU 统计：每个 CPU 独立计数，无锁
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 64);
    __type(key, __u32);
    __type(value, __u64);
} redirect_stats SEC(".maps");

// 路由表：源子网 → 目标 ifindex
struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __uint(max_entries, 1024);
    __type(key, struct lpm_key);
    __type(value, __u32);
    __uint(map_flags, BPF_F_NO_PREALLOC);
} route_table SEC(".maps");

struct lpm_key {
    __u32 prefixlen;
    __be32 addr;
};

SEC("xdp")
int xdp_multi_nic_redirect(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_ABORTED;
    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;

    // 根据目标 IP 查路由表，决定从哪个网卡发出
    struct lpm_key lpm = { .prefixlen = 32, .addr = ip->daddr };
    __u32 *target_ifindex = bpf_map_lookup_elem(&route_table, &lpm);
    if (!target_ifindex)
        return XDP_PASS;  // 无匹配路由，交给内核协议栈

    // Per-CPU 统计更新（无锁，每个 CPU 核写自己的计数器）
    __u32 idx = *target_ifindex;
    __u64 *cnt = bpf_map_lookup_elem(&redirect_stats, &idx);
    if (cnt)
        (*cnt)++;

    // bpf_redirect_map：把包转发到目标网卡
    // 最后一个参数是 fallback action（Map 查找失败时的动作）
    return bpf_redirect_map(&tx_port_map, *target_ifindex, XDP_PASS);
}

char _license[] SEC("license") = "GPL";

# 1. 填充设备 Map（用户态）
# 假设 eth1=ifindex 3, eth2=ifindex 4, eth3=ifindex 5
bpftool map update pinned /sys/fs/bpf/tx_port_map \
    key 3 0 0 0 value 3 0 0 0 0 0 0 0
bpftool map update pinned /sys/fs/bpf/tx_port_map \
    key 4 0 0 0 value 4 0 0 0 0 0 0 0

# 2. 绑定网卡中断到特定 CPU（避免跨 NUMA 转发）
# 查看网卡中断号
grep eth0 /proc/interrupts
# 假设中断号是 36-43（8 个队列）
# 绑定到 CPU 0-7
for i in $(seq 0 7); do
    echo $i > /proc/irq/$((36+i))/smp_affinity_list
done

# 3. 设置 XDP 程序的 CPU 亲和
# 确保 XDP 处理和中断在同一 CPU 上（避免跨核数据传输）
ethtool -L eth0 combined 8   # 8 个收发队列
ethtool -N eth0 rx-flow-hash udp4 sdfn  # 按四元组哈希分流

// 设备映射表：ifindex -> 转发目标
struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP);
    __uint(max_entries, 64);
    __type(key, __u32);
    __type(value, __u32);
} tx_port SEC(".maps");

SEC("xdp")
int xdp_redirect_prog(struct xdp_md *ctx)
{
    // 从 eth0 收到的包转发到 eth1 (ifindex=3)
    __u32 dest_ifindex = 3;
    return bpf_redirect_map(&tx_port, dest_ifindex, 0);
}

// IP 分片检查——frag_off 低 13 位是偏移，高位是 MF 标志
if (ip->frag_off & bpf_htons(IP_MF | IP_OFFSET)) {
    // 分片包，偏移 > 0 时可能没有 TCP/UDP 头
    return XDP_PASS;  // 保守做法：放行让内核处理
}

bpf_printk("src_ip: %x, action: DROP\n", src_ip);

# 读取 trace 输出
sudo cat /sys/kernel/debug/tracing/trace_pipe

// 用 tail call 实现多个 XDP 程序的链式调用
struct {
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
    __uint(max_entries, 8);
    __type(key, __u32);
    __type(value, __u32);
} jmp_table SEC(".maps");

SEC("xdp")
int xdp_entry(struct xdp_md *ctx)
{
    // 先执行防火墙逻辑
    // ...

    // 然后跳到下一个程序（限速器）
    bpf_tail_call(ctx, &jmp_table, 1);

    // 如果 tail call 失败（目标程序未加载），继续执行
    return XDP_PASS;
}