Представим: сервер может отправлять легитимные запросы, но IP, на которые он будет их слать, неизвестны. В журнале сетевого фильтра видно что запросы таки да, идут. Но не ясно - это как раз легитимные или информация уже утекает к злоумышленникам? Было бы проще если бы был известен домен на который сервер посылает данные. Увы, но PTR не в моде, а securitytrails показывает или ничего, или слишком много по этому IP.

Можно запустить tcpdump. Но кто захочет постоянно смотреть в монитор? А если сервер не один? Есть packetbeat. Это чудовище, которое выжрало процессор на всех серверах. Брр… Не хочу о нём вспоминать. Osquery - неплохой инструмент который многое знает о сетевых подключениях и ничего - о DNS-запросах. Соответствующее предложение было просто закрыто. Zeek - о нём я узнал когда начал искать как отслеживать DNS-запросы. Похоже он неплох, но меня смутило два момента: он следит не только за DNS, а значит ресурсы будут тратиться на работу результат которой мне не нужен (хотя, возможно, в настройках можно выбрать протоколы); а ещё он ничего не знает о том какой процесс послал запрос.

Неужели это всё? Я вроде бы что-то слышал про eBPF…

Я не буду рассказывать здесь про то что такое eBPF. Теории по этому вопросу достаточно. Например вот отличный цикл статей (спасибо, @aspsk, твои статьи полезные и интересные!). Чего, на мой взгляд, хотелось бы больше (особенно на русском языке) - так это практики. Поэтому в этой статье я опишу процесс создания реального приложения с самого начала, постепенно обогащая функционал и сопровождая всё это пояснениями, комментариями и ссылками на исходники. А иногда - немного отходя в сторону, потому что хочется дать чуть больше примеров, а не просто решение конкретной задачи. Как итог - надеюсь желающие познакомиться с eBPF затратят меньше времени на поиск полезных материалов и быстрее приступят к программированию.

Что не так с packetbeat?

Я не смог удержаться и не поделиться наболевшим :-) В документации сказано: чем больше размер кольцевого буфера, тем меньше системных вызовов должно быть, а следовательно - меньше ресурса ЦП. Ну увеличил я ему память. Посмотрел на графики - да, памяти больше стало потребляться. Процессора… тоже больше.

А вот так стали выглядеть сервера когда я задолбался и снёс packetbeat:

Знакомство

Писать будем на Python и начнём с простейшего - поймём как вообще происходит взаимодействие Python и eBPF. В этом нам поможет пример взятый здесь (жаль что автор так и не написал следующую статью, должно было быть интересно). Вначале поставим эти пакеты:

python3-bpfcc bpfcc-tools libbpfcc linux-headers-$(uname -r)

Это для Debian. Но если вы собрались лезть в ядро, то найти нужные пакеты под ваш дистрибутив не должно быть для вас проблемой =). А теперь приступим:

#!/usr/bin/env python3

from bcc import BPF

BPF_PROGRAM = r"""
int hello(void *ctx) {
  bpf_trace_printk("Hello world! clone() is calling\n");
  return 0;
}
"""


bpf = BPF(text=BPF_PROGRAM)
bpf.attach_kprobe(event=bpf.get_syscall_fnname("clone"), fn_name="hello")

while True:
    try:
        (_, _, _, _, _, msg_b) = bpf.trace_fields()
        msg = msg_b.decode('utf8')
        if 'Hello world' in msg:
            print(msg)
    except ValueError:
        continue
    except KeyboardInterrupt:
        break

Как и положено всем приветмирным примерам, он не делает ничего полезного, но знакомит нас с базой. eBPF-программы могут вызываться на разные события происходящие в ядре. attach_kprobe() означает срабатывание когда вызывается определённая функция ядра. Но нам привычнее иметь дело с системными вызовами, кто знает имена соответствующих функций? Поэтому, для преобразования имени системного вызова в функцию ядра, используется вспомогательная функция get_syscall_fnname().

Самый простой вариант вывода в eBPF - это функция bpf_trace_printk(). Но это - вывод для отладки. Всё что вы передадите в эту функцию - будет доступно через файл /sys/kernel/debug/tracing/trace_pipe. И чтобы не читать в соседней консоли этот файл - мы используем функцию trace_fields(), которая сама читает этот файл и делает его содержимое доступным нам в программе.

Остальная часть должна быть понятна - в бесконечном цикле, который прерывается по нажатию Ctrl-C, мы читаем отладочный вывод и если в строке встречается "Hello world" - выводим её целиком.

NB: bpf_trace_printk() умеет форматировать текст, подобно printf(), но с важными ограничениями - не более 3-х аргументов и среди них всего один %s.

Теперь, поняв как вообще происходит работа с eBPF, давайте начнём строить настоящее приложение. Оно будет мониторить все запросы и ответы DNS и писать в журнал кто что спрашивал и какой ответ получил.

Первый шаг

Начнём с eBPF. Самый простой способ работать с пакетами - прицепится к сетевому сокету. В таком случае наша программа будет срабатывать на каждый пакет. Как именно это делается - покажу позже, а пока - нам нужно среди всех пакетов поймать UDP с портом 53. И для этого нам придётся самим разобрать структуру пакета и разделить все вложенные протоколы. На C. Начиная с Ethernet. В этом нам поможет макрос cursor_advance, который перемещает курсор (указатель) по пакету, возвращая его текущее положение и сдвигая на указанную величину (неплохо про этот макрос написано на StackOverflow):

#include <linux/if_ether.h>
#include <linux/in.h>
#include <bcc/proto.h>

int dns_matching(struct __sk_buff *skb) {
    u8 *cursor = 0;

    // Проверяем протокол IP:
    struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet));

    if (ethernet->type == ETH_P_IP) {
        …

Структура ethernet_t описана в файле proto.h:

struct ethernet_t {
  unsigned long long  dst:48;
  unsigned long long  src:48;
  unsigned int        type:16;
}

Сам формат Ethernet-кадра довольно простой – это 6 байт (48 бит) назначения, столько же источника, а затем два байта (16 бит) типа содержимого.

Тип содержимого и кодируется константой ETH_P_IP, которая равна 0x0800 и определена в файле if_ether.h - она позволяет убедиться что протоколом следующего уровня является IP (этот код, а так же другие возможные значения, описан у IEEE).

Идём дальше. Теперь проверим что в IP вложен UDP с портом 53:

        // Проверяем протокол UDP:
        struct ip_t *ip = cursor_advance(cursor, sizeof(*ip));

        if (ip->nextp == IPPROTO_UDP) {
            // Проверяем порт 53:
            struct udp_t *udp = cursor_advance(cursor, sizeof(*udp));

            if (udp->dport == 53) {
                // Запрос
                return -1;
            }

            if (udp->sport == 53) {
                // Ответ
                return -1;
            }
        }

ip_t и udp_t определены всё в том же proto.h. А вот IPPROTO_UDP уже из файла in.h. Вообще этот пример не совсем корректный. Структура IP уже чуть сложнее - в  ней есть необязательное поле из-за чего длина заголовка может варьироваться. Было бы правильным вначале из заголовка получить значение его длины, а уже потом выполнять смещение, но мы же только приступили - не будем сходу усложнять.

DNS-пакет мы нашли и это оказалось не сложно. Теперь нужно разобрать его структуру. Чтобы сделать это легче - передадим пакет в пространство пользователя (за это отвечает return -1 - код возврата 0 означал бы что пакет копировать не надо).

Вернёмся к Python. Во-первых всё же прицепим нашу программу на сокет:

#!/usr/bin/env python3

import dnslib
import sys

from bcc import BPF

bpf = BPF(text=BPF_PROGRAM)
function_dns_matching = bpf.load_func("dns_matching", BPF.SOCKET_FILTER)
BPF.attach_raw_socket(function_dns_matching, '')

Такое отличие от прошлого примера и связано тем, что теперь наша программа будет вызываться не при вызове какой-либо функции, а на каждый пакет. Пустой аргумент в attach_raw_socket означает "все сетевые интерфейсы". Если бы нам нужен был какой-то конкретный - там должно быть его имя.

Переведём сокет в блокирующий режим:

import fcntl
import os

socket_fd = function_dns_matching.sock
fl = fcntl.fcntl(socket_fd, fcntl.F_GETFL)
fcntl.fcntl(socket_fd, fcntl.F_SETFL, fl & ~os.O_NONBLOCK)

Остальная часть незамысловата - используем аналогичный бесконечный цикл, в нём читаем данные из сокета, отсекаем все заголовки, добираясь непосредственно до DNS-пакета и декодируем его.

#!/usr/bin/env python3

import dnslib
import fcntl
import os
import sys

from bcc import BPF


BPF_PROGRAM = r'''
#include <linux/if_ether.h>
#include <linux/in.h>
#include <bcc/proto.h>

int dns_matching(struct __sk_buff *skb) {
    u8 *cursor = 0;

    // Проверяем протокол IP:
    struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet));

    if (ethernet->type == ETH_P_IP) {
        // Проверяем протокол UDP:
        struct ip_t *ip = cursor_advance(cursor, sizeof(*ip));

        if (ip->nextp == IPPROTO_UDP) {
            // Проверяем порт 53:
            struct udp_t *udp = cursor_advance(cursor, sizeof(*udp));

            if (udp->dport == 53 || udp->sport == 53) {
                return -1;
            }
        }
    }
    return 0;
}
'''


bpf = BPF(text=BPF_PROGRAM)
function_dns_matching = bpf.load_func("dns_matching", BPF.SOCKET_FILTER)
BPF.attach_raw_socket(function_dns_matching, '')

socket_fd = function_dns_matching.sock
fl = fcntl.fcntl(socket_fd, fcntl.F_GETFL)
fcntl.fcntl(socket_fd, fcntl.F_SETFL, fl & ~os.O_NONBLOCK)

while True:
    try:
        packet_str = os.read(socket_fd, 2048)
    except KeyboardInterrupt:
        sys.exit(0)

    packet_bytearray = bytearray(packet_str)

    ETH_HLEN = 14
    UDP_HLEN = 8

    # Длина заголовка IP
    ip_header_length = packet_bytearray[ETH_HLEN]
    ip_header_length = ip_header_length & 0x0F
    ip_header_length = ip_header_length << 2

    # Начало DNS-пакета
    payload_offset = ETH_HLEN + ip_header_length + UDP_HLEN

    payload = packet_bytearray[payload_offset:]

    dnsrec = dnslib.DNSRecord.parse(payload)

    # Если это ответ:
    if dnsrec.rr:
        print(f'ОТВЕТ: {dnsrec.rr[0].rname} {dnslib.QTYPE.get(dnsrec.rr[0].rtype)} {", ".join([repr(dnsrec.rr[i].rdata) for i in range(0, len(dnsrec.rr))])}')
    # Если запрос:
    else:
        print(f'ЗАПРОС: {dnsrec.questions[0].qname} {dnslib.QTYPE.get(dnsrec.questions[0].qtype)}')

Этот пример (его оригинал находится тут) покажет какие DNS-запросы/ответы проходят через ваш сетевой интерфейс, но мы таким образом не узнаем какой процесс с ними работает. Т. е. как раз та информация, из-за отсутствия которой я не выбрал Zeek.

Всё-таки теория

Для получения информации о процессе в eBPF используются следующие функции - bpf_get_current_pid_tgid(), bpf_get_current_uid_gid(), bpf_get_current_comm(char *buf, int size_of_buf). Они доступны когда мы привязываем нашу программу к вызову какой-то функции ядра (как в первом примере). С UID/GID должно быть понятно. А вот первая требует пояснения для тех кто раньше не сталкивался с такими подробностями работы ядра. Дело в том, что то, что в ядре видится как PID - в пространстве пользователя отображается как идентификатор нити процесса. А то что ядро считает thread group ID - в пространстве пользователя является PID'ом. Схожим образом и с bpf_get_current_comm() - она возвращает не привычное имя процесса, которое можно увидеть через ps, а имя нити.

Хорошо, данные о процессе мы получим. Как нам их передать в пространство пользователя? Для этого используются таблицы. Создаются они как BPF_PERF_OUTPUT(event), передаются методом event.perf_submit(ctx, data, data_size), а принимаются путём опроса через b.perf_buffer_poll(). После чего, как только данные будут доступны, вызовется функция callback(), таким образом: b["event"].open_perf_buffer(callback).

Всё это детально я распишу ниже, а пока давайте продолжим теорию и поразмышляем вот над чем. Передать сам пакет мы сможем так же как и данные. Но для этого нам нужно выделить в структуре с передаваемыми данными переменную определённой длины. Какой? Быстрый и неправильный ответ - 512 байт. Но он не учитывает EDNS, а ещё хотелось бы отслеживать (корректно!) DNS-пакеты ходящие через TCP. Так что нам пришлось бы выделять большой объём "про запас", отбрасывать пакеты которые всё же окажутся крупнее и большую часть времени у нас будет выделено памяти больше чем фактически надо. Мне такой подход не нравится. К счастью есть ещё один метод - perf_submit_skb(). Помимо данных - он передаёт так же указанное количество байт пакета из буфера. Но есть нюанс - метод доступен только для сетевых программ eBPF - сокет, XDP. Т. е. тех, где мы не можем получить информацию о процессе =)

К счастью мы можем использовать несколько eBPF-программ и даже обмениваться между ними данными! И это тоже происходит через таблицы. Объявляются они так:

BPF_TABLE_PUBLIC("hash", key, val, name, max_elements);

Это чтобы сделать её доступной для других eBPF-программ. А чтобы к ней обратиться, в другой программе пишем так:

BPF_TABLE("extern", key, val, name, max_elements);

Чтобы нам не потерять наш пакет среди остальных - достаточно 5 уникальных параметров: протокол, адрес источника, порт источника, адрес получателя, порт получателя. Поэтому ключом будет следующая структура:

struct port_key {
    u8 proto;
    u32 saddr;
    u32 daddr;
    u16 sport;
    u16 dport;
};

А значением - всё то, что мы хотим узнать о процессе:

struct port_val {
    u32 ifindex;
    u32 pid;
    u32 tgid;
    u32 uid;
    u32 gid;
    char comm[64];
};

ifindex - это сетевое устройство. Заполнять это значение мы будем в другой программе, работающей на сокете. А здесь используем чтобы в дальнейшем целиком передать всю эту структуру в пространство пользователя.

Итого: при вызове функции ядра для отправки пакета - мы сохраняем информацию о том какой процесс в этом замешан. А когда на сетевом интерфейсе появляется какой-либо пакет (причём не важно - исходящий или входящий) мы проверяем - есть ли у нас какая-то информация для пакетов ходящих между этими адресатами по такому-то протоколу. Если она есть - вместе с самим пакетом мы передаём её в Python, где уже и делаем оставшуюся работу.

Что ж, основную логику будущей программы проговорили - давайте уже программировать!

А кто это сделал?!

Начнём с того что получим информацию о процессе. Для отправки пакетов используются функции udp_sendmsg() и tcp_sendmsg(). Обе в качестве первого аргумента принимают структуру sock которая нам нужна. В eBPF получить доступ к аргументам исследуемой функции можно двумя способами: указать их как параметры нашей функции либо воспользоваться макросом PT_REGS_PARMx, где x - номер аргумента. Ниже я покажу оба этих варианта. И вот наша первая программа, BPF_KPROBE_TEXT:

// Структура которая будет использоваться в качестве ключа для
// eBPF-таблицы 'proc_ports':
struct port_key {
    u8 proto;
    u32 saddr;
    u32 daddr;
    u16 sport;
    u16 dport;
};

// Структура которая будет храниться в eBPF-таблице 'proc_ports',
// содержит информацию о процессе:
struct port_val {
    u32 ifindex;
    u32 pid;
    u32 tgid;
    u32 uid;
    u32 gid;
    char comm[64];
};

// Публичная (доступная из других eBPF-программ) eBPF-таблица
// в которую записывается информация о процессе.
// Читается при появлении пакета на сокете:
BPF_TABLE_PUBLIC("hash", struct port_key, struct port_val, proc_ports, 20480);


// Это два способа получения доступа к аргументам функции:
//int trace_udp_sendmsg(struct pt_regs *ctx) {
//    struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx);
int trace_udp_sendmsg(struct pt_regs *ctx, struct sock *sk) {
    u16 sport = sk->sk_num;
    u16 dport = sk->sk_dport;
  
    // Обрабатываем только пакеты на порту 53.
    // 13568 = ntohs(53);
    if (sport == 13568 || dport == 13568) {
        // Подготавливаем данные:
        u32 saddr = sk->sk_rcv_saddr;
        u32 daddr = sk->sk_daddr;
        u64 pid_tgid = bpf_get_current_pid_tgid();
        u64 uid_gid  = bpf_get_current_uid_gid();

        // Формируем структуру-ключ.
        // Эти странные преобразования будут объяснены ниже.
        struct port_key key = {.proto = 17};
        key.saddr = htonl(saddr);
        key.daddr = htonl(daddr);
        key.sport = sport;
        key.dport = htons(dport);

        // Формируем структуру со свойствами процесса:
        struct port_val val = {};
        val.pid = pid_tgid >> 32;
        val.tgid = (u32)pid_tgid;
        val.uid = (u32)uid_gid;
        val.gid = uid_gid >> 32;
        bpf_get_current_comm(val.comm, 64);

        // Записываем значение в таблицу eBPF:
        proc_ports.update(&key, &val);
    }
    return 0;
}

Работа с tcp_sendmsg будет абсолютной такой же. Единственное отличие - в структуре port_key поле proto будет равно 6. Два этих значения (17 и 6) являются кодами протоколов UDP и TCP соответственно. Эти значения можно посмотреть в файле /etc/protocols.

Обе функции bpf_get_current_* возвращают 64 бита, поэтому чтобы извлечь данные - мы берём из них отдельно нижние и верхние 32 бита. Причём для PID/TGID мы сразу берём их в привычном для нас виде (т. е. в поле pid записываем верхние 32 бита, которые содержат то, что ядро считает TGID).

Теперь на счёт преобразований при формировании структуры-ключа. Аналогичную структуру мы будем формировать в программе в следующем разделе. Вот только будем брать данные не из ядерной структуры sock, а из eBPF'ной __sk_buff, а в ней данные хранятся именно в таком виде:

	__u32 remote_ip4;	/* Stored in network byte order */
	__u32 local_ip4;	/* Stored in network byte order */
	__u32 remote_port;	/* Stored in network byte order */
	__u32 local_port;	/* stored in host byte order */

Ловим пакеты

Вторая наша программа, BPF_SOCK_TEXT, которая будет "висеть" на сокете, для каждого пакета будет проверять наличие информации о соответствующем процессе и передавать её, вместе с самим пакетом, в пользовательское пространство:

// Структура которая будет использоваться в качестве ключа для
// eBPF-таблицы 'proc_ports':
struct port_key {
    u8 proto;
    u32 saddr;
    u32 daddr;
    u16 sport;
    u16 dport;
};

// Структура которая будет храниться в eBPF-таблице 'proc_ports',
// содержит информацию о процессе:
struct port_val {
    u32 ifindex;
    u32 pid;
    u32 tgid;
    u32 uid;
    u32 gid;
    char comm[64];
};

// eBPF-таблица из которой извлекается информация о процессе.
// Наполняется при вызове функций ядра udp_sendmsg()/tcp_sendmsg():
BPF_TABLE("extern", struct port_key, struct port_val, proc_ports, 20480);

// Таблица для передачи данных в пользовательское пространство:
BPF_PERF_OUTPUT(dns_events);


// Среди проходящих через сокет данных ищем DNS-пакеты
// и проверяем наличие информации о процессе:
int dns_matching(struct __sk_buff *skb) {
    u8 *cursor = 0;

    // Проверяем протокол IP:
    struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet));

    if (ethernet->type == ETH_P_IP) {
        struct ip_t *ip = cursor_advance(cursor, sizeof(*ip));

        u8 proto;
        u16 sport;
        u16 dport;

        // Проверяем протокол транспортного уровня:
        if (ip->nextp == IPPROTO_UDP) {
            struct udp_t *udp = cursor_advance(cursor, sizeof(*udp));

            proto = 17;

            // Получаем данные о портах:
            sport = udp->sport;
            dport = udp->dport;
        } else if (ip->nextp == IPPROTO_TCP) {
            struct tcp_t *tcp = cursor_advance(cursor, sizeof(*tcp));

            // Нам не нужны пакеты где не передаются данные:
            if (!tcp->flag_psh) {
                return 0;
            }

            proto = 6;

            // Получаем данные о портах:
            sport = tcp->src_port;
            dport = tcp->dst_port;
        } else {
            return 0;
        }

        // Если это DNS-запрос:
        if (dport == 53 || sport == 53) {
            // Формируем структуру-ключ:
            struct port_key key = {};
            key.proto = proto;
            if (skb->ingress_ifindex == 0) {
                key.saddr = ip->src;
                key.daddr = ip->dst;
                key.sport = sport;
                key.dport = dport;
            } else {
                key.saddr = ip->dst;
                key.daddr = ip->src;
                key.sport = dport;
                key.dport = sport;
            }

            // По ключу ищем значение в таблице eBPF:
            struct port_val *p_val;
            p_val = proc_ports.lookup(&key);

            // Если значение не найдено - значит у нас нет информации о
            // процессе и дальше продлжать нет смысла:
            if (!p_val) {
                return 0;
            }

            // Индекс сетевого устройства:
            p_val->ifindex = skb->ifindex;

            // Передаём структуру с информацией о процессе вместе с
            // skb->len байтами отправленными в сокет:
            dns_events.perf_submit_skb(skb, skb->len, p_val,
                                       sizeof(struct port_val));
            return 0;
        } //dport == 53 || sport == 53
    } //ethernet->type == ETH_P_IP

    return 0;
}

Начинается программа так же, как и один из первых рассмотренных примеров. Мы смещаемся по пакету и собираем информацию с протоколов разных уровней. По прежнему в силе замечание о том что такой подход не учитывает фактическую длину заголовка IP. Но добавилось и кое-что новое - для TCP-пакетов мы проверяем флаг - нам не нужны пакеты которые не несут в себе данные (SYN, ACK и т. п.).

А вот дальше нам нужно восстановить ключ чтобы получить данные из таблицы proc_ports. При этом мы должны различать направление трафика - ведь когда мы заносили в таблицу данные, мы подразумевали что источником являемся мы. Но для входящих пакетов источником будет удалённый сервер. Чтобы понять направление движения пакетов - я использовал поле ingress_ifindex, которое для исходящего трафика равно 0.

Обрабатываем данные

От Python'а нам нужно три вещи: загрузить в ядро наши программы, получить от них данные и обработать их.

Первые две задачи простенькие. Тем более оба метода работы с eBPF мы уже рассмотрели в первых примерах:

# Инициализация BPF:
bpf_kprobe = BPF(text=BPF_KPROBE_TEXT)
bpf_sock = BPF(text=BPF_SOCK_TEXT)

# Отправка UDP:
bpf_kprobe.attach_kprobe(event="udp_sendmsg", fn_name="trace_udp_sendmsg")

# Отправка TCP:
bpf_kprobe.attach_kprobe(event="tcp_sendmsg", fn_name="trace_tcp_sendmsg")

# Сокет:
function_dns_matching = bpf_sock.load_func("dns_matching", BPF.SOCKET_FILTER)
BPF.attach_raw_socket(function_dns_matching, '')

Получение данных ещё короче:

bpf_sock["dns_events"].open_perf_buffer(print_dns)

while True:
    try:
        bpf_sock.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

А вот обработка данных будет более громоздкой. Не смотря на наличие готовых модулей - я решил сам разобрать заголовки протоколов. Во-первых я хотел сам разобраться как это происходит (и наконец-то правильно обработать длину заголовка IP пакета, хотя в данном случае это и бессмысленно, ведь пакеты с дополнительными опциями в заголовке отбросятся ещё в eBPF), а во-вторых - уменьшить зависимость от модулей. Правда для разбора непосредственно DNS я всё же (пока что) использую модуль - структура DNS чуть сложнее, чем у IP/TCP. Ещё один модуль (ctypes) нужен для работы с C-шными типами данных:

def print_dns(cpu, data, size):
    import ctypes as ct
    class SkbEvent(ct.Structure):
        _fields_ =  [
            ("ifindex", ct.c_uint32),
            ("pid", ct.c_uint32),
            ("tgid", ct.c_uint32),
            ("uid", ct.c_uint32),
            ("gid", ct.c_uint32),
            ("comm", ct.c_char * 64),
            ("raw", ct.c_ubyte * (size - ct.sizeof(ct.c_uint32 * 5) - ct.sizeof(ct.c_char * 64)))
        ]
    # Получам нашу структуру 'port_val', а так же сам пакет в поле 'raw':
    sk = ct.cast(data, ct.POINTER(SkbEvent)).contents

    # Протоколы:
    NET_PROTO = {6: "TCP", 17: "UDP"}

    # eBPF оперирует именами нитей.
    # Иногда они совпадают с именами процессов, но зачастую - нет.
    # Поэтому попробуем получить имя процесса по его PID'у:
    try:
        with open(f'/proc/{sk.pid}/comm', 'r') as proc_comm:
            proc_name = proc_comm.read().rstrip()
    except:
        proc_name = sk.comm.decode()

    # Получаем имя сетевого интерфейса по индексу:
    ifname = if_indextoname(sk.ifindex)

    # Длина заголовка Ethernet-кадра - 14 байт:
    ip_packet = bytes(sk.raw[14:])

    # Длина заголовка IP-пакета не фиксированна из-за произвольного
    # количества параметров.
    # Из всего возможного заголовка IP нас интересуют только 20 байт:
    (length, _, _, _, _, proto, _, saddr, daddr) = unpack('!BBHLBBHLL', ip_packet[:20])
    # Непосредственно длина записана во второй половины первого байта (0b00001111 = 15):
    len_iph = length & 15
    # Длина записывается в 32-битных словах, переводим их в байты:
    len_iph = len_iph * 4
    # Преобразовываем адреса из чисел в IP, собирая его по октетам:
    saddr = ".".join(map(str, [saddr >> 24 & 0xff, saddr >> 16 & 0xff, saddr >> 8 & 0xff, saddr & 0xff]))
    daddr = ".".join(map(str, [daddr >> 24 & 0xff, daddr >> 16 & 0xff, daddr >> 8 & 0xff, daddr & 0xff]))

    # Если протокол транспортного уровня - UDP:
    if proto == 17:
        udp_packet = ip_packet[len_iph:]
        (sport, dport) = unpack('!HH', udp_packet[:4])
        # Длина заголовка UDP-датаграммы - 8 байт:
        dns_packet = udp_packet[8:]
    # Если протокол транспортного уровня - TCP:
    elif proto == 6:
        tcp_packet = ip_packet[len_iph:]
        # Длина заголовка TCP-пакета тоже не фиксирована из-за необязательности
        # опций. Из всего заголовка TCP нас интересуют только данные по 13-й
        # байт (длину заголовка):
        (sport, dport, _, length) = unpack('!HHQB', tcp_packet[:13])
        # Непосредственно длина записана в первой половине (4-х битах):
        len_tcph = length >> 4
        # Длина записывается в 32-битных словах, переводим в байты:
        len_tcph = len_tcph * 4
        # Самая загадочная часть.
        # Непонятно где я ошибся и зачем нужно смещение на 2 байта,
        # но оно необходимо, т. к. DNS-пакет начинается только после него:
        dns_packet = tcp_packet[len_tcph + 2:]
    # Прочие протоколы не обрабатываем:
    else:
        return

    # Декодирование DNS-данных:
    dns_data = dnslib.DNSRecord.parse(dns_packet)

    # Типы ресурсных записей:
    DNS_QTYPE = {1: "A", 28: "AAAA"}

    # Запрос:
    if dns_data.header.qr == 0:
        # Нас интересуют только A (1) и AAAA (28) записи:
        for q in dns_data.questions:
            if q.qtype == 1 or q.qtype == 28:
                print(f'COMM={proc_name} PID={sk.pid} TGID={sk.tgid} DEV={ifname} PROTO={NET_PROTO[proto]} SRC={saddr} DST={daddr} SPT={sport} DPT={dport} UID={sk.uid} GID={sk.gid} DNS_QR=0 DNS_NAME={q.qname} DNS_TYPE={DNS_QTYPE[q.qtype]}')
    # Ответ:
    elif dns_data.header.qr == 1:
        # Нас интересуют только A (1) и AAAA (28) записи:
        for rr in dns_data.rr:
            if rr.rtype == 1 or rr.rtype == 28:
                print(f'COMM={proc_name} PID={sk.pid} TGID={sk.tgid} DEV={ifname} PROTO={NET_PROTO[proto]} SRC={saddr} DST={daddr} SPT={sport} DPT={dport} UID={sk.uid} GID={sk.gid} DNS_QR=1 DNS_NAME={rr.rname} DNS_TYPE={DNS_QTYPE[rr.rtype]} DNS_DATA={rr.rdata}')
    else:
        print('Неверный тип запроса DNS.')

Финал

Запустим приложение и выполним в соседней консоли запрос:

$ dig @dns3.p08.nsone.net. api.github.com +tcp

Вывод программы:

$ sudo python ~/eBPF-habr.py
Программа запущена. Нажмите Ctrl-C для прерывания.
COMM=dig PID=1030124 TGID=1030124 DEV=tap0 PROTO=UDP SRC=10.x.x.x DST=10.y.y.y SPT=52383 DPT=53 UID=1000 GID=1000 DNS_QR=0 DNS_NAME=dns3.p08.nsone.net. DNS_TYPE=A
COMM=dig PID=1030124 TGID=1030124 DEV=tap0 PROTO=UDP SRC=10.x.x.x DST=10.y.y.y SPT=52383 DPT=53 UID=1000 GID=1000 DNS_QR=0 DNS_NAME=dns3.p08.nsone.net. DNS_TYPE=AAAA
COMM=dig PID=1030124 TGID=1030124 DEV=tap0 PROTO=UDP SRC=10.y.y.y DST=10.x.x.x SPT=53 DPT=52383 UID=1000 GID=1000 DNS_QR=1 DNS_NAME=dns3.p08.nsone.net. DNS_TYPE=A DNS_DATA=198.51.44.72
COMM=dig PID=1030124 TGID=1030124 DEV=tap0 PROTO=UDP SRC=10.y.y.y DST=10.x.x.x SPT=53 DPT=52383 UID=1000 GID=1000 DNS_QR=1 DNS_NAME=dns3.p08.nsone.net. DNS_TYPE=AAAA DNS_DATA=2620:4d:4000:6259:7:8:0:3
COMM=dig PID=1030124 TGID=1030125 DEV=wlp1s0 PROTO=TCP SRC=192.x.x.x DST=198.51.44.72 SPT=38085 DPT=53 UID=1000 GID=1000 DNS_QR=0 DNS_NAME=api.github.com. DNS_TYPE=A
COMM=dig PID=1030124 TGID=1030125 DEV=wlp1s0 PROTO=TCP SRC=198.51.44.72 DST=192.x.x.x SPT=53 DPT=38085 UID=1000 GID=1000 DNS_QR=1 DNS_NAME=api.github.com. DNS_TYPE=A DNS_DATA=140.82.121.6

Вот мы и создали полезное приложение которое показывает все DNS-запросы в нашей системе. Надеюсь мои объяснения были достаточно подробными и, если вы заинтересовались написанием eBPF-программ, вам будет проще начать. Лично мне это приложение уже помогло лучше понять что происходит на серверах. Ниже я размещаю его полный код.

Можно ли сделать ещё лучше? Конечно! Во-первых стоит добавить поддержку IPv6. Во-вторых - наконец перестать полагаться на фиксированную длину заголовка IP и нормально его разобрать. Я не зря отказался от использования библиотеки в Python'е для работы с пакетами - в C всё равно придётся делать это вручную. В-третьих - хорошо бы полностью переписать код на C, отказавшись от Python'а. Это приведёт к четвёртому пункту - ручной анализ DNS-пакета. И наконец самый заманчивый пункт - перестать смотреть на порты, а попробовать анализировать каждый пакет и искать среди них те, которые подходят под формат DNS. Это позволит нам засекать пакеты даже на нестандартных портах.

#!/usr/bin/env python3

from bcc import BPF
from socket import if_indextoname
from struct import unpack


BPF_KPROBE_TEXT = """
#include <net/sock.h>

// Структура которая будет использоваться в качестве ключа для
// eBPF-таблицы 'proc_ports':
struct port_key {
    u8 proto;
    u32 saddr;
    u32 daddr;
    u16 sport;
    u16 dport;
};

// Структура которая будет храниться в eBPF-таблице 'proc_ports',
// содержит информацию о процессе:
struct port_val {
    u32 ifindex;
    u32 pid;
    u32 tgid;
    u32 uid;
    u32 gid;
    char comm[64];
};

// Публичная (доступная из других eBPF-программ) eBPF-таблица
// в которую записывается информация о процессе.
// Читается при появлении пакета на сокете:
BPF_TABLE_PUBLIC("hash", struct port_key, struct port_val, proc_ports, 20480);


int trace_udp_sendmsg(struct pt_regs *ctx) {
    struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx);

    u16 sport = sk->sk_num;
    u16 dport = sk->sk_dport;
  
    // Обрабатываем только пакеты на порту 53.
    // 13568 = ntohs(53);
    if (sport == 13568 || dport == 13568) {
        // Подготавливаем данные:
        u32 saddr = sk->sk_rcv_saddr;
        u32 daddr = sk->sk_daddr;
        u64 pid_tgid = bpf_get_current_pid_tgid();
        u64 uid_gid  = bpf_get_current_uid_gid();

        // Формируем структуру-ключ.
        struct port_key key = {.proto = 17};
        key.saddr = htonl(saddr);
        key.daddr = htonl(daddr);
        key.sport = sport;
        key.dport = htons(dport);

        // Формируем структуру со свойствами сокета:
        struct port_val val = {};
        val.pid = pid_tgid >> 32;
        val.tgid = (u32)pid_tgid;
        val.uid = (u32)uid_gid;
        val.gid = uid_gid >> 32;
        bpf_get_current_comm(val.comm, 64);

        // Записываем значение в таблицу eBPF:
        proc_ports.update(&key, &val);
    }
    return 0;
}

int trace_tcp_sendmsg(struct pt_regs *ctx, struct sock *sk) {
    u16 sport = sk->sk_num;
    u16 dport = sk->sk_dport;
  
    // Обрабатываем только пакеты на порту 53.
    // 13568 = ntohs(53);
    if (sport == 13568 || dport == 13568) {
        // Подготавливаем данные:
        u32 saddr = sk->sk_rcv_saddr;
        u32 daddr = sk->sk_daddr;
        u64 pid_tgid = bpf_get_current_pid_tgid();
        u64 uid_gid  = bpf_get_current_uid_gid();

        // Формируем структуру-ключ.
        struct port_key key = {.proto = 6};
        key.saddr = htonl(saddr);
        key.daddr = htonl(daddr);
        key.sport = sport;
        key.dport = htons(dport);

        // Формируем структуру со свойствами сокета:
        struct port_val val = {};
        val.pid = pid_tgid >> 32;
        val.tgid = (u32)pid_tgid;
        val.uid = (u32)uid_gid;
        val.gid = uid_gid >> 32;
        bpf_get_current_comm(val.comm, 64);

        // Записываем значение в таблицу eBPF:
        proc_ports.update(&key, &val);
    }
    return 0;
}
"""


BPF_SOCK_TEXT = r'''
#include <net/sock.h>
#include <bcc/proto.h>

// Структура которая будет использоваться в качестве ключа для
// eBPF-таблицы 'proc_ports':
struct port_key {
    u8 proto;
    u32 saddr;
    u32 daddr;
    u16 sport;
    u16 dport;
};

// Структура которая будет храниться в eBPF-таблице 'proc_ports',
// содержит информацию о процессе:
struct port_val {
    u32 ifindex;
    u32 pid;
    u32 tgid;
    u32 uid;
    u32 gid;
    char comm[64];
};

// eBPF-таблица из которой извлекается информация о процессе.
// Наполняется при вызове функций ядра udp_sendmsg()/tcp_sendmsg():
BPF_TABLE("extern", struct port_key, struct port_val, proc_ports, 20480);

// Таблица для передачи данных в пользовательское пространство:
BPF_PERF_OUTPUT(dns_events);


// Среди проходящих через сокет данных ищем DNS-пакеты
// и проверяем наличие информации о процессе:
int dns_matching(struct __sk_buff *skb) {
    u8 *cursor = 0;

    // Проверяем протокол IP:
    struct ethernet_t *ethernet = cursor_advance(cursor, sizeof(*ethernet));

    if (ethernet->type == ETH_P_IP) {
        struct ip_t *ip = cursor_advance(cursor, sizeof(*ip));

        u8 proto;
        u16 sport;
        u16 dport;

        // Проверяем протокол транспортного уровня:
        if (ip->nextp == IPPROTO_UDP) {
            struct udp_t *udp = cursor_advance(cursor, sizeof(*udp));

            proto = 17;

            // Получаем данные о портах:
            sport = udp->sport;
            dport = udp->dport;
        } else if (ip->nextp == IPPROTO_TCP) {
            struct tcp_t *tcp = cursor_advance(cursor, sizeof(*tcp));

            // Нам не нужны пакеты где не передаются данные:
            if (!tcp->flag_psh) {
                return 0;
            }

            proto = 6;

            // Получаем данные о портах:
            sport = tcp->src_port;
            dport = tcp->dst_port;
        } else {
            return 0;
        }

        // Если это DNS-запрос:
        if (dport == 53 || sport == 53) {
            // Формируем структуру-ключ:
            struct port_key key = {};
            key.proto = proto;
            if (skb->ingress_ifindex == 0) {
                key.saddr = ip->src;
                key.daddr = ip->dst;
                key.sport = sport;
                key.dport = dport;
            } else {
                key.saddr = ip->dst;
                key.daddr = ip->src;
                key.sport = dport;
                key.dport = sport;
            }

            // По ключу ищем значение в таблице eBPF:
            struct port_val *p_val;
            p_val = proc_ports.lookup(&key);

            // Если значение не найдено - значит у нас нет информации о
            // процессе и дальше продлжать нет смысла:
            if (!p_val) {
                return 0;
            }

            // Индекс сетевого устройства:
            p_val->ifindex = skb->ifindex;

            // Передаём структуру с информацией процессе вместе с
            // skb->len байтами отправленными в сокет:
            dns_events.perf_submit_skb(skb, skb->len, p_val,
                                       sizeof(struct port_val));
            return 0;
        } //dport == 53 || sport == 53
    } //ethernet->type == ETH_P_IP

    return 0;
}
'''


try:
    import dnslib
except ImportError:
    print("Ошибка: требуется модуль Python dnslib.")
    print("Установите его при помощи команды:")
    print("\t$ pip3 install dnslib")
    print("   или")
    print("\t$ sudo apt-get install python3-dnslib"
          "(на Ubuntu 18.04+)")
    exit(1)


def print_dns(cpu, data, size):
    import ctypes as ct
    class SkbEvent(ct.Structure):
        _fields_ =  [
            ("ifindex", ct.c_uint32),
            ("pid", ct.c_uint32),
            ("tgid", ct.c_uint32),
            ("uid", ct.c_uint32),
            ("gid", ct.c_uint32),
            ("comm", ct.c_char * 64),
            ("raw", ct.c_ubyte * (size - ct.sizeof(ct.c_uint32 * 5) - ct.sizeof(ct.c_char * 64)))
        ]
    # Получам нашу структуру 'port_val', а так же сам пакет в поле 'raw':
    sk = ct.cast(data, ct.POINTER(SkbEvent)).contents

    # Протоколы:
    NET_PROTO = {6: "TCP", 17: "UDP"}

    # eBPF оперирует именами нитей.
    # Иногда они совпадают с именами процессов, но зачастую - нет.
    # Поэтому попробуем получить имя процесса по его PID'у:
    try:
        with open(f'/proc/{sk.pid}/comm', 'r') as proc_comm:
            proc_name = proc_comm.read().rstrip()
    except:
        proc_name = sk.comm.decode()

    # Получаем имя сетевого интерфейса по индексу:
    ifname = if_indextoname(sk.ifindex)

    # Длина заголовка Ethernet-кадра - 14 байт:
    ip_packet = bytes(sk.raw[14:])

    # Длина заголовка IP-пакета не фиксированна из-за произвольного
    # количества параметров.
    # Из всего возможного заголовка IP нас интересуют только 20 байт:
    (length, _, _, _, _, proto, _, saddr, daddr) = unpack('!BBHLBBHLL', ip_packet[:20])
    # Непосредственно длина записана во второй половины первого байта (0b00001111 = 15):
    len_iph = length & 15
    # Длина записывается в 32-битных словах, переводим в байты:
    len_iph = len_iph * 4
    # Преобразовываем адреса из чисел в IP:
    saddr = ".".join(map(str, [saddr >> 24 & 0xff, saddr >> 16 & 0xff, saddr >> 8 & 0xff, saddr & 0xff]))
    daddr = ".".join(map(str, [daddr >> 24 & 0xff, daddr >> 16 & 0xff, daddr >> 8 & 0xff, daddr & 0xff]))

    # Если протокол транспортного уровня - UDP:
    if proto == 17:
        udp_packet = ip_packet[len_iph:]
        (sport, dport) = unpack('!HH', udp_packet[:4])
        # Длина заголовка UDP-датаграммы - 8 байт:
        dns_packet = udp_packet[8:]
    # Если протокол транспортного уровня - TCP:
    elif proto == 6:
        tcp_packet = ip_packet[len_iph:]
        # Длина заголовка TCP-пакета тоже не фиксирована из-за необязательности опций.
        # Из всего заголовка TCP нас интересуют только данные по 13-й байт
        # (длину заголовка):
        (sport, dport, _, length) = unpack('!HHQB', tcp_packet[:13])
        # Непосредственно длина записана в первой половине (4-х битах):
        len_tcph = length >> 4
        # Длина записывается в 32-битных словах, переводим в байты:
        len_tcph = len_tcph * 4
        # Самая загадочная часть.
        # Непонятно где я ошибся и зачем нужно смещение на 2 байта,
        # но оно необходимо, т. к. DNS-пакет начинается только после него:
        dns_packet = tcp_packet[len_tcph + 2:]
    # Прочие протоколы не обрабатываем:
    else:
        return

    # Декодирование DNS-данных:
    dns_data = dnslib.DNSRecord.parse(dns_packet)

    # Типы ресурсных записей:
    DNS_QTYPE = {1: "A", 28: "AAAA"}

    # Запрос:
    if dns_data.header.qr == 0:
        # Нас интересуют только A (1) и AAAA (28) записи:
        for q in dns_data.questions:
            if q.qtype == 1 or q.qtype == 28:
                print(f'COMM={proc_name} PID={sk.pid} TGID={sk.tgid} DEV={ifname} PROTO={NET_PROTO[proto]} SRC={saddr} DST={daddr} SPT={sport} DPT={dport} UID={sk.uid} GID={sk.gid} DNS_QR=0 DNS_NAME={q.qname} DNS_TYPE={DNS_QTYPE[q.qtype]}')
    # Ответ:
    elif dns_data.header.qr == 1:
        # Нас интересуют только A (1) и AAAA (28) записи:
        for rr in dns_data.rr:
            if rr.rtype == 1 or rr.rtype == 28:
                print(f'COMM={proc_name} PID={sk.pid} TGID={sk.tgid} DEV={ifname} PROTO={NET_PROTO[proto]} SRC={saddr} DST={daddr} SPT={sport} DPT={dport} UID={sk.uid} GID={sk.gid} DNS_QR=1 DNS_NAME={rr.rname} DNS_TYPE={DNS_QTYPE[rr.rtype]} DNS_DATA={rr.rdata}')
    else:
        print('Неверный тип запроса DNS.')

# Инициализация BPF:
bpf_kprobe = BPF(text=BPF_KPROBE_TEXT)
bpf_sock = BPF(text=BPF_SOCK_TEXT)

# Отправка UDP:
bpf_kprobe.attach_kprobe(event="udp_sendmsg", fn_name="trace_udp_sendmsg")

# Отправка TCP:
bpf_kprobe.attach_kprobe(event="tcp_sendmsg", fn_name="trace_tcp_sendmsg")

# Сокет:
function_dns_matching = bpf_sock.load_func("dns_matching", BPF.SOCKET_FILTER)
BPF.attach_raw_socket(function_dns_matching, '')

print('Программа запущена. Нажмите Ctrl-C для прерывания.')

bpf_sock["dns_events"].open_perf_buffer(print_dns)

while True:
    try:
        bpf_sock.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

Полезные ссылки

Я уже упоминал в самом начале статьи цикл от @aspsk. Но кроме него есть ещё несколько очень важных ссылок:

• В первую очередь стоит, конечно, сказать о https://github.com/iovisor/bcc/blob/master/docs/reference_guide.md - краткий справочник по eBPF, включая модуль Python'а. Каждая функция имеет ссылку на поиск для просмотра примеров в которых она используется.

• https://blogs.oracle.com/linux/post/bpf-in-depth-bpf-helper-functions - функции eBPF. Удобство в том, что здесь они сгруппированы по типам программ.

• https://github.com/iovisor/bcc/blob/master/docs/tutorial_bcc_python_developer.md - множество коротких примеров на Python с пояснениями, но раздел про сеть пока отсутствует.

• https://github.com/xdp-project/xdp-tutorial - уроки по XDP, разбитые по уровням сложности. Для тех кто хочет погрузиться глубже.

• https://dev.to/satrobit/absolute-beginner-s-guide-to-bcc-xdp-and-ebpf-47oi - XDP для самых маленьких. Не так масштабно как предыдущая ссылка, всего один пример, но, субъективно, легче для вхождения.

• "Linux Network Architecture" - если хотите разобраться в сетевых функциях ядра по книге, а не по чтению исходного кода. Хорошо описывает что происходит в udp_sendmsg() и tcp_sendmsg().