guard/tests/subnet_detection.rs
loki5512344 918e561a61
feat(xdp): IPv6 UDP rate limit, working loader; English JavaDoc comments
XDP behaviour:
- udp_rate_limit6 (LRU, 128-bit source key) + throttle_hit6, so
  udp_policy = "rate-limit" now applies to native IPv6 as well.
- scripts/xdp_ipv6_smoke.sh: phase 4 patches .rodata before load and
  verifies policy=2 on a real kernel (3 pass / 3 rate-limited).

XDP loader (was completely broken, never reached the verifier):
- .rodata is now one struct rampart_config with frozen offsets enforced by
  _Static_assert; XdpGlobals is #[repr(C)] and the image is built with
  offset_of!. Previously a 96-byte image was written into a 76-byte map at
  offsets clang had reordered, so load() failed with EINVAL.
- patch_rodata fails loudly when the map size and the image size diverge.
- build.rs tracks xdp/core and xdp/hooks, not just universal_filter.c.
- build_ringbuf looked for "events_map"; the map is "events_ringbuf".
- tests/xdp_object_maps.rs: verifies map names and .rodata size without root;
  the real binary was confirmed to attach in a netns.

Docs and style:
- Code comments are English, JavaDoc/Rustdoc style, without emoji or
  decorative banners (new project rule, TODO §0.8).
- README rewritten bilingual: Russian first, English below, TOC and
  copy-paste quick start.
- docs/README.md: documentation index and maintenance rules;
  configuration.md documents the whole [xdp] section and IPv4/IPv6 coverage;
  testing.md describes the real-kernel smoke; stale research links removed.
2026-11-15 23:44:07 +01:00

215 lines
6.6 KiB
Rust

//! Integration tests for subnet-level detection: tracker, detector and verdicts.
use rampart::config::Config;
use rampart::engine::subnet_tracker::SubnetTracker;
use rampart::traffic::prefix::{
PrefixKey, PrefixSnapshot, PrefixStatsSource, PrefixStatsVal, SubnetDetector, SubnetVerdict, prefix_of,
};
use std::collections::HashMap;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
fn v4(octets: [u8; 4]) -> IpAddr {
IpAddr::V4(Ipv4Addr::from(octets))
}
/// Fixed snapshot source that imitates the XDP map without a kernel.
struct FixedSource(Vec<(IpAddr, PrefixSnapshot)>);
impl PrefixStatsSource for FixedSource {
async fn snapshot(&self) -> anyhow::Result<Vec<(IpAddr, PrefixSnapshot)>> {
Ok(self.0.clone())
}
}
#[tokio::test]
async fn tracker_feeds_detector_and_blocks_distributed_attack() {
let tracker = SubnetTracker::new();
// 40 unique sources from one /24 is a distributed attack: 6 SYNs each,
// i.e. 240 >= 4 x threshold(50).
for _ in 0..6 {
for last in 1..=40u8 {
tracker.record_connection(v4([203, 0, 113, last]));
}
}
let snaps = tracker.take_snapshot();
let detector = SubnetDetector::new(50, 16);
let verdicts = detector.evaluate(&snaps);
assert_eq!(verdicts.len(), 1);
assert_eq!(verdicts[0].prefix, v4([203, 0, 113, 0]));
assert_eq!(verdicts[0].verdict, SubnetVerdict::Block);
assert_eq!(verdicts[0].snapshot.syn_count, 240);
assert_eq!(verdicts[0].snapshot.unique_sources, 40);
// Full pipeline through the trait source, the way the binary drives it.
let source_snaps = FixedSource(snaps).snapshot().await.expect("source snapshot");
assert_eq!(detector.evaluate(&source_snaps)[0].verdict, SubnetVerdict::Block);
}
#[tokio::test]
async fn spoof_gate_many_syn_few_sources_no_block() {
let tracker = SubnetTracker::new();
// 500 SYNs from only 3 addresses: a burst, but not distributed.
for _ in 0..167 {
for ip in [v4([198, 51, 100, 1]), v4([198, 51, 100, 2]), v4([198, 51, 100, 3])] {
tracker.record_connection(ip);
}
}
let snaps = tracker.take_snapshot();
let detector = SubnetDetector::new(50, 16);
let verdicts = detector.evaluate(&snaps);
assert_eq!(verdicts.len(), 1);
assert_eq!(verdicts[0].snapshot.syn_count, 501);
assert_eq!(verdicts[0].snapshot.unique_sources, 3);
assert_ne!(verdicts[0].verdict, SubnetVerdict::Block);
assert_eq!(verdicts[0].verdict, SubnetVerdict::Challenge);
}
#[test]
fn ipv6_prefixes_aggregated_separately_from_ipv4() {
let tracker = SubnetTracker::new();
let v6a = IpAddr::V6("2001:db8:1:2::1".parse::<Ipv6Addr>().expect("valid"));
let v6b = IpAddr::V6("2001:db8:1:2::ffff".parse::<Ipv6Addr>().expect("valid"));
tracker.record_connection(v6a);
tracker.record_connection(v6b);
tracker.record_connection(v4([10, 0, 0, 1]));
let snaps: HashMap<IpAddr, PrefixSnapshot> = tracker.take_snapshot().into_iter().collect();
assert_eq!(snaps.len(), 2);
assert_eq!(
snaps[&IpAddr::V6("2001:db8:1:2::".parse::<Ipv6Addr>().expect("valid"))].unique_sources,
2
);
assert_eq!(snaps[&v4([10, 0, 0, 0])].unique_sources, 1);
}
#[test]
fn mapped_v6_joins_ipv4_prefix_bucket() {
// ::ffff:192.0.2.9
assert_eq!(
prefix_of(IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xc000, 0x0209))),
v4([192, 0, 2, 0])
);
}
#[test]
fn detect_prefix_config_section_parses_end_to_end() {
let config = Config::parse_str(
r#"
[detect.prefix]
enabled = true
syn_threshold = 250
window_secs = 30
min_unique_sources = 4
"#,
)
.expect("[detect.prefix] must parse");
assert!(config.detect.prefix.enabled);
let detector = SubnetDetector::from_config(&config.detect.prefix);
let snaps = vec![(
v4([203, 0, 113, 0]),
PrefixSnapshot {
syn_count: 1200,
unique_sources: 5,
..PrefixSnapshot::default()
},
)];
let verdicts = detector.evaluate(&snaps);
assert_eq!(verdicts[0].verdict, SubnetVerdict::Block);
}
fn verdict_for(detector: &SubnetDetector, snap: &PrefixSnapshot) -> SubnetVerdict {
let verdicts = detector.evaluate(&[(v4([10, 9, 9, 0]), *snap)]);
verdicts[0].verdict
}
#[test]
fn ipv4_prefix_masked_to_24() {
assert_eq!(prefix_of(v4([203, 0, 113, 77])), v4([203, 0, 113, 0]));
assert_eq!(prefix_of(v4([198, 51, 100, 1])), v4([198, 51, 100, 0]));
}
#[test]
fn ipv6_prefix_masked_to_64() {
let ip = IpAddr::V6("2001:db8:1:2:3:4:5:6".parse::<Ipv6Addr>().expect("valid"));
assert_eq!(
prefix_of(ip),
IpAddr::V6("2001:db8:1:2::".parse::<Ipv6Addr>().expect("valid"))
);
}
#[test]
fn mapped_ipv6_treated_as_ipv4() {
// ::ffff:203.0.113.77
let mapped = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xcb00, 0x714d));
assert_eq!(prefix_of(mapped), v4([203, 0, 113, 0]));
}
#[test]
fn prefix_key_roundtrip_and_layout() {
assert_eq!(size_of::<PrefixKey>(), 24);
assert_eq!(size_of::<PrefixStatsVal>(), 24);
let key = PrefixKey::new(v4([10, 1, 2, 3]));
assert_eq!(key.family, rampart::traffic::prefix::PREFIX_FAMILY_V4);
assert_eq!(key.to_prefix(), Some(v4([10, 1, 2, 0])));
assert_eq!(PrefixKey::from_bytes(key.to_bytes()), key);
let key6 = PrefixKey::new(IpAddr::V6("2001:db8::1".parse::<Ipv6Addr>().expect("valid")));
assert_eq!(key6.family, rampart::traffic::prefix::PREFIX_FAMILY_V6);
assert_eq!(
key6.to_prefix(),
Some(IpAddr::V6("2001:db8::".parse::<Ipv6Addr>().expect("valid")))
);
}
#[test]
fn escalation_ladder_monitor_to_block() {
let detector = SubnetDetector::new(100, 16);
let snap = |syn: u64| PrefixSnapshot {
syn_count: syn,
unique_sources: 32,
..PrefixSnapshot::default()
};
assert_eq!(verdict_for(&detector, &snap(99)), SubnetVerdict::Monitor);
assert_eq!(verdict_for(&detector, &snap(100)), SubnetVerdict::StrictLimit);
assert_eq!(verdict_for(&detector, &snap(150)), SubnetVerdict::StrictLimit);
assert_eq!(verdict_for(&detector, &snap(200)), SubnetVerdict::Challenge);
assert_eq!(verdict_for(&detector, &snap(400)), SubnetVerdict::Block);
}
#[test]
fn spoof_gate_downgrades_block_to_challenge() {
let detector = SubnetDetector::new(100, 16);
// Many SYNs from one source (or unknown diversity) must not yield Block.
let few = PrefixSnapshot {
syn_count: 1000,
unique_sources: 3,
..PrefixSnapshot::default()
};
let unknown = PrefixSnapshot {
syn_count: 1000,
..PrefixSnapshot::default()
};
assert_eq!(verdict_for(&detector, &few), SubnetVerdict::Challenge);
assert_eq!(verdict_for(&detector, &unknown), SubnetVerdict::Challenge);
}
#[test]
fn evaluate_skips_empty_prefixes() {
let detector = SubnetDetector::new(100, 0);
let snaps = vec![
(v4([10, 0, 0, 0]), PrefixSnapshot::default()),
(
v4([10, 0, 1, 0]),
PrefixSnapshot {
syn_count: 500,
unique_sources: 40,
..PrefixSnapshot::default()
},
),
];
let verdicts = detector.evaluate(&snaps);
assert_eq!(verdicts.len(), 1);
assert_eq!(verdicts[0].prefix, v4([10, 0, 1, 0]));
assert_eq!(verdicts[0].verdict, SubnetVerdict::Block);
}