EBPFMon.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection — EBPFMon implementazione
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0
 *
 * Se BSC_HAS_EBPF non e' definito (libbpf assente a compile-time)
 * tutte le funzioni sono stub vuoti — zero overhead sul daemon.
 *
 * Cambiamenti v2 (copertura estesa):
 *   - attacchiamo tutti i programmi dentro il .o, non solo il tracepoint
 *     `bsc_inet_sock_set_state`. Ora coesistono anche i kprobe per
 *     tcp_v{4,6}_connect e udp{,v6}_sendmsg.
 *   - se un singolo attach fallisce (es. simbolo non presente su un
 *     kernel custom) non abortiamo tutto: loggiamo warning e proseguiamo.
 *     Il daemon cade elegantemente da "coverage completa" a "coverage
 *     parziale" invece di disabilitare eBPF del tutto.
 */
 
#include "bsc/ebpf/EBPFMon.hpp"
#include "bsc/logging/Logger.hpp"
#include <arpa/inet.h>
#include <chrono>
#include <cstring>
 
#ifdef BSC_HAS_EBPF
#  include <bpf/libbpf.h>
#  include <bpf/bpf.h>
#endif
 
namespace bsc::ebpf {
 
/* ── Conversione evento → Connection ──────────────────────────── */
 
bsc::model::Connection event_to_connection(const ConnEvent& ev)
{
    bsc::model::Connection c;
 
    c.process_id   = ev.pid;
    c.user_id      = ev.uid;
    c.process_comm = std::string(ev.comm,
                                 strnlen(ev.comm, sizeof(ev.comm)));
 
    c.protocol = (ev.proto == 6) ? "tcp" : "udp";
 
    char buf[INET6_ADDRSTRLEN]{};
    if (ev.family == AF_INET) {
        // src
        inet_ntop(AF_INET, ev.src_addr, buf, sizeof(buf));
        c.src_ip = buf;
        // dst
        inet_ntop(AF_INET, ev.dst_addr, buf, sizeof(buf));
        c.dst_ip = buf;
    } else {
        inet_ntop(AF_INET6, ev.src_addr, buf, sizeof(buf));
        c.src_ip = buf;
        inet_ntop(AF_INET6, ev.dst_addr, buf, sizeof(buf));
        c.dst_ip = buf;
    }
 
    c.src_port = ev.src_port;
    c.dst_port = ev.dst_port;
 
    // Timestamp: converte ns monotoni in system_clock (approssimato)
    // Il daemon usa seen_at solo per ordinamento nella UI — non critico.
    c.seen_at = std::chrono::system_clock::now();
 
    return c;
}
 
/* ── EBPFMon ──────────────────────────────────────────────────── */
 
EBPFMon::EBPFMon()  = default;
EBPFMon::~EBPFMon() { stop(); }
 
#ifdef BSC_HAS_EBPF
 
// Callback chiamata da ring_buffer__poll per ogni record nella ring buffer.
// Converte il byte blob in ConnEvent e lo accoda nel buffer del monitor.
// Callback C per libbpf ring_buffer__new.
// Dichiarata friend in EBPFMon.hpp per accedere ai membri privati.
int ringbuf_callback(void* ctx, void* data, size_t size)
{
    if (!ctx || !data) return 0;
 
    // Retro-compat: accettiamo sia il layout v1 (sizeof ConnEvent v1 = stesso
    // di v2 perche' abbiamo sostituito _pad[2] con event_kind+_pad[1], quindi
    // e' letteralmente identico). Qui serve solo che il record sia >= quello
    // che copiamo — se un giorno estendiamo oltre, il kernel potrebbe ancora
    // scrivere record piu' piccoli: in quel caso ignoriamo gracefully.
    if (size < sizeof(ConnEvent)) return 0;
 
    auto* mon = static_cast<EBPFMon*>(ctx);
    ConnEvent ev{};
    std::memcpy(&ev, data, sizeof(ev));
 
    // Non filtrare il loopback qui: anche le connessioni locali servono per
    // attribuire correttamente il processo ai popup realtime. Le regole UI o
    // firewall possono decidere di ignorarle piu' avanti, ma il proc attribution
    // deve comunque essere catturato e messo in cache.
 
    auto conn = event_to_connection(ev);
    {
        std::lock_guard lk(mon->buf_mutex_);
        mon->buf_.push_back(std::move(conn));
 
        // Tetto di sicurezza: non accumuliamo piu' di 8192 eventi non ancora
        // consumati da drain(). Se il daemon e' lento (debug build, alto carico)
        // droppare eventi eBPF e' preferibile a OOM. Il fallback /proc/net/tcp
        // copre i gap.
        if (mon->buf_.size() > 8192)
            mon->buf_.erase(mon->buf_.begin(),
                            mon->buf_.begin() + (mon->buf_.size() - 8192));
    }
    return 0;
}
 
bool EBPFMon::start(const std::string& obj_path)
{
    auto& log = bsc::logging::Logger::instance();
 
    // ── 1. Silenzia i messaggi di libbpf verso stderr ──────────────
    libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
    // Reindirizza i log di libbpf al nostro logger
    libbpf_set_print([](enum libbpf_print_level level,
                        const char* fmt, va_list args) -> int {
        char buf[512];
        vsnprintf(buf, sizeof(buf), fmt, args);
        auto& l = bsc::logging::Logger::instance();
        if (level == LIBBPF_WARN)  l.warning(std::string("[libbpf] ") + buf);
        else if (level == LIBBPF_INFO) l.info(std::string("[libbpf] ") + buf);
        else l.debug(std::string("[libbpf] ") + buf);
        return 0;
    });
 
    // ── 2. Carica l'oggetto BPF ────────────────────────────────────
    struct bpf_object_open_opts opts{};
    opts.sz = sizeof(opts);
    struct bpf_object* obj = bpf_object__open_file(obj_path.c_str(), &opts);
    if (!obj || libbpf_get_error(obj)) {
        log.warning("EBPFMon: impossibile aprire " + obj_path +
                    " — eBPF disabilitato");
        return false;
    }
    bpf_obj_ = obj;
 
    if (bpf_object__load(obj) != 0) {
        log.warning("EBPFMon: bpf_object__load fallito — "
                    "kernel BTF disponibile? CAP_BPF presente?");
        bpf_object__close(obj);
        bpf_obj_ = nullptr;
        return false;
    }
 
    // ── 3. Attach di TUTTI i programmi dell'oggetto ────────────────
    //
    // Iteriamo su ogni bpf_program definito nel .o e facciamo attach.
    // bpf_program__attach() legge la sezione SEC() del programma e
    // usa il tipo appropriato (tracepoint, kprobe, ...).
    //
    // Se un singolo attach fallisce (esempio classico: kprobe su un
    // simbolo che non esiste nel kernel in esecuzione) non abortiamo
    // l'intera init: loggiamo e proseguiamo, cosi' la coverage resta
    // parziale invece di essere nulla.
    int attached = 0;
    int total    = 0;
    struct bpf_program* prog = nullptr;
    bpf_object__for_each_program(prog, obj) {
        ++total;
        const char* name = bpf_program__name(prog);
        const char* sect = bpf_program__section_name(prog);
 
        struct bpf_link* lnk = bpf_program__attach(prog);
        if (!lnk || libbpf_get_error(lnk)) {
            log.warning(std::string("EBPFMon: attach fallito per ")
                        + (name ? name : "?")
                        + " (sezione " + (sect ? sect : "?") + ") — "
                        + "il simbolo potrebbe non esistere su questo kernel");
            continue;
        }
        links_.push_back(lnk);
        ++attached;
        log.debug(std::string("EBPFMon: attached ")
                  + (name ? name : "?")
                  + " (" + (sect ? sect : "?") + ")");
    }
 
    if (attached == 0) {
        log.warning("EBPFMon: nessun programma attaccato — disabilito eBPF");
        bpf_object__close(obj);
        bpf_obj_ = nullptr;
        return false;
    }
 
    // ── 4. Apri la ring buffer ─────────────────────────────────────
    struct bpf_map* rb_map =
        bpf_object__find_map_by_name(obj, "bsc_events");
    if (!rb_map) {
        log.warning("EBPFMon: mappa 'bsc_events' non trovata");
        for (auto* l : links_) bpf_link__destroy(static_cast<struct bpf_link*>(l));
        links_.clear();
        bpf_object__close(obj);
        bpf_obj_ = nullptr;
        return false;
    }
 
    struct ring_buffer* rb =
        ring_buffer__new(bpf_map__fd(rb_map), ringbuf_callback, this, nullptr);
    if (!rb) {
        log.warning("EBPFMon: ring_buffer__new fallito");
        for (auto* l : links_) bpf_link__destroy(static_cast<struct bpf_link*>(l));
        links_.clear();
        bpf_object__close(obj);
        bpf_obj_ = nullptr;
        return false;
    }
    ring_buf_ = rb;
 
    // ── 5. Avvia il thread di polling ─────────────────────────────
    stop_.store(false);
    active_.store(true);
    thread_ = std::thread(&EBPFMon::drain_loop, this);
 
    log.info("EBPFMon: attivo — " + std::to_string(attached) + "/" +
             std::to_string(total) + " probe agganciati "
             "(tracepoint + kprobes TCP/UDP)");
    return true;
}
 
void EBPFMon::stop()
{
    if (!active_.load()) return;
    stop_.store(true);
    if (thread_.joinable()) thread_.join();
    active_.store(false);
 
    if (ring_buf_) {
        ring_buffer__free(static_cast<struct ring_buffer*>(ring_buf_));
        ring_buf_ = nullptr;
    }
    for (auto* l : links_) {
        if (l) bpf_link__destroy(static_cast<struct bpf_link*>(l));
    }
    links_.clear();
    if (bpf_obj_) {
        bpf_object__close(static_cast<struct bpf_object*>(bpf_obj_));
        bpf_obj_ = nullptr;
    }
    bsc::logging::Logger::instance().info("EBPFMon: fermato");
}
 
void EBPFMon::drain_loop()
{
    // ring_buffer__poll: blocca al massimo timeout_ms millisecondi,
    // poi richiama il callback per ogni record disponibile.
    // Con timeout 20ms abbiamo latenza ≤20ms tra evento kernel e
    // arrivo in drain(). NFQUEUE e' gia' piu' veloce per i pacchetti
    // intercettati; eBPF serve per i flow che NFQUEUE non vede
    // (gia' stabiliti al boot, UDP senza SYN, ecc.)
    auto* rb = static_cast<struct ring_buffer*>(ring_buf_);
    while (!stop_.load()) {
        ring_buffer__poll(rb, 20 /* ms */);
    }
}
 
std::vector<bsc::model::Connection> EBPFMon::drain()
{
    std::vector<bsc::model::Connection> out;
    {
        std::lock_guard lk(buf_mutex_);
        out.swap(buf_);  // O(1), nessuna copia
    }
    return out;
}
 
#else  // BSC_HAS_EBPF non definito → stub no-op
 
bool EBPFMon::start(const std::string&)
{
    bsc::logging::Logger::instance().info(
        "EBPFMon: compilato senza libbpf — eBPF non disponibile");
    return false;
}
 
void EBPFMon::stop() {}
 
std::vector<bsc::model::Connection> EBPFMon::drain() { return {}; }
 
void EBPFMon::drain_loop() {}
 
#endif  // BSC_HAS_EBPF
 
} // namespace bsc::ebpf