style: switch rustfmt to hard tabs; document tests-separate rule in TODO

- rustfmt.toml: hard_tabs = true.
- TODO §0.7: tests live in tests/, no #[cfg(test)] modules in code files.
This commit is contained in:
Loki 2026-11-15 22:34:29 +01:00
parent d8393e0f39
commit a90f0da226
Signed by: boba
GPG key ID: 6CDE87BC9A778D97
96 changed files with 6542 additions and 6537 deletions

View file

@ -2,18 +2,18 @@ use rampart::config::Config;
#[test]
fn parses_minimal_config_with_defaults() {
let config = Config::parse_str("").expect("empty config must parse with defaults");
assert_eq!(config.bind.address, "0.0.0.0");
assert_eq!(config.bind.port, 25565);
assert_eq!(config.backend.upstreams, vec!["127.0.0.1:25566"]);
assert_eq!(config.workers.count, 4);
assert!(!config.pow.enabled);
let config = Config::parse_str("").expect("empty config must parse with defaults");
assert_eq!(config.bind.address, "0.0.0.0");
assert_eq!(config.bind.port, 25565);
assert_eq!(config.backend.upstreams, vec!["127.0.0.1:25566"]);
assert_eq!(config.workers.count, 4);
assert!(!config.pow.enabled);
}
#[test]
fn parses_full_config() {
let config = Config::parse_str(
r#"
let config = Config::parse_str(
r#"
[bind]
port = 8443
@ -33,46 +33,46 @@ clickhouse_url = "http://localhost:8123"
whitelist = ["203.0.113.7"]
"#,
)
.expect("full config must parse");
)
.expect("full config must parse");
assert_eq!(config.bind.port, 8443);
assert_eq!(config.backend.upstreams.len(), 2);
assert!((config.limits.rate_limit_pps - 50.0).abs() < f64::EPSILON);
assert!(config.pow.enabled);
assert_eq!(config.pow.difficulty, 5);
assert_eq!(config.store.redis_url.as_deref(), Some("redis://localhost:6379/1"));
assert_eq!(config.bind.port, 8443);
assert_eq!(config.backend.upstreams.len(), 2);
assert!((config.limits.rate_limit_pps - 50.0).abs() < f64::EPSILON);
assert!(config.pow.enabled);
assert_eq!(config.pow.difficulty, 5);
assert_eq!(config.store.redis_url.as_deref(), Some("redis://localhost:6379/1"));
}
#[test]
fn rejects_empty_upstreams() {
let err = Config::parse_str("[backend]\nupstreams = []\n").expect_err("must reject empty upstream list");
assert!(err.to_string().contains("upstreams"));
let err = Config::parse_str("[backend]\nupstreams = []\n").expect_err("must reject empty upstream list");
assert!(err.to_string().contains("upstreams"));
}
#[test]
fn rejects_malformed_upstream_address() {
let result = Config::parse_str("[backend]\nupstreams = [\"example.invalid\"]\n");
assert!(result.is_err(), "hostname-only upstreams are not supported");
let result = Config::parse_str("[backend]\nupstreams = [\"example.invalid\"]\n");
assert!(result.is_err(), "hostname-only upstreams are not supported");
}
#[test]
fn rejects_invalid_whitelist_ip() {
let result = Config::parse_str("whitelist = [\"10.0.0.999\"]");
assert!(result.is_err());
let result = Config::parse_str("whitelist = [\"10.0.0.999\"]");
assert!(result.is_err());
}
#[test]
fn detect_autoban_defaults_disabled() {
let config = Config::parse_str("").expect("empty config must parse");
assert!(!config.detect.autoban.enabled);
assert_eq!(config.detect.autoban.reputation_threshold, -50);
let config = Config::parse_str("").expect("empty config must parse");
assert!(!config.detect.autoban.enabled);
assert_eq!(config.detect.autoban.reputation_threshold, -50);
}
#[test]
fn parses_detect_sections() {
let config = Config::parse_str(
r#"
let config = Config::parse_str(
r#"
[detect.autoban]
enabled = true
reputation_threshold = -30
@ -80,36 +80,36 @@ reputation_threshold = -30
[detect.alert]
webhook_url = "https://hooks.example.test/rampart"
"#,
)
.expect("detect sections must parse");
assert!(config.detect.autoban.enabled);
assert_eq!(config.detect.autoban.reputation_threshold, -30);
assert_eq!(
config.detect.alert.webhook_url.as_deref(),
Some("https://hooks.example.test/rampart")
);
)
.expect("detect sections must parse");
assert!(config.detect.autoban.enabled);
assert_eq!(config.detect.autoban.reputation_threshold, -30);
assert_eq!(
config.detect.alert.webhook_url.as_deref(),
Some("https://hooks.example.test/rampart")
);
}
#[test]
fn xdp_section_defaults() {
let config = Config::parse_str("").expect("empty config must parse");
let xdp = &config.xdp;
assert_eq!(xdp.protected_port_start, 1);
assert_eq!(xdp.protected_port_end, 65535);
assert_eq!(xdp.udp_policy, "pass");
assert_eq!(xdp.udp_rate_hit_count, 100);
assert_eq!(xdp.udp_rate_window_ms, 1000);
assert!(!xdp.syn_challenge_enabled);
assert!(xdp.challenge_secret_hex.is_none());
assert_eq!(xdp.challenge_timeout_ms, 3000);
assert!(xdp.throttle_enabled);
assert!(xdp.events_enabled);
let config = Config::parse_str("").expect("empty config must parse");
let xdp = &config.xdp;
assert_eq!(xdp.protected_port_start, 1);
assert_eq!(xdp.protected_port_end, 65535);
assert_eq!(xdp.udp_policy, "pass");
assert_eq!(xdp.udp_rate_hit_count, 100);
assert_eq!(xdp.udp_rate_window_ms, 1000);
assert!(!xdp.syn_challenge_enabled);
assert!(xdp.challenge_secret_hex.is_none());
assert_eq!(xdp.challenge_timeout_ms, 3000);
assert!(xdp.throttle_enabled);
assert!(xdp.events_enabled);
}
#[test]
fn parses_xdp_section() {
let config = Config::parse_str(
r#"
let config = Config::parse_str(
r#"
[xdp]
enabled = true
interface = "ens3"
@ -124,19 +124,19 @@ challenge_timeout_ms = 1500
throttle_enabled = false
events_enabled = false
"#,
)
.expect("[xdp] section must parse");
let xdp = &config.xdp;
assert!(xdp.enabled);
assert_eq!(xdp.interface, "ens3");
assert_eq!(xdp.protected_port_start, 25560);
assert_eq!(xdp.protected_port_end, 25600);
assert_eq!(xdp.udp_policy, "drop");
assert_eq!(xdp.udp_rate_hit_count, 250);
assert_eq!(xdp.udp_rate_window_ms, 500);
assert!(xdp.syn_challenge_enabled);
assert_eq!(xdp.challenge_secret_hex.as_deref(), Some("dead_beef_dead_beef"));
assert_eq!(xdp.challenge_timeout_ms, 1500);
assert!(!xdp.throttle_enabled);
assert!(!xdp.events_enabled);
)
.expect("[xdp] section must parse");
let xdp = &config.xdp;
assert!(xdp.enabled);
assert_eq!(xdp.interface, "ens3");
assert_eq!(xdp.protected_port_start, 25560);
assert_eq!(xdp.protected_port_end, 25600);
assert_eq!(xdp.udp_policy, "drop");
assert_eq!(xdp.udp_rate_hit_count, 250);
assert_eq!(xdp.udp_rate_window_ms, 500);
assert!(xdp.syn_challenge_enabled);
assert_eq!(xdp.challenge_secret_hex.as_deref(), Some("dead_beef_dead_beef"));
assert_eq!(xdp.challenge_timeout_ms, 1500);
assert!(!xdp.throttle_enabled);
assert!(!xdp.events_enabled);
}

View file

@ -5,52 +5,52 @@ use rampart::filter::blacklist::Blacklist;
use rampart::filter::rate_limit::RateLimiter;
fn ip(octet: u8) -> IpAddr {
IpAddr::V4(Ipv4Addr::new(192, 168, 0, octet))
IpAddr::V4(Ipv4Addr::new(192, 168, 0, octet))
}
#[test]
fn rate_limiter_allows_burst_then_blocks() {
let limiter = RateLimiter::new(1.0, 3.0);
for _ in 0..3 {
assert!(limiter.check(ip(1)), "burst tokens must be available");
}
assert!(!limiter.check(ip(1)), "exhausted bucket must block");
assert!(limiter.check(ip(2)), "other IPs are independent buckets");
let limiter = RateLimiter::new(1.0, 3.0);
for _ in 0..3 {
assert!(limiter.check(ip(1)), "burst tokens must be available");
}
assert!(!limiter.check(ip(1)), "exhausted bucket must block");
assert!(limiter.check(ip(2)), "other IPs are independent buckets");
}
#[test]
fn rate_limiter_refills_over_time() {
let limiter = RateLimiter::new(100.0, 1.0);
assert!(limiter.check(ip(3)));
assert!(!limiter.check(ip(3)));
std::thread::sleep(Duration::from_millis(30));
assert!(limiter.check(ip(3)), "tokens must refill at configured rate");
let limiter = RateLimiter::new(100.0, 1.0);
assert!(limiter.check(ip(3)));
assert!(!limiter.check(ip(3)));
std::thread::sleep(Duration::from_millis(30));
assert!(limiter.check(ip(3)), "tokens must refill at configured rate");
}
#[test]
fn rate_limiter_buckets_are_independent() {
let limiter = RateLimiter::new(1.0, 1.0);
assert!(limiter.check(ip(4)));
assert!(!limiter.check(ip(4)));
assert!(limiter.check(ip(5)), "other IPs are independent buckets");
let limiter = RateLimiter::new(1.0, 1.0);
assert!(limiter.check(ip(4)));
assert!(!limiter.check(ip(4)));
assert!(limiter.check(ip(5)), "other IPs are independent buckets");
}
#[test]
fn blacklist_blocks_until_ttl_expires() {
let blacklist = Blacklist::new();
blacklist.add(ip(6), Duration::from_millis(30), "test");
let blacklist = Blacklist::new();
blacklist.add(ip(6), Duration::from_millis(30), "test");
assert!(blacklist.is_blocked(ip(6)), "fresh ban must block");
assert_eq!(blacklist.len(), 1);
std::thread::sleep(Duration::from_millis(40));
assert!(!blacklist.is_blocked(ip(6)), "expired ban must not block");
assert!(blacklist.is_empty(), "expired entry must be dropped on check");
assert!(blacklist.is_blocked(ip(6)), "fresh ban must block");
assert_eq!(blacklist.len(), 1);
std::thread::sleep(Duration::from_millis(40));
assert!(!blacklist.is_blocked(ip(6)), "expired ban must not block");
assert!(blacklist.is_empty(), "expired entry must be dropped on check");
}
#[test]
fn blacklist_remove_clears_ban() {
let blacklist = Blacklist::new();
blacklist.add(ip(7), Duration::from_secs(60), "test");
blacklist.remove(ip(7));
assert!(!blacklist.is_blocked(ip(7)));
let blacklist = Blacklist::new();
blacklist.add(ip(7), Duration::from_secs(60), "test");
blacklist.remove(ip(7));
assert!(!blacklist.is_blocked(ip(7)));
}

View file

@ -9,123 +9,123 @@ use tokio::net::{TcpListener, TcpStream};
const REQUEST: &[u8] = b"GET /index.html HTTP/1.1\r\nHost: example.com\r\n\r\n";
fn handler() -> HttpProtocolHandler {
HttpProtocolHandler::new(&HttpProtocolConfig::default(), &["127.0.0.1:9000".to_string()])
HttpProtocolHandler::new(&HttpProtocolConfig::default(), &["127.0.0.1:9000".to_string()])
}
async fn socket_pair() -> (TcpStream, TcpStream) {
let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
let addr = listener.local_addr().expect("local addr");
let client = TcpStream::connect(addr).await.expect("connect");
let (server, _) = listener.accept().await.expect("accept");
(client, server)
let listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
let addr = listener.local_addr().expect("local addr");
let client = TcpStream::connect(addr).await.expect("connect");
let (server, _) = listener.accept().await.expect("accept");
(client, server)
}
#[tokio::test]
async fn valid_request_is_allowed() {
let (mut client, mut server) = socket_pair().await;
client.write_all(REQUEST).await.expect("write");
assert!(handler().handshake(&mut server).await.is_ok());
let (mut client, mut server) = socket_pair().await;
client.write_all(REQUEST).await.expect("write");
assert!(handler().handshake(&mut server).await.is_ok());
}
#[tokio::test]
async fn fragmented_head_is_accumulated_and_parsed() {
let (mut client, mut server) = socket_pair().await;
for chunk in REQUEST.chunks(7) {
client.write_all(chunk).await.expect("write chunk");
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
assert!(handler().handshake(&mut server).await.is_ok());
let (mut client, mut server) = socket_pair().await;
for chunk in REQUEST.chunks(7) {
client.write_all(chunk).await.expect("write chunk");
tokio::time::sleep(std::time::Duration::from_millis(10)).await;
}
assert!(handler().handshake(&mut server).await.is_ok());
}
#[tokio::test]
async fn oversized_head_is_rejected() {
let config = HttpProtocolConfig {
max_header_bytes: 32,
..HttpProtocolConfig::default()
};
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"GET / HTTP/1.1\r\nHost: a-very-long-host-name-value\r\n")
.await
.expect("write");
let err = handler_with(&config)
.handshake(&mut server)
.await
.expect_err("oversized head must be rejected");
assert!(err.to_string().contains("exceeds"));
let config = HttpProtocolConfig {
max_header_bytes: 32,
..HttpProtocolConfig::default()
};
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"GET / HTTP/1.1\r\nHost: a-very-long-host-name-value\r\n")
.await
.expect("write");
let err = handler_with(&config)
.handshake(&mut server)
.await
.expect_err("oversized head must be rejected");
assert!(err.to_string().contains("exceeds"));
}
#[tokio::test]
async fn unknown_method_is_rejected() {
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"TRACE / HTTP/1.1\r\nHost: h\r\n\r\n")
.await
.expect("write");
let err = handler()
.handshake(&mut server)
.await
.expect_err("unknown method must be rejected");
assert!(err.to_string().contains("method"));
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"TRACE / HTTP/1.1\r\nHost: h\r\n\r\n")
.await
.expect("write");
let err = handler()
.handshake(&mut server)
.await
.expect_err("unknown method must be rejected");
assert!(err.to_string().contains("method"));
}
#[tokio::test]
async fn missing_host_is_rejected() {
let (mut client, mut server) = socket_pair().await;
client.write_all(b"GET / HTTP/1.1\r\n\r\n").await.expect("write");
let err = handler()
.handshake(&mut server)
.await
.expect_err("missing host must be rejected");
assert!(err.to_string().contains("host"));
let (mut client, mut server) = socket_pair().await;
client.write_all(b"GET / HTTP/1.1\r\n\r\n").await.expect("write");
let err = handler()
.handshake(&mut server)
.await
.expect_err("missing host must be rejected");
assert!(err.to_string().contains("host"));
}
#[tokio::test]
async fn blocked_path_is_rejected() {
let config = HttpProtocolConfig {
blocked_paths: vec!["/admin".to_string()],
..HttpProtocolConfig::default()
};
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"GET /admin/secrets HTTP/1.1\r\nHost: h\r\n\r\n")
.await
.expect("write");
let err = handler_with(&config)
.handshake(&mut server)
.await
.expect_err("blocked path must be rejected");
assert!(err.to_string().contains("blocklisted"));
let config = HttpProtocolConfig {
blocked_paths: vec!["/admin".to_string()],
..HttpProtocolConfig::default()
};
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"GET /admin/secrets HTTP/1.1\r\nHost: h\r\n\r\n")
.await
.expect("write");
let err = handler_with(&config)
.handshake(&mut server)
.await
.expect_err("blocked path must be rejected");
assert!(err.to_string().contains("blocklisted"));
}
#[tokio::test]
async fn required_user_agent_missing_is_rejected() {
let config = HttpProtocolConfig {
require_user_agent: true,
..HttpProtocolConfig::default()
};
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"GET / HTTP/1.1\r\nHost: h\r\n\r\n")
.await
.expect("write");
let err = handler_with(&config)
.handshake(&mut server)
.await
.expect_err("missing user-agent must be rejected");
assert!(err.to_string().contains("user-agent"));
let config = HttpProtocolConfig {
require_user_agent: true,
..HttpProtocolConfig::default()
};
let (mut client, mut server) = socket_pair().await;
client
.write_all(b"GET / HTTP/1.1\r\nHost: h\r\n\r\n")
.await
.expect("write");
let err = handler_with(&config)
.handshake(&mut server)
.await
.expect_err("missing user-agent must be rejected");
assert!(err.to_string().contains("user-agent"));
}
#[tokio::test]
async fn registry_resolves_http_handler_when_feature_enabled() {
let mut registry = ProtocolRegistry::new();
registry.register(Box::new(handler()));
assert_eq!(registry.names(), vec!["http"]);
let resolved = registry.get("http").expect("http handler must resolve");
assert_eq!(resolved.name(), "http");
assert!(registry.primary().is_ok());
let mut registry = ProtocolRegistry::new();
registry.register(Box::new(handler()));
assert_eq!(registry.names(), vec!["http"]);
let resolved = registry.get("http").expect("http handler must resolve");
assert_eq!(resolved.name(), "http");
assert!(registry.primary().is_ok());
}
fn handler_with(config: &HttpProtocolConfig) -> HttpProtocolHandler {
HttpProtocolHandler::new(config, &["127.0.0.1:9000".to_string()])
HttpProtocolHandler::new(config, &["127.0.0.1:9000".to_string()])
}

View file

@ -8,17 +8,17 @@ const FIXED_TOKEN: [u8; 32] = *b"rampart-pow-fixed-token-test-v1!";
#[test]
fn solver_output_passes_verifier() {
let mut challenge = Challenge::generate(3);
let nonce = solve(&challenge.challenge_string(), 3).expect("solver must find nonce for difficulty 3");
assert!(challenge.verify(&nonce));
let mut challenge = Challenge::generate(3);
let nonce = solve(&challenge.challenge_string(), 3).expect("solver must find nonce for difficulty 3");
assert!(challenge.verify(&nonce));
}
#[test]
fn verifier_rejects_garbage_and_replay() {
let mut challenge = Challenge::with_token(FIXED_TOKEN, 2);
assert!(!challenge.verify("garbage"));
let mut challenge = Challenge::with_token(FIXED_TOKEN, 2);
assert!(!challenge.verify("garbage"));
let nonce = solve(&challenge.challenge_string(), 2).expect("solved");
assert!(challenge.verify(&nonce), "first use passes");
assert!(!challenge.verify(&nonce), "replay is rejected");
let nonce = solve(&challenge.challenge_string(), 2).expect("solved");
assert!(challenge.verify(&nonce), "first use passes");
assert!(!challenge.verify(&nonce), "replay is rejected");
}

View file

@ -7,32 +7,32 @@ use tokio::net::TcpStream;
struct NoopHandler;
impl ProtocolHandler for NoopHandler {
fn name(&self) -> &'static str {
"noop"
}
fn name(&self) -> &'static str {
"noop"
}
fn handshake<'a>(
&'a self,
_stream: &'a mut TcpStream,
) -> Pin<Box<dyn Future<Output = anyhow::Result<HandshakeResult>> + Send + 'a>> {
Box::pin(async { Ok(HandshakeResult::new(Upstream::new("127.0.0.1:9000"))) })
}
fn handshake<'a>(
&'a self,
_stream: &'a mut TcpStream,
) -> Pin<Box<dyn Future<Output = anyhow::Result<HandshakeResult>> + Send + 'a>> {
Box::pin(async { Ok(HandshakeResult::new(Upstream::new("127.0.0.1:9000"))) })
}
}
#[tokio::test]
async fn empty_registry_reports_missing_protocols() {
let registry = ProtocolRegistry::new();
assert!(registry.is_empty());
let err = registry.primary().err().expect("empty registry must fail fast");
assert!(err.to_string().contains("no protocol plugins compiled"));
let registry = ProtocolRegistry::new();
assert!(registry.is_empty());
let err = registry.primary().err().expect("empty registry must fail fast");
assert!(err.to_string().contains("no protocol plugins compiled"));
}
#[tokio::test]
async fn registered_handler_resolves_by_name() {
let mut registry = ProtocolRegistry::new();
registry.register(Box::new(NoopHandler));
let mut registry = ProtocolRegistry::new();
registry.register(Box::new(NoopHandler));
assert_eq!(registry.names(), vec!["noop"]);
let handler = registry.primary().expect("registered handler must resolve");
assert_eq!(handler.name(), "noop");
assert_eq!(registry.names(), vec!["noop"]);
let handler = registry.primary().expect("registered handler must resolve");
assert_eq!(handler.name(), "noop");
}

View file

@ -3,213 +3,213 @@
use rampart::config::Config;
use rampart::engine::subnet_tracker::SubnetTracker;
use rampart::traffic::prefix::{
PrefixKey, PrefixSnapshot, PrefixStatsSource, PrefixStatsVal, SubnetDetector, SubnetVerdict, prefix_of,
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))
IpAddr::V4(Ipv4Addr::from(octets))
}
/// Фиксированный источник снапшотов — имитирует XDP-карту без ядра.
struct FixedSource(Vec<(IpAddr, PrefixSnapshot)>);
impl PrefixStatsSource for FixedSource {
async fn snapshot(&self) -> anyhow::Result<Vec<(IpAddr, PrefixSnapshot)>> {
Ok(self.0.clone())
}
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 уникальных источников из одного /24 — распределённая атака
// (6 SYN от каждого: 240 >= 4 × 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 tracker = SubnetTracker::new();
// 40 уникальных источников из одного /24 — распределённая атака
// (6 SYN от каждого: 240 >= 4 × 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);
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);
// Полный конвейер через трейт-источник (как в бинарнике).
let source_snaps = FixedSource(snaps).snapshot().await.expect("source snapshot");
assert_eq!(detector.evaluate(&source_snaps)[0].verdict, SubnetVerdict::Block);
// Полный конвейер через трейт-источник (как в бинарнике).
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 SYN всего из 3 адресов — всплеск, но не распределённый.
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);
let tracker = SubnetTracker::new();
// 500 SYN всего из 3 адресов — всплеск, но не распределённый.
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 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);
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])
);
// ::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#"
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);
)
.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
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]));
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"))
);
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]));
// ::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);
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")))
);
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);
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);
// Много SYN из одного источника (или неизвестное разнообразие) → нет 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);
let detector = SubnetDetector::new(100, 16);
// Много SYN из одного источника (или неизвестное разнообразие) → нет 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);
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);
}

View file

@ -12,101 +12,101 @@ use std::sync::Arc;
use std::time::Duration;
fn ip(octets: [u8; 4]) -> IpAddr {
IpAddr::V4(Ipv4Addr::from(octets))
IpAddr::V4(Ipv4Addr::from(octets))
}
fn autoban_cfg(enabled: bool) -> DetectAutobanConfig {
DetectAutobanConfig {
enabled,
reputation_threshold: -50,
}
DetectAutobanConfig {
enabled,
reputation_threshold: -50,
}
}
#[test]
fn reputation_fall_after_drops_triggers_autoban() {
let reputation = Arc::new(IpReputation::new());
let blacklist = Arc::new(Blacklist::new());
let hook = TrafficHook::new(Arc::clone(&reputation), Arc::clone(&blacklist), autoban_cfg(true), 60);
let attacker = ip([198, 51, 100, 7]);
let reputation = Arc::new(IpReputation::new());
let blacklist = Arc::new(Blacklist::new());
let hook = TrafficHook::new(Arc::clone(&reputation), Arc::clone(&blacklist), autoban_cfg(true), 60);
let attacker = ip([198, 51, 100, 7]);
for _ in 0..6 {
// Шесть дропов rate-limit'ом: -10 за каждый, порог auto-ban = -50.
reputation.record_bad(attacker);
hook.on_connection_end(attacker);
}
for _ in 0..6 {
// Шесть дропов rate-limit'ом: -10 за каждый, порог auto-ban = -50.
reputation.record_bad(attacker);
hook.on_connection_end(attacker);
}
assert!(
reputation.score(attacker) <= -50,
"reputation must fall below threshold"
);
assert!(
blacklist.is_blocked(attacker),
"auto-ban must fire after repeated drops"
);
assert!(
reputation.score(attacker) <= -50,
"reputation must fall below threshold"
);
assert!(
blacklist.is_blocked(attacker),
"auto-ban must fire after repeated drops"
);
}
#[test]
fn autoban_ttl_expires_ban() {
let reputation = Arc::new(IpReputation::new());
let blacklist = Arc::new(Blacklist::new());
let hook = TrafficHook::new(
Arc::clone(&reputation),
Arc::clone(&blacklist),
autoban_cfg(true),
// Короткий TTL из «конфига» как мок времени.
0,
);
let attacker = ip([198, 51, 100, 8]);
for _ in 0..20 {
reputation.record_bad(attacker);
}
hook.on_connection_end(attacker);
std::thread::sleep(Duration::from_millis(5));
assert!(
!blacklist.is_blocked(attacker),
"zero TTL must not produce an active ban"
);
let reputation = Arc::new(IpReputation::new());
let blacklist = Arc::new(Blacklist::new());
let hook = TrafficHook::new(
Arc::clone(&reputation),
Arc::clone(&blacklist),
autoban_cfg(true),
// Короткий TTL из «конфига» как мок времени.
0,
);
let attacker = ip([198, 51, 100, 8]);
for _ in 0..20 {
reputation.record_bad(attacker);
}
hook.on_connection_end(attacker);
std::thread::sleep(Duration::from_millis(5));
assert!(
!blacklist.is_blocked(attacker),
"zero TTL must not produce an active ban"
);
}
#[test]
fn detector_flags_synthetic_traffic_spike() {
let mut detector = AttackDetector::new();
let mut detector = AttackDetector::new();
// Базовая линия: тихий профиль.
for _ in 0..12 {
detector.analyze(500.0, 50.0);
}
// Базовая линия: тихий профиль.
for _ in 0..12 {
detector.analyze(500.0, 50.0);
}
// Синтетический всплеск: x200 pps и cps три окна подряд.
assert_eq!(
detector.analyze(100_000.0, 10_000.0),
AttackStatus::Suspicious,
"first anomalous window is suspicious"
);
assert_eq!(detector.analyze(100_000.0, 10_000.0), AttackStatus::Suspicious);
assert_eq!(
detector.analyze(100_000.0, 10_000.0),
AttackStatus::UnderAttack,
"three anomalous windows in a row must escalate to UnderAttack"
);
// Синтетический всплеск: x200 pps и cps три окна подряд.
assert_eq!(
detector.analyze(100_000.0, 10_000.0),
AttackStatus::Suspicious,
"first anomalous window is suspicious"
);
assert_eq!(detector.analyze(100_000.0, 10_000.0), AttackStatus::Suspicious);
assert_eq!(
detector.analyze(100_000.0, 10_000.0),
AttackStatus::UnderAttack,
"three anomalous windows in a row must escalate to UnderAttack"
);
}
#[test]
fn alerts_fire_only_on_state_transitions() {
let dispatcher = AlertDispatcher::new();
let sequence = [
AttackStatus::Normal,
AttackStatus::Normal,
AttackStatus::Suspicious,
AttackStatus::UnderAttack,
AttackStatus::UnderAttack,
AttackStatus::UnderAttack,
AttackStatus::Suspicious,
AttackStatus::Normal,
AttackStatus::Normal,
];
let alerts: Vec<_> = sequence.iter().filter_map(|s| dispatcher.on_status(*s)).collect();
assert_eq!(alerts.len(), 2, "two transitions must yield exactly two alerts");
assert!(alerts[0].message.contains("attack started"));
assert!(alerts[1].message.contains("attack ended"));
let dispatcher = AlertDispatcher::new();
let sequence = [
AttackStatus::Normal,
AttackStatus::Normal,
AttackStatus::Suspicious,
AttackStatus::UnderAttack,
AttackStatus::UnderAttack,
AttackStatus::UnderAttack,
AttackStatus::Suspicious,
AttackStatus::Normal,
AttackStatus::Normal,
];
let alerts: Vec<_> = sequence.iter().filter_map(|s| dispatcher.on_status(*s)).collect();
assert_eq!(alerts.len(), 2, "two transitions must yield exactly two alerts");
assert!(alerts[0].message.contains("attack started"));
assert!(alerts[1].message.contains("attack ended"));
}

View file

@ -9,151 +9,151 @@ use rampart::tui::state::{AppState, counter_rate};
#[test]
fn parses_metric_with_labels_value_and_timestamp() {
let set = parse("rampart_xdp_total{iface=\"eth0\",core=\"0\"} 123 1700000000000\n");
assert_eq!(
set.samples(),
vec![MetricSample {
name: "rampart_xdp_total".to_owned(),
labels: [("iface", "eth0"), ("core", "0")]
.iter()
.map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
.collect(),
value: 123.0,
}]
);
let set = parse("rampart_xdp_total{iface=\"eth0\",core=\"0\"} 123 1700000000000\n");
assert_eq!(
set.samples(),
vec![MetricSample {
name: "rampart_xdp_total".to_owned(),
labels: [("iface", "eth0"), ("core", "0")]
.iter()
.map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
.collect(),
value: 123.0,
}]
);
}
#[test]
fn parser_skips_comments_help_and_type() {
let body = "\
let body = "\
# HELP rampart_xdp_dropped Packets dropped\n\
# TYPE rampart_xdp_dropped gauge\n\
# обычный комментарий\n\
rampart_xdp_dropped 42\n";
let set = parse(body);
assert_eq!(set.samples().len(), 1);
assert_eq!(set.sum("rampart_xdp_dropped"), 42.0);
let set = parse(body);
assert_eq!(set.samples().len(), 1);
assert_eq!(set.sum("rampart_xdp_dropped"), 42.0);
}
#[test]
fn parser_sums_counter_vec_series() {
let body = "rampart_auto_bans_total{reason=\"cps\"} 3\nrampart_auto_bans_total{reason=\"syn\"} 4\n";
assert_eq!(parse(body).sum("rampart_auto_bans_total"), 7.0);
let body = "rampart_auto_bans_total{reason=\"cps\"} 3\nrampart_auto_bans_total{reason=\"syn\"} 4\n";
assert_eq!(parse(body).sum("rampart_auto_bans_total"), 7.0);
}
#[test]
fn parser_missing_metric_is_zero() {
assert_eq!(parse("# nothing here\n").sum("rampart_xdp_tcp"), 0.0);
assert_eq!(parse("# nothing here\n").sum("rampart_xdp_tcp"), 0.0);
}
#[test]
fn parser_tolerates_malformed_lines() {
let set = parse("garbage\nm{unterminated=\"v} 1\nok_metric 5\n");
assert_eq!(set.sum("ok_metric"), 5.0);
assert_eq!(set.samples().len(), 1);
let set = parse("garbage\nm{unterminated=\"v} 1\nok_metric 5\n");
assert_eq!(set.sum("ok_metric"), 5.0);
assert_eq!(set.samples().len(), 1);
}
// ---------- rate ----------
#[test]
fn rate_from_two_samples_divides_by_elapsed() {
// 1200 - 1100 = 100 пакетов за 2 сек
assert_eq!(counter_rate(Some(1100.0), Some(1200.0), 2.0), 50.0);
// 1200 - 1100 = 100 пакетов за 2 сек
assert_eq!(counter_rate(Some(1100.0), Some(1200.0), 2.0), 50.0);
}
#[test]
fn rate_first_sample_and_counter_reset_are_zero() {
assert_eq!(counter_rate(None, Some(10.0), 1.0), 0.0);
assert_eq!(counter_rate(Some(20.0), Some(10.0), 1.0), 0.0);
assert_eq!(counter_rate(Some(10.0), Some(12.0), 0.0), 0.0);
assert_eq!(counter_rate(None, Some(10.0), 1.0), 0.0);
assert_eq!(counter_rate(Some(20.0), Some(10.0), 1.0), 0.0);
assert_eq!(counter_rate(Some(10.0), Some(12.0), 0.0), 0.0);
}
#[test]
fn state_accumulates_history_rates() {
let state = AppState::new("http://test/metrics");
state.apply_fetch(Ok(parse("rampart_xdp_total 100\n")), 1.0);
state.apply_fetch(Ok(parse("rampart_xdp_total 150\n")), 1.0);
let frame = state.frame_data();
assert_eq!(frame.history.points().len(), 2);
assert_eq!(frame.history.points()[1].packets_per_sec, 50.0);
assert!(frame.snapshot.error.is_none());
let state = AppState::new("http://test/metrics");
state.apply_fetch(Ok(parse("rampart_xdp_total 100\n")), 1.0);
state.apply_fetch(Ok(parse("rampart_xdp_total 150\n")), 1.0);
let frame = state.frame_data();
assert_eq!(frame.history.points().len(), 2);
assert_eq!(frame.history.points()[1].packets_per_sec, 50.0);
assert!(frame.snapshot.error.is_none());
}
// ---------- ошибки fetch (мок Fetcher + локальный HTTP-сервер) ----------
struct FailingFetcher {
error: FetchError,
error: FetchError,
}
impl Fetcher for FailingFetcher {
fn fetch(&self) -> BoxFuture<'_, Result<String, FetchError>> {
let error = self.error.clone();
Box::pin(async { Err(error) })
}
fn fetch(&self) -> BoxFuture<'_, Result<String, FetchError>> {
let error = self.error.clone();
Box::pin(async { Err(error) })
}
}
#[test]
fn network_error_sets_error_banner_not_panic() {
let state = AppState::new("http://127.0.0.1:9/metrics");
let fetcher = FailingFetcher {
error: FetchError::Network("connection refused".to_owned()),
};
let state = AppState::new("http://127.0.0.1:9/metrics");
let fetcher = FailingFetcher {
error: FetchError::Network("connection refused".to_owned()),
};
// Тот же путь, что и в spawn_fetch_loop: normalize → apply_fetch.
let normalized = rampart::tui::app::normalize(Err(fetcher.error));
assert!(normalized.is_err());
let message = match normalized {
Err(message) => message,
Ok(_) => return,
};
// Тот же путь, что и в spawn_fetch_loop: normalize → apply_fetch.
let normalized = rampart::tui::app::normalize(Err(fetcher.error));
assert!(normalized.is_err());
let message = match normalized {
Err(message) => message,
Ok(_) => return,
};
state.apply_fetch(Err(message), 1.0);
assert_eq!(state.frame_data().snapshot.error.as_deref(), Some("connection refused"));
state.apply_fetch(Err(message), 1.0);
assert_eq!(state.frame_data().snapshot.error.as_deref(), Some("connection refused"));
}
#[tokio::test]
async fn http_fetcher_reads_prometheus_body_from_local_server() {
let Ok(listener) = tokio::net::TcpListener::bind("127.0.0.1:0").await else {
return;
};
let Ok(addr) = listener.local_addr() else {
return;
};
let server = tokio::spawn(async move {
use tokio::io::AsyncWriteExt;
if let Ok((mut stream, _)) = listener.accept().await {
let body = "rampart_xdp_total 99\n";
let head = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
let _ = stream.write_all(head.as_bytes()).await;
let _ = stream.write_all(body.as_bytes()).await;
}
});
let Ok(listener) = tokio::net::TcpListener::bind("127.0.0.1:0").await else {
return;
};
let Ok(addr) = listener.local_addr() else {
return;
};
let server = tokio::spawn(async move {
use tokio::io::AsyncWriteExt;
if let Ok((mut stream, _)) = listener.accept().await {
let body = "rampart_xdp_total 99\n";
let head = format!(
"HTTP/1.1 200 OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
body.len()
);
let _ = stream.write_all(head.as_bytes()).await;
let _ = stream.write_all(body.as_bytes()).await;
}
});
let Some(fetcher) = HttpFetcher::new(format!("http://{addr}/metrics")) else {
server.abort();
return;
};
let Ok(body) = fetcher.fetch().await else {
server.abort();
return;
};
assert_eq!(parse(&body).sum("rampart_xdp_total"), 99.0);
server.abort();
let Some(fetcher) = HttpFetcher::new(format!("http://{addr}/metrics")) else {
server.abort();
return;
};
let Ok(body) = fetcher.fetch().await else {
server.abort();
return;
};
assert_eq!(parse(&body).sum("rampart_xdp_total"), 99.0);
server.abort();
}
#[test]
fn failed_fetch_keeps_last_good_metrics_but_reports_error() {
let state = AppState::new("http://test/metrics");
state.apply_fetch(Ok(parse("rampart_xdp_total 7\n")), 1.0);
state.apply_fetch(Err("connection refused".to_owned()), 1.0);
let state = AppState::new("http://test/metrics");
state.apply_fetch(Ok(parse("rampart_xdp_total 7\n")), 1.0);
state.apply_fetch(Err("connection refused".to_owned()), 1.0);
let frame = state.frame_data();
assert_eq!(frame.snapshot.error.as_deref(), Some("connection refused"));
assert_eq!(
frame.snapshot.metrics.as_ref().map(|m| m.sum("rampart_xdp_total")),
Some(7.0)
);
let frame = state.frame_data();
assert_eq!(frame.snapshot.error.as_deref(), Some("connection refused"));
assert_eq!(
frame.snapshot.metrics.as_ref().map(|m| m.sum("rampart_xdp_total")),
Some(7.0)
);
}

View file

@ -2,133 +2,133 @@ use rampart::xdp::{AttachMode, EnvironmentReport, KernelVersion, MIN_KERNEL, Sys
use std::collections::HashMap;
struct MockProbe {
files: HashMap<String, String>,
symlinks: HashMap<String, String>,
uid: u32,
files: HashMap<String, String>,
symlinks: HashMap<String, String>,
uid: u32,
}
impl MockProbe {
fn linux(driver: &str, release: &str) -> Self {
let mut files = HashMap::new();
files.insert("/proc/sys/kernel/osrelease".to_owned(), format!("{release}\n"));
files.insert("/sys/kernel/btf/vmlinux".to_owned(), String::new());
files.insert("/proc/self/status".to_owned(), "Uid:\t0\t0\t0\t0\n".to_owned());
let mut symlinks = HashMap::new();
if !driver.is_empty() {
symlinks.insert(
"/sys/class/net/eth0/device/driver".to_owned(),
format!("/sys/bus/pci/drivers/{driver}"),
);
}
Self {
files,
symlinks,
uid: 0,
}
}
fn linux(driver: &str, release: &str) -> Self {
let mut files = HashMap::new();
files.insert("/proc/sys/kernel/osrelease".to_owned(), format!("{release}\n"));
files.insert("/sys/kernel/btf/vmlinux".to_owned(), String::new());
files.insert("/proc/self/status".to_owned(), "Uid:\t0\t0\t0\t0\n".to_owned());
let mut symlinks = HashMap::new();
if !driver.is_empty() {
symlinks.insert(
"/sys/class/net/eth0/device/driver".to_owned(),
format!("/sys/bus/pci/drivers/{driver}"),
);
}
Self {
files,
symlinks,
uid: 0,
}
}
fn collect(&self) -> EnvironmentReport {
EnvironmentReport::collect(self, "eth0")
}
fn collect(&self) -> EnvironmentReport {
EnvironmentReport::collect(self, "eth0")
}
}
impl SystemProbe for MockProbe {
fn read_file(&self, path: &str) -> std::io::Result<String> {
self.files
.get(path)
.cloned()
.ok_or_else(|| std::io::Error::other("file not found"))
}
fn read_file(&self, path: &str) -> std::io::Result<String> {
self.files
.get(path)
.cloned()
.ok_or_else(|| std::io::Error::other("file not found"))
}
fn path_exists(&self, path: &str) -> bool {
self.files.contains_key(path) || self.symlinks.contains_key(path)
}
fn path_exists(&self, path: &str) -> bool {
self.files.contains_key(path) || self.symlinks.contains_key(path)
}
fn symlink_target(&self, path: &str) -> Option<String> {
self.symlinks.get(path).cloned()
}
fn symlink_target(&self, path: &str) -> Option<String> {
self.symlinks.get(path).cloned()
}
fn effective_uid(&self) -> u32 {
self.uid
}
fn effective_uid(&self) -> u32 {
self.uid
}
}
#[test]
fn parses_kernel_release_with_distro_suffixes() {
assert_eq!(
KernelVersion::parse("6.8.0-45-generic"),
Some(KernelVersion::new(6, 8, 0))
);
assert_eq!(KernelVersion::parse("5.15.0"), Some(KernelVersion::new(5, 15, 0)));
assert_eq!(KernelVersion::parse("6.12"), Some(KernelVersion::new(6, 12, 0)));
assert_eq!(KernelVersion::parse(""), None);
assert_eq!(KernelVersion::parse("generic"), None);
assert_eq!(
KernelVersion::parse("6.8.0-45-generic"),
Some(KernelVersion::new(6, 8, 0))
);
assert_eq!(KernelVersion::parse("5.15.0"), Some(KernelVersion::new(5, 15, 0)));
assert_eq!(KernelVersion::parse("6.12"), Some(KernelVersion::new(6, 12, 0)));
assert_eq!(KernelVersion::parse(""), None);
assert_eq!(KernelVersion::parse("generic"), None);
}
#[test]
fn selects_attach_mode_by_driver_table() {
let virtio = MockProbe::linux("virtio_net", "6.8.0-45-generic").collect();
assert_eq!(virtio.attach_mode(), AttachMode::Native);
let virtio = MockProbe::linux("virtio_net", "6.8.0-45-generic").collect();
assert_eq!(virtio.attach_mode(), AttachMode::Native);
let realtek = MockProbe::linux("r8169", "6.8.0-45-generic").collect();
assert_eq!(realtek.attach_mode(), AttachMode::Generic);
let realtek = MockProbe::linux("r8169", "6.8.0-45-generic").collect();
assert_eq!(realtek.attach_mode(), AttachMode::Generic);
}
#[test]
fn unknown_driver_falls_back_to_generic() {
assert!(!driver_supports_native_xdp("r8169"));
assert!(driver_supports_native_xdp("mlx5_core"));
assert!(!driver_supports_native_xdp("r8169"));
assert!(driver_supports_native_xdp("mlx5_core"));
let no_driver = MockProbe::linux("", "6.1.0").collect();
assert_eq!(no_driver.driver_name, None);
assert_eq!(no_driver.attach_mode(), rampart::xdp::AttachMode::Generic);
let no_driver = MockProbe::linux("", "6.1.0").collect();
assert_eq!(no_driver.driver_name, None);
assert_eq!(no_driver.attach_mode(), rampart::xdp::AttachMode::Generic);
}
#[test]
fn verdict_explains_generic_cpu_cost() {
let report = MockProbe::linux("r8169", "6.8.0-45-generic").collect();
let verdict = report.verdict();
assert!(verdict.contains("r8169"), "verdict must name the driver: {verdict}");
assert!(
verdict.contains("generic mode"),
"verdict must mention generic: {verdict}"
);
assert!(verdict.contains("CPU"), "verdict must explain CPU cost: {verdict}");
let report = MockProbe::linux("r8169", "6.8.0-45-generic").collect();
let verdict = report.verdict();
assert!(verdict.contains("r8169"), "verdict must name the driver: {verdict}");
assert!(
verdict.contains("generic mode"),
"verdict must mention generic: {verdict}"
);
assert!(verdict.contains("CPU"), "verdict must explain CPU cost: {verdict}");
let native = MockProbe::linux("ixgbe", "6.1.0").collect();
assert!(native.verdict().contains("native XDP"));
let native = MockProbe::linux("ixgbe", "6.1.0").collect();
assert!(native.verdict().contains("native XDP"));
}
#[test]
fn fails_fast_on_kernel_below_minimum() {
let old = MockProbe::linux("virtio_net", "5.10.0-rc6");
let err = old.collect().validate().expect_err("kernel 5.10 must be rejected");
assert!(err.to_string().contains("5.10"));
let old = MockProbe::linux("virtio_net", "5.10.0-rc6");
let err = old.collect().validate().expect_err("kernel 5.10 must be rejected");
assert!(err.to_string().contains("5.10"));
let mut unknown = MockProbe::linux("virtio_net", "6.8.0");
unknown.files.remove("/proc/sys/kernel/osrelease");
assert!(unknown.collect().validate().is_err(), "unknown kernel must be rejected");
let mut unknown = MockProbe::linux("virtio_net", "6.8.0");
unknown.files.remove("/proc/sys/kernel/osrelease");
assert!(unknown.collect().validate().is_err(), "unknown kernel must be rejected");
}
#[test]
fn accepts_supported_kernels() {
assert!(MIN_KERNEL == KernelVersion::new(5, 15, 0));
for release in ["5.15.0", "6.1.0-13-amd64", "6.12.8"] {
let report = MockProbe::linux("virtio_net", release).collect();
report.validate().expect("supported kernel must pass validation");
}
assert!(MIN_KERNEL == KernelVersion::new(5, 15, 0));
for release in ["5.15.0", "6.1.0-13-amd64", "6.12.8"] {
let report = MockProbe::linux("virtio_net", release).collect();
report.validate().expect("supported kernel must pass validation");
}
}
#[test]
fn warns_when_not_privileged_and_btf_missing() {
let mut probe = MockProbe::linux("virtio_net", "6.8.0");
probe.uid = 1000;
probe.files.remove("/sys/kernel/btf/vmlinux");
let mut probe = MockProbe::linux("virtio_net", "6.8.0");
probe.uid = 1000;
probe.files.remove("/sys/kernel/btf/vmlinux");
let report = probe.collect();
assert!(!report.privileged);
assert!(!report.btf_available);
let joined = report.warnings.join("\n");
assert!(joined.contains("CAP_BPF"), "must warn about capabilities: {joined}");
assert!(joined.contains("CO-RE"), "must warn about missing BTF: {joined}");
let report = probe.collect();
assert!(!report.privileged);
assert!(!report.btf_available);
let joined = report.warnings.join("\n");
assert!(joined.contains("CAP_BPF"), "must warn about capabilities: {joined}");
assert!(joined.contains("CO-RE"), "must warn about missing BTF: {joined}");
}

View file

@ -11,163 +11,163 @@ const IP: [u8; 4] = [203, 0, 113, 7];
/// Собирает кадр ровно как ядро (`push_event`, common.h:87-97): скаляры — native
/// (host) order, `src_ip` — сетевой порядок октетов (raw из заголовка пакета).
fn frame(kind: u32, octets: [u8; 4], metadata: u32, ts: u64) -> [u8; XDP_EVENT_LEN] {
let mut b = [0u8; XDP_EVENT_LEN];
b[0..4].copy_from_slice(&kind.to_ne_bytes());
b[4..8].copy_from_slice(&octets);
b[8..12].copy_from_slice(&metadata.to_ne_bytes());
// b[12..16] — выравнивающий padding под __u64: ядро его не инициализирует.
b[16..24].copy_from_slice(&ts.to_ne_bytes());
b
let mut b = [0u8; XDP_EVENT_LEN];
b[0..4].copy_from_slice(&kind.to_ne_bytes());
b[4..8].copy_from_slice(&octets);
b[8..12].copy_from_slice(&metadata.to_ne_bytes());
// b[12..16] — выравнивающий padding под __u64: ядро его не инициализирует.
b[16..24].copy_from_slice(&ts.to_ne_bytes());
b
}
#[test]
fn struct_size_is_24_bytes() {
// Раскладка common.h: __u32×3 + pad(4) + __u64 = 24, НЕ 16 как парсил код ранее.
assert_eq!(XDP_EVENT_LEN, 24);
// Раскладка common.h: __u32×3 + pad(4) + __u64 = 24, НЕ 16 как парсил код ранее.
assert_eq!(XDP_EVENT_LEN, 24);
}
#[test]
fn round_trip_recovers_all_fields() {
let ev = parse_xdp_event(&frame(1, IP, 100, 0xDEAD_BEEF)).expect("valid frame parses");
assert_eq!(ev.kind, XdpEventKind::RateLimit);
assert_eq!(ev.src_ip, Ipv4Addr::new(203, 0, 113, 7));
assert_eq!(ev.metadata, 100);
assert_eq!(ev.timestamp_ns, 0xDEAD_BEEF);
let ev = parse_xdp_event(&frame(1, IP, 100, 0xDEAD_BEEF)).expect("valid frame parses");
assert_eq!(ev.kind, XdpEventKind::RateLimit);
assert_eq!(ev.src_ip, Ipv4Addr::new(203, 0, 113, 7));
assert_eq!(ev.metadata, 100);
assert_eq!(ev.timestamp_ns, 0xDEAD_BEEF);
}
#[test]
fn dirty_padding_does_not_corrupt_parse() {
let mut f = frame(3, IP, 5, 0x1_0000_0000);
f[12..16].copy_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD]);
let ev = parse_xdp_event(&f).expect("padding must be ignored");
assert_eq!(ev.kind, XdpEventKind::ConnDrop);
assert_eq!(ev.metadata, 5);
assert_eq!(ev.timestamp_ns, 0x1_0000_0000);
let mut f = frame(3, IP, 5, 0x1_0000_0000);
f[12..16].copy_from_slice(&[0xAA, 0xBB, 0xCC, 0xDD]);
let ev = parse_xdp_event(&f).expect("padding must be ignored");
assert_eq!(ev.kind, XdpEventKind::ConnDrop);
assert_eq!(ev.metadata, 5);
assert_eq!(ev.timestamp_ns, 0x1_0000_0000);
}
#[test]
fn src_ip_is_network_order_octets_not_native_u32() {
// КЛЮЧЕВОЙ вывод по endianness: октеты лежат в точковом порядке напрямую.
let f = frame(2, [198, 51, 100, 23], 0, 0);
let ev = parse_xdp_event(&f).expect("parses");
assert_eq!(ev.src_ip, Ipv4Addr::new(198, 51, 100, 23));
// Старый баг (`u32::from_ne_bytes` → Ipv4Addr::from(u32)) на little-endian
// давал бы переёрнутый адрес — фиксируем, что мы так НЕ делаем.
if cfg!(target_endian = "little") {
let naive = u32::from_ne_bytes(<[u8; 4]>::try_from(&f[4..8]).expect("4 octets"));
assert_eq!(Ipv4Addr::from(naive), Ipv4Addr::new(23, 100, 51, 198));
assert_ne!(Ipv4Addr::from(naive), ev.src_ip);
}
// КЛЮЧЕВОЙ вывод по endianness: октеты лежат в точковом порядке напрямую.
let f = frame(2, [198, 51, 100, 23], 0, 0);
let ev = parse_xdp_event(&f).expect("parses");
assert_eq!(ev.src_ip, Ipv4Addr::new(198, 51, 100, 23));
// Старый баг (`u32::from_ne_bytes` → Ipv4Addr::from(u32)) на little-endian
// давал бы переёрнутый адрес — фиксируем, что мы так НЕ делаем.
if cfg!(target_endian = "little") {
let naive = u32::from_ne_bytes(<[u8; 4]>::try_from(&f[4..8]).expect("4 octets"));
assert_eq!(Ipv4Addr::from(naive), Ipv4Addr::new(23, 100, 51, 198));
assert_ne!(Ipv4Addr::from(naive), ev.src_ip);
}
}
#[test]
fn truncated_frames_are_rejected() {
let full = frame(1, IP, 0, 0);
assert!(parse_xdp_event(&full[..16]).is_none(), "старая длина 16 — не валидна");
assert!(parse_xdp_event(&full[..23]).is_none(), "на 1 байт короче — не валидна");
assert!(parse_xdp_event(&full).is_some(), "ровно 24 — валидна");
assert!(parse_xdp_event(&[]).is_none());
let full = frame(1, IP, 0, 0);
assert!(parse_xdp_event(&full[..16]).is_none(), "старая длина 16 — не валидна");
assert!(parse_xdp_event(&full[..23]).is_none(), "на 1 байт короче — не валидна");
assert!(parse_xdp_event(&full).is_some(), "ровно 24 — валидна");
assert!(parse_xdp_event(&[]).is_none());
}
#[test]
fn unknown_event_type_is_rejected() {
for kind in [4u32, 9, 255, u32::MAX] {
assert!(parse_xdp_event(&frame(kind, IP, 0, 0)).is_none(), "type {kind} unknown");
}
for kind in [4u32, 9, 255, u32::MAX] {
assert!(parse_xdp_event(&frame(kind, IP, 0, 0)).is_none(), "type {kind} unknown");
}
}
#[test]
fn decision_matrix_by_type_and_enablement() {
let enabled = AutoBanConfig {
enabled: true,
..AutoBanConfig::default()
};
let disabled = AutoBanConfig {
enabled: false,
..AutoBanConfig::default()
};
// (kind, metadata=fails/хиты, банить ли при enabled)
let rows = [
(0u32, 255u32, false), // EVENT_BAN — ядро уже забанило: никогда
(1, 100, true), // EVENT_RATE_LIMIT — всегда баним
(2, 0, false), // EVENT_POLICY_DROP — политика по дефолту не банит
(3, 10, true), // EVENT_CONN_DROP fails=10 >= 3 — баним
(3, 0, false), // EVENT_CONN_DROP fails=0 (hook-drop) — не баним
(3, 2, false), // EVENT_CONN_DROP fails=2 < 3 — не баним
];
for (kind, meta, should_ban_when_on) in rows {
let ev = parse_xdp_event(&frame(kind, IP, meta, 0)).expect("known type");
assert!(
auto_ban_decision(&ev, &disabled).is_none(),
"disabled: kind {kind} meta {meta} must never ban"
);
let decided = auto_ban_decision(&ev, &enabled).is_some();
assert_eq!(
decided, should_ban_when_on,
"enabled: kind {kind} meta {meta} -> ban={decided}, expected {should_ban_when_on}"
);
}
let enabled = AutoBanConfig {
enabled: true,
..AutoBanConfig::default()
};
let disabled = AutoBanConfig {
enabled: false,
..AutoBanConfig::default()
};
// (kind, metadata=fails/хиты, банить ли при enabled)
let rows = [
(0u32, 255u32, false), // EVENT_BAN — ядро уже забанило: никогда
(1, 100, true), // EVENT_RATE_LIMIT — всегда баним
(2, 0, false), // EVENT_POLICY_DROP — политика по дефолту не банит
(3, 10, true), // EVENT_CONN_DROP fails=10 >= 3 — баним
(3, 0, false), // EVENT_CONN_DROP fails=0 (hook-drop) — не баним
(3, 2, false), // EVENT_CONN_DROP fails=2 < 3 — не баним
];
for (kind, meta, should_ban_when_on) in rows {
let ev = parse_xdp_event(&frame(kind, IP, meta, 0)).expect("known type");
assert!(
auto_ban_decision(&ev, &disabled).is_none(),
"disabled: kind {kind} meta {meta} must never ban"
);
let decided = auto_ban_decision(&ev, &enabled).is_some();
assert_eq!(
decided, should_ban_when_on,
"enabled: kind {kind} meta {meta} -> ban={decided}, expected {should_ban_when_on}"
);
}
}
#[test]
fn ban_carries_configured_duration_and_reason() {
let cfg = AutoBanConfig {
enabled: true,
duration_secs: 120,
conn_drop_fails: 3,
};
let rl = parse_xdp_event(&frame(1, IP, 0, 0)).expect("rate limit frame");
let ban = auto_ban_decision(&rl, &cfg).expect("rate limit bans");
assert_eq!(ban.ip, Ipv4Addr::new(203, 0, 113, 7));
assert_eq!(ban.duration_secs, 120);
assert_eq!(ban.reason, "xdp-rate-limit");
let cfg = AutoBanConfig {
enabled: true,
duration_secs: 120,
conn_drop_fails: 3,
};
let rl = parse_xdp_event(&frame(1, IP, 0, 0)).expect("rate limit frame");
let ban = auto_ban_decision(&rl, &cfg).expect("rate limit bans");
assert_eq!(ban.ip, Ipv4Addr::new(203, 0, 113, 7));
assert_eq!(ban.duration_secs, 120);
assert_eq!(ban.reason, "xdp-rate-limit");
let cd = parse_xdp_event(&frame(3, IP, 4, 0)).expect("conn drop frame");
assert_eq!(
auto_ban_decision(&cd, &cfg).expect("conn drop bans").reason,
"xdp-conn-drop"
);
let cd = parse_xdp_event(&frame(3, IP, 4, 0)).expect("conn drop frame");
assert_eq!(
auto_ban_decision(&cd, &cfg).expect("conn drop bans").reason,
"xdp-conn-drop"
);
}
#[test]
fn defaults_disable_autoban_without_xdp_keys() {
let cfg = Config::parse_str("").expect("empty config parses");
assert!(
!cfg.xdp.auto_ban_enabled,
"авто-бан обязан быть выключен по умолчанию (safe-by-default)"
);
assert_eq!(cfg.xdp.auto_ban_duration_secs, 60);
assert_eq!(cfg.xdp.auto_ban_conn_drop_fails, 3);
let cfg = Config::parse_str("").expect("empty config parses");
assert!(
!cfg.xdp.auto_ban_enabled,
"авто-бан обязан быть выключен по умолчанию (safe-by-default)"
);
assert_eq!(cfg.xdp.auto_ban_duration_secs, 60);
assert_eq!(cfg.xdp.auto_ban_conn_drop_fails, 3);
let policy = AutoBanConfig::from_xdp(&cfg.xdp);
let rl = parse_xdp_event(&frame(1, IP, 0, 0)).expect("frame parses");
assert!(auto_ban_decision(&rl, &policy).is_none(), "default policy bans nothing");
let policy = AutoBanConfig::from_xdp(&cfg.xdp);
let rl = parse_xdp_event(&frame(1, IP, 0, 0)).expect("frame parses");
assert!(auto_ban_decision(&rl, &policy).is_none(), "default policy bans nothing");
}
#[test]
fn xdp_section_enables_autoban_and_maps_fields() {
let cfg = Config::parse_str(
r#"
let cfg = Config::parse_str(
r#"
[xdp]
auto_ban_enabled = true
auto_ban_duration_secs = 45
auto_ban_conn_drop_fails = 5
"#,
)
.expect("[xdp] auto-ban keys parse");
let policy = AutoBanConfig::from_xdp(&cfg.xdp);
assert!(policy.enabled);
assert_eq!(policy.duration_secs, 45);
assert_eq!(policy.conn_drop_fails, 5);
)
.expect("[xdp] auto-ban keys parse");
let policy = AutoBanConfig::from_xdp(&cfg.xdp);
assert!(policy.enabled);
assert_eq!(policy.duration_secs, 45);
assert_eq!(policy.conn_drop_fails, 5);
// fails=4 ниже нового порога 5 — не бан; fails=5 — бан.
let below = parse_xdp_event(&frame(3, IP, 4, 0)).expect("frame parses");
assert!(auto_ban_decision(&below, &policy).is_none());
let at = parse_xdp_event(&frame(3, IP, 5, 0)).expect("frame parses");
assert_eq!(
auto_ban_decision(&at, &policy)
.expect("at-threshold bans")
.duration_secs,
45
);
// fails=4 ниже нового порога 5 — не бан; fails=5 — бан.
let below = parse_xdp_event(&frame(3, IP, 4, 0)).expect("frame parses");
assert!(auto_ban_decision(&below, &policy).is_none());
let at = parse_xdp_event(&frame(3, IP, 5, 0)).expect("frame parses");
assert_eq!(
auto_ban_decision(&at, &policy)
.expect("at-threshold bans")
.duration_secs,
45
);
}

View file

@ -5,55 +5,55 @@ use rampart::xdp::XdpGlobals;
#[test]
fn rodata_image_size_is_stable() {
let img = XdpGlobals::default().build_rodata_image();
assert_eq!(img.len(), 96, ".rodata image size must match config.h layout");
let img = XdpGlobals::default().build_rodata_image();
assert_eq!(img.len(), 96, ".rodata image size must match config.h layout");
}
#[test]
fn rodata_defaults_match_config_h() {
let img = XdpGlobals::default().build_rodata_image();
let rd = |off: usize| u64::from_le_bytes(img[off..off + 8].try_into().expect("8 bytes"));
let rd32 = |off: usize| u32::from_le_bytes(img[off..off + 4].try_into().expect("4 bytes"));
assert_eq!(&img[0..2], 1u16.to_le_bytes());
assert_eq!(&img[2..4], 65535u16.to_le_bytes());
assert_eq!(rd32(4), 10); // G_SYN_HIT_COUNT
assert_eq!(rd(8), 3_000_000_000); // G_SYN_WINDOW_NS
assert_eq!(rd(16), 60_000_000_000); // G_SYN_BAN_DURATION_NS
assert_eq!(rd(24), 30_000_000_000); // G_CONNTRACK_IDLE_NS
assert_eq!(rd(32), 120_000_000_000); // G_PLAYER_IDLE_NS
assert_eq!(rd(40), 300_000_000_000); // G_BAN_DURATION_NS
assert_eq!(img[48], 4); // G_MAX_OUT_OF_ORDER
assert_eq!(img[49], 0); // G_UDP_POLICY
assert_eq!(rd32(52), 100); // G_UDP_HIT_COUNT (padding 50..52)
assert_eq!(rd(56), 1_000_000_000); // G_UDP_WINDOW_NS
assert_eq!(img[64], 1); // G_FEATURE_SYN_THROTTLE
assert_eq!(img[65], 1); // G_FEATURE_EVENTS
assert_eq!(img[66], 0); // G_SYN_CHALLENGE_ENABLED
assert_eq!(rd(72), 0xA5A5_A5A5_A5A5_A5A5); // G_CHALLENGE_SECRET (padding 67..72)
assert_eq!(rd32(80), 3000); // G_CHALLENGE_TIMEOUT_MS
assert_eq!(rd(88), 300_000_000_000); // G_CHALLENGE_VERIFIED_TTL_NS (padding 84..88)
let img = XdpGlobals::default().build_rodata_image();
let rd = |off: usize| u64::from_le_bytes(img[off..off + 8].try_into().expect("8 bytes"));
let rd32 = |off: usize| u32::from_le_bytes(img[off..off + 4].try_into().expect("4 bytes"));
assert_eq!(&img[0..2], 1u16.to_le_bytes());
assert_eq!(&img[2..4], 65535u16.to_le_bytes());
assert_eq!(rd32(4), 10); // G_SYN_HIT_COUNT
assert_eq!(rd(8), 3_000_000_000); // G_SYN_WINDOW_NS
assert_eq!(rd(16), 60_000_000_000); // G_SYN_BAN_DURATION_NS
assert_eq!(rd(24), 30_000_000_000); // G_CONNTRACK_IDLE_NS
assert_eq!(rd(32), 120_000_000_000); // G_PLAYER_IDLE_NS
assert_eq!(rd(40), 300_000_000_000); // G_BAN_DURATION_NS
assert_eq!(img[48], 4); // G_MAX_OUT_OF_ORDER
assert_eq!(img[49], 0); // G_UDP_POLICY
assert_eq!(rd32(52), 100); // G_UDP_HIT_COUNT (padding 50..52)
assert_eq!(rd(56), 1_000_000_000); // G_UDP_WINDOW_NS
assert_eq!(img[64], 1); // G_FEATURE_SYN_THROTTLE
assert_eq!(img[65], 1); // G_FEATURE_EVENTS
assert_eq!(img[66], 0); // G_SYN_CHALLENGE_ENABLED
assert_eq!(rd(72), 0xA5A5_A5A5_A5A5_A5A5); // G_CHALLENGE_SECRET (padding 67..72)
assert_eq!(rd32(80), 3000); // G_CHALLENGE_TIMEOUT_MS
assert_eq!(rd(88), 300_000_000_000); // G_CHALLENGE_VERIFIED_TTL_NS (padding 84..88)
}
#[test]
fn rodata_padding_bytes_stay_zero() {
let g = XdpGlobals {
max_out_of_order: u8::MAX,
udp_policy: u8::MAX,
feature_syn_throttle: true,
feature_events: true,
syn_challenge_enabled: true,
..XdpGlobals::default()
};
let img = g.build_rodata_image();
for off in [50, 51, 67, 68, 69, 70, 71, 84, 85, 86, 87] {
assert_eq!(img[off], 0, "alignment padding at {off} must stay zeroed");
}
let g = XdpGlobals {
max_out_of_order: u8::MAX,
udp_policy: u8::MAX,
feature_syn_throttle: true,
feature_events: true,
syn_challenge_enabled: true,
..XdpGlobals::default()
};
let img = g.build_rodata_image();
for off in [50, 51, 67, 68, 69, 70, 71, 84, 85, 86, 87] {
assert_eq!(img[off], 0, "alignment padding at {off} must stay zeroed");
}
}
#[test]
fn from_config_maps_fields() {
let cfg = Config::parse_str(
r#"
let cfg = Config::parse_str(
r#"
[xdp]
protected_port_start = 25560
protected_port_end = 25600
@ -66,53 +66,53 @@ challenge_timeout_ms = 7000
throttle_enabled = false
events_enabled = false
"#,
)
.expect("[xdp] section must parse");
let g = XdpGlobals::from_config(&cfg.xdp).expect("globals must build");
assert_eq!(g.start_port, 25560);
assert_eq!(g.end_port, 25600);
assert_eq!(g.udp_policy, 2);
assert_eq!(g.udp_hit_count, 500);
assert_eq!(g.udp_window_ns, 2_000_000_000);
assert!(!g.feature_syn_throttle);
assert!(!g.feature_events);
assert!(g.syn_challenge_enabled);
assert_eq!(g.challenge_secret, 0x0011_2233_4455_6677);
assert_eq!(g.challenge_timeout_ms, 7000);
)
.expect("[xdp] section must parse");
let g = XdpGlobals::from_config(&cfg.xdp).expect("globals must build");
assert_eq!(g.start_port, 25560);
assert_eq!(g.end_port, 25600);
assert_eq!(g.udp_policy, 2);
assert_eq!(g.udp_hit_count, 500);
assert_eq!(g.udp_window_ns, 2_000_000_000);
assert!(!g.feature_syn_throttle);
assert!(!g.feature_events);
assert!(g.syn_challenge_enabled);
assert_eq!(g.challenge_secret, 0x0011_2233_4455_6677);
assert_eq!(g.challenge_timeout_ms, 7000);
let img = g.build_rodata_image();
assert_eq!(img[49], 2);
assert_eq!(img[64], 0);
assert_eq!(&img[0..2], 25560u16.to_le_bytes());
let img = g.build_rodata_image();
assert_eq!(img[49], 2);
assert_eq!(img[64], 0);
assert_eq!(&img[0..2], 25560u16.to_le_bytes());
}
#[test]
fn from_config_rejects_bad_udp_policy() {
let cfg = Config::parse_str("[xdp]\nudp_policy = \"flood\"\n").expect("config parses");
assert!(XdpGlobals::from_config(&cfg.xdp).is_err());
let cfg = Config::parse_str("[xdp]\nudp_policy = \"flood\"\n").expect("config parses");
assert!(XdpGlobals::from_config(&cfg.xdp).is_err());
}
#[test]
fn from_config_rejects_inverted_port_range() {
let cfg = Config::parse_str("[xdp]\nprotected_port_start = 100\nprotected_port_end = 50\n").expect("config parses");
assert!(XdpGlobals::from_config(&cfg.xdp).is_err());
let cfg = Config::parse_str("[xdp]\nprotected_port_start = 100\nprotected_port_end = 50\n").expect("config parses");
assert!(XdpGlobals::from_config(&cfg.xdp).is_err());
}
#[test]
fn from_config_rejects_bad_secret_hex() {
for secret in ["nothex", "0011", "001122334455667788"] {
let toml = format!("[xdp]\nchallenge_secret_hex = \"{secret}\"\n");
let cfg = Config::parse_str(&toml).expect("config parses");
assert!(
XdpGlobals::from_config(&cfg.xdp).is_err(),
"secret '{secret}' must be rejected"
);
}
for secret in ["nothex", "0011", "001122334455667788"] {
let toml = format!("[xdp]\nchallenge_secret_hex = \"{secret}\"\n");
let cfg = Config::parse_str(&toml).expect("config parses");
assert!(
XdpGlobals::from_config(&cfg.xdp).is_err(),
"secret '{secret}' must be rejected"
);
}
}
#[test]
fn xdp_section_defaults_match_config_h() {
let cfg = Config::parse_str("").expect("empty config parses");
let g = XdpGlobals::from_config(&cfg.xdp).expect("globals must build");
assert_eq!(g, XdpGlobals::default());
let cfg = Config::parse_str("").expect("empty config parses");
let g = XdpGlobals::from_config(&cfg.xdp).expect("globals must build");
assert_eq!(g, XdpGlobals::default());
}