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:
parent
d8393e0f39
commit
a90f0da226
96 changed files with 6542 additions and 6537 deletions
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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()])
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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"));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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}");
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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());
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue