feat(xdp): auto-ban from ringbuf events; fix feature gating, exit path, pow flake

- xdp: real 24-byte xdp_event parsing (fixes LE byte-swap of src IP),
  opt-in [xdp] auto_ban (RATE_LIMIT always, CONN_DROP at fails>=threshold;
  EVENT_BAN/POLICY_DROP excluded by design), rampart_xdp_autobans_total;
  wired in app before load(); 10 tests in tests/xdp_events.rs
- build: --no-default-features compiles — redis paths cfg-gated behind
  store-redis, manager fail-fasts without it; CI gates the config now
- app: RunExit enum replaces process::exit in lib; single exit site in main
- tests: seed PoW roundtrip token (was ~1/16 flaky; 50 pre-fix fails -> 0)
- docs: TODO statuses refreshed (round 2)
This commit is contained in:
Loki 2026-09-16 00:49:41 +02:00
parent bf6d34c882
commit f85ea6c380
Signed by: boba
GPG key ID: 6CDE87BC9A778D97
23 changed files with 714 additions and 50 deletions

View file

@ -1,8 +1,15 @@
use anyhow::{Context, Result};
use libbpf_rs::{MapCore, Object, OpenObject, RingBuffer, RingBufferBuilder};
use std::ffi::CString;
use std::net::IpAddr;
use std::sync::Arc;
use std::time::Duration;
use crate::filter::blacklist::Blacklist;
use crate::xdp::globals::{RODATA_MAP_NAME, XdpGlobals};
use crate::xdp::metrics::XDP_AUTOBANS_TOTAL;
use super::events::{AutoBanConfig, auto_ban_decision, parse_xdp_event};
/// Builds the NUL-terminated C string libc's `if_nametoindex` requires.
/// Rejects interface names containing an interior NUL byte instead of
@ -22,18 +29,59 @@ pub(super) fn patch_rodata(open_obj: &mut OpenObject, globals: &XdpGlobals) -> R
.with_context(|| format!("failed to set initial value of '{RODATA_MAP_NAME}'"))
}
pub(super) fn build_ringbuf(obj: &Object) -> Result<RingBuffer<'static>> {
/// Собирает ringbuf-колбэк для `events_map`.
///
/// Колбэк обязан быть `'static`, поэтому всё разделяемое состояние (`Arc<Blacklist>`,
/// копия `AutoBanConfig`) захватывается `move`-клонами. Когда `blacklist` — `None`
/// (фича не подключена) или политика выключена, события только парсятся и
/// логируются структурированно; баны не пишутся. В горячем пути нет `format!` —
/// `tracing`-поля и `&'static str` причины.
pub(super) fn build_ringbuf(
obj: &Object,
blacklist: Option<Arc<Blacklist>>,
cfg: AutoBanConfig,
) -> Result<RingBuffer<'static>> {
let map = obj
.maps()
.find(|m| m.name() == "events_map")
.context("events_map not found")?;
let mut builder = RingBufferBuilder::new();
builder.add(&map, |data: &[u8]| {
if data.len() >= 16 {
let ty = u32::from_ne_bytes(data[0..4].try_into().expect("4 bytes for type"));
let ip4 = u32::from_ne_bytes(data[4..8].try_into().expect("4 bytes for ip"));
let val = u64::from_ne_bytes(data[8..16].try_into().expect("8 bytes for val"));
tracing::debug!(event = ty, src_ip = ip4, data = val, "xdp event");
builder.add(&map, move |data: &[u8]| {
let Some(event) = parse_xdp_event(data) else {
tracing::debug!(
len = data.len(),
"xdp ringbuf frame ignored (too short or unknown type)"
);
return 0;
};
tracing::debug!(
kind = ?event.kind,
src_ip = %event.src_ip,
metadata = event.metadata,
"xdp event"
);
let Some(blacklist) = &blacklist else {
return 0;
};
if let Some(ban) = auto_ban_decision(&event, &cfg) {
let addr = IpAddr::V4(ban.ip);
// `Blacklist::add` возвращает `()` (DashMap::insert игнорируется), а
// править blacklist.rs вне нашей зоны нельзя — поэтому «новый ли бан»
// определяем через публичный `is_blocked` ДО перезаписи. Это дедуп
// лога/метрики по активному бану, а не по факту вставки.
let already_banned = blacklist.is_blocked(addr);
blacklist.add(addr, Duration::from_secs(ban.duration_secs), ban.reason);
if already_banned {
tracing::debug!(src_ip = %ban.ip, reason = ban.reason, "xdp auto-ban refreshed");
} else {
XDP_AUTOBANS_TOTAL.inc();
tracing::info!(
src_ip = %ban.ip,
reason = ban.reason,
duration_secs = ban.duration_secs,
"xdp auto-ban issued"
);
}
}
0
})?;

166
src/xdp/filter/events.rs Normal file
View file

@ -0,0 +1,166 @@
//! Разбор и политика для событий XDP-ringbuf (`struct xdp_event`).
//!
//! Чистые (без I/O, без libbpf) функции, чтобы их можно было покрыть
//! юнит-тестами без ядра/Redis. Wiring колбэка — в [`super::attach`].
use std::net::Ipv4Addr;
use crate::config::XdpConfig;
/// Точный размер `struct xdp_event` (см. `xdp/core/common.h:61-66`):
/// `__u32 type` @0, `__u32 src_ip` @4, `__u32 metadata` @8,
/// 4 байта padding @12 (выравнивание `__u64`), `__u64 timestamp` @16 → 24.
pub const XDP_EVENT_LEN: usize = 24;
/// Тип события из `enum event_type` (`common.h:54-59`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum XdpEventKind {
/// `EVENT_BAN` — пакет уже был в blacklist_map и сброшен ядром.
Ban,
/// `EVENT_RATE_LIMIT` — превышен порог троттлинга (SYN/UDP).
RateLimit,
/// `EVENT_POLICY_DROP` — статичная политика (UDP drop / вредоносные TCP-флаги).
PolicyDrop,
/// `EVENT_CONN_DROP` — flow сброшен (несоответствие seq или verdict хука).
ConnDrop,
}
impl XdpEventKind {
/// Декодирует числовое значение из C-enum. Неизвестный тип → `None` + debug.
fn from_u32(raw: u32) -> Option<Self> {
match raw {
0 => Some(Self::Ban),
1 => Some(Self::RateLimit),
2 => Some(Self::PolicyDrop),
3 => Some(Self::ConnDrop),
other => {
tracing::debug!(event_type = other, "xdp event: unknown type, dropped");
None
},
}
}
}
/// Разобранное событие ringbuf.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct XdpEvent {
pub kind: XdpEventKind,
/// IPv4 источника (для IPv4-mapped IPv6 ядро кладёт в `src_ip` младший u32).
pub src_ip: Ipv4Addr,
/// Поле `__u32 metadata`: для `RateLimit` — порог срабатывания троттлинга,
/// для `ConnDrop` — счётчик `conn->fails`, иначе `0`.
pub metadata: u32,
/// `bpf_ktime_get_ns()` на момент генерации (monotonic, не wall-clock).
pub timestamp_ns: u64,
}
/// Разбирает 24-байтовый кадр `struct xdp_event`.
///
/// # Byte order (проверено по C-источнику)
/// Скалярные поля (`type`, `metadata`, `timestamp`) пишутся ядром в ПОРЯДКЕ ХОСТА
/// без конверсии: `push_event` присваивает их как есть — `e->type = type`,
/// `e->metadata = meta`, `e->timestamp = bpf_ktime_get_ns()`
/// (`common.h:92-95`, `bpf_htonl`/`bpf_ntohl` к ним НЕ применяется). Userspace
/// читает те же байты на той же машине → `from_ne_bytes` корректно.
///
/// А вот `src_ip` — сетевой порядок (big-endian octets): он приходит прямо из
/// заголовка пакета `src_ip = ip->saddr` (`universal_filter.c:149`) и пишется в
/// событие без `bpf_htonl` (`common.h:93`). Значит байты `data[4..8]` — это октеты
/// адреса в точковом порядке, и читать их надо как `Ipv4Addr::new(octets...)`, а НЕ
/// как `from_ne_bytes(u32)` (прежний баг: на LE-хосте давал перевернутый IP).
///
/// Возвращает `None`, если кадр короче `XDP_EVENT_LEN` или тип неизвестен.
pub fn parse_xdp_event(bytes: &[u8]) -> Option<XdpEvent> {
let raw: &[u8; XDP_EVENT_LEN] = bytes.get(..XDP_EVENT_LEN)?.try_into().ok()?;
let kind = XdpEventKind::from_u32(u32::from_ne_bytes(raw[0..4].try_into().ok()?))?;
let src_ip = Ipv4Addr::new(raw[4], raw[5], raw[6], raw[7]);
let metadata = u32::from_ne_bytes(raw[8..12].try_into().ok()?);
// raw[12..16] — выравнивающий padding под __u64, не читаем (он не инициализирован).
let timestamp_ns = u64::from_ne_bytes(raw[16..24].try_into().ok()?);
Some(XdpEvent {
kind,
src_ip,
metadata,
timestamp_ns,
})
}
/// Параметры авто-бана, резолвинг из секции `[xdp]`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AutoBanConfig {
pub enabled: bool,
pub duration_secs: u64,
pub conn_drop_fails: u8,
}
impl Default for AutoBanConfig {
fn default() -> Self {
Self {
enabled: false,
duration_secs: 60,
conn_drop_fails: 3,
}
}
}
impl AutoBanConfig {
/// Берёт значения из `[xdp]`-секции конфига (единственный источник истины).
pub fn from_xdp(cfg: &XdpConfig) -> Self {
Self {
enabled: cfg.auto_ban_enabled,
duration_secs: cfg.auto_ban_duration_secs,
conn_drop_fails: cfg.auto_ban_conn_drop_fails,
}
}
}
/// Готовый бан для применения к userspace-`Blacklist`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct BanAction {
pub ip: Ipv4Addr,
pub duration_secs: u64,
/// Статичная причина (без аллокаций в горячем пути).
pub reason: &'static str,
}
/// Чистое решение: банить ли источник события и на сколько.
///
/// Возвращает `None`, если фича выключена или тип события не банится.
/// Разбор по типам обоснован C-кодом:
///
/// * [`XdpEventKind::Ban`] — НЕ баним. Событие эмитится уже ПОСЛЕ того, как
/// ядро нашло IP в `blacklist_map` и дропнуло пакет (`universal_filter.c:220-225`);
/// повторный userspace-бан бессмысленен и мог бы скрыть штатный expiry.
/// * [`XdpEventKind::PolicyDrop`] — НЕ баним по умолчанию. Это статичная
/// политика на каждый пакет: UDP-drop-политика (`:234`) и вредоносные TCP-флаги
/// (`:259`). Бан по одному malformed-пакету перебанит легитимных, но глючных
/// клиентов — порог аккумулирования здесь отсутствует по смыслу.
/// * [`XdpEventKind::RateLimit`] — банیم. Порог троттлинга уже фактически превышен;
/// при этом UDP-путь (`:237-243`) только дропает и НЕ заносит в blacklist (в
/// отличие от SYN-пути `:295`) — userspace-бан добавляет реальную защиту.
/// * [`XdpEventKind::ConnDrop`] — баним, только если `metadata` (=`conn->fails`)
/// достиг порога (`:364-368`). Дроп по протокольному хуку приходит с `fails = 0`
/// (`:418`) и ниже порога, т.е. не банится.
#[must_use]
pub fn auto_ban_decision(event: &XdpEvent, config: &AutoBanConfig) -> Option<BanAction> {
if !config.enabled {
return None;
}
match event.kind {
XdpEventKind::Ban | XdpEventKind::PolicyDrop => None,
XdpEventKind::RateLimit => Some(BanAction {
ip: event.src_ip,
duration_secs: config.duration_secs,
reason: "xdp-rate-limit",
}),
XdpEventKind::ConnDrop if event.metadata >= u32::from(config.conn_drop_fails) => Some(BanAction {
ip: event.src_ip,
duration_secs: config.duration_secs,
reason: "xdp-conn-drop",
}),
XdpEventKind::ConnDrop => None,
}
}
// Покрытие парсера и политики — в `tests/xdp_events.rs` (держим модуль под
// лимитом 250 строк; `src/xdp/filter/` уже на пределе в 4 файла на каталог).

View file

@ -3,15 +3,20 @@ use libbpf_rs::{MapCore, MapFlags, Object, ObjectBuilder, RingBuffer, Xdp, XdpFl
use std::net::IpAddr;
use std::net::Ipv4Addr;
use std::os::unix::io::AsFd;
use std::sync::Arc;
use super::XdpStats;
use super::globals::XdpGlobals;
use crate::config::XdpConfig;
use crate::filter::blacklist::Blacklist;
use crate::traffic::prefix::{PrefixKey, PrefixStatsVal};
use attach::{build_ringbuf, interface_cstr, patch_rodata};
use events::AutoBanConfig;
use maps::{blacklist_expiry_ns, blacklist_key, unix_ns};
mod attach;
pub(crate) mod events;
mod maps;
pub struct XdpFilter {
@ -20,6 +25,8 @@ pub struct XdpFilter {
ifindex: i32,
interface: String,
globals: XdpGlobals,
blacklist: Option<Arc<Blacklist>>,
autoban: AutoBanConfig,
}
impl XdpFilter {
@ -30,6 +37,8 @@ impl XdpFilter {
ifindex: 0,
interface: interface.to_string(),
globals: XdpGlobals::default(),
blacklist: None,
autoban: AutoBanConfig::default(),
}
}
@ -38,6 +47,16 @@ impl XdpFilter {
self.globals = globals;
}
/// Подключает OPT-IN авто-бан по ringbuf-событиям к userspace-`Blacklist`.
///
/// До вызова `load()`. Политика читается из `[xdp]`-секции; если
/// `auto_ban_enabled = false` (по умолчанию), колбэк лишь логирует события и
/// не трогает blacklist.
pub fn set_autoban(&mut self, blacklist: Arc<Blacklist>, config: &XdpConfig) {
self.blacklist = Some(blacklist);
self.autoban = AutoBanConfig::from_xdp(config);
}
pub fn load(&mut self) -> Result<()> {
// Диагностика ДО загрузки: fail-fast на неподдерживаемом ядре/драйвере.
super::probe::preflight(&self.interface)?;
@ -66,7 +85,8 @@ impl XdpFilter {
.context("XDP program 'rampart_universal_filter' not found")?;
Xdp::new(prog.as_fd()).attach(ifindex as i32, XdpFlags::NONE)?;
let rbuf = build_ringbuf(&obj)?;
super::metrics::init();
let rbuf = build_ringbuf(&obj, self.blacklist.clone(), self.autoban)?;
self.obj = Some(obj);
self.ringbuf = Some(rbuf);