feat(xdp): IPv6 parity — blacklist6_map, v6 bans, v6 prefix stats

- 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).
This commit is contained in:
Loki 2026-11-15 23:02:12 +01:00
parent cacd01c657
commit 59d5a088b2
Signed by: boba
GPG key ID: 6CDE87BC9A778D97
11 changed files with 309 additions and 36 deletions

27
TODO.md
View file

@ -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

138
scripts/xdp_ipv6_smoke.sh Executable file
View file

@ -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 ]

View file

@ -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}"),
}
}

View file

@ -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());

View file

@ -16,6 +16,8 @@ mod attach;
pub(crate) mod events;
mod maps;
pub use maps::blacklist6_key;
pub struct XdpFilter {
obj: Option<Object>,
ringbuf: Option<RingBuffer<'static>>,

View file

@ -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,
};

View file

@ -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(())
}

38
tests/xdp_ban_v6.rs Normal file
View file

@ -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);
}

View file

@ -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,

View file

@ -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);

View file

@ -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,16 +182,20 @@ 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;
}
}
// ── Parse L4 header ──
__u8 ip_hdr_len;
@ -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)) {