WEBKT

基于eBPF构建网络安全检测工具：如何实时防御DDoS和端口扫描？

50 0 0 0

前言：eBPF与网络安全的奇妙碰撞

为什么选择eBPF？传统方案的痛点

eBPF实战：DDoS攻击检测与防御

1. 识别DDoS攻击的特征

2. 使用eBPF程序监控网络流量

3. 设置阈值并采取防御措施

4. 清理计数器

eBPF实战：端口扫描检测

1. 识别端口扫描的特征

2. 使用eBPF程序监控连接尝试

3. 设置阈值并采取防御措施

4. 定期清理Map

进一步的思考：更智能的安全策略

总结与展望

前言：eBPF与网络安全的奇妙碰撞

想象一下，如果有一种技术，它能像一位经验丰富的安全专家一样，在你服务器的核心地带默默守护，实时分析网络流量，识别潜在的攻击，并在攻击造成损害之前将其扼杀在摇篮中，那该有多棒？

这就是eBPF（extended Berkeley Packet Filter）的魅力所在。它就像一个灵活的探针，允许你在内核中安全地运行自定义代码，而无需修改内核源代码或加载内核模块。这为网络安全领域带来了革命性的变革，尤其是在实时攻击检测和防御方面。

作为一名对网络安全充满热情的工程师，我一直在探索如何利用eBPF来构建更强大、更高效的安全工具。在这篇文章中，我将分享我的一些实践经验，重点介绍如何使用eBPF来实时检测DDoS攻击和端口扫描，并采取相应的防御措施。

为什么选择eBPF？传统方案的痛点

在深入探讨eBPF的实际应用之前，我们先来回顾一下传统的网络安全检测方案，以及它们存在的局限性：

  • 基于Netfilter/iptables： 这是Linux系统中最常见的防火墙方案。虽然iptables功能强大，但其规则配置复杂，难以应对动态变化的网络环境。此外，iptables工作在内核空间，规则匹配的性能会随着规则数量的增加而显著下降。
  • 基于用户空间的IDS/IPS： 这类系统（如Snort、Suricata）通常需要将网络数据包从内核空间复制到用户空间进行分析。这种数据复制会带来额外的性能开销，在高流量环境下容易成为瓶颈。
  • 基于DPDK： DPDK（Data Plane Development Kit）是一种高性能的数据包处理框架，它允许应用程序绕过内核协议栈直接访问网卡。虽然DPDK可以显著提高数据包处理速度，但它需要修改应用程序的代码，增加了开发和维护的复杂性。

相比之下，eBPF具有以下优势：

  • 高性能： eBPF程序运行在内核空间，避免了用户空间和内核空间之间的数据复制，减少了延迟，提高了性能。
  • 安全性： eBPF程序在加载到内核之前会经过严格的验证，确保程序的安全性，防止恶意代码破坏系统。
  • 灵活性： eBPF允许开发者使用C等高级语言编写自定义的检测和防御逻辑，可以灵活地应对各种复杂的网络安全威胁。
  • 可观测性： eBPF可以访问内核中的各种数据结构和事件，为网络安全分析提供了丰富的上下文信息。

eBPF实战：DDoS攻击检测与防御

DDoS（Distributed Denial of Service）攻击是一种常见的网络攻击手段，攻击者通过控制大量的“僵尸主机”向目标服务器发送大量的请求，导致服务器资源耗尽，无法正常提供服务。下面，我们来看看如何使用eBPF来检测和防御DDoS攻击。

1. 识别DDoS攻击的特征

DDoS攻击通常具有以下特征：

  • 高流量： 大量的请求涌入服务器，导致网络带宽被耗尽。
  • 源IP地址分散： 攻击请求来自大量的不同的IP地址。
  • 请求模式单一： 攻击请求通常具有相同的特征，例如相同的User-Agent、相同的请求路径等。

2. 使用eBPF程序监控网络流量

我们可以编写一个eBPF程序，挂载到网络接口上，监控网络流量，并统计以下信息：

  • 每秒钟收到的数据包数量
  • 每秒钟收到的来自不同IP地址的数据包数量
  • 每秒钟收到的具有相同特征的数据包数量
// ddos_detect.c
#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include <arpa/inet.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
 
#include "bpf_helpers.h"
 
#define MAX_IP_ADDRESSES 1024
 
struct bpf_map_def SEC("maps") ip_counts = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(uint32_t), // IP address
    .value_size = sizeof(uint32_t), // Packet count
    .max_entries = MAX_IP_ADDRESSES,
};
 
SEC("xdp")
int xdp_ddos_detect(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
 
    struct ethhdr *eth = data;
    if (data + sizeof(struct ethhdr) > data_end) {
        return XDP_PASS;
    }
 
    if (eth->h_proto != htons(ETH_P_IP)) {
        return XDP_PASS;
    }
 
    struct iphdr *iph = data + sizeof(struct ethhdr);
    if (data + sizeof(struct ethhdr) + sizeof(struct iphdr) > data_end) {
        return XDP_PASS;
    }
 
    uint32_t src_ip = iph->saddr;
    uint32_t *count = bpf_map_lookup_elem(&ip_counts, &src_ip);
    if (count) {
        (*count)++;
    } else {
        uint32_t init_count = 1;
        bpf_map_update_elem(&ip_counts, &src_ip, &init_count, BPF_ANY);
    }
 
    return XDP_PASS;
}
 
char _license[] SEC("license") = "GPL";

这段代码的核心逻辑如下：

  1. 定义了一个名为ip_counts的BPF Map，用于存储每个IP地址的数据包计数。Map的键是IP地址（uint32_t），值是数据包计数（uint32_t）。
  2. 定义了一个名为xdp_ddos_detect的XDP程序，该程序将在网络接口收到数据包时被调用。
  3. 在XDP程序中，首先解析以太网头部和IP头部，获取源IP地址。
  4. 然后，使用bpf_map_lookup_elem函数在ip_counts Map中查找该IP地址的计数。
  5. 如果找到该IP地址的计数，则将其加1；否则，将该IP地址添加到Map中，并将计数初始化为1。
  6. 最后，程序返回XDP_PASS，表示允许数据包通过。

3. 设置阈值并采取防御措施

我们可以设置一个阈值，例如，如果某个IP地址在1秒钟内发送的数据包数量超过1000个，则认为该IP地址可能正在发起DDoS攻击。然后，我们可以采取以下防御措施：

  • 丢弃数据包： 使用eBPF程序直接丢弃来自该IP地址的数据包。
  • 限制流量： 使用TC（Traffic Control）限制来自该IP地址的流量。
  • 加入黑名单： 将该IP地址加入黑名单，阻止其访问服务器。
// ddos_mitigation.c
#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include <arpa/inet.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
 
#include "bpf_helpers.h"
 
#define MAX_IP_ADDRESSES 1024
#define THRESHOLD 1000
 
struct bpf_map_def SEC("maps") ip_counts = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(uint32_t), // IP address
    .value_size = sizeof(uint32_t), // Packet count
    .max_entries = MAX_IP_ADDRESSES,
};
 
struct bpf_map_def SEC("maps") blacklist = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(uint32_t), // IP address
    .value_size = sizeof(uint8_t), // Blacklisted (1) or not (0)
    .max_entries = MAX_IP_ADDRESSES,
};
 
SEC("xdp")
int xdp_ddos_mitigation(struct xdp_md *ctx) {
    void *data = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;
 
    struct ethhdr *eth = data;
    if (data + sizeof(struct ethhdr) > data_end) {
        return XDP_PASS;
    }
 
    if (eth->h_proto != htons(ETH_P_IP)) {
        return XDP_PASS;
    }
 
    struct iphdr *iph = data + sizeof(struct ethhdr);
    if (data + sizeof(struct ethhdr) + sizeof(struct iphdr) > data_end) {
        return XDP_PASS;
    }
 
    uint32_t src_ip = iph->saddr;
 
    // Check if the IP is blacklisted
    uint8_t *is_blacklisted = bpf_map_lookup_elem(&blacklist, &src_ip);
    if (is_blacklisted && *is_blacklisted == 1) {
        // Drop the packet if it's blacklisted
        return XDP_DROP;
    }
 
    uint32_t *count = bpf_map_lookup_elem(&ip_counts, &src_ip);
    if (count) {
        if (*count > THRESHOLD) {
            // Add the IP to the blacklist
            uint8_t blacklisted = 1;
            bpf_map_update_elem(&blacklist, &src_ip, &blacklisted, BPF_ANY);
            
            // Drop the packet
            return XDP_DROP;
        }
        (*count)++;
    } else {
        uint32_t init_count = 1;
        bpf_map_update_elem(&ip_counts, &src_ip, &init_count, BPF_ANY);
    }
 
    return XDP_PASS;
}
 
char _license[] SEC("license") = "GPL";

这段代码在前一个例子的基础上进行了扩展，增加了以下功能：

  1. 定义了一个名为blacklist的BPF Map，用于存储被列入黑名单的IP地址。Map的键是IP地址（uint32_t），值是一个字节（uint8_t），用于表示该IP地址是否被列入黑名单（1表示已列入黑名单，0表示未列入黑名单）。
  2. 在XDP程序中，首先检查该IP地址是否已被列入黑名单。如果是，则直接丢弃该数据包。
  3. 如果该IP地址未被列入黑名单，则检查其数据包计数是否超过阈值。如果超过阈值，则将该IP地址添加到黑名单中，并丢弃该数据包。

4. 清理计数器

上述代码没有展示如何清理ip_counts这个map。实际使用中，你需要定期清理这个map，例如每秒清理一次，以避免map无限增长，耗尽内存。你可以使用一个单独的eBPF程序或者用户空间的程序来完成这个任务。

eBPF实战：端口扫描检测

端口扫描是一种常见的网络侦查技术，攻击者通过扫描目标服务器的端口，探测服务器上运行的服务，从而发现潜在的漏洞。下面，我们来看看如何使用eBPF来检测端口扫描。

1. 识别端口扫描的特征

端口扫描通常具有以下特征：

  • 短时间内扫描大量端口： 攻击者会在短时间内尝试连接目标服务器的多个端口。
  • 连接模式单一： 攻击者通常使用相同的连接模式，例如TCP SYN扫描、UDP扫描等。

2. 使用eBPF程序监控连接尝试

我们可以编写一个eBPF程序，挂载到tcp_connect或者udp_sendmsg等内核tracepoint上，监控连接尝试，并统计以下信息：

  • 每秒钟来自同一个IP地址的连接尝试数量
  • 每秒钟来自同一个IP地址的不同端口的连接尝试数量
// port_scan_detect.c
#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include <arpa/inet.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
 
#include "bpf_helpers.h"
 
#define MAX_IP_ADDRESSES 1024
#define MAX_PORTS 65535
 
struct key_t {
    uint32_t ip;
    uint16_t port;
};
 
struct bpf_map_def SEC("maps") port_scan_counts = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(struct key_t),
    .value_size = sizeof(uint32_t),
    .max_entries = MAX_IP_ADDRESSES * 10, // Adjusted for port variation
};
 
SEC("kprobe/tcp_v4_connect")
int kprobe__tcp_v4_connect(struct pt_regs *ctx) {
    struct sock *sk = (struct sock *)PT_REGS_PAR1(ctx);
    
    // Get source IP and destination port
    uint32_t src_ip = sk->__sk_common.skc_rcv_saddr;
    uint16_t dest_port = sk->__sk_common.skc_dport;
 
    // Convert network byte order to host byte order
    dest_port = ntohs(dest_port);
 
    struct key_t key = {.ip = src_ip, .port = dest_port};
 
    uint32_t *count = bpf_map_lookup_elem(&port_scan_counts, &key);
    if (count) {
        (*count)++;
    } else {
        uint32_t init_count = 1;
        bpf_map_update_elem(&port_scan_counts, &key, &init_count, BPF_ANY);
    }
 
    return 0;
}
 
char _license[] SEC("license") = "GPL";

这段代码使用kprobe hook了tcp_v4_connect函数，该函数在TCP连接建立时被调用。程序的核心逻辑如下：

  1. 定义了一个名为port_scan_counts的BPF Map，用于存储每个IP地址和端口的连接尝试计数。Map的键是一个结构体key_t，包含IP地址（uint32_t）和端口（uint16_t），值是连接尝试计数（uint32_t）。
  2. 在kprobe__tcp_v4_connect函数中，首先获取源IP地址和目标端口。
  3. 然后，使用bpf_map_lookup_elem函数在port_scan_counts Map中查找该IP地址和端口的计数。
  4. 如果找到该IP地址和端口的计数，则将其加1；否则，将该IP地址和端口添加到Map中，并将计数初始化为1。

3. 设置阈值并采取防御措施

我们可以设置一个阈值，例如，如果某个IP地址在1秒钟内尝试连接超过10个不同的端口，则认为该IP地址可能正在进行端口扫描。然后，我们可以采取以下防御措施：

  • 阻止连接： 使用eBPF程序阻止来自该IP地址的连接。
  • 记录日志： 将该IP地址记录到日志中，以便后续分析。
  • 触发警报： 向安全管理员发送警报，提醒管理员注意该IP地址。
// port_scan_mitigation.c
#include <linux/bpf.h>
#include <linux/pkt_cls.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include <arpa/inet.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/tcp.h>
 
#include "bpf_helpers.h"
 
#define MAX_IP_ADDRESSES 1024
#define MAX_PORTS 65535
#define THRESHOLD 10 // Number of distinct ports within a time window
 
struct key_t {
    uint32_t ip;
    uint16_t port;
};
 
struct bpf_map_def SEC("maps") port_scan_counts = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(struct key_t),
    .value_size = sizeof(uint32_t),
    .max_entries = MAX_IP_ADDRESSES * 10, // Adjusted for port variation
};
 
struct bpf_map_def SEC("maps") ip_port_count = {
    .type = BPF_MAP_TYPE_HASH,
    .key_size = sizeof(uint32_t), // Source IP Address
    .value_size = sizeof(uint32_t), // Count of distinct ports
    .max_entries = MAX_IP_ADDRESSES,
};
 
SEC("kprobe/tcp_v4_connect")
int kprobe__tcp_v4_connect(struct pt_regs *ctx) {
    struct sock *sk = (struct sock *)PT_REGS_PAR1(ctx);
    
    // Get source IP and destination port
    uint32_t src_ip = sk->__sk_common.skc_rcv_saddr;
    uint16_t dest_port = sk->__sk_common.skc_dport;
 
    // Convert network byte order to host byte order
    dest_port = ntohs(dest_port);
 
    struct key_t key = {.ip = src_ip, .port = dest_port};
 
    uint32_t *count = bpf_map_lookup_elem(&port_scan_counts, &key);
    if (count) {
        (*count)++;
    } else {
        uint32_t init_count = 1;
        bpf_map_update_elem(&port_scan_counts, &key, &init_count, BPF_ANY);
 
        // Increment distinct port count for the source IP
        uint32_t *distinct_port_count = bpf_map_lookup_elem(&ip_port_count, &src_ip);
        if (distinct_port_count) {
            (*distinct_port_count)++;
            if (*distinct_port_count > THRESHOLD) {
                // Port scan detected, implement mitigation strategy here
                bpf_printk("Port scan detected from IP: %x\n", src_ip);
                // Implement your mitigation strategy here (e.g., drop packets, block IP)
            }
        } else {
            uint32_t init_port_count = 1;
            bpf_map_update_elem(&ip_port_count, &src_ip, &init_port_count, BPF_ANY);
        }
    }
 
    return 0;
}
 
char _license[] SEC("license") = "GPL";

这段代码在之前的代码基础上进行了修改，增加了一个ip_port_count的map，用于记录每个IP尝试连接的不同端口的数量。如果某个IP尝试连接的不同端口的数量超过了预设的阈值，就会打印一条log，并在这里可以实现具体的防御策略，例如丢弃数据包，或者屏蔽IP。

4. 定期清理Map

和DDoS检测类似，端口扫描检测也需要定期清理port_scan_counts和ip_port_count这两个map，避免内存泄漏。

进一步的思考：更智能的安全策略

上述示例只是eBPF在网络安全领域应用的冰山一角。实际上，我们可以利用eBPF的强大功能，构建更智能、更自适应的安全策略。

  • 动态阈值调整： 我们可以根据网络流量的变化，动态调整DDoS攻击和端口扫描的阈值，以适应不同的网络环境。
  • 行为分析： 我们可以使用eBPF程序分析网络流量的行为模式，识别异常流量，例如，如果某个IP地址突然开始发送大量的SYN包，则可能正在进行SYN Flood攻击。
  • 机器学习： 我们可以将eBPF与机器学习算法相结合，训练模型来识别各种网络攻击，并根据模型的预测结果采取相应的防御措施。

总结与展望

eBPF为网络安全领域带来了革命性的变革，它允许我们在内核中安全地运行自定义代码，实时分析网络流量，识别潜在的攻击，并在攻击造成损害之前将其扼杀在摇篮中。虽然eBPF的学习曲线较为陡峭，但其在性能、安全性和灵活性方面的优势使其成为构建下一代网络安全工具的理想选择。

我希望这篇文章能够帮助你了解eBPF在网络安全领域的应用，并激发你对eBPF的兴趣。如果你有任何问题或想法，欢迎在评论区与我交流。让我们一起探索eBPF的无限可能，共同构建更安全、更可靠的网络世界！

安全小黑 eBPF网络安全DDoS防御

评论点评

打赏赞助
sponsor

感谢您的支持让我们更好的前行

分享

QRcode

https://www.webkt.com/article/9695