diff --git a/TODO.md b/TODO.md index a79c55a..e139b5f 100644 --- a/TODO.md +++ b/TODO.md @@ -183,14 +183,17 @@ guard/ - 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). +- [x] **Expiry бана из userspace не работал в ядре** (найден и починен 2026-11-15, касался v4 и v6): + `blacklist_expiry_ns` писал `SystemTime` (epoch ns ≈ 1.7e18), а C сравнивает с + `bpf_ktime_get_ns()` (monotonic ≈ uptime) — бан жил до перезагрузки. Теперь userspace пишет + `CLOCK_MONOTONIC`-ns (`xdp::monotonic_ns`), регрессия — `tests/xdp_ban_clock.rs` и expiry-фаза + в `scripts/xdp_ipv6_smoke.sh`. +- [x] **Короткий L4-хвост обходил blacklist** (найден и починен 2026-11-15, v4 и v6): + `universal_filter.c` требовал `sizeof(struct tcphdr)` (20 байт) для всех протоколов, иначе + ранний `XDP_PASS` — UDP-датаграмма короче 20 байт не доходила до порт-гейта и blacklist. + Теперь минимум считается по протоколу (`sizeof(struct udphdr)` для UDP); регрессия — + «короткая датаграмма» в `scripts/xdp_ipv6_smoke.sh`. TCP-путь не изменился: там по-прежнему + требуется полный `struct tcphdr`. ## 3. Backlog diff --git a/scripts/xdp_ipv6_smoke.sh b/scripts/xdp_ipv6_smoke.sh index 47e71f2..1492014 100755 --- a/scripts/xdp_ipv6_smoke.sh +++ b/scripts/xdp_ipv6_smoke.sh @@ -1,18 +1,17 @@ #!/usr/bin/env bash -# Функциональный smoke IPv6-бана в XDP (blacklist6_map) на РЕАЛЬНОМ ядре. +# Функциональный smoke XDP-банов на РЕАЛЬНОМ ядре (netns + veth + verifier). # # Что проверяет: -# 1. verifier принимает universal_filter.o после v6-изменений; -# 2. native-IPv6 пакет без бана проходит (счётчики pass/udp растут); -# 3. запись /128 в blacklist6_map реально дропает пакет (blacklist+drop); -# 4. после удаления записи трафик снова проходит. +# 1. verifier принимает universal_filter.o; +# 2. native-IPv6 без бана проходит, с записью /128 в blacklist6_map — дропается; +# 3. короткая UDP-датаграмма (<20 байт L4) тоже дропается — раньше она уходила +# в XDP_PASS мимо blacklist (проверка длины была рассчитана на TCP); +# 4. то же для IPv4 (общий L4-гейт); +# 5. expiry: бан с монотонным TTL реально истекает в ядре (раньше userspace +# писал epoch-ns, а C сравнивал с bpf_ktime_get_ns() — бан жил вечно). # -# Требует root/CAP_BPF+CAP_NET_ADMIN (создаёт netns и veth), bpftool, clang, python3. +# Требует root/CAP_BPF+CAP_NET_ADMIN, bpftool, clang, python3. # Запуск: sudo bash scripts/xdp_ipv6_smoke.sh -# -# Замечание: программа требует ≥20 байт L4 (граница struct tcphdr для обоих -# протоколов), поэтому датаграмма должна быть не меньше 20 байт, иначе пакет -# уходит в XDP_PASS до проверки blacklist — это существующее поведение. set -u @@ -21,20 +20,19 @@ DEV0=rth6 DEV1=rtap6 HOST6=fd00::1 NS6=fd00::2 +HOST4=10.99.0.1 +NS4=10.99.0.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" + rm -f "$PIN" "$OBJ" ip link del "$DEV0" 2>/dev/null ip netns del "$NS" 2>/dev/null } @@ -52,39 +50,53 @@ 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 addr add "$HOST4/24" dev "$DEV0" ip link set "$DEV0" up ip -n "$NS" -6 addr add "$NS6/64" dev "$DEV1" +ip -n "$NS" addr add "$NS4/24" dev "$DEV1" ip -n "$NS" link set "$DEV1" up ip -n "$NS" link set lo up -ok "netns $NS + veth ($HOST6 <-> $NS6)" +ok "netns $NS + veth ($HOST6/$HOST4 <-> $NS6/$NS4)" 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 ',' ' ') +B4="" 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 + desc=$(bpftool map show id "$id" 2>/dev/null) + case "$desc" in + *"name blacklist6_map"*) B6=$id ;; + *"name blacklist_map"*) B4=$id ;; + *"name stats_map"*) ST=$id ;; + esac done -[ -n "$B6" ] || { echo "blacklist6_map не найдена"; exit 1; } -[ -n "$ST" ] || { echo "stats_map не найдена"; exit 1; } -ok "blacklist6_map id=$B6, stats_map id=$ST" +[ -n "$B4" ] && [ -n "$B6" ] && [ -n "$ST" ] || { echo "карты не найдены"; exit 1; } +ok "blacklist_map id=$B4, 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" +# Ключи LPM: prefixlen (u32 LE) + адрес в network order. +KEY6="80 00 00 00 fd 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02" +KEY4="20 00 00 00 0a 63 00 02" -send() { +send6() { # $1 = размер payload ip netns exec "$NS" python3 -c " import socket s = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM) -s.sendto(b'x' * 100, ('$HOST6', $PORT)) +s.sendto(b'x' * $1, ('$HOST6', $PORT)) +" +} +send4() { + ip netns exec "$NS" python3 -c " +import socket +s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) +s.sendto(b'x' * $1, ('$HOST4', $PORT)) " } -# Суммы per-CPU счётчиков: печатает только ненулевые. +# Суммы per-CPU счётчиков (только ненулевые). stats() { bpftool -j map dump id "$ST" | python3 -c " import json, sys @@ -98,41 +110,74 @@ for e in json.load(sys.stdin): 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" +mono_ns_hex() { # монотонные ns + $1 секунд, 8 байт little-endian + python3 -c " +import time +ns = time.clock_gettime_ns(time.CLOCK_MONOTONIC) + $1 * 1_000_000_000 +print(' '.join(f'{b:02x}' for b in ns.to_bytes(8, 'little'))) +" +} + +# ── Фаза 1: IPv6 ── +pass0=$(metric pass) +for _ in 1 2 3; do send6 100; done +sleep 0.5 +pass1=$(metric pass) +[ "${pass1:-0}" -gt "${pass0:-0}" ] \ + && ok "v6 без бана проходит (pass $pass0 -> $pass1)" \ + || fail "v6 без бана не проходит ($(stats))" + +drop0=$(metric drop) +bpftool map update id "$B6" key hex $KEY6 value hex ff ff ff ff ff ff ff ff || fail "v6 map update" +for _ in 1 2 3; do send6 100; done +for _ in 1 2 3; do send6 1; done # короткая датаграмма +sleep 0.5 +drop1=$(metric drop) +[ "${drop1:-0}" -ge $((${drop0:-0} + 6)) ] \ + && ok "v6 с баном дропает обычные и короткие (drop $drop0 -> $drop1)" \ + || fail "v6 бан не дропает всё ($(stats))" + +bpftool map delete id "$B6" key hex $KEY6 || fail "v6 map delete" +pass2=$(metric pass) +for _ in 1 2 3; do send6 100; done +sleep 0.5 +pass3=$(metric pass) +[ "${pass3:-0}" -gt "${pass2:-0}" ] \ + && ok "v6 после снятия бана проходит (pass $pass2 -> $pass3)" \ + || fail "v6 после снятия бана не проходит ($(stats))" + +# ── Фаза 2: IPv4 (общий L4-гейт) ── +drop0=$(metric drop) +bpftool map update id "$B4" key hex $KEY4 value hex ff ff ff ff ff ff ff ff || fail "v4 map update" +for _ in 1 2 3; do send4 1; done # только короткие — регрессия на min_l4 +sleep 0.5 +drop1=$(metric drop) +[ "${drop1:-0}" -ge $((${drop0:-0} + 3)) ] \ + && ok "v4 короткие датаграммы дропаются баном (drop $drop0 -> $drop1)" \ + || fail "v4 короткая датаграмма прошла мимо бана ($(stats))" +bpftool map delete id "$B4" key hex $KEY4 || fail "v4 map delete" + +# ── Фаза 3: expiry бана (монотонные часы) ── +TTL=2 +bpftool map update id "$B6" key hex $KEY6 value hex $(mono_ns_hex $TTL) || fail "expiry update" +drop0=$(metric drop) +for _ in 1 2 3; do send6 100; done +sleep 0.5 +drop1=$(metric drop) +[ "${drop1:-0}" -ge $((${drop0:-0} + 3)) ] \ + && ok "бан с TTL=${TTL}s дропает сразу (drop $drop0 -> $drop1)" \ + || fail "свежий бан не дропает ($(stats))" + +sleep $((TTL + 2)) +drop2=$(metric drop); pass2=$(metric pass) +for _ in 1 2 3; do send6 100; done +sleep 0.5 +drop3=$(metric drop); pass3=$(metric pass) +[ "${drop3:-0}" -eq "${drop2:-0}" ] && [ "${pass3:-0}" -gt "${pass2:-0}" ] \ + && ok "бан истёк по монотонным часам (pass $pass2 -> $pass3, drop $drop2 -> $drop3)" \ + || fail "бан не истёк (pass $pass2 -> $pass3, drop $drop2 -> $drop3)" + +[ "$PASS" = 1 ] && echo "PASS: XDP-баны (v4/v6, короткий L4, expiry) работают на живом ядре" || echo "FAIL" [ "$PASS" = 1 ] diff --git a/src/xdp/filter/maps.rs b/src/xdp/filter/maps.rs index 23da663..f23432e 100644 --- a/src/xdp/filter/maps.rs +++ b/src/xdp/filter/maps.rs @@ -3,11 +3,21 @@ use anyhow::Result; use libbpf_rs::{MapCore, MapFlags}; use std::net::{IpAddr, Ipv4Addr}; -pub(super) fn unix_ns() -> u64 { - std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap_or_default() - .as_nanos() as u64 +/// Monotonic clock in ns since boot — the same clock as `bpf_ktime_get_ns()`, +/// which is what the XDP program compares ban expiry against. `SystemTime` +/// (epoch ns) is ~50 years larger, so bans written with it never expired. +/// +/// # Panics +/// Never: `clock_gettime(CLOCK_MONOTONIC)` cannot fail on Linux. +#[must_use] +pub fn monotonic_ns() -> u64 { + let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 }; + // SAFETY: `ts` is a valid, writable `timespec` and CLOCK_MONOTONIC is + // always available on Linux (the only target of the `xdp` feature). + unsafe { libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts) }; + let secs = u64::try_from(ts.tv_sec).unwrap_or(0); + secs.saturating_mul(1_000_000_000) + .saturating_add(u64::try_from(ts.tv_nsec).unwrap_or(0)) } /// Encodes an LPM-trie key for `blacklist_map`: prefix length in byte 0 and the @@ -29,7 +39,7 @@ pub fn blacklist6_key(prefix_len: u8, v6: &[u8; 16]) -> [u8; 20] { key } -/// Absolute ban expiry in ns-since-epoch, saturating so an absurd duration +/// Absolute ban expiry on the monotonic clock, 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 { now_ns.saturating_add(duration_secs.saturating_mul(1_000_000_000)) @@ -51,7 +61,7 @@ impl XdpFilter { fn blacklist_update(&self, prefix_len: u8, v4: &[u8; 4], duration_secs: u64) -> Result<()> { let map = self.find_map("blacklist_map")?; let key = blacklist_key(prefix_len, v4); - let expiry_ns = blacklist_expiry_ns(unix_ns(), duration_secs); + let expiry_ns = blacklist_expiry_ns(monotonic_ns(), duration_secs); map.update(&key, &expiry_ns.to_le_bytes(), MapFlags::ANY)?; Ok(()) } @@ -59,7 +69,7 @@ impl XdpFilter { 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); + let expiry_ns = blacklist_expiry_ns(monotonic_ns(), duration_secs); map.update(&key, &expiry_ns.to_le_bytes(), MapFlags::ANY)?; Ok(()) } diff --git a/src/xdp/filter/mod.rs b/src/xdp/filter/mod.rs index c58d47e..11b0ba7 100644 --- a/src/xdp/filter/mod.rs +++ b/src/xdp/filter/mod.rs @@ -16,7 +16,7 @@ mod attach; pub(crate) mod events; mod maps; -pub use maps::blacklist6_key; +pub use maps::{blacklist6_key, monotonic_ns}; pub struct XdpFilter { obj: Option, diff --git a/src/xdp/mod.rs b/src/xdp/mod.rs index ce84086..ee0cbb7 100644 --- a/src/xdp/mod.rs +++ b/src/xdp/mod.rs @@ -24,6 +24,8 @@ pub use filter::blacklist6_key; pub use filter::events::{ AutoBanConfig, BanAction, XDP_EVENT_LEN, XdpEvent, XdpEventKind, auto_ban_decision, parse_xdp_event, }; +#[cfg(feature = "xdp")] +pub use filter::monotonic_ns; #[cfg(feature = "xdp")] pub use probe::XdpMetrics; diff --git a/tests/xdp_ban_clock.rs b/tests/xdp_ban_clock.rs new file mode 100644 index 0000000..2d5b474 --- /dev/null +++ b/tests/xdp_ban_clock.rs @@ -0,0 +1,29 @@ +//! Часы бана: XDP сравнивает expiry с `bpf_ktime_get_ns()` (монотонные ns +//! с загрузки), поэтому userspace обязан писать то же самое. Регрессия: +//! раньше писался `SystemTime` (epoch ns ≈ 1.7e18), и бан не истекал никогда. +#![cfg(feature = "xdp")] + +use rampart::xdp::monotonic_ns; + +fn clock_monotonic_ns() -> u64 { + let mut ts = libc::timespec { tv_sec: 0, tv_nsec: 0 }; + // SAFETY: `ts` — валидный writable `timespec`; CLOCK_MONOTONIC на Linux + // поддерживается всегда (xdp-фича собирается только под Linux). + let rc = unsafe { libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut ts) }; + assert_eq!(rc, 0, "clock_gettime(CLOCK_MONOTONIC) failed"); + let secs = u64::try_from(ts.tv_sec).expect("tv_sec fits u64"); + let nanos = u64::try_from(ts.tv_nsec).expect("tv_nsec fits u64"); + secs * 1_000_000_000 + nanos +} + +#[test] +fn ban_clock_is_monotonic_not_wall_clock() { + let expected = clock_monotonic_ns(); + let got = monotonic_ns(); + + let diff = got.abs_diff(expected); + assert!( + diff < 5_000_000_000, + "monotonic_ns must read CLOCK_MONOTONIC: got {got}, expected ~{expected}" + ); +} diff --git a/xdp/core/universal_filter.c b/xdp/core/universal_filter.c index 3d2ae70..a809730 100644 --- a/xdp/core/universal_filter.c +++ b/xdp/core/universal_filter.c @@ -211,7 +211,13 @@ int rampart_universal_filter(struct xdp_md *ctx) ip_hdr_len = ip->ihl * 4; } - if ((void *)l4 + sizeof(struct tcphdr) > data_end) + // Minimum L4 header per protocol: a short UDP datagram used to fall through + // to XDP_PASS because the check was sized for TCP, letting it bypass the + // blacklist entirely. IPv6 native fragmentation is already filtered above + // (nexthdr must be TCP/UDP), so a short UDP header here is a real datagram. + __u32 min_l4 = (l4_proto == IPPROTO_TCP) ? sizeof(struct tcphdr) + : sizeof(struct udphdr); + if ((void *)l4 + min_l4 > data_end) return XDP_PASS; // ── Port range check (protected services) ──