WEBKT

告别传统抓包，用 eBPF 玩转 DNS 监控：揪出恶意域名与劫持攻击

75 0 0 0

作为一名网络安全工程师，你是否还在为传统的 DNS 流量监控方式而头疼？传统的 tcpdump 抓包分析，不仅效率低下，而且在高流量环境下容易丢包，难以实时掌握 DNS 的运行状态。现在，是时候告别这些繁琐的工具，拥抱 eBPF 这一强大的内核技术了！

什么是 eBPF？

eBPF（extended Berkeley Packet Filter）是一种革命性的内核技术，它允许你在内核中安全地运行自定义代码，而无需修改内核源代码或加载内核模块。这意味着你可以实时地监控和分析系统事件，而无需担心性能问题或系统崩溃的风险。eBPF 最初设计用于网络数据包过滤，但现在已经扩展到各种应用场景，包括性能分析、安全监控和跟踪。

为什么要用 eBPF 监控 DNS？

相比传统的 DNS 监控方法，eBPF 具有以下显著优势：

  • 高性能： eBPF 程序直接在内核中运行，避免了用户态和内核态之间的数据拷贝，从而大大提高了性能。在高流量环境下，eBPF 仍然能够稳定地监控 DNS 流量，不会出现丢包现象。
  • 实时性： eBPF 程序可以实时地捕获和分析 DNS 数据包，让你能够及时发现潜在的安全威胁和性能问题。
  • 灵活性： 你可以使用 eBPF 编写自定义的监控逻辑，根据自己的需求来分析 DNS 流量。例如，你可以监控特定域名的查询延迟，或者识别恶意域名。
  • 安全性： eBPF 程序运行在受限的环境中，无法访问内核的敏感数据，从而保证了系统的安全性。

如何使用 eBPF 监控 DNS？

接下来，我将向你展示如何使用 eBPF 监控 DNS 查询请求，并分析查询延迟和失败率，识别恶意域名和 DNS 劫持攻击。

1. 确定监控点

首先，你需要确定在哪个位置监控 DNS 查询请求。通常情况下，你可以在以下几个位置进行监控：

  • 网络接口： 监控所有经过网络接口的 DNS 数据包。这种方式可以捕获到所有的 DNS 查询请求，包括来自本地主机和外部网络的请求。
  • DNS 服务器： 监控 DNS 服务器接收和发送的 DNS 数据包。这种方式可以更精确地分析 DNS 服务器的性能和安全性。
  • 应用程序： 监控应用程序发起的 DNS 查询请求。这种方式可以了解应用程序的 DNS 使用情况，并识别潜在的性能问题。

2. 编写 eBPF 程序

接下来，你需要编写一个 eBPF 程序来捕获和分析 DNS 数据包。你可以使用多种编程语言来编写 eBPF 程序，例如 C、Go 和 Python。在这里，我将使用 C 语言来编写一个简单的 eBPF 程序，用于监控 DNS 查询请求的延迟。

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <arpa/inet.h>
 
#include "bpf_helpers.h"
 
#define DNS_PORT 53
 
struct dns_header {
    __u16 id;
    __u16 flags;
    __u16 qdcount;
    __u16 ancount;
    __u16 nscount;
    __u16 arcount;
};
 
struct data_t {
    __u32 timestamp;
    __u32 latency;
    char  domain[64];
};
 
BPF_PERF_OUTPUT(events);
 
int kprobe__dns_query(struct pt_regs *ctx, struct sk_buff *skb, struct net_device *dev, unsigned int len)
{
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;
 
    struct ethhdr *eth = data;
    if (data + sizeof(struct ethhdr) > data_end)
        return 0;
    if (eth->h_proto != htons(ETH_P_IP))
        return 0;
 
    data += sizeof(struct ethhdr);
    struct iphdr *ip = data;
    if (data + sizeof(struct iphdr) > data_end)
        return 0;
    if (ip->protocol != IPPROTO_UDP)
        return 0;
 
    data += sizeof(struct iphdr);
    struct udphdr *udp = data;
    if (data + sizeof(struct udphdr) > data_end)
        return 0;
    if (ntohs(udp->dest) != DNS_PORT && ntohs(udp->source) != DNS_PORT)
        return 0;
 
    data += sizeof(struct udphdr);
    struct dns_header *dns = data;
    if (data + sizeof(struct dns_header) > data_end)
        return 0;
 
    // Extract domain name (simplified, assumes single query)
    char *domain_start = data + sizeof(struct dns_header);
    char *domain_end = data_end;
    if (domain_start >= domain_end)
        return 0;
 
    char domain[64] = {0};
    int i = 0, j = 0;
    while (domain_start + i < domain_end && j < 63) {
        unsigned char len = domain_start[i];
        if (domain_start + i + len + 1 > domain_end)
            break;
        i++;
        if (j > 0) domain[j++] = '.';
        __builtin_memcpy(domain + j, domain_start + i, len);
        j += len;
        i += len;
    }
    domain[j] = 0;
 
    struct data_t event = {
        .timestamp = bpf_ktime_get_ns(),
    };
    __builtin_memcpy(event.domain, domain, sizeof(event.domain) - 1);
 
    events.perf_submit(ctx, &event, sizeof(event));
 
    return 0;
}
 
char _license[] SEC("license") = "GPL";

这个 eBPF 程序的作用是：

  1. 定义数据结构： 定义了 dns_header 和 data_t 结构体，用于存储 DNS 头部信息和自定义的监控数据。
  2. 定义 perf 输出： 使用 BPF_PERF_OUTPUT 宏定义了一个 perf 事件输出，用于将监控数据发送到用户态。
  3. 定义 kprobe： 使用 kprobe__dns_query 函数定义了一个 kprobe，用于在 dns_query 函数被调用时执行该 eBPF 程序。dns_query 是内核中处理 DNS 查询请求的函数。
  4. 解析 DNS 数据包： 在 kprobe__dns_query 函数中，首先解析 DNS 数据包，提取 DNS 头部信息和域名。
  5. 记录监控数据： 然后，记录当前的时间戳和域名，并将这些数据存储在 data_t 结构体中。
  6. 发送监控数据： 最后，使用 events.perf_submit 函数将监控数据发送到用户态。

3. 编译和加载 eBPF 程序

你需要使用 clang 和 libbpf 库来编译和加载 eBPF 程序。首先，你需要安装这些工具：

sudo apt-get install clang libbpf-dev

然后，你可以使用以下命令来编译 eBPF 程序：

clang -O2 -target bpf -c dns_monitor.c -o dns_monitor.o

接下来，你需要编写一个用户态程序来加载 eBPF 程序，并从 perf 事件输出中读取监控数据。你可以使用 Python 和 libbpf 库来实现这个功能。

from bcc import BPF
import socket
import struct
 
# 加载 eBPF 程序
b = BPF(src_file="dns_monitor.c")
 
# 定义回调函数，用于处理 perf 事件
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print(f"Timestamp: {event.timestamp}, Domain: {event.domain.decode('utf-8')}")
 
# 附加 perf 事件
b["events"].open_perf_buffer(print_event)
 
# 循环读取 perf 事件
while True:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

这个 Python 程序的作用是：

  1. 加载 eBPF 程序： 使用 BPF(src_file="dns_monitor.c") 加载编译好的 eBPF 程序。
  2. 定义回调函数： 定义 print_event 函数，用于处理 perf 事件。该函数从 perf 事件中读取监控数据，并打印到控制台。
  3. 附加 perf 事件： 使用 b["events"].open_perf_buffer(print_event) 附加 perf 事件，并将 print_event 函数注册为回调函数。
  4. 循环读取 perf 事件： 使用 b.perf_buffer_poll() 循环读取 perf 事件，并调用回调函数来处理这些事件。

最后，你可以使用以下命令来运行用户态程序：

sudo python dns_monitor.py

运行这个程序后，你就可以在控制台上看到 DNS 查询请求的监控数据了。

4. 分析 DNS 数据

有了 DNS 监控数据，你就可以进行各种分析，例如：

  • 分析查询延迟： 统计每个域名的查询延迟，找出延迟较高的域名，并分析其原因。可能是 DNS 服务器性能问题，也可能是网络问题。
  • 分析失败率： 统计每个域名的查询失败率，找出失败率较高的域名，并分析其原因。可能是 DNS 服务器故障，也可能是域名解析错误。
  • 识别恶意域名： 将监控到的域名与恶意域名库进行比对，识别恶意域名。你可以使用公开的恶意域名库，也可以自己维护一个恶意域名库。
  • 识别 DNS 劫持攻击： 监控 DNS 查询请求的响应，如果发现响应的 IP 地址与预期不符，则可能是 DNS 劫持攻击。你可以将响应的 IP 地址与权威 DNS 服务器返回的 IP 地址进行比对。

案例分析：使用 eBPF 发现 DNS 劫持攻击

假设你发现某个用户的 DNS 查询请求被劫持到了一个恶意的 IP 地址。你可以使用 eBPF 来监控该用户的 DNS 查询请求，并分析其响应数据。以下是一个简单的 eBPF 程序，用于监控 DNS 查询请求的响应 IP 地址：

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <arpa/inet.h>
 
#include "bpf_helpers.h"
 
#define DNS_PORT 53
 
struct dns_header {
    __u16 id;
    __u16 flags;
    __u16 qdcount;
    __u16 ancount;
    __u16 nscount;
    __u16 arcount;
};
 
struct data_t {
    __u32 timestamp;
    __u32 ip;
    char  domain[64];
};
 
BPF_PERF_OUTPUT(events);
 
int kretprobe__dns_query(struct pt_regs *ctx)
{
    struct sk_buff *skb = (struct sk_buff *)PT_REGS_RC(ctx);
    if (!skb) return 0;
 
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;
 
    struct ethhdr *eth = data;
    if (data + sizeof(struct ethhdr) > data_end)
        return 0;
    if (eth->h_proto != htons(ETH_P_IP))
        return 0;
 
    data += sizeof(struct ethhdr);
    struct iphdr *ip = data;
    if (data + sizeof(struct iphdr) > data_end)
        return 0;
    if (ip->protocol != IPPROTO_UDP)
        return 0;
 
    data += sizeof(struct iphdr);
    struct udphdr *udp = data;
    if (data + sizeof(struct udphdr) > data_end)
        return 0;
    if (ntohs(udp->dest) != DNS_PORT && ntohs(udp->source) != DNS_PORT)
        return 0;
 
    data += sizeof(struct udphdr);
    struct dns_header *dns = data;
    if (data + sizeof(struct dns_header) > data_end)
        return 0;
 
    // Simplified parsing to get the first IP address in the answer section
    // This is highly dependent on the DNS response structure and might need adjustments
    char *answer_start = data + sizeof(struct dns_header);
    // Skipping question section (name, type, class)
    // This is a simplification and might not be accurate for all DNS responses
    char *current = answer_start;
    // Move past the domain name in the question
    while (*current != 0 && current < data_end) current++;
    if (current >= data_end) return 0;
    current++; // Move past the null terminator
 
    // Skip type and class (2 bytes each)
    current += 4;
    if (current + 10 > data_end) return 0; // Check if there's enough data
 
    // Skip TTL (4 bytes) and data length (2 bytes)
    current += 6;
 
    // Now 'current' points to the beginning of the IP address (assuming it's an A record)
    if (current + 4 > data_end) return 0; // Ensure we have enough data for an IP address
 
    __u32 ip_address = *(__u32*)current;
 
    struct data_t event = {
        .timestamp = bpf_ktime_get_ns(),
        .ip = ip_address,
    };
 
    // Extract domain name (simplified, assumes single query)
    char *domain_start = data + sizeof(struct dns_header);
    char *domain_end = data_end;
    if (domain_start >= domain_end)
        return 0;
 
    char domain[64] = {0};
    int i = 0, j = 0;
    while (domain_start + i < domain_end && j < 63) {
        unsigned char len = domain_start[i];
        if (domain_start + i + len + 1 > domain_end)
            break;
        i++;
        if (j > 0) domain[j++] = '.';
        __builtin_memcpy(domain + j, domain_start + i, len);
        j += len;
        i += len;
    }
    domain[j] = 0;
    __builtin_memcpy(event.domain, domain, sizeof(event.domain) - 1);
 
    events.perf_submit(ctx, &event, sizeof(event));
 
    return 0;
}
 
char _license[] SEC("license") = "GPL";

这个 eBPF 程序使用了 kretprobe 来监控 dns_query 函数的返回值。kretprobe 允许你在函数返回时执行 eBPF 程序，从而可以访问函数的返回值。在这个程序中，我们使用 kretprobe 来获取 dns_query 函数返回的 sk_buff 结构体，该结构体包含了 DNS 响应数据。然后，我们解析 DNS 响应数据，提取响应的 IP 地址，并将其发送到用户态。

在用户态程序中，你可以将监控到的 IP 地址与权威 DNS 服务器返回的 IP 地址进行比对，如果发现不一致，则可能是 DNS 劫持攻击。

总结

eBPF 是一种强大的内核技术，可以用于监控 DNS 流量，并分析查询延迟和失败率，识别恶意域名和 DNS 劫持攻击。相比传统的 DNS 监控方法，eBPF 具有高性能、实时性、灵活性和安全性等优势。通过学习和掌握 eBPF 技术，你可以更好地保护你的网络安全。

进一步学习

希望这篇文章能够帮助你了解如何使用 eBPF 监控 DNS 流量，并提高你的网络安全技能。如果你有任何问题或建议，请随时与我联系。让我们一起探索 eBPF 的更多可能性！

安全小黑 eBPFDNS 监控网络安全

评论点评

打赏赞助
sponsor

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

分享

QRcode

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