From cacd01c65798dd85fad482b6dbbd215c853e09dd Mon Sep 17 00:00:00 2001 From: loki5512344 Date: Sun, 15 Nov 2026 22:51:52 +0100 Subject: [PATCH 1/2] docs(todo): record XDP IPv6-parity plan (C + Rust + tests + non-goals) --- TODO.md | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/TODO.md b/TODO.md index eb5b1a7..dcb3fa9 100644 --- a/TODO.md +++ b/TODO.md @@ -165,7 +165,23 @@ guard/ `RunExit`, единственный `process::exit` теперь в `main` бина (clippy там не срабатывает). - [x] Флакающий тест `pow_roundtrip::verifier_rejects_garbage_and_replay` (p≈1/16 из-за случайного токена) — сидирован, 50 прогонов до (3 fail) / после (0 fail). -- [ ] IPv6-банов в XDP-putи нет (`ban_cidr` bail'ит на v6) — IPv6-паритет (вывод №8). +- [ ] IPv6-паритет XDP (вывод №8) — план: + - [ ] **C**: `struct lpm_key6 { u32 prefixlen; u8 addr[16]; }` в `common.h`; + `blacklist6_map` (LPM_TRIE, 20-байтный ключ, value `u64` expiry, 100000, NO_PREALLOC) в `maps.h`; + в `universal_filter.c` non-mapped IPv6 не возвращает PASS раньше времени: общий L4-парсинг + + порт-гейт, затем блок `if (native_v6)`: `is_blacklisted6` (lookup `prefixlen=128`, + expiry-cleanup как у v4) → DROP; UDP при `G_UDP_POLICY==1` → DROP; `detect_tcp_bypass` → DROP; + TCP → `prefix_key_from_v6` + `update_prefix_stats` (оживляет мёртвый код, замыкает + детектор подсетей на v6); иначе PASS. Ringbuf-события для v6 не шлём (ABI `src_ip` u32). + - [ ] **Rust**: `pub fn blacklist6_key(prefix_len: u8, &[u8;16]) -> [u8;20]` (prefixlen LE в 0..4, + addr network order в 4..20); `blacklist6_update`; `ban_cidr` матчит V4/V6; + `gateway.rs::xdp_ban` → `ban_cidr(ip, 32|128, dur)` для обоих семейств; `ban_ip` удаляется + (после перевода gateway вызовов нет — «мёртвый код = баг»), `noop.rs` синхронизировать. + - [ ] **Тесты**: `tests/xdp_ban_v6.rs` (layout ключа `/64` и `/128`, network order); C — clang-сборка + через `build.rs` + smoke в netns при CAP_BPF. + - Non-goals (позже): conntrack/throttle/UDP rate-limit (`policy==2`)/RST-challenge для нативного v6 + (нужны 128-битные flow/throttle-ключи); whitelist6 (у `whitelist_map` нет писателя даже для v4); + ringbuf-события для v6; unban v6. ## 3. Backlog From 59d5a088b2c8dcba4a7ebaf72463112caa4b8f59 Mon Sep 17 00:00:00 2001 From: loki5512344 Date: Sun, 15 Nov 2026 23:02:12 +0100 Subject: [PATCH 2/2] =?UTF-8?q?feat(xdp):=20IPv6=20parity=20=E2=80=94=20bl?= =?UTF-8?q?acklist6=5Fmap,=20v6=20bans,=20v6=20prefix=20stats?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - C: lpm_key6 + blacklist6_map (LPM_TRIE, 20-byte key); native IPv6 no longer returns XDP_PASS before filtering: same L4/port gates, then blacklist6, UDP drop-policy, TCP flag checks and /64 prefix stats. - Rust: blacklist6_key/blacklist6_update; ban_cidr handles V4 and V6; gateway xdp_ban uses ban_cidr (/32 or /128); dead ban_ip removed. - tests/xdp_ban_v6.rs (key layout) and scripts/xdp_ipv6_smoke.sh (real kernel: pass -> ban drops -> unban passes). - TODO: record done items and two findings (userspace ban expiry clock mismatch; short-L4 bypass of blacklist). --- TODO.md | 27 ++++--- scripts/xdp_ipv6_smoke.sh | 138 +++++++++++++++++++++++++++++++++++ src/engine/tunnel/gateway.rs | 14 ++-- src/xdp/filter/maps.rs | 38 +++++++--- src/xdp/filter/mod.rs | 2 + src/xdp/mod.rs | 2 + src/xdp/noop.rs | 3 - tests/xdp_ban_v6.rs | 38 ++++++++++ xdp/core/common.h | 6 ++ xdp/core/maps.h | 10 +++ xdp/core/universal_filter.c | 67 +++++++++++++++-- 11 files changed, 309 insertions(+), 36 deletions(-) create mode 100755 scripts/xdp_ipv6_smoke.sh create mode 100644 tests/xdp_ban_v6.rs diff --git a/TODO.md b/TODO.md index dcb3fa9..a79c55a 100644 --- a/TODO.md +++ b/TODO.md @@ -165,23 +165,32 @@ guard/ `RunExit`, единственный `process::exit` теперь в `main` бина (clippy там не срабатывает). - [x] Флакающий тест `pow_roundtrip::verifier_rejects_garbage_and_replay` (p≈1/16 из-за случайного токена) — сидирован, 50 прогонов до (3 fail) / после (0 fail). -- [ ] IPv6-паритет XDP (вывод №8) — план: - - [ ] **C**: `struct lpm_key6 { u32 prefixlen; u8 addr[16]; }` в `common.h`; +- [x] IPv6-паритет XDP (вывод №8) — сделано (2026-11-15): + - [x] **C**: `struct lpm_key6 { u32 prefixlen; u8 addr[16]; }` в `common.h`; `blacklist6_map` (LPM_TRIE, 20-байтный ключ, value `u64` expiry, 100000, NO_PREALLOC) в `maps.h`; - в `universal_filter.c` non-mapped IPv6 не возвращает PASS раньше времени: общий L4-парсинг + + в `universal_filter.c` non-mapped IPv6 больше не возвращает PASS раньше времени: общий L4-парсинг + порт-гейт, затем блок `if (native_v6)`: `is_blacklisted6` (lookup `prefixlen=128`, expiry-cleanup как у v4) → DROP; UDP при `G_UDP_POLICY==1` → DROP; `detect_tcp_bypass` → DROP; - TCP → `prefix_key_from_v6` + `update_prefix_stats` (оживляет мёртвый код, замыкает + TCP → `prefix_key_from_v6` + `update_prefix_stats` (оживило мёртвый код, замкнуло детектор подсетей на v6); иначе PASS. Ringbuf-события для v6 не шлём (ABI `src_ip` u32). - - [ ] **Rust**: `pub fn blacklist6_key(prefix_len: u8, &[u8;16]) -> [u8;20]` (prefixlen LE в 0..4, + - [x] **Rust**: `pub fn blacklist6_key(prefix_len: u8, &[u8;16]) -> [u8;20]` (prefixlen LE в 0..4, addr network order в 4..20); `blacklist6_update`; `ban_cidr` матчит V4/V6; - `gateway.rs::xdp_ban` → `ban_cidr(ip, 32|128, dur)` для обоих семейств; `ban_ip` удаляется - (после перевода gateway вызовов нет — «мёртвый код = баг»), `noop.rs` синхронизировать. - - [ ] **Тесты**: `tests/xdp_ban_v6.rs` (layout ключа `/64` и `/128`, network order); C — clang-сборка - через `build.rs` + smoke в netns при CAP_BPF. + `gateway.rs::xdp_ban` → `ban_cidr(ip, 32|128, dur)` для обоих семейств; `ban_ip` удалён + (после перевода gateway вызовов не осталось — «мёртвый код = баг»), `noop.rs` синхронизирован. + - [x] **Тесты**: `tests/xdp_ban_v6.rs` (layout ключа `/64` и `/128`, network order); + `scripts/xdp_ipv6_smoke.sh` — реальный netns+verifier smoke (без бана pass → с баном + blacklist+drop → после снятия снова pass), проверен на ядре 7.3.4. - Non-goals (позже): conntrack/throttle/UDP rate-limit (`policy==2`)/RST-challenge для нативного v6 (нужны 128-битные flow/throttle-ключи); whitelist6 (у `whitelist_map` нет писателя даже для v4); ringbuf-события для v6; unban v6. +- [ ] **Баг: expiry бана из userspace не работает в ядре** (найден 2026-11-15, касается и v4, и v6): + `blacklist_expiry_ns` пишет `SystemTime` (epoch ns ≈ 1.7e18), а C сравнивает с + `bpf_ktime_get_ns()` (monotonic ≈ uptime). Любой бан из gateway/детектора подсетей живёт + до перезагрузки. Чинить переходом userspace на `CLOCK_MONOTONIC` (libc уже в dep'ах под feature xdp). +- [ ] **Баг: короткий L4-хвост обходит blacklist** (найден 2026-11-15, v4 и v6): + `universal_filter.c` требует `l4 + sizeof(struct tcphdr) (20 байт) <= data_end` для ВСЕХ + протоколов, иначе ранний `XDP_PASS`. UDP-датаграмма короче 20 байт не доходит ни до порт-гейта, + ни до blacklist. Чинить: минимум считать по протоколу (`sizeof(struct udphdr)` для UDP). ## 3. Backlog diff --git a/scripts/xdp_ipv6_smoke.sh b/scripts/xdp_ipv6_smoke.sh new file mode 100755 index 0000000..47e71f2 --- /dev/null +++ b/scripts/xdp_ipv6_smoke.sh @@ -0,0 +1,138 @@ +#!/usr/bin/env bash +# Функциональный smoke IPv6-бана в XDP (blacklist6_map) на РЕАЛЬНОМ ядре. +# +# Что проверяет: +# 1. verifier принимает universal_filter.o после v6-изменений; +# 2. native-IPv6 пакет без бана проходит (счётчики pass/udp растут); +# 3. запись /128 в blacklist6_map реально дропает пакет (blacklist+drop); +# 4. после удаления записи трафик снова проходит. +# +# Требует root/CAP_BPF+CAP_NET_ADMIN (создаёт netns и veth), bpftool, clang, python3. +# Запуск: sudo bash scripts/xdp_ipv6_smoke.sh +# +# Замечание: программа требует ≥20 байт L4 (граница struct tcphdr для обоих +# протоколов), поэтому датаграмма должна быть не меньше 20 байт, иначе пакет +# уходит в XDP_PASS до проверки blacklist — это существующее поведение. + +set -u + +NS=rampart_v6_smoke +DEV0=rth6 +DEV1=rtap6 +HOST6=fd00::1 +NS6=fd00::2 +PORT=4444 +OBJ=$(mktemp /tmp/rampart_v6_smoke.XXXXXX.o) +PIN=/sys/fs/bpf/rampart_v6_smoke +LOG=$(mktemp /tmp/rampart_v6_smoke.XXXXXX.log) +LPID="" +PASS=1 + +fail() { echo "FAIL: $1"; PASS=0; } +ok() { echo "ok: $1"; } + +cleanup() { + [ -n "$LPID" ] && kill -9 "$LPID" 2>/dev/null + bpftool net detach xdp dev "$DEV0" 2>/dev/null + rm -f "$PIN" "$OBJ" "$LOG" + ip link del "$DEV0" 2>/dev/null + ip netns del "$NS" 2>/dev/null +} +trap cleanup EXIT + +[ "$(id -u)" = 0 ] || { echo "нужен root (CAP_BPF+CAP_NET_ADMIN)"; exit 2; } +cd "$(dirname "$0")/.." || exit 2 + +clang -O2 -g -target bpf -mcpu=v3 -c xdp/core/universal_filter.c -o "$OBJ" \ + -Ixdp -Ixdp/core -Ixdp/hooks -I/usr/include/x86_64-linux-gnu \ + || { echo "clang: не собралось"; exit 1; } +ok "clang: universal_filter.c собран" + +ip netns add "$NS" || { echo "не удалось создать netns"; exit 2; } +ip link add "$DEV0" type veth peer name "$DEV1" || exit 2 +ip link set "$DEV1" netns "$NS" +ip -6 addr add "$HOST6/64" dev "$DEV0" +ip link set "$DEV0" up +ip -n "$NS" -6 addr add "$NS6/64" dev "$DEV1" +ip -n "$NS" link set "$DEV1" up +ip -n "$NS" link set lo up +ok "netns $NS + veth ($HOST6 <-> $NS6)" + +bpftool prog load "$OBJ" "$PIN" type xdp || { echo "verifier отверг программу"; exit 1; } +bpftool net attach xdp pinned "$PIN" dev "$DEV0" || exit 1 +ok "verifier принял программу, attach на $DEV0" + +IDS=$(bpftool prog show pinned "$PIN" | grep -o 'map_ids [0-9,]*' | cut -d' ' -f2 | tr ',' ' ') +B6="" +ST="" +for id in $IDS; do + if bpftool map show id "$id" 2>/dev/null | grep -q blacklist6_map; then B6=$id; fi + if bpftool map show id "$id" 2>/dev/null | grep -q 'name stats_map'; then ST=$id; fi +done +[ -n "$B6" ] || { echo "blacklist6_map не найдена"; exit 1; } +[ -n "$ST" ] || { echo "stats_map не найдена"; exit 1; } +ok "blacklist6_map id=$B6, stats_map id=$ST" + +# Ключ: prefixlen=128 (u32 LE) + fd00::2 в network order. +KEY="80 00 00 00 fd 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02" + +send() { + ip netns exec "$NS" python3 -c " +import socket +s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) +s.sendto(b'x' * 100, ('$HOST6', $PORT)) +" +} + +# Суммы per-CPU счётчиков: печатает только ненулевые. +stats() { + bpftool -j map dump id "$ST" | python3 -c " +import json, sys +names = {0: 'total', 1: 'tcp', 2: 'whitelist', 3: 'blacklist', 4: 'syn_thr', + 5: 'pass', 6: 'drop', 7: 'udp', 8: 'rate', 9: 'chal_sent'} +out = {} +for e in json.load(sys.stdin): + k = names.get(e['formatted']['key']) + if k is not None: + out[k] = sum(v['value'] for v in e['formatted']['values']) +print(' '.join(f'{k}={v}' for k, v in out.items() if v) or 'все нули') +" +} + +for _ in 1 2 3; do send; done +sleep 0.5 +out=$(stats) +case "$out" in + *pass=[1-9]*) ok "без бана проходит: $out" ;; + *) fail "без бана не проходит: $out" ;; +esac + +bpftool map update id "$B6" key hex $KEY value hex ff ff ff ff ff ff ff ff \ + || fail "map update" +ok "бан $NS6/128 вставлен" + +for _ in 1 2 3; do send; done +sleep 0.5 +out=$(stats) +case "$out" in + *blacklist=[1-9]*drop=[1-9]*) ok "с баном дропается: $out" ;; + *) fail "бан не дропает: $out" ;; +esac + +bpftool map delete id "$B6" key hex $KEY || fail "map delete" +ok "бан снят" + +# Счётчики кумулятивные: после снятия бана drop не должен расти, а pass — должен. +metric() { stats | tr ' ' '\n' | sed -n "s/^$1=//p" | head -1; } +drop0=$(metric drop); pass0=$(metric pass) +for _ in 1 2 3; do send; done +sleep 0.5 +drop1=$(metric drop); pass1=$(metric pass) +if [ "${drop1:-0}" -eq "${drop0:-0}" ] && [ "${pass1:-0}" -gt "${pass0:-0}" ]; then + ok "после снятия бана снова проходит (pass $pass0 -> $pass1, drop $drop0 -> $drop1)" +else + fail "после снятия бана трафик не восстановился (pass $pass0 -> $pass1, drop $drop0 -> $drop1)" +fi + +[ "$PASS" = 1 ] && echo "PASS: IPv6-бан работает на живом ядре" || echo "FAIL" +[ "$PASS" = 1 ] diff --git a/src/engine/tunnel/gateway.rs b/src/engine/tunnel/gateway.rs index 396956b..6f45085 100644 --- a/src/engine/tunnel/gateway.rs +++ b/src/engine/tunnel/gateway.rs @@ -202,12 +202,14 @@ impl Gateway { let Some(xdp) = &self.xdp else { return; }; - let IpAddr::V4(ip_v4) = ip else { - return; - }; - match xdp.lock().expect("xdp lock poisoned").ban_ip(ip_v4, duration_secs) { - Ok(()) => tracing::debug!("xdp ban {ip_v4} for {duration_secs}s"), - Err(e) => tracing::warn!("xdp ban failed for {ip_v4}: {e}"), + let prefix_len = if ip.is_ipv4() { 32 } else { 128 }; + match xdp + .lock() + .expect("xdp lock poisoned") + .ban_cidr(ip, prefix_len, duration_secs) + { + Ok(()) => tracing::debug!("xdp ban {ip} for {duration_secs}s"), + Err(e) => tracing::warn!("xdp ban failed for {ip}: {e}"), } } diff --git a/src/xdp/filter/maps.rs b/src/xdp/filter/maps.rs index eb59cc1..23da663 100644 --- a/src/xdp/filter/maps.rs +++ b/src/xdp/filter/maps.rs @@ -1,5 +1,5 @@ use super::XdpFilter; -use anyhow::{Result, bail}; +use anyhow::Result; use libbpf_rs::{MapCore, MapFlags}; use std::net::{IpAddr, Ipv4Addr}; @@ -19,6 +19,16 @@ pub(super) fn blacklist_key(prefix_len: u8, v4: &[u8; 4]) -> [u8; 8] { key } +/// Encodes an LPM-trie key for `blacklist6_map`: prefix length as a +/// little-endian u32 in bytes 0..4 and the 16-byte IPv6 address in network +/// order in bytes 4..20 (20 bytes total, matching the C `struct lpm_key6`). +pub fn blacklist6_key(prefix_len: u8, v6: &[u8; 16]) -> [u8; 20] { + let mut key = [0u8; 20]; + key[0] = prefix_len; + key[4..20].copy_from_slice(v6); + key +} + /// Absolute ban expiry in ns-since-epoch, saturating so an absurd duration /// clamps to `u64::MAX` rather than wrapping into the past. pub(super) fn blacklist_expiry_ns(now_ns: u64, duration_secs: u64) -> u64 { @@ -26,16 +36,16 @@ pub(super) fn blacklist_expiry_ns(now_ns: u64, duration_secs: u64) -> u64 { } impl XdpFilter { - pub fn ban_ip(&self, ip: Ipv4Addr, duration_secs: u64) -> Result<()> { - self.blacklist_update(32, &ip.octets(), duration_secs) - } - - /// Adds a CIDR ban to the LPM trie. IPv6 enforcement is not supported yet. + /// Adds a CIDR ban to the matching LPM trie: `blacklist_map` for IPv4, + /// `blacklist6_map` for IPv6. + /// + /// # Errors + /// XDP not loaded, map missing from the object, or a BPF update failure. pub fn ban_cidr(&self, prefix: IpAddr, prefix_len: u8, duration_secs: u64) -> Result<()> { - let IpAddr::V4(net) = prefix else { - bail!("ipv6 cidr bans not supported yet"); - }; - self.blacklist_update(prefix_len, &net.octets(), duration_secs) + match prefix { + IpAddr::V4(net) => self.blacklist_update(prefix_len, &net.octets(), duration_secs), + IpAddr::V6(net) => self.blacklist6_update(prefix_len, &net.octets(), duration_secs), + } } fn blacklist_update(&self, prefix_len: u8, v4: &[u8; 4], duration_secs: u64) -> Result<()> { @@ -46,6 +56,14 @@ impl XdpFilter { Ok(()) } + fn blacklist6_update(&self, prefix_len: u8, v6: &[u8; 16], duration_secs: u64) -> Result<()> { + let map = self.find_map("blacklist6_map")?; + let key = blacklist6_key(prefix_len, v6); + let expiry_ns = blacklist_expiry_ns(unix_ns(), duration_secs); + map.update(&key, &expiry_ns.to_le_bytes(), MapFlags::ANY)?; + Ok(()) + } + pub fn unban_ip(&self, ip: Ipv4Addr) -> Result<()> { let map = self.find_map("blacklist_map")?; let key = blacklist_key(32, &ip.octets()); diff --git a/src/xdp/filter/mod.rs b/src/xdp/filter/mod.rs index 736956a..c58d47e 100644 --- a/src/xdp/filter/mod.rs +++ b/src/xdp/filter/mod.rs @@ -16,6 +16,8 @@ mod attach; pub(crate) mod events; mod maps; +pub use maps::blacklist6_key; + pub struct XdpFilter { obj: Option, ringbuf: Option>, diff --git a/src/xdp/mod.rs b/src/xdp/mod.rs index 578ad3a..ce84086 100644 --- a/src/xdp/mod.rs +++ b/src/xdp/mod.rs @@ -19,6 +19,8 @@ mod filter; #[cfg(feature = "xdp")] pub use filter::XdpFilter; #[cfg(feature = "xdp")] +pub use filter::blacklist6_key; +#[cfg(feature = "xdp")] pub use filter::events::{ AutoBanConfig, BanAction, XDP_EVENT_LEN, XdpEvent, XdpEventKind, auto_ban_decision, parse_xdp_event, }; diff --git a/src/xdp/noop.rs b/src/xdp/noop.rs index 252e55d..74ca104 100644 --- a/src/xdp/noop.rs +++ b/src/xdp/noop.rs @@ -16,9 +16,6 @@ impl XdpFilter { Ok(()) } pub fn drain_events(&self) {} - pub fn ban_ip(&self, _ip: Ipv4Addr, _duration_secs: u64) -> Result<()> { - Ok(()) - } pub fn ban_cidr(&self, _prefix: IpAddr, _prefix_len: u8, _duration_secs: u64) -> Result<()> { Ok(()) } diff --git a/tests/xdp_ban_v6.rs b/tests/xdp_ban_v6.rs new file mode 100644 index 0000000..d136175 --- /dev/null +++ b/tests/xdp_ban_v6.rs @@ -0,0 +1,38 @@ +//! Раскладка ключа `blacklist6_map` (LPM-trie): префикс-длина в байтах 0..4 +//! little-endian + 16 байт адреса в network order (байты 4..20). +//! Ядро не нужно: проверяется чистая функция кодирования ключа. +#![cfg(feature = "xdp")] + +use rampart::xdp::blacklist6_key; + +const ADDR_2001_DB8_1: [u8; 16] = [0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]; + +#[test] +fn key_layout_for_128_prefix() { + let key = blacklist6_key(128, &ADDR_2001_DB8_1); + + assert_eq!(key.len(), 20); + assert_eq!(key[0], 128, "prefixlen goes first"); + assert_eq!(key[1..4], [0, 0, 0], "u32 LE padding stays zero"); + assert_eq!(key[4..20], ADDR_2001_DB8_1, "address kept in network order"); +} + +#[test] +fn key_layout_for_64_prefix() { + let key = blacklist6_key(64, &ADDR_2001_DB8_1); + + assert_eq!(key[0], 64); + assert_eq!(key[1..4], [0, 0, 0]); + assert_eq!(key[4..20], ADDR_2001_DB8_1); +} + +#[test] +fn leading_zero_address_is_not_confused_with_prefix_len() { + // ::1 — 15 нулевых байт перед единицей: ключ не должен «съесть» ни одного. + let key = blacklist6_key(128, &[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]); + + assert_eq!(key[0], 128, "prefixlen is not overwritten by the address"); + assert_eq!(key[1..4], [0, 0, 0]); + assert_eq!(key[4..19], [0u8; 15]); + assert_eq!(key[19], 1); +} diff --git a/xdp/core/common.h b/xdp/core/common.h index a8516bf..b19828f 100644 --- a/xdp/core/common.h +++ b/xdp/core/common.h @@ -50,6 +50,12 @@ struct lpm_key { __u32 ip; }; +// ── LPM key for IPv6 blacklist (format of bpf_lpm_trie_key, 20 bytes) ── +struct lpm_key6 { + __u32 prefixlen; + __u8 addr[16]; +}; + // ── Ringbuf event (userspace receives these) ── enum event_type { EVENT_BAN = 0, diff --git a/xdp/core/maps.h b/xdp/core/maps.h index 94dc572..cdf8dc0 100644 --- a/xdp/core/maps.h +++ b/xdp/core/maps.h @@ -11,6 +11,16 @@ struct { __uint(map_flags, BPF_F_NO_PREALLOC); } blacklist_map SEC(".maps"); +// 🔗 IPv6 blacklist (LPM_TRIE, 128-bit prefix keys) +// Same value/expiry contract as blacklist_map +struct { + __uint(type, BPF_MAP_TYPE_LPM_TRIE); + __uint(max_entries, 100000); + __type(key, struct lpm_key6); + __type(value, __u64); // ban expiry (ktime_ns) + __uint(map_flags, BPF_F_NO_PREALLOC); +} blacklist6_map SEC(".maps"); + // 🔗 Whitelist (LPM_TRIE for CIDR) — checked before any filter struct { __uint(type, BPF_MAP_TYPE_LPM_TRIE); diff --git a/xdp/core/universal_filter.c b/xdp/core/universal_filter.c index b5477c1..3d2ae70 100644 --- a/xdp/core/universal_filter.c +++ b/xdp/core/universal_filter.c @@ -72,6 +72,22 @@ static __always_inline __u8 is_blacklisted(__u32 src_ip, __u64 now) return 0; } +// ── IPv6 blacklist lookup with expiry; removes expired entries ── +// Key layout mirrors bpf_lpm_trie_key: prefixlen (host order) + 16 addr bytes. +static __always_inline __u8 is_blacklisted6(const __u8 addr[16], __u64 now) +{ + struct lpm_key6 key = {}; + key.prefixlen = 128; + __builtin_memcpy(key.addr, addr, 16); + __u64 *ban_until = bpf_map_lookup_elem(&blacklist6_map, &key); + if (!ban_until) + return 0; + if (*ban_until > now) + return 1; + bpf_map_delete_elem(&blacklist6_map, &key); // expired — clean up + return 0; +} + static __always_inline void ban_ip(__u32 src_ip, __u64 until) { struct lpm_key key = { .prefixlen = 32, .ip = src_ip }; @@ -127,6 +143,8 @@ int rampart_universal_filter(struct xdp_md *ctx) __u32 dst_ip = 0; __u8 l4_proto = 0; __u8 is_ipv6 = 0; + __u8 native_v6 = 0; + __u8 src6[16]; if (eth->h_proto == bpf_htons(ETH_P_IP)) { struct iphdr *ip = (void *)(eth + 1); @@ -164,15 +182,19 @@ int rampart_universal_filter(struct xdp_md *ctx) ip6->daddr.in6_u.u6_addr32[0] != 0 || ip6->daddr.in6_u.u6_addr32[1] != 0 || ip6->daddr.in6_u.u6_addr32[2] != bpf_htonl(0xFFFF)) { - // Non-mapped IPv6 — pass for now (not supported) - return XDP_PASS; + // Native IPv6 — no 32-bit representable address, handled separately + // after the generic L4/port gates; must NOT touch v4 maps. + native_v6 = 1; + is_ipv6 = 1; + l4_proto = ip6->nexthdr; + __builtin_memcpy(src6, &ip6->saddr, 16); + } else { + // FIX: source address must come from saddr, never daddr + src_ip = ip6->saddr.in6_u.u6_addr32[3]; + dst_ip = ip6->daddr.in6_u.u6_addr32[3]; + l4_proto = ip6->nexthdr; + is_ipv6 = 1; } - - // FIX: source address must come from saddr, never daddr - src_ip = ip6->saddr.in6_u.u6_addr32[3]; - dst_ip = ip6->daddr.in6_u.u6_addr32[3]; - l4_proto = ip6->nexthdr; - is_ipv6 = 1; } // ── Parse L4 header ── @@ -209,6 +231,35 @@ int rampart_universal_filter(struct xdp_md *ctx) __u64 now = bpf_ktime_get_ns(); + // ── Native IPv6: blacklist + cheap L4 policy (no stateful v6 yet) ── + if (native_v6) { + if (is_blacklisted6(src6, now)) { + inc_blacklist(); + inc_drop(); + return XDP_DROP; + } + if (l4_proto == IPPROTO_UDP) { + if (G_UDP_POLICY == 1) { // drop + inc_drop(); + return XDP_DROP; + } + inc_pass(); + return XDP_PASS; // policy 2 (rate-limit) needs a 128-bit key — not supported for v6 + } + // TCP: forged-flag combos are L4-generic, no state needed + if (detect_tcp_bypass((struct tcphdr *)l4)) { + inc_drop(); + return XDP_DROP; + } + // Per-prefix stats (/64) — feeds the subnet detector for IPv6 + struct prefix_key pkey6; + prefix_key_from_v6(&pkey6, src6); + struct tcphdr *tcp6 = (struct tcphdr *)l4; + update_prefix_stats(&pkey6, (tcp6->syn && !tcp6->ack) ? 1 : 0, now); + inc_pass(); + return XDP_PASS; + } + // ── Whitelist check (CIDR) — before any filtering ── struct lpm_key wl_key = { .prefixlen = 32, .ip = src_ip }; if (bpf_map_lookup_elem(&whitelist_map, &wl_key)) {