diff --git a/TODO.md b/TODO.md index fe25fa8..eb5b1a7 100644 --- a/TODO.md +++ b/TODO.md @@ -39,6 +39,9 @@ 4. Блокирующие операции → `spawn_blocking` 5. Логи: `tracing::info!` / `debug!` / `error!` 6. Метрики: register один раз при старте, инкремент в hot path +7. **Тесты отдельно от кода**: в .rs-файлах с кодом НЕТ `#[cfg(test)]`-модулей — + тесты живут в `tests/` (нужный хелпер делай `pub` с реальным вызовом-потребителем). + Существующие инлайн-тесты — легаси, мигрировать постепенно (см. бэклог). --- @@ -166,6 +169,8 @@ guard/ ## 3. Backlog +- [ ] Мигрировать существующие инлайн-тесты (`#[cfg(test)]` в src/) в `tests/` — + правило §0.7; при миграции хелперы, нужные тестам, получают `pub` с потребителем. - [ ] protocol-gRPC plugin (после http) - [ ] BPF hook #1 реальный: HTTP поверх XDP (rate-limit до userspace) - [ ] GeoIP/ASN reputation (enum есть, реализации нет) diff --git a/build.rs b/build.rs index 9784e90..cb20306 100644 --- a/build.rs +++ b/build.rs @@ -2,44 +2,44 @@ use std::path::PathBuf; use std::process::Command; fn main() -> Result<(), Box> { - let has_xdp_feature = std::env::var("CARGO_FEATURE_XDP").is_ok(); - if !has_xdp_feature { - return Ok(()); - } + let has_xdp_feature = std::env::var("CARGO_FEATURE_XDP").is_ok(); + if !has_xdp_feature { + return Ok(()); + } - let manifest_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR")?); - let xdp_dir = manifest_dir.join("xdp"); - let out_dir = PathBuf::from(std::env::var("OUT_DIR")?); + let manifest_dir = PathBuf::from(std::env::var("CARGO_MANIFEST_DIR")?); + let xdp_dir = manifest_dir.join("xdp"); + let out_dir = PathBuf::from(std::env::var("OUT_DIR")?); - let src = xdp_dir.join("core/universal_filter.c"); - let dst = out_dir.join("universal_filter.o"); + let src = xdp_dir.join("core/universal_filter.c"); + let dst = out_dir.join("universal_filter.o"); - println!("cargo:rerun-if-changed={}", src.display()); + println!("cargo:rerun-if-changed={}", src.display()); - let host_triple = std::env::var("HOST").unwrap_or_default(); - let arch = host_triple.split('-').next().unwrap_or(&host_triple); - let status = Command::new("clang") - .args([ - "-O2", - "-g", - "-target", - "bpf", - "-mcpu=v3", - "-c", - src.to_str().ok_or("src path is not valid UTF-8")?, - "-o", - dst.to_str().ok_or("dst path is not valid UTF-8")?, - &format!("-I{}", xdp_dir.display()), - &format!("-I{}", xdp_dir.join("core").display()), - &format!("-I{}", xdp_dir.join("hooks").display()), - &format!("-I/usr/include/{}-linux-gnu", arch), - ]) - .status()?; + let host_triple = std::env::var("HOST").unwrap_or_default(); + let arch = host_triple.split('-').next().unwrap_or(&host_triple); + let status = Command::new("clang") + .args([ + "-O2", + "-g", + "-target", + "bpf", + "-mcpu=v3", + "-c", + src.to_str().ok_or("src path is not valid UTF-8")?, + "-o", + dst.to_str().ok_or("dst path is not valid UTF-8")?, + &format!("-I{}", xdp_dir.display()), + &format!("-I{}", xdp_dir.join("core").display()), + &format!("-I{}", xdp_dir.join("hooks").display()), + &format!("-I/usr/include/{}-linux-gnu", arch), + ]) + .status()?; - if !status.success() { - return Err("XDP C compilation failed (see clang errors above)".into()); - } + if !status.success() { + return Err("XDP C compilation failed (see clang errors above)".into()); + } - println!("cargo:rerun-if-env-changed=CARGO_FEATURE_XDP"); - Ok(()) + println!("cargo:rerun-if-env-changed=CARGO_FEATURE_XDP"); + Ok(()) } diff --git a/rustfmt.toml b/rustfmt.toml index 305472f..50112e7 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -2,7 +2,7 @@ max_width = 120 tab_spaces = 4 edition = "2024" newline_style = "Unix" -hard_tabs = false +hard_tabs = true use_small_heuristics = "Default" reorder_imports = true diff --git a/src/app/runtime.rs b/src/app/runtime.rs index 238f8c9..a9f9104 100644 --- a/src/app/runtime.rs +++ b/src/app/runtime.rs @@ -25,11 +25,11 @@ use super::services::{build_registry, build_whitelist, start_subnet_tracker, sta use super::shutdown::{RunExit, spawn_shutdown_drain}; fn attack_status_value(status: AttackStatus) -> i64 { - match status { - AttackStatus::Normal => 0, - AttackStatus::Suspicious => 1, - AttackStatus::UnderAttack => 2, - } + match status { + AttackStatus::Normal => 0, + AttackStatus::Suspicious => 1, + AttackStatus::UnderAttack => 2, + } } /// Точка входа edge-демона (`rampart`): то, что делал `main` бинаря. @@ -39,194 +39,194 @@ fn attack_status_value(status: AttackStatus) -> i64 { /// # Errors /// Ошибки старта: нечитаемый конфиг, пустой реестр протоколов, сбой listener. pub async fn run() -> anyhow::Result { - tracing_subscriber::fmt() - .with_env_filter(EnvFilter::from_default_env().add_directive("rampart=info".parse()?)) - .init(); + tracing_subscriber::fmt() + .with_env_filter(EnvFilter::from_default_env().add_directive("rampart=info".parse()?)) + .init(); - let config_path = std::env::var("RAMPART_CONFIG").unwrap_or_else(|_| "/etc/rampart/config.toml".to_string()); - let config = Arc::new(Config::from_file(&config_path)?); + let config_path = std::env::var("RAMPART_CONFIG").unwrap_or_else(|_| "/etc/rampart/config.toml".to_string()); + let config = Arc::new(Config::from_file(&config_path)?); - let registry = Arc::new(build_registry(&config)); - if registry.is_empty() { - anyhow::bail!( - "no protocol plugins compiled; available feature flags: protocol-http, \ + let registry = Arc::new(build_registry(&config)); + if registry.is_empty() { + anyhow::bail!( + "no protocol plugins compiled; available feature flags: protocol-http, \ store-redis, geoip, xdp, io-uring. Build with --features protocol-http \ or link an external ProtocolHandler implementation" - ); - } - let whitelist = build_whitelist(&config)?; + ); + } + let whitelist = build_whitelist(&config)?; - let rate_limiter = Arc::new(RateLimiter::new( - config.limits.rate_limit_pps, - config.limits.rate_limit_burst, - )); - let blacklist = Arc::new(Blacklist::new()); - let reputation = Arc::new(IpReputation::new()); - let detector = Arc::new(Mutex::new(AttackDetector::new())); - let hook = Arc::new(TrafficHook::new( - reputation.clone(), - blacklist.clone(), - config.detect.autoban.clone(), - config.ban.ban_duration_secs, - )); - let alert_dispatcher = AlertDispatcher::new(); - let webhook_url = config.detect.alert.webhook_url.clone(); - let allowed_1s = Arc::new(AtomicU64::new(0)); + let rate_limiter = Arc::new(RateLimiter::new( + config.limits.rate_limit_pps, + config.limits.rate_limit_burst, + )); + let blacklist = Arc::new(Blacklist::new()); + let reputation = Arc::new(IpReputation::new()); + let detector = Arc::new(Mutex::new(AttackDetector::new())); + let hook = Arc::new(TrafficHook::new( + reputation.clone(), + blacklist.clone(), + config.detect.autoban.clone(), + config.ban.ban_duration_secs, + )); + let alert_dispatcher = AlertDispatcher::new(); + let webhook_url = config.detect.alert.webhook_url.clone(); + let allowed_1s = Arc::new(AtomicU64::new(0)); - let (shutdown_tx, shutdown_rx) = watch::channel(false); - let (drain_tx, drain_rx) = oneshot::channel(); + let (shutdown_tx, shutdown_rx) = watch::channel(false); + let (drain_tx, drain_rx) = oneshot::channel(); - spawn_shutdown_drain(shutdown_tx.clone(), drain_tx); + spawn_shutdown_drain(shutdown_tx.clone(), drain_tx); - #[cfg(feature = "store-redis")] - if let Some(redis_url) = &config.store.redis_url - && !redis_url.is_empty() - { - let bl = blacklist.clone(); - let sd = shutdown_rx.clone(); - let url = redis_url.clone(); - tokio::spawn(async move { - let client = match redis::Client::open(url.as_str()) { - Ok(c) => c, - Err(e) => { - tracing::warn!("Invalid redis_url: {e}, blacklist sync disabled"); - return; - }, - }; - let local_events = bl.subscribe_local_bans(); - let publisher_client = client.clone(); - let publisher_blacklist = bl.clone(); - let publisher_shutdown = sd.clone(); - tokio::spawn(async move { - crate::store::start_local_ban_publisher( - publisher_client, - publisher_blacklist, - local_events, - publisher_shutdown, - ) - .await; - }); - crate::store::start_blacklist_sync(&client, bl, sd).await; - }); - } + #[cfg(feature = "store-redis")] + if let Some(redis_url) = &config.store.redis_url + && !redis_url.is_empty() + { + let bl = blacklist.clone(); + let sd = shutdown_rx.clone(); + let url = redis_url.clone(); + tokio::spawn(async move { + let client = match redis::Client::open(url.as_str()) { + Ok(c) => c, + Err(e) => { + tracing::warn!("Invalid redis_url: {e}, blacklist sync disabled"); + return; + }, + }; + let local_events = bl.subscribe_local_bans(); + let publisher_client = client.clone(); + let publisher_blacklist = bl.clone(); + let publisher_shutdown = sd.clone(); + tokio::spawn(async move { + crate::store::start_local_ban_publisher( + publisher_client, + publisher_blacklist, + local_events, + publisher_shutdown, + ) + .await; + }); + crate::store::start_blacklist_sync(&client, bl, sd).await; + }); + } - if config.metrics.enabled { - let metrics_addr = format!("0.0.0.0:{}", config.metrics.port); - tracing::info!("Metrics server listening on {metrics_addr}"); - tokio::spawn(async move { - metrics::run_metrics_server(&metrics_addr).await; - }); - } + if config.metrics.enabled { + let metrics_addr = format!("0.0.0.0:{}", config.metrics.port); + tracing::info!("Metrics server listening on {metrics_addr}"); + tokio::spawn(async move { + metrics::run_metrics_server(&metrics_addr).await; + }); + } - let clickhouse: Option>> = match &config.store.clickhouse_url { - Some(url) if !url.is_empty() => { - let writer = Arc::new(tokio::sync::Mutex::new(ClickHouseWriter::new(url))); - crate::store::clickhouse::start_flush_task(writer.clone(), shutdown_rx.clone()); - Some(writer) - }, - _ => None, - }; + let clickhouse: Option>> = match &config.store.clickhouse_url { + Some(url) if !url.is_empty() => { + let writer = Arc::new(tokio::sync::Mutex::new(ClickHouseWriter::new(url))); + crate::store::clickhouse::start_flush_task(writer.clone(), shutdown_rx.clone()); + Some(writer) + }, + _ => None, + }; - let xdp_filter = start_xdp(&config, &shutdown_rx, &blacklist)?; - let subnet_tracker = start_subnet_tracker(&config); - monitor::spawn( - &config.detect.prefix, - subnet_tracker.clone(), - xdp_filter.clone(), - shutdown_rx.clone(), - ); + let xdp_filter = start_xdp(&config, &shutdown_rx, &blacklist)?; + let subnet_tracker = start_subnet_tracker(&config); + monitor::spawn( + &config.detect.prefix, + subnet_tracker.clone(), + xdp_filter.clone(), + shutdown_rx.clone(), + ); - let rl = rate_limiter.clone(); - let bl = blacklist.clone(); - let det = detector.clone(); - let intel = hook.clone(); - let a1s = allowed_1s.clone(); - let ch = clickhouse.clone(); - let mut sd = shutdown_rx.clone(); - tokio::spawn(async move { - let mut sec_tick = tokio::time::interval(Duration::from_secs(1)); - let mut min_tick = tokio::time::interval(Duration::from_secs(60)); - sec_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); - min_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); - loop { - tokio::select! { - biased; - _ = sd.changed() => { - if *sd.borrow() { - return; - } - } - _ = sec_tick.tick() => { - let pps = a1s.swap(0, Ordering::Relaxed) as f64; - let cps = intel.take_cps() as f64; - metrics::INTEL_CPS.set(cps as i64); - let status = det.lock().expect("detector lock poisoned").analyze(pps, cps); - metrics::ATTACK_STATUS.set(attack_status_value(status)); - if let Some(alert) = alert_dispatcher.on_status(status) { - // Дедупликация: алерт только на переходе состояния атаки. - metrics::INTEL_ALERTS_TOTAL.inc(); - tracing::warn!(pps, cps, "{alert}"); - push_attack_event(&ch, pps).await; - if let Some(url) = webhook_url.clone() { - tokio::spawn(send_webhook(url, alert.clone())); - } - } - if status == AttackStatus::UnderAttack { - let banned = intel.ban_offenders(); - if banned > 0 { - tracing::info!(banned, "escalation: offenders auto-banned during attack"); - } - } - } - _ = min_tick.tick() => { - rl.sweep(); - bl.clear_expired(); - } - } - } - }); + let rl = rate_limiter.clone(); + let bl = blacklist.clone(); + let det = detector.clone(); + let intel = hook.clone(); + let a1s = allowed_1s.clone(); + let ch = clickhouse.clone(); + let mut sd = shutdown_rx.clone(); + tokio::spawn(async move { + let mut sec_tick = tokio::time::interval(Duration::from_secs(1)); + let mut min_tick = tokio::time::interval(Duration::from_secs(60)); + sec_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); + min_tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); + loop { + tokio::select! { + biased; + _ = sd.changed() => { + if *sd.borrow() { + return; + } + } + _ = sec_tick.tick() => { + let pps = a1s.swap(0, Ordering::Relaxed) as f64; + let cps = intel.take_cps() as f64; + metrics::INTEL_CPS.set(cps as i64); + let status = det.lock().expect("detector lock poisoned").analyze(pps, cps); + metrics::ATTACK_STATUS.set(attack_status_value(status)); + if let Some(alert) = alert_dispatcher.on_status(status) { + // Дедупликация: алерт только на переходе состояния атаки. + metrics::INTEL_ALERTS_TOTAL.inc(); + tracing::warn!(pps, cps, "{alert}"); + push_attack_event(&ch, pps).await; + if let Some(url) = webhook_url.clone() { + tokio::spawn(send_webhook(url, alert.clone())); + } + } + if status == AttackStatus::UnderAttack { + let banned = intel.ban_offenders(); + if banned > 0 { + tracing::info!(banned, "escalation: offenders auto-banned during attack"); + } + } + } + _ = min_tick.tick() => { + rl.sweep(); + bl.clear_expired(); + } + } + } + }); - tracing::info!("Rampart edge starting on {}:{}", config.bind.address, config.bind.port); - tracing::info!("Upstreams: {:?}", config.backend.upstreams); + tracing::info!("Rampart edge starting on {}:{}", config.bind.address, config.bind.port); + tracing::info!("Upstreams: {:?}", config.backend.upstreams); - let adjuster = Arc::new(Mutex::new(DifficultyAdjuster::default())); - let gateway = Arc::new(Gateway::new( - config.clone(), - rate_limiter, - blacklist, - adjuster, - whitelist, - reputation, - xdp_filter, - clickhouse, - allowed_1s, - registry, - subnet_tracker, - )); - tokio::select! { - result = listener::run(config, gateway, hook, shutdown_rx) => { - result?; - Ok(RunExit::Ok) - } - // Drain-таймаут сработал: возвращаем сигнал бинарю завершить процесс - // немедленно, как это делал прежний `process::exit(0)`. - _ = drain_rx => Ok(RunExit::DrainTimeout), - } + let adjuster = Arc::new(Mutex::new(DifficultyAdjuster::default())); + let gateway = Arc::new(Gateway::new( + config.clone(), + rate_limiter, + blacklist, + adjuster, + whitelist, + reputation, + xdp_filter, + clickhouse, + allowed_1s, + registry, + subnet_tracker, + )); + tokio::select! { + result = listener::run(config, gateway, hook, shutdown_rx) => { + result?; + Ok(RunExit::Ok) + } + // Drain-таймаут сработал: возвращаем сигнал бинарю завершить процесс + // немедленно, как это делал прежний `process::exit(0)`. + _ = drain_rx => Ok(RunExit::DrainTimeout), + } } async fn push_attack_event(writer: &Option>>, pps: f64) { - let Some(writer) = writer else { - return; - }; - let event = ClickHouseEvent { - timestamp: chrono::Utc::now(), - event_type: "attack".to_string(), - ip: String::new(), - data_float: pps, - data_int: 0, - data_string: "under_attack".to_string(), - }; - if let Err(e) = writer.lock().await.push(event).await { - tracing::debug!("clickhouse push error: {e}"); - } + let Some(writer) = writer else { + return; + }; + let event = ClickHouseEvent { + timestamp: chrono::Utc::now(), + event_type: "attack".to_string(), + ip: String::new(), + data_float: pps, + data_int: 0, + data_string: "under_attack".to_string(), + }; + if let Err(e) = writer.lock().await.push(event).await { + tracing::debug!("clickhouse push error: {e}"); + } } diff --git a/src/app/services.rs b/src/app/services.rs index 06b33fd..9195fad 100644 --- a/src/app/services.rs +++ b/src/app/services.rs @@ -19,116 +19,116 @@ use tokio::sync::watch; /// HTTP/1.1-обработчик с политикой из секции `[protocol.http]`. /// Внешние крейты регистрируют свои обработчики в этом же месте. pub(crate) fn build_registry(config: &Config) -> ProtocolRegistry { - #[cfg(feature = "protocol-minecraft")] - if config.protocol.minecraft.enabled { - let mut registry = ProtocolRegistry::new(); - registry.register(Box::new(crate::protocol::minecraft::MinecraftProtocolHandler::new( - &config.protocol.minecraft, - &config.backend.upstreams, - ))); - return registry; - } - #[cfg(feature = "protocol-http")] - { - let mut registry = ProtocolRegistry::new(); - register_http(&mut registry, config); - registry - } - #[cfg(not(feature = "protocol-http"))] - { - let _ = config; - ProtocolRegistry::new() - } + #[cfg(feature = "protocol-minecraft")] + if config.protocol.minecraft.enabled { + let mut registry = ProtocolRegistry::new(); + registry.register(Box::new(crate::protocol::minecraft::MinecraftProtocolHandler::new( + &config.protocol.minecraft, + &config.backend.upstreams, + ))); + return registry; + } + #[cfg(feature = "protocol-http")] + { + let mut registry = ProtocolRegistry::new(); + register_http(&mut registry, config); + registry + } + #[cfg(not(feature = "protocol-http"))] + { + let _ = config; + ProtocolRegistry::new() + } } #[cfg(feature = "protocol-http")] fn register_http(registry: &mut ProtocolRegistry, config: &Config) { - registry.register(Box::new(crate::protocol::http::HttpProtocolHandler::new( - &config.protocol.http, - &config.backend.upstreams, - ))); + registry.register(Box::new(crate::protocol::http::HttpProtocolHandler::new( + &config.protocol.http, + &config.backend.upstreams, + ))); } #[cfg(feature = "xdp")] pub(crate) fn start_xdp( - config: &Arc, - shutdown_rx: &watch::Receiver, - blacklist: &Arc, + config: &Arc, + shutdown_rx: &watch::Receiver, + blacklist: &Arc, ) -> anyhow::Result>>> { - use std::time::Duration; + use std::time::Duration; - use crate::xdp::XdpMetrics; + use crate::xdp::XdpMetrics; - if !config.xdp.enabled { - return Ok(None); - } + if !config.xdp.enabled { + return Ok(None); + } - let filter = XdpFilter::new(&config.xdp.interface); - let shared = Arc::new(Mutex::new(filter)); - { - let mut guard = shared.lock().expect("xdp lock poisoned"); - let globals = XdpGlobals::from_config(&config.xdp)?; - guard.set_globals(globals); - // With ingress PROXY protocol, XDP sees only the provider's transport - // address, so its events must not trigger per-player or provider bans. - if !config.proxy_protocol.ingress_enabled { - // load() captures the blacklist and auto-ban policy in its ringbuf - // callback, so set_autoban must happen first. - guard.set_autoban(blacklist.clone(), &config.xdp); - } else if config.xdp.auto_ban_enabled { - tracing::warn!( - "XDP auto-ban is disabled while inbound PROXY protocol is enabled; XDP only sees transport peers" - ); - } - guard.load()?; - } - let xdp_metrics = XdpMetrics::register()?; + let filter = XdpFilter::new(&config.xdp.interface); + let shared = Arc::new(Mutex::new(filter)); + { + let mut guard = shared.lock().expect("xdp lock poisoned"); + let globals = XdpGlobals::from_config(&config.xdp)?; + guard.set_globals(globals); + // With ingress PROXY protocol, XDP sees only the provider's transport + // address, so its events must not trigger per-player or provider bans. + if !config.proxy_protocol.ingress_enabled { + // load() captures the blacklist and auto-ban policy in its ringbuf + // callback, so set_autoban must happen first. + guard.set_autoban(blacklist.clone(), &config.xdp); + } else if config.xdp.auto_ban_enabled { + tracing::warn!( + "XDP auto-ban is disabled while inbound PROXY protocol is enabled; XDP only sees transport peers" + ); + } + guard.load()?; + } + let xdp_metrics = XdpMetrics::register()?; - let sd = shutdown_rx.clone(); - let shared_thread = shared.clone(); - std::thread::spawn(move || { - while !*sd.borrow() { - let guard = match shared_thread.lock() { - Ok(g) => g, - Err(_) => break, - }; - guard.drain_events(); - if let Ok(stats) = guard.get_stats() { - xdp_metrics.update(&stats); - } - drop(guard); - std::thread::sleep(Duration::from_secs(5)); - } - if let Ok(mut guard) = shared_thread.lock() { - guard.unload().ok(); - } - }); - Ok(Some(shared)) + let sd = shutdown_rx.clone(); + let shared_thread = shared.clone(); + std::thread::spawn(move || { + while !*sd.borrow() { + let guard = match shared_thread.lock() { + Ok(g) => g, + Err(_) => break, + }; + guard.drain_events(); + if let Ok(stats) = guard.get_stats() { + xdp_metrics.update(&stats); + } + drop(guard); + std::thread::sleep(Duration::from_secs(5)); + } + if let Ok(mut guard) = shared_thread.lock() { + guard.unload().ok(); + } + }); + Ok(Some(shared)) } #[cfg(not(feature = "xdp"))] pub(crate) fn start_xdp( - _config: &Arc, - _shutdown_rx: &watch::Receiver, - _blacklist: &Arc, + _config: &Arc, + _shutdown_rx: &watch::Receiver, + _blacklist: &Arc, ) -> anyhow::Result>>> { - Ok(None) + Ok(None) } /// Юзерспейс-агрегатор префиксов: активен, когда detect.prefix включён, /// а XDP-путь не работает (не собран или выключен в конфиге). pub(crate) fn start_subnet_tracker(config: &Config) -> Option> { - let xdp_active = cfg!(feature = "xdp") && config.xdp.enabled; - if config.detect.prefix.enabled && !xdp_active { - tracing::info!( - window_secs = config.detect.prefix.window_secs, - syn_threshold = config.detect.prefix.syn_threshold, - "subnet tracker enabled (userspace prefix aggregation)" - ); - Some(Arc::new(SubnetTracker::new())) - } else { - None - } + let xdp_active = cfg!(feature = "xdp") && config.xdp.enabled; + if config.detect.prefix.enabled && !xdp_active { + tracing::info!( + window_secs = config.detect.prefix.window_secs, + syn_threshold = config.detect.prefix.syn_threshold, + "subnet tracker enabled (userspace prefix aggregation)" + ); + Some(Arc::new(SubnetTracker::new())) + } else { + None + } } /// Store-фичи проверяются на старте edge-демона: конфиг, запрашивающий redis, @@ -137,71 +137,71 @@ pub(crate) fn start_subnet_tracker(config: &Config) -> Option /// Точка вызова — `build_whitelist`: ближайший `?`-хук, принимающий конфиг /// до бинда listener'а (сам runtime.rs вне правок этой задачи). fn ensure_store_features(config: &Config) -> anyhow::Result<()> { - #[cfg(not(feature = "store-redis"))] - if config.store.redis_url.as_deref().is_some_and(|url| !url.is_empty()) { - anyhow::bail!("[store].redis_url requires a redis-backed store: built without store-redis feature"); - } - #[cfg(feature = "store-redis")] - let _ = config; - Ok(()) + #[cfg(not(feature = "store-redis"))] + if config.store.redis_url.as_deref().is_some_and(|url| !url.is_empty()) { + anyhow::bail!("[store].redis_url requires a redis-backed store: built without store-redis feature"); + } + #[cfg(feature = "store-redis")] + let _ = config; + Ok(()) } pub(crate) fn build_whitelist(config: &Config) -> anyhow::Result>> { - ensure_store_features(config)?; - let mut set = HashSet::with_capacity(config.whitelist.len()); - for entry in &config.whitelist { - let ip: IpAddr = entry - .parse() - .map_err(|_| anyhow::anyhow!("invalid whitelist entry: {entry}"))?; - set.insert(ip); - } - Ok(Arc::new(set)) + ensure_store_features(config)?; + let mut set = HashSet::with_capacity(config.whitelist.len()); + for entry in &config.whitelist { + let ip: IpAddr = entry + .parse() + .map_err(|_| anyhow::anyhow!("invalid whitelist entry: {entry}"))?; + set.insert(ip); + } + Ok(Arc::new(set)) } #[cfg(test)] mod tests { - use super::*; + use super::*; - fn config_with_redis() -> Config { - Config { - store: crate::config::StoreConfig { - redis_url: Some("redis://127.0.0.1:6379/0".to_string()), - ..Default::default() - }, - ..Default::default() - } - } + fn config_with_redis() -> Config { + Config { + store: crate::config::StoreConfig { + redis_url: Some("redis://127.0.0.1:6379/0".to_string()), + ..Default::default() + }, + ..Default::default() + } + } - #[cfg(not(feature = "store-redis"))] - #[test] - fn redis_config_without_feature_fails_fast() { - let err = ensure_store_features(&config_with_redis()).expect_err("must fail without store-redis"); - assert!(err.to_string().contains("built without store-redis feature")); - } + #[cfg(not(feature = "store-redis"))] + #[test] + fn redis_config_without_feature_fails_fast() { + let err = ensure_store_features(&config_with_redis()).expect_err("must fail without store-redis"); + assert!(err.to_string().contains("built without store-redis feature")); + } - #[cfg(not(feature = "store-redis"))] - #[test] - fn empty_store_config_passes_without_feature() { - assert!(ensure_store_features(&Config::default()).is_ok()); - } + #[cfg(not(feature = "store-redis"))] + #[test] + fn empty_store_config_passes_without_feature() { + assert!(ensure_store_features(&Config::default()).is_ok()); + } - #[cfg(feature = "store-redis")] - #[test] - fn guard_is_noop_with_feature() { - assert!(ensure_store_features(&config_with_redis()).is_ok()); - } + #[cfg(feature = "store-redis")] + #[test] + fn guard_is_noop_with_feature() { + assert!(ensure_store_features(&config_with_redis()).is_ok()); + } - /// Wiring-тасовка XDP auto-ban: `start_xdp` обязан принимать `Arc` - /// (т.е. существовать в сигнатуре с blacklist) и при выключенном `[xdp]` - /// не трогать ни ядро, ни blacklist. Порядок `set_autoban` -> `load()` - /// внутри enabled-ветки без ядра непроверяем — см. комментарий на месте вызова. - #[test] - fn start_xdp_accepts_blacklist_and_skips_kernel_when_disabled() { - let (_tx, rx) = watch::channel(false); - let blacklist = Arc::new(Blacklist::new()); - let started = start_xdp(&Arc::new(Config::default()), &rx, &blacklist) - .expect("xdp disabled: no kernel work and no error"); - assert!(started.is_none()); - assert!(blacklist.is_empty()); - } + /// Wiring-тасовка XDP auto-ban: `start_xdp` обязан принимать `Arc` + /// (т.е. существовать в сигнатуре с blacklist) и при выключенном `[xdp]` + /// не трогать ни ядро, ни blacklist. Порядок `set_autoban` -> `load()` + /// внутри enabled-ветки без ядра непроверяем — см. комментарий на месте вызова. + #[test] + fn start_xdp_accepts_blacklist_and_skips_kernel_when_disabled() { + let (_tx, rx) = watch::channel(false); + let blacklist = Arc::new(Blacklist::new()); + let started = start_xdp(&Arc::new(Config::default()), &rx, &blacklist) + .expect("xdp disabled: no kernel work and no error"); + assert!(started.is_none()); + assert!(blacklist.is_empty()); + } } diff --git a/src/app/shutdown.rs b/src/app/shutdown.rs index aaf94a8..a8729eb 100644 --- a/src/app/shutdown.rs +++ b/src/app/shutdown.rs @@ -9,22 +9,22 @@ use tokio::sync::watch; /// поэтому библиотечный код остаётся свободным от lint `exit`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum RunExit { - /// Listener отработал штатно: drain уложился в таймаут. - Ok, - /// Истёк drain-таймаут: бинарь обязан завершить процесс немедленно - /// (замена прежнему `process::exit(0)` внутри shutdown-таймера). - DrainTimeout, + /// Listener отработал штатно: drain уложился в таймаут. + Ok, + /// Истёк drain-таймаут: бинарь обязан завершить процесс немедленно + /// (замена прежнему `process::exit(0)` внутри shutdown-таймера). + DrainTimeout, } impl RunExit { - /// Код завершения процесса для данного результата. - #[must_use] - pub const fn code(self) -> i32 { - match self { - Self::Ok => 0, - Self::DrainTimeout => 0, - } - } + /// Код завершения процесса для данного результата. + #[must_use] + pub const fn code(self) -> i32 { + match self { + Self::Ok => 0, + Self::DrainTimeout => 0, + } + } } /// Ставит фоновую shutdown-задачу. @@ -33,35 +33,35 @@ impl RunExit { /// бинарь, а здесь мы лишь уведомляем `run` об истечении drain-таймаута через /// oneshot-канал. Логи и тайминг (5s после сигнала) сохранены без изменений. pub(crate) fn spawn_shutdown_drain(shutdown_tx: watch::Sender, drain_tx: oneshot::Sender<()>) { - tokio::spawn(async move { - wait_for_signal().await; - tracing::info!("shutdown signal received, draining connections..."); - let _ = shutdown_tx.send(true); - tokio::time::sleep(Duration::from_secs(5)).await; - tracing::info!("shutdown timeout reached, exiting"); - let _ = drain_tx.send(()); - }); + tokio::spawn(async move { + wait_for_signal().await; + tracing::info!("shutdown signal received, draining connections..."); + let _ = shutdown_tx.send(true); + tokio::time::sleep(Duration::from_secs(5)).await; + tracing::info!("shutdown timeout reached, exiting"); + let _ = drain_tx.send(()); + }); } async fn wait_for_signal() { - let ctrl_c = tokio::signal::ctrl_c(); - let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) - .expect("failed to install SIGTERM handler"); + let ctrl_c = tokio::signal::ctrl_c(); + let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) + .expect("failed to install SIGTERM handler"); - tokio::select! { - _ = ctrl_c => {} - _ = term.recv() => {} - } + tokio::select! { + _ = ctrl_c => {} + _ = term.recv() => {} + } } #[cfg(test)] mod tests { - use super::RunExit; + use super::RunExit; - #[test] - fn run_exit_codes_match_previous_process_exit() { - // Штатный путь и прежний drain-timeout (`process::exit(0)`) завершались с кодом 0. - assert_eq!(RunExit::Ok.code(), 0); - assert_eq!(RunExit::DrainTimeout.code(), 0); - } + #[test] + fn run_exit_codes_match_previous_process_exit() { + // Штатный путь и прежний drain-timeout (`process::exit(0)`) завершались с кодом 0. + assert_eq!(RunExit::Ok.code(), 0); + assert_eq!(RunExit::DrainTimeout.code(), 0); + } } diff --git a/src/bin/rampart-cli.rs b/src/bin/rampart-cli.rs index a9528a1..3b9405e 100644 --- a/src/bin/rampart-cli.rs +++ b/src/bin/rampart-cli.rs @@ -6,67 +6,67 @@ use rampart::cli::commands; #[derive(Parser)] #[command(name = "rampart-cli", about = "Rampart management CLI")] struct Cli { - #[command(subcommand)] - command: Commands, + #[command(subcommand)] + command: Commands, } #[derive(Subcommand)] enum Commands { - /// Show overall system status - Status, - /// Run full diagnostics - Doctor, - /// Get/set configuration - Config { - #[arg(required = false)] - key: Option, - #[arg(required = false)] - value: Option, - }, - /// Manage blacklist - Blacklist { - #[command(subcommand)] - action: BlacklistAction, - }, - /// Emergency mode - Emergency { - #[arg(value_enum)] - mode: EmergencyMode, - }, - /// Gracefully drain a node - Drain { node: String }, + /// Show overall system status + Status, + /// Run full diagnostics + Doctor, + /// Get/set configuration + Config { + #[arg(required = false)] + key: Option, + #[arg(required = false)] + value: Option, + }, + /// Manage blacklist + Blacklist { + #[command(subcommand)] + action: BlacklistAction, + }, + /// Emergency mode + Emergency { + #[arg(value_enum)] + mode: EmergencyMode, + }, + /// Gracefully drain a node + Drain { node: String }, } #[derive(Subcommand)] enum BlacklistAction { - Add { target: String, reason: Option }, - Remove { target: String }, - List, + Add { target: String, reason: Option }, + Remove { target: String }, + List, } #[derive(clap::ValueEnum, Clone)] enum EmergencyMode { - Enable, - Disable, + Enable, + Disable, } #[tokio::main] async fn main() -> anyhow::Result<()> { - let cli = Cli::parse(); + let cli = Cli::parse(); - match cli.command { - Commands::Status => commands::node::status::run().await, - Commands::Doctor => commands::doctor::run().await, - Commands::Config { key, value } => commands::config::run(key, value).await, - Commands::Blacklist { action } => match action { - BlacklistAction::Add { target, reason } => commands::blacklist::add(target, reason).await, - BlacklistAction::Remove { target } => commands::blacklist::remove(target).await, - BlacklistAction::List => commands::blacklist::list().await, - }, - Commands::Emergency { mode } => match mode { - EmergencyMode::Enable => commands::node::emergency::enable().await, - EmergencyMode::Disable => commands::node::emergency::disable().await, - }, - Commands::Drain { node } => commands::node::drain::run(&node).await, - } + match cli.command { + Commands::Status => commands::node::status::run().await, + Commands::Doctor => commands::doctor::run().await, + Commands::Config { key, value } => commands::config::run(key, value).await, + Commands::Blacklist { action } => match action { + BlacklistAction::Add { target, reason } => commands::blacklist::add(target, reason).await, + BlacklistAction::Remove { target } => commands::blacklist::remove(target).await, + BlacklistAction::List => commands::blacklist::list().await, + }, + Commands::Emergency { mode } => match mode { + EmergencyMode::Enable => commands::node::emergency::enable().await, + EmergencyMode::Disable => commands::node::emergency::disable().await, + }, + Commands::Drain { node } => commands::node::drain::run(&node).await, + } } diff --git a/src/bin/rampart-manager.rs b/src/bin/rampart-manager.rs index 91efa87..ab70658 100644 --- a/src/bin/rampart-manager.rs +++ b/src/bin/rampart-manager.rs @@ -1,8 +1,8 @@ use axum::{ - Router, - http::HeaderValue, - middleware, - routing::{get, post}, + Router, + http::HeaderValue, + middleware, + routing::{get, post}, }; use dashmap::DashMap; #[cfg(feature = "store-redis")] @@ -14,84 +14,84 @@ use tracing_subscriber::EnvFilter; #[tokio::main] async fn main() -> anyhow::Result<()> { - tracing_subscriber::fmt() - .with_env_filter(EnvFilter::from_default_env().add_directive("rampart=info".parse()?)) - .init(); + tracing_subscriber::fmt() + .with_env_filter(EnvFilter::from_default_env().add_directive("rampart=info".parse()?)) + .init(); - // Manager живёт исключительно на redis-хранилище: без фичи стартовать - // нечего — fail-fast вместо полумёртвого API (features additive, TODO SOLID D). - if !cfg!(feature = "store-redis") { - anyhow::bail!("rampart-manager requires a redis state store: built without store-redis feature"); - } + // Manager живёт исключительно на redis-хранилище: без фичи стартовать + // нечего — fail-fast вместо полумёртвого API (features additive, TODO SOLID D). + if !cfg!(feature = "store-redis") { + anyhow::bail!("rampart-manager requires a redis state store: built without store-redis feature"); + } - #[cfg(feature = "store-redis")] - let redis_url = std::env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1:6379/0".to_string()); - #[cfg(feature = "store-redis")] - let redis_client = redis::Client::open(redis_url)?; + #[cfg(feature = "store-redis")] + let redis_url = std::env::var("REDIS_URL").unwrap_or_else(|_| "redis://127.0.0.1:6379/0".to_string()); + #[cfg(feature = "store-redis")] + let redis_client = redis::Client::open(redis_url)?; - let jwt_secret = std::env::var("JWT_SECRET").map_err(|_| anyhow::anyhow!("JWT_SECRET must be set"))?; - if jwt_secret.len() < 32 { - return Err(anyhow::anyhow!("JWT_SECRET must be at least 32 bytes")); - } - let jwt_audience = std::env::var("JWT_AUDIENCE").unwrap_or_else(|_| "rampart".to_string()); - let jwt_expiration = std::env::var("JWT_EXPIRATION_SECS") - .unwrap_or_else(|_| "86400".to_string()) - .parse::() - .map_err(|_| anyhow::anyhow!("JWT_EXPIRATION_SECS must be a valid u64"))?; + let jwt_secret = std::env::var("JWT_SECRET").map_err(|_| anyhow::anyhow!("JWT_SECRET must be set"))?; + if jwt_secret.len() < 32 { + return Err(anyhow::anyhow!("JWT_SECRET must be at least 32 bytes")); + } + let jwt_audience = std::env::var("JWT_AUDIENCE").unwrap_or_else(|_| "rampart".to_string()); + let jwt_expiration = std::env::var("JWT_EXPIRATION_SECS") + .unwrap_or_else(|_| "86400".to_string()) + .parse::() + .map_err(|_| anyhow::anyhow!("JWT_EXPIRATION_SECS must be a valid u64"))?; - let api_password = std::env::var("API_PASSWORD").map_err(|_| anyhow::anyhow!("API_PASSWORD must be set"))?; - if api_password == "changeme" { - return Err(anyhow::anyhow!("API_PASSWORD must not be the default 'changeme'")); - } + let api_password = std::env::var("API_PASSWORD").map_err(|_| anyhow::anyhow!("API_PASSWORD must be set"))?; + if api_password == "changeme" { + return Err(anyhow::anyhow!("API_PASSWORD must not be the default 'changeme'")); + } - let state = Arc::new(AppState { - #[cfg(feature = "store-redis")] - redis_client, - jwt_secret, - jwt_audience, - jwt_expiration, - api_password, - login_limiter: DashMap::new(), - }); + let state = Arc::new(AppState { + #[cfg(feature = "store-redis")] + redis_client, + jwt_secret, + jwt_audience, + jwt_expiration, + api_password, + login_limiter: DashMap::new(), + }); - #[cfg(feature = "store-redis")] - tokio::spawn(sync::heartbeat::start_heartbeat_check(state.clone())); + #[cfg(feature = "store-redis")] + tokio::spawn(sync::heartbeat::start_heartbeat_check(state.clone())); - let public = Router::new() - .route("/api/v1/health", get(api::inventory::health::health_check)) - .route("/api/v1/auth/login", post(api::auth::login)); + let public = Router::new() + .route("/api/v1/health", get(api::inventory::health::health_check)) + .route("/api/v1/auth/login", post(api::auth::login)); - // Redis-зависимые маршруты существуют только вместе с фичей; сам manager - // без неё bail'ит выше, поэтому 501-заглушки были бы недостижимым кодом. - let protected = Router::new(); - #[cfg(feature = "store-redis")] - let protected = protected - .route("/api/v1/servers", get(api::inventory::servers::list_servers)) - .route( - "/api/v1/blacklist", - get(api::blacklist::list_blacklist) - .post(api::blacklist::add_blacklist) - .delete(api::blacklist::remove_blacklist), - ) - .route("/api/v1/nodes", get(api::inventory::nodes::list_nodes)); - let protected = protected.route_layer(middleware::from_fn_with_state(state.clone(), auth::auth_middleware)); + // Redis-зависимые маршруты существуют только вместе с фичей; сам manager + // без неё bail'ит выше, поэтому 501-заглушки были бы недостижимым кодом. + let protected = Router::new(); + #[cfg(feature = "store-redis")] + let protected = protected + .route("/api/v1/servers", get(api::inventory::servers::list_servers)) + .route( + "/api/v1/blacklist", + get(api::blacklist::list_blacklist) + .post(api::blacklist::add_blacklist) + .delete(api::blacklist::remove_blacklist), + ) + .route("/api/v1/nodes", get(api::inventory::nodes::list_nodes)); + let protected = protected.route_layer(middleware::from_fn_with_state(state.clone(), auth::auth_middleware)); - let cors = match std::env::var("CORS_ORIGIN") { - Ok(origin) if origin.is_empty() || origin == "*" => CorsLayer::new().allow_origin(tower_http::cors::Any), - Ok(origin) => CorsLayer::new().allow_origin(HeaderValue::from_str(&origin)?), - Err(_) => CorsLayer::new().allow_origin(HeaderValue::from_static("http://localhost:5173")), - }; + let cors = match std::env::var("CORS_ORIGIN") { + Ok(origin) if origin.is_empty() || origin == "*" => CorsLayer::new().allow_origin(tower_http::cors::Any), + Ok(origin) => CorsLayer::new().allow_origin(HeaderValue::from_str(&origin)?), + Err(_) => CorsLayer::new().allow_origin(HeaderValue::from_static("http://localhost:5173")), + }; - let app = Router::new() - .merge(public) - .merge(protected) - .layer(cors) - .with_state(state); + let app = Router::new() + .merge(public) + .merge(protected) + .layer(cors) + .with_state(state); - let addr = "0.0.0.0:8080"; - tracing::info!("Manager API listening on {addr}"); - let listener = tokio::net::TcpListener::bind(addr).await?; - let app = app.into_make_service_with_connect_info::(); - axum::serve(listener, app).await?; - Ok(()) + let addr = "0.0.0.0:8080"; + tracing::info!("Manager API listening on {addr}"); + let listener = tokio::net::TcpListener::bind(addr).await?; + let app = app.into_make_service_with_connect_info::(); + axum::serve(listener, app).await?; + Ok(()) } diff --git a/src/bin/rampart-tui.rs b/src/bin/rampart-tui.rs index 4c10538..47d445a 100644 --- a/src/bin/rampart-tui.rs +++ b/src/bin/rampart-tui.rs @@ -14,51 +14,51 @@ use rampart::tui::state::AppState; #[derive(Parser)] #[command( - name = "rampart-tui", - about = "Rampart live metrics TUI (Prometheus /metrics source)" + name = "rampart-tui", + about = "Rampart live metrics TUI (Prometheus /metrics source)" )] struct Cli { - /// URL Prometheus metrics endpoint - #[arg(long, default_value = "http://127.0.0.1:9090/metrics")] - url: String, - /// Период опроса, секунды - #[arg(long, default_value_t = 1)] - refresh_secs: u64, + /// URL Prometheus metrics endpoint + #[arg(long, default_value = "http://127.0.0.1:9090/metrics")] + url: String, + /// Период опроса, секунды + #[arg(long, default_value_t = 1)] + refresh_secs: u64, } fn main() -> anyhow::Result<()> { - let cli = Cli::parse(); - let Some(fetcher) = HttpFetcher::new(cli.url.clone()) else { - anyhow::bail!("failed to build http client"); - }; - let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build()?; + let cli = Cli::parse(); + let Some(fetcher) = HttpFetcher::new(cli.url.clone()) else { + anyhow::bail!("failed to build http client"); + }; + let runtime = tokio::runtime::Builder::new_current_thread().enable_all().build()?; - let terminal = ratatui::try_init()?; - let result = runtime.block_on(run( - terminal, - Arc::new(fetcher) as Arc, - cli.url, - Duration::from_secs(cli.refresh_secs.max(1)), - )); - ratatui::restore(); - result + let terminal = ratatui::try_init()?; + let result = runtime.block_on(run( + terminal, + Arc::new(fetcher) as Arc, + cli.url, + Duration::from_secs(cli.refresh_secs.max(1)), + )); + ratatui::restore(); + result } async fn run( - mut terminal: Terminal>, - fetcher: Arc, - url: String, - refresh: Duration, + mut terminal: Terminal>, + fetcher: Arc, + url: String, + refresh: Duration, ) -> anyhow::Result<()> { - let state = Arc::new(AppState::new(url)); - let notify = Arc::new(Notify::new()); - tokio::spawn(app::spawn_fetch_loop( - fetcher, - Arc::clone(&state), - refresh, - Arc::clone(¬ify), - )); - app::run_ui(&mut terminal, state, notify) - .await - .map_err(anyhow::Error::from) + let state = Arc::new(AppState::new(url)); + let notify = Arc::new(Notify::new()); + tokio::spawn(app::spawn_fetch_loop( + fetcher, + Arc::clone(&state), + refresh, + Arc::clone(¬ify), + )); + app::run_ui(&mut terminal, state, notify) + .await + .map_err(anyhow::Error::from) } diff --git a/src/bin/rampart.rs b/src/bin/rampart.rs index 0bbd751..4aec901 100644 --- a/src/bin/rampart.rs +++ b/src/bin/rampart.rs @@ -2,10 +2,10 @@ use rampart::app::{self, RunExit}; #[tokio::main] async fn main() -> anyhow::Result<()> { - match app::run().await? { - // Штатное завершение listener: управление возвращается tokio-рантайму. - RunExit::Ok => Ok(()), - // Drain-таймаут: бинарь — единственное место, где допустим process::exit. - exit => std::process::exit(exit.code()), - } + match app::run().await? { + // Штатное завершение listener: управление возвращается tokio-рантайму. + RunExit::Ok => Ok(()), + // Drain-таймаут: бинарь — единственное место, где допустим process::exit. + exit => std::process::exit(exit.code()), + } } diff --git a/src/cli/commands/blacklist.rs b/src/cli/commands/blacklist.rs index 70caefc..dc59719 100644 --- a/src/cli/commands/blacklist.rs +++ b/src/cli/commands/blacklist.rs @@ -3,97 +3,97 @@ use serde::Serialize; #[derive(Deserialize)] struct AddResponse { - status: String, - target: String, + status: String, + target: String, } #[derive(Deserialize)] struct BlacklistItem { - target: String, - reason: String, + target: String, + reason: String, } #[derive(Deserialize)] struct BlacklistResponse { - items: Vec, - total: usize, + items: Vec, + total: usize, } #[derive(Deserialize)] struct LoginResponse { - token: String, + token: String, } #[derive(Serialize)] struct RemoveRequest<'a> { - target: &'a str, + target: &'a str, } async fn authenticated_client() -> anyhow::Result<(reqwest::Client, String, String)> { - let manager_url = std::env::var("RAMPART_MANAGER").unwrap_or_else(|_| "http://localhost:8080".to_string()); - let password = std::env::var("RAMPART_API_PASSWORD") - .map_err(|_| anyhow::anyhow!("RAMPART_API_PASSWORD must be set to use the manager blacklist API"))?; - let client = reqwest::Client::new(); - let response = client - .post(format!("{manager_url}/api/v1/auth/login")) - .json(&serde_json::json!({"password": password})) - .send() - .await? - .error_for_status()?; - let token = response.json::().await?.token; - Ok((client, manager_url, token)) + let manager_url = std::env::var("RAMPART_MANAGER").unwrap_or_else(|_| "http://localhost:8080".to_string()); + let password = std::env::var("RAMPART_API_PASSWORD") + .map_err(|_| anyhow::anyhow!("RAMPART_API_PASSWORD must be set to use the manager blacklist API"))?; + let client = reqwest::Client::new(); + let response = client + .post(format!("{manager_url}/api/v1/auth/login")) + .json(&serde_json::json!({"password": password})) + .send() + .await? + .error_for_status()?; + let token = response.json::().await?.token; + Ok((client, manager_url, token)) } pub async fn add(target: String, reason: Option) -> anyhow::Result<()> { - let (client, manager_url, token) = authenticated_client().await?; + let (client, manager_url, token) = authenticated_client().await?; - let body = serde_json::json!({ - "target": target, - "type": "ip", - "reason": reason.unwrap_or_else(|| "manual".to_string()), - }); + let body = serde_json::json!({ + "target": target, + "type": "ip", + "reason": reason.unwrap_or_else(|| "manual".to_string()), + }); - let resp = client - .post(format!("{manager_url}/api/v1/blacklist")) - .bearer_auth(token) - .json(&body) - .send() - .await? - .error_for_status()? - .json::() - .await?; - println!("[OK] {}: {}", resp.status, resp.target); - Ok(()) + let resp = client + .post(format!("{manager_url}/api/v1/blacklist")) + .bearer_auth(token) + .json(&body) + .send() + .await? + .error_for_status()? + .json::() + .await?; + println!("[OK] {}: {}", resp.status, resp.target); + Ok(()) } pub async fn remove(target: String) -> anyhow::Result<()> { - let (client, manager_url, token) = authenticated_client().await?; - let response = client - .delete(format!("{manager_url}/api/v1/blacklist")) - .bearer_auth(token) - .json(&RemoveRequest { target: &target }) - .send() - .await? - .error_for_status()?; - let result: serde_json::Value = response.json().await?; - println!("[OK] {}: {}", result["status"].as_str().unwrap_or("removed"), target); - Ok(()) + let (client, manager_url, token) = authenticated_client().await?; + let response = client + .delete(format!("{manager_url}/api/v1/blacklist")) + .bearer_auth(token) + .json(&RemoveRequest { target: &target }) + .send() + .await? + .error_for_status()?; + let result: serde_json::Value = response.json().await?; + println!("[OK] {}: {}", result["status"].as_str().unwrap_or("removed"), target); + Ok(()) } pub async fn list() -> anyhow::Result<()> { - let (client, manager_url, token) = authenticated_client().await?; - let list = client - .get(format!("{manager_url}/api/v1/blacklist")) - .bearer_auth(token) - .send() - .await? - .error_for_status()? - .json::() - .await?; - println!("Blacklist ({} entries)", list.total); - println!("----------------------"); - for item in &list.items { - println!(" {} ({})", item.target, item.reason); - } - Ok(()) + let (client, manager_url, token) = authenticated_client().await?; + let list = client + .get(format!("{manager_url}/api/v1/blacklist")) + .bearer_auth(token) + .send() + .await? + .error_for_status()? + .json::() + .await?; + println!("Blacklist ({} entries)", list.total); + println!("----------------------"); + for item in &list.items { + println!(" {} ({})", item.target, item.reason); + } + Ok(()) } diff --git a/src/cli/commands/config.rs b/src/cli/commands/config.rs index 4c97383..15c5f29 100644 --- a/src/cli/commands/config.rs +++ b/src/cli/commands/config.rs @@ -1,19 +1,19 @@ pub async fn run(key: Option, value: Option) -> anyhow::Result<()> { - match (key, value) { - (Some(_), Some(_)) => { - anyhow::bail!("config updates are not implemented; edit the edge config and restart Rampart") - }, - (Some(_), None) => anyhow::bail!("config lookup is not implemented"), - (None, Some(_)) | (None, None) => { - println!("Configuration"); - println!("=============\n"); - println!("Use: rampart config [value]"); - println!(); - println!("Example keys:"); - println!(" workers.count"); - println!(" limits.rate_limit_login_pps"); - println!(" limits.max_connections_per_ip"); - Ok(()) - }, - } + match (key, value) { + (Some(_), Some(_)) => { + anyhow::bail!("config updates are not implemented; edit the edge config and restart Rampart") + }, + (Some(_), None) => anyhow::bail!("config lookup is not implemented"), + (None, Some(_)) | (None, None) => { + println!("Configuration"); + println!("=============\n"); + println!("Use: rampart config [value]"); + println!(); + println!("Example keys:"); + println!(" workers.count"); + println!(" limits.rate_limit_login_pps"); + println!(" limits.max_connections_per_ip"); + Ok(()) + }, + } } diff --git a/src/cli/commands/doctor.rs b/src/cli/commands/doctor.rs index d773396..95ce33b 100644 --- a/src/cli/commands/doctor.rs +++ b/src/cli/commands/doctor.rs @@ -3,104 +3,104 @@ use crate::xdp::{EnvironmentReport, FilesystemProbe, SystemProbe}; /// Ищет интерфейс с маршрутом по умолчанию в /proc/net/route /// (destination == 00000000). Работает без root. fn default_route_interface(probe: &impl SystemProbe) -> Option { - let routes = probe.read_file("/proc/net/route").ok()?; - routes.lines().skip(1).find_map(|line| { - let fields: Vec<&str> = line.split_whitespace().collect(); - (fields.len() > 7 && fields[1] == "00000000").then(|| fields[0].to_owned()) - }) + let routes = probe.read_file("/proc/net/route").ok()?; + routes.lines().skip(1).find_map(|line| { + let fields: Vec<&str> = line.split_whitespace().collect(); + (fields.len() > 7 && fields[1] == "00000000").then(|| fields[0].to_owned()) + }) } /// Подсекция network/XDP: что видно окружению без root. fn print_network_section(all_ok: &mut bool) { - println!("\nNetwork / XDP"); - println!("-------------"); + println!("\nNetwork / XDP"); + println!("-------------"); - let probe = FilesystemProbe; - let Some(interface) = default_route_interface(&probe) else { - println!("[WARN] Default route interface not found, XDP checks skipped"); - return; - }; - println!("Interface: {interface}"); + let probe = FilesystemProbe; + let Some(interface) = default_route_interface(&probe) else { + println!("[WARN] Default route interface not found, XDP checks skipped"); + return; + }; + println!("Interface: {interface}"); - let report = EnvironmentReport::collect(&probe, &interface); - let kernel = report - .kernel_version - .map_or_else(|| "unknown".to_owned(), |v| v.to_string()); - println!("Kernel: {kernel}"); - println!( - "BTF: {}", - if report.btf_available { - "available" - } else { - "missing (CO-RE disabled)" - } - ); - println!( - "Privileges: {}", - if report.privileged { - "root (capabilities assumed)" - } else { - "non-root" - } - ); - println!("Driver: {}", report.driver_name.as_deref().unwrap_or("unknown")); - println!("Attach mode: {}", report.attach_mode()); - println!("Verdict: {}", report.verdict()); - for warning in &report.warnings { - println!("[WARN] {warning}"); - } - if let Err(e) = report.validate() { - println!("[FAIL] {e}"); - *all_ok = false; - } else { - println!("[OK] XDP environment"); - } + let report = EnvironmentReport::collect(&probe, &interface); + let kernel = report + .kernel_version + .map_or_else(|| "unknown".to_owned(), |v| v.to_string()); + println!("Kernel: {kernel}"); + println!( + "BTF: {}", + if report.btf_available { + "available" + } else { + "missing (CO-RE disabled)" + } + ); + println!( + "Privileges: {}", + if report.privileged { + "root (capabilities assumed)" + } else { + "non-root" + } + ); + println!("Driver: {}", report.driver_name.as_deref().unwrap_or("unknown")); + println!("Attach mode: {}", report.attach_mode()); + println!("Verdict: {}", report.verdict()); + for warning in &report.warnings { + println!("[WARN] {warning}"); + } + if let Err(e) = report.validate() { + println!("[FAIL] {e}"); + *all_ok = false; + } else { + println!("[OK] XDP environment"); + } } pub async fn run() -> anyhow::Result<()> { - println!("Rampart Diagnostics"); - println!("=====================\n"); + println!("Rampart Diagnostics"); + println!("=====================\n"); - let mut all_ok = true; + let mut all_ok = true; - let manager_url = std::env::var("RAMPART_MANAGER").unwrap_or_else(|_| "http://localhost:8080".to_string()); + let manager_url = std::env::var("RAMPART_MANAGER").unwrap_or_else(|_| "http://localhost:8080".to_string()); - match reqwest::get(format!("{manager_url}/api/v1/health")).await { - Ok(resp) if resp.status().is_success() => { - println!("[OK] Manager API"); - }, - _ => { - println!("[FAIL] Manager API"); - all_ok = false; - }, - } + match reqwest::get(format!("{manager_url}/api/v1/health")).await { + Ok(resp) if resp.status().is_success() => { + println!("[OK] Manager API"); + }, + _ => { + println!("[FAIL] Manager API"); + all_ok = false; + }, + } - match reqwest::get(format!("{manager_url}/api/v1/blacklist")).await { - Ok(resp) if resp.status().is_success() => { - println!("[OK] Blacklist API"); - }, - _ => { - println!("[WARN] Blacklist API unavailable"); - }, - } + match reqwest::get(format!("{manager_url}/api/v1/blacklist")).await { + Ok(resp) if resp.status().is_success() => { + println!("[OK] Blacklist API"); + }, + _ => { + println!("[WARN] Blacklist API unavailable"); + }, + } - match reqwest::get(format!("{manager_url}/api/v1/servers")).await { - Ok(resp) if resp.status().is_success() => { - println!("[OK] Servers API"); - }, - _ => { - println!("[WARN] Servers API unavailable"); - }, - } + match reqwest::get(format!("{manager_url}/api/v1/servers")).await { + Ok(resp) if resp.status().is_success() => { + println!("[OK] Servers API"); + }, + _ => { + println!("[WARN] Servers API unavailable"); + }, + } - print_network_section(&mut all_ok); + print_network_section(&mut all_ok); - println!(); - if all_ok { - println!("All checks passed."); - } else { - println!("Some checks failed. Run with --verbose for details."); - } + println!(); + if all_ok { + println!("All checks passed."); + } else { + println!("Some checks failed. Run with --verbose for details."); + } - Ok(()) + Ok(()) } diff --git a/src/cli/commands/node/drain.rs b/src/cli/commands/node/drain.rs index 3d33261..113a24a 100644 --- a/src/cli/commands/node/drain.rs +++ b/src/cli/commands/node/drain.rs @@ -1,3 +1,3 @@ pub async fn run(node: &str) -> anyhow::Result<()> { - anyhow::bail!("graceful drain is not implemented for node {node}") + anyhow::bail!("graceful drain is not implemented for node {node}") } diff --git a/src/cli/commands/node/emergency.rs b/src/cli/commands/node/emergency.rs index 91b88e2..fc1bf69 100644 --- a/src/cli/commands/node/emergency.rs +++ b/src/cli/commands/node/emergency.rs @@ -1,7 +1,7 @@ pub async fn enable() -> anyhow::Result<()> { - anyhow::bail!("emergency mode is not implemented; change the edge policy and restart Rampart") + anyhow::bail!("emergency mode is not implemented; change the edge policy and restart Rampart") } pub async fn disable() -> anyhow::Result<()> { - anyhow::bail!("emergency mode is not implemented; change the edge policy and restart Rampart") + anyhow::bail!("emergency mode is not implemented; change the edge policy and restart Rampart") } diff --git a/src/cli/commands/node/status.rs b/src/cli/commands/node/status.rs index 95f3d90..6ab043d 100644 --- a/src/cli/commands/node/status.rs +++ b/src/cli/commands/node/status.rs @@ -1,23 +1,23 @@ pub async fn run() -> anyhow::Result<()> { - println!("Rampart Status"); - println!("================\n"); + println!("Rampart Status"); + println!("================\n"); - let manager_url = std::env::var("RAMPART_MANAGER").unwrap_or_else(|_| "http://localhost:8080".to_string()); + let manager_url = std::env::var("RAMPART_MANAGER").unwrap_or_else(|_| "http://localhost:8080".to_string()); - match reqwest::get(format!("{manager_url}/api/v1/health")).await { - Ok(resp) => { - if let Ok(body) = resp.json::().await { - println!( - "Manager: {} (v{})", - body["status"].as_str().unwrap_or("unknown"), - body["version"].as_str().unwrap_or("?") - ); - } - }, - Err(e) => println!("Manager: unreachable ({e})"), - } + match reqwest::get(format!("{manager_url}/api/v1/health")).await { + Ok(resp) => { + if let Ok(body) = resp.json::().await { + println!( + "Manager: {} (v{})", + body["status"].as_str().unwrap_or("unknown"), + body["version"].as_str().unwrap_or("?") + ); + } + }, + Err(e) => println!("Manager: unreachable ({e})"), + } - println!(); - println!("To check individual components, run: rampart doctor"); - Ok(()) + println!(); + println!("To check individual components, run: rampart doctor"); + Ok(()) } diff --git a/src/config/mod.rs b/src/config/mod.rs index 62ba1aa..e790f70 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -8,9 +8,9 @@ pub use sections::MinecraftProtocolConfig; #[cfg(any(feature = "protocol-http", feature = "protocol-minecraft"))] pub use sections::ProtocolConfig; pub use sections::{ - BackendConfig, BanConfig, BindConfig, DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig, - LimitsConfig, LoggingConfig, MetricsConfig, PowConfig, ProxyProtocolConfig, StoreConfig, TrustedProxyCidr, - WorkerConfig, XdpConfig, + BackendConfig, BanConfig, BindConfig, DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig, + LimitsConfig, LoggingConfig, MetricsConfig, PowConfig, ProxyProtocolConfig, StoreConfig, TrustedProxyCidr, + WorkerConfig, XdpConfig, }; use serde::Deserialize; @@ -18,141 +18,141 @@ use std::fs; #[derive(Debug, Clone, Default, Deserialize)] pub struct Config { - #[serde(default)] - pub bind: BindConfig, - #[serde(default)] - pub backend: BackendConfig, - #[serde(default)] - pub workers: WorkerConfig, - #[serde(default)] - pub limits: LimitsConfig, - #[serde(default)] - pub proxy_protocol: ProxyProtocolConfig, - #[serde(default)] - pub ban: BanConfig, - #[serde(default)] - pub store: StoreConfig, - #[serde(default)] - pub xdp: XdpConfig, - #[serde(default)] - pub logging: LoggingConfig, - #[serde(default)] - pub metrics: MetricsConfig, - #[serde(default)] - pub pow: PowConfig, - #[serde(default)] - pub detect: DetectConfig, - #[cfg(any(feature = "protocol-http", feature = "protocol-minecraft"))] - #[serde(default)] - pub protocol: ProtocolConfig, - #[serde(default)] - pub whitelist: Vec, + #[serde(default)] + pub bind: BindConfig, + #[serde(default)] + pub backend: BackendConfig, + #[serde(default)] + pub workers: WorkerConfig, + #[serde(default)] + pub limits: LimitsConfig, + #[serde(default)] + pub proxy_protocol: ProxyProtocolConfig, + #[serde(default)] + pub ban: BanConfig, + #[serde(default)] + pub store: StoreConfig, + #[serde(default)] + pub xdp: XdpConfig, + #[serde(default)] + pub logging: LoggingConfig, + #[serde(default)] + pub metrics: MetricsConfig, + #[serde(default)] + pub pow: PowConfig, + #[serde(default)] + pub detect: DetectConfig, + #[cfg(any(feature = "protocol-http", feature = "protocol-minecraft"))] + #[serde(default)] + pub protocol: ProtocolConfig, + #[serde(default)] + pub whitelist: Vec, } impl Config { - /// Парсит конфиг из TOML-строки и валидирует семантику. - /// - /// # Errors - /// Возвращает ошибку при невалидном TOML или нарушении инвариантов - /// (пустой список upstream-бэкендов, некорректные адреса). - pub fn parse_str(contents: &str) -> anyhow::Result { - let config: Config = toml::from_str(contents)?; - config.validate()?; - Ok(config) - } + /// Парсит конфиг из TOML-строки и валидирует семантику. + /// + /// # Errors + /// Возвращает ошибку при невалидном TOML или нарушении инвариантов + /// (пустой список upstream-бэкендов, некорректные адреса). + pub fn parse_str(contents: &str) -> anyhow::Result { + let config: Config = toml::from_str(contents)?; + config.validate()?; + Ok(config) + } - /// Читает и парсит конфиг из файла. - /// - /// # Errors - /// Возвращает ошибку при невозможности прочитать файл или невалидном содержимом. - pub fn from_file(path: &str) -> anyhow::Result { - let contents = fs::read_to_string(path)?; - Self::parse_str(&contents) - } + /// Читает и парсит конфиг из файла. + /// + /// # Errors + /// Возвращает ошибку при невозможности прочитать файл или невалидном содержимом. + pub fn from_file(path: &str) -> anyhow::Result { + let contents = fs::read_to_string(path)?; + Self::parse_str(&contents) + } - fn validate(&self) -> anyhow::Result<()> { - if self.backend.upstreams.is_empty() { - anyhow::bail!("backend.upstreams must not be empty"); - } - for upstream in &self.backend.upstreams { - if upstream.parse::().is_err() { - anyhow::bail!("invalid upstream address: {upstream}"); - } - } - for entry in &self.whitelist { - if entry.parse::().is_err() { - anyhow::bail!("invalid whitelist entry: {entry}"); - } - } - if self.detect.prefix.enabled && self.detect.prefix.syn_threshold == 0 { - anyhow::bail!("detect.prefix.syn_threshold must be positive when enabled"); - } - if self.limits.max_connections_per_ip == 0 { - anyhow::bail!("limits.max_connections_per_ip must be positive"); - } - if self.proxy_protocol.ingress_enabled { - if self.proxy_protocol.trusted_cidrs.is_empty() { - anyhow::bail!("proxy_protocol.ingress_enabled requires at least one trusted_cidrs entry"); - } - if self.proxy_protocol.ingress_timeout_ms == 0 || self.proxy_protocol.ingress_timeout_ms > 5_000 { - anyhow::bail!("proxy_protocol.ingress_timeout_ms must be between 1 and 5000"); - } - if self.proxy_protocol.max_header_bytes < 52 || self.proxy_protocol.max_header_bytes > 4096 { - anyhow::bail!("proxy_protocol.max_header_bytes must be between 52 and 4096"); - } - #[cfg(feature = "protocol-minecraft")] - if !self.protocol.minecraft.enabled { - anyhow::bail!("proxy_protocol.ingress_enabled requires protocol.minecraft.enabled"); - } - #[cfg(not(feature = "protocol-minecraft"))] - anyhow::bail!("proxy_protocol.ingress_enabled requires the protocol-minecraft feature"); - } - #[cfg(feature = "protocol-http")] - { - if self.protocol.http.max_header_bytes == 0 { - anyhow::bail!("protocol.http.max_header_bytes must be positive"); - } - if self.protocol.http.timeout_secs == 0 { - anyhow::bail!("protocol.http.timeout_secs must be positive"); - } - } - #[cfg(feature = "protocol-minecraft")] - if self.protocol.minecraft.enabled { - if self.pow.enabled { - anyhow::bail!("pow.enabled is incompatible with protocol.minecraft"); - } - if self.backend.upstreams.len() != 1 { - anyhow::bail!("protocol.minecraft requires exactly one backend.upstreams entry"); - } - if self.protocol.minecraft.max_frame_bytes == 0 { - anyhow::bail!("protocol.minecraft.max_frame_bytes must be positive"); - } - if self.protocol.minecraft.timeout_secs == 0 { - anyhow::bail!("protocol.minecraft.timeout_secs must be positive"); - } - } - Ok(()) - } + fn validate(&self) -> anyhow::Result<()> { + if self.backend.upstreams.is_empty() { + anyhow::bail!("backend.upstreams must not be empty"); + } + for upstream in &self.backend.upstreams { + if upstream.parse::().is_err() { + anyhow::bail!("invalid upstream address: {upstream}"); + } + } + for entry in &self.whitelist { + if entry.parse::().is_err() { + anyhow::bail!("invalid whitelist entry: {entry}"); + } + } + if self.detect.prefix.enabled && self.detect.prefix.syn_threshold == 0 { + anyhow::bail!("detect.prefix.syn_threshold must be positive when enabled"); + } + if self.limits.max_connections_per_ip == 0 { + anyhow::bail!("limits.max_connections_per_ip must be positive"); + } + if self.proxy_protocol.ingress_enabled { + if self.proxy_protocol.trusted_cidrs.is_empty() { + anyhow::bail!("proxy_protocol.ingress_enabled requires at least one trusted_cidrs entry"); + } + if self.proxy_protocol.ingress_timeout_ms == 0 || self.proxy_protocol.ingress_timeout_ms > 5_000 { + anyhow::bail!("proxy_protocol.ingress_timeout_ms must be between 1 and 5000"); + } + if self.proxy_protocol.max_header_bytes < 52 || self.proxy_protocol.max_header_bytes > 4096 { + anyhow::bail!("proxy_protocol.max_header_bytes must be between 52 and 4096"); + } + #[cfg(feature = "protocol-minecraft")] + if !self.protocol.minecraft.enabled { + anyhow::bail!("proxy_protocol.ingress_enabled requires protocol.minecraft.enabled"); + } + #[cfg(not(feature = "protocol-minecraft"))] + anyhow::bail!("proxy_protocol.ingress_enabled requires the protocol-minecraft feature"); + } + #[cfg(feature = "protocol-http")] + { + if self.protocol.http.max_header_bytes == 0 { + anyhow::bail!("protocol.http.max_header_bytes must be positive"); + } + if self.protocol.http.timeout_secs == 0 { + anyhow::bail!("protocol.http.timeout_secs must be positive"); + } + } + #[cfg(feature = "protocol-minecraft")] + if self.protocol.minecraft.enabled { + if self.pow.enabled { + anyhow::bail!("pow.enabled is incompatible with protocol.minecraft"); + } + if self.backend.upstreams.len() != 1 { + anyhow::bail!("protocol.minecraft requires exactly one backend.upstreams entry"); + } + if self.protocol.minecraft.max_frame_bytes == 0 { + anyhow::bail!("protocol.minecraft.max_frame_bytes must be positive"); + } + if self.protocol.minecraft.timeout_secs == 0 { + anyhow::bail!("protocol.minecraft.timeout_secs must be positive"); + } + } + Ok(()) + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn empty_config_uses_defaults() { - let config = Config::parse_str("").expect("empty config should parse"); - 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!(!config.pow.enabled); - assert!(!config.xdp.enabled); - } + #[test] + fn empty_config_uses_defaults() { + let config = Config::parse_str("").expect("empty config should parse"); + 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!(!config.pow.enabled); + assert!(!config.xdp.enabled); + } - #[test] - fn full_config_parses() { - let config = Config::parse_str( - r#" + #[test] + fn full_config_parses() { + let config = Config::parse_str( + r#" [bind] address = "10.0.0.1" port = 443 @@ -166,78 +166,78 @@ difficulty = 6 whitelist = ["203.0.113.7"] "#, - ) - .expect("config should parse"); - assert_eq!(config.bind.port, 443); - assert_eq!(config.backend.upstreams.len(), 2); - assert!(config.pow.enabled); - assert_eq!(config.pow.difficulty, 6); - } + ) + .expect("config should parse"); + assert_eq!(config.bind.port, 443); + assert_eq!(config.backend.upstreams.len(), 2); + assert!(config.pow.enabled); + assert_eq!(config.pow.difficulty, 6); + } - #[test] - fn empty_upstreams_rejected() { - let result = Config::parse_str( - r#" + #[test] + fn empty_upstreams_rejected() { + let result = Config::parse_str( + r#" [backend] upstreams = [] "#, - ); - assert!(result.is_err()); - } + ); + assert!(result.is_err()); + } - #[test] - fn invalid_upstream_rejected() { - let result = Config::parse_str( - r#" + #[test] + fn invalid_upstream_rejected() { + let result = Config::parse_str( + r#" [backend] upstreams = ["not-an-addr"] "#, - ); - assert!(result.is_err()); - } + ); + assert!(result.is_err()); + } - #[test] - fn invalid_whitelist_entry_rejected() { - let result = Config::parse_str("whitelist = [\"999.999.1.1\"]"); - assert!(result.is_err()); - } + #[test] + fn invalid_whitelist_entry_rejected() { + let result = Config::parse_str("whitelist = [\"999.999.1.1\"]"); + assert!(result.is_err()); + } - #[test] - fn prefix_detect_defaults_disabled() { - let config = Config::parse_str("").expect("empty config should parse"); - assert!(!config.detect.prefix.enabled); - assert_eq!(config.detect.prefix.syn_threshold, 500); - assert_eq!(config.detect.prefix.window_secs, 10); - assert_eq!(config.detect.prefix.min_unique_sources, 16); - } + #[test] + fn prefix_detect_defaults_disabled() { + let config = Config::parse_str("").expect("empty config should parse"); + assert!(!config.detect.prefix.enabled); + assert_eq!(config.detect.prefix.syn_threshold, 500); + assert_eq!(config.detect.prefix.window_secs, 10); + assert_eq!(config.detect.prefix.min_unique_sources, 16); + } - #[test] - fn prefix_detect_section_parses() { - let config = Config::parse_str( - r#" + #[test] + fn prefix_detect_section_parses() { + let config = Config::parse_str( + r#" [detect.prefix] enabled = true syn_threshold = 1000 window_secs = 5 min_unique_sources = 8 "#, - ) - .expect("detect.prefix section should parse"); - assert!(config.detect.prefix.enabled); - assert_eq!(config.detect.prefix.syn_threshold, 1000); - assert_eq!(config.detect.prefix.window_secs, 5); - assert_eq!(config.detect.prefix.min_unique_sources, 8); - } + ) + .expect("detect.prefix section should parse"); + assert!(config.detect.prefix.enabled); + assert_eq!(config.detect.prefix.syn_threshold, 1000); + assert_eq!(config.detect.prefix.window_secs, 5); + assert_eq!(config.detect.prefix.min_unique_sources, 8); + } - #[test] - fn prefix_detect_zero_threshold_rejected_when_enabled() { - let result = Config::parse_str( - r#" + #[test] + fn prefix_detect_zero_threshold_rejected_when_enabled() { + let result = Config::parse_str( + r#" [detect.prefix] enabled = true syn_threshold = 0 "#, - ); - assert!(result.is_err()); - } + ); + assert!(result.is_err()); + } } diff --git a/src/config/sections/detect.rs b/src/config/sections/detect.rs index 2d90c7b..420d522 100644 --- a/src/config/sections/detect.rs +++ b/src/config/sections/detect.rs @@ -3,12 +3,12 @@ use serde::Deserialize; /// Секция `[detect]`: детекторы распределённых атак. #[derive(Debug, Clone, Default, Deserialize)] pub struct DetectConfig { - #[serde(default)] - pub prefix: DetectPrefixConfig, - #[serde(default)] - pub autoban: DetectAutobanConfig, - #[serde(default)] - pub alert: DetectAlertConfig, + #[serde(default)] + pub prefix: DetectPrefixConfig, + #[serde(default)] + pub autoban: DetectAutobanConfig, + #[serde(default)] + pub alert: DetectAlertConfig, } /// Секция `[detect.autoban]`: авто-бан источников по репутации и сигналам @@ -16,150 +16,150 @@ pub struct DetectConfig { /// TTL берётся из `ban.ban_duration_secs`. #[derive(Debug, Clone, Deserialize)] pub struct DetectAutobanConfig { - #[serde(default)] - pub enabled: bool, - #[serde(default = "default_autoban_reputation_threshold")] - pub reputation_threshold: i32, + #[serde(default)] + pub enabled: bool, + #[serde(default = "default_autoban_reputation_threshold")] + pub reputation_threshold: i32, } impl Default for DetectAutobanConfig { - fn default() -> Self { - Self { - enabled: false, - reputation_threshold: default_autoban_reputation_threshold(), - } - } + fn default() -> Self { + Self { + enabled: false, + reputation_threshold: default_autoban_reputation_threshold(), + } + } } fn default_autoban_reputation_threshold() -> i32 { - -50 + -50 } /// Секция `[detect.alert]`: webhook-алерты на переходах состояния атаки /// («атака началась» / «атака закончилась»). #[derive(Debug, Clone, Default, Deserialize)] pub struct DetectAlertConfig { - #[serde(default)] - pub webhook_url: Option, + #[serde(default)] + pub webhook_url: Option, } /// Секция `[detect.prefix]`: subnet-level детектор распределённых атак. #[derive(Debug, Clone, Deserialize)] pub struct DetectPrefixConfig { - #[serde(default)] - pub enabled: bool, - #[serde(default = "default_prefix_syn_threshold")] - pub syn_threshold: u64, - #[serde(default = "default_prefix_window_secs")] - pub window_secs: u64, - #[serde(default = "default_prefix_min_unique_sources")] - pub min_unique_sources: u64, + #[serde(default)] + pub enabled: bool, + #[serde(default = "default_prefix_syn_threshold")] + pub syn_threshold: u64, + #[serde(default = "default_prefix_window_secs")] + pub window_secs: u64, + #[serde(default = "default_prefix_min_unique_sources")] + pub min_unique_sources: u64, } impl Default for DetectPrefixConfig { - fn default() -> Self { - Self { - enabled: false, - syn_threshold: default_prefix_syn_threshold(), - window_secs: default_prefix_window_secs(), - min_unique_sources: default_prefix_min_unique_sources(), - } - } + fn default() -> Self { + Self { + enabled: false, + syn_threshold: default_prefix_syn_threshold(), + window_secs: default_prefix_window_secs(), + min_unique_sources: default_prefix_min_unique_sources(), + } + } } fn default_prefix_syn_threshold() -> u64 { - 500 + 500 } fn default_prefix_window_secs() -> u64 { - 10 + 10 } fn default_prefix_min_unique_sources() -> u64 { - 16 + 16 } /// Секция `[protocol]`: протокольные обработчики (plugin-by-feature). #[cfg(any(feature = "protocol-http", feature = "protocol-minecraft"))] #[derive(Debug, Clone, Default, Deserialize)] pub struct ProtocolConfig { - #[cfg(feature = "protocol-http")] - #[serde(default)] - pub http: HttpProtocolConfig, - #[cfg(feature = "protocol-minecraft")] - #[serde(default)] - pub minecraft: MinecraftProtocolConfig, + #[cfg(feature = "protocol-http")] + #[serde(default)] + pub http: HttpProtocolConfig, + #[cfg(feature = "protocol-minecraft")] + #[serde(default)] + pub minecraft: MinecraftProtocolConfig, } #[cfg(feature = "protocol-minecraft")] #[derive(Debug, Clone, Deserialize)] pub struct MinecraftProtocolConfig { - #[serde(default = "default_minecraft_enabled")] - pub enabled: bool, - #[serde(default = "default_minecraft_max_frame_bytes")] - pub max_frame_bytes: usize, - #[serde(default = "default_minecraft_timeout_secs")] - pub timeout_secs: u64, - #[serde(default, alias = "proxy_protocol")] - pub send_proxy_protocol: bool, + #[serde(default = "default_minecraft_enabled")] + pub enabled: bool, + #[serde(default = "default_minecraft_max_frame_bytes")] + pub max_frame_bytes: usize, + #[serde(default = "default_minecraft_timeout_secs")] + pub timeout_secs: u64, + #[serde(default, alias = "proxy_protocol")] + pub send_proxy_protocol: bool, } #[cfg(feature = "protocol-minecraft")] impl Default for MinecraftProtocolConfig { - fn default() -> Self { - Self { - enabled: default_minecraft_enabled(), - max_frame_bytes: default_minecraft_max_frame_bytes(), - timeout_secs: default_minecraft_timeout_secs(), - send_proxy_protocol: false, - } - } + fn default() -> Self { + Self { + enabled: default_minecraft_enabled(), + max_frame_bytes: default_minecraft_max_frame_bytes(), + timeout_secs: default_minecraft_timeout_secs(), + send_proxy_protocol: false, + } + } } #[cfg(feature = "protocol-minecraft")] fn default_minecraft_enabled() -> bool { - !cfg!(feature = "protocol-http") + !cfg!(feature = "protocol-http") } #[cfg(feature = "protocol-minecraft")] fn default_minecraft_max_frame_bytes() -> usize { - 8192 + 8192 } #[cfg(feature = "protocol-minecraft")] fn default_minecraft_timeout_secs() -> u64 { - 5 + 5 } /// Секция `[protocol.http]`: политика HTTP/1.1-обработчика на edge-ноде. #[cfg(feature = "protocol-http")] #[derive(Debug, Clone, Deserialize)] pub struct HttpProtocolConfig { - #[serde(default = "default_http_max_header_bytes")] - pub max_header_bytes: usize, - #[serde(default = "default_http_timeout_secs")] - pub timeout_secs: u64, - #[serde(default)] - pub blocked_paths: Vec, - #[serde(default)] - pub require_user_agent: bool, + #[serde(default = "default_http_max_header_bytes")] + pub max_header_bytes: usize, + #[serde(default = "default_http_timeout_secs")] + pub timeout_secs: u64, + #[serde(default)] + pub blocked_paths: Vec, + #[serde(default)] + pub require_user_agent: bool, } #[cfg(feature = "protocol-http")] impl Default for HttpProtocolConfig { - fn default() -> Self { - Self { - max_header_bytes: default_http_max_header_bytes(), - timeout_secs: default_http_timeout_secs(), - blocked_paths: Vec::new(), - require_user_agent: false, - } - } + fn default() -> Self { + Self { + max_header_bytes: default_http_max_header_bytes(), + timeout_secs: default_http_timeout_secs(), + blocked_paths: Vec::new(), + require_user_agent: false, + } + } } #[cfg(feature = "protocol-http")] fn default_http_max_header_bytes() -> usize { - 8192 + 8192 } #[cfg(feature = "protocol-http")] fn default_http_timeout_secs() -> u64 { - 5 + 5 } diff --git a/src/config/sections/edge.rs b/src/config/sections/edge.rs index bb0a5b0..746970c 100644 --- a/src/config/sections/edge.rs +++ b/src/config/sections/edge.rs @@ -4,241 +4,241 @@ use std::str::FromStr; #[derive(Debug, Clone, Deserialize)] pub struct BindConfig { - #[serde(default = "default_bind_address")] - pub address: String, - #[serde(default = "default_bind_port")] - pub port: u16, + #[serde(default = "default_bind_address")] + pub address: String, + #[serde(default = "default_bind_port")] + pub port: u16, } impl Default for BindConfig { - fn default() -> Self { - Self { - address: default_bind_address(), - port: default_bind_port(), - } - } + fn default() -> Self { + Self { + address: default_bind_address(), + port: default_bind_port(), + } + } } fn default_bind_address() -> String { - "0.0.0.0".to_string() + "0.0.0.0".to_string() } fn default_bind_port() -> u16 { - 25565 + 25565 } /// Generic upstream-бэкенды (список addr:port) за edge-нодой. #[derive(Debug, Clone, Deserialize)] pub struct BackendConfig { - #[serde(default = "default_upstreams")] - pub upstreams: Vec, + #[serde(default = "default_upstreams")] + pub upstreams: Vec, } impl Default for BackendConfig { - fn default() -> Self { - Self { - upstreams: default_upstreams(), - } - } + fn default() -> Self { + Self { + upstreams: default_upstreams(), + } + } } fn default_upstreams() -> Vec { - vec!["127.0.0.1:25566".to_string()] + vec!["127.0.0.1:25566".to_string()] } #[derive(Debug, Clone, Deserialize)] pub struct WorkerConfig { - #[serde(default = "default_worker_count")] - pub count: usize, + #[serde(default = "default_worker_count")] + pub count: usize, } impl Default for WorkerConfig { - fn default() -> Self { - Self { count: 4 } - } + fn default() -> Self { + Self { count: 4 } + } } fn default_worker_count() -> usize { - 4 + 4 } #[derive(Debug, Clone, Deserialize)] pub struct LimitsConfig { - #[serde(default = "default_handshake_timeout")] - pub handshake_timeout_secs: u64, - #[serde(default = "default_max_connections_per_ip")] - pub max_connections_per_ip: u32, - #[serde(default = "default_rate_limit_pps")] - pub rate_limit_pps: f64, - #[serde(default = "default_rate_limit_burst")] - pub rate_limit_burst: f64, + #[serde(default = "default_handshake_timeout")] + pub handshake_timeout_secs: u64, + #[serde(default = "default_max_connections_per_ip")] + pub max_connections_per_ip: u32, + #[serde(default = "default_rate_limit_pps")] + pub rate_limit_pps: f64, + #[serde(default = "default_rate_limit_burst")] + pub rate_limit_burst: f64, } impl Default for LimitsConfig { - fn default() -> Self { - Self { - handshake_timeout_secs: default_handshake_timeout(), - max_connections_per_ip: default_max_connections_per_ip(), - rate_limit_pps: default_rate_limit_pps(), - rate_limit_burst: default_rate_limit_burst(), - } - } + fn default() -> Self { + Self { + handshake_timeout_secs: default_handshake_timeout(), + max_connections_per_ip: default_max_connections_per_ip(), + rate_limit_pps: default_rate_limit_pps(), + rate_limit_burst: default_rate_limit_burst(), + } + } } fn default_handshake_timeout() -> u64 { - 5 + 5 } fn default_max_connections_per_ip() -> u32 { - 10 + 10 } fn default_rate_limit_pps() -> f64 { - 5.0 + 5.0 } fn default_rate_limit_burst() -> f64 { - 10.0 + 10.0 } #[derive(Debug, Clone, Deserialize)] pub struct BanConfig { - #[serde(default = "default_ban_duration")] - pub ban_duration_secs: u64, + #[serde(default = "default_ban_duration")] + pub ban_duration_secs: u64, } impl Default for BanConfig { - fn default() -> Self { - Self { - ban_duration_secs: default_ban_duration(), - } - } + fn default() -> Self { + Self { + ban_duration_secs: default_ban_duration(), + } + } } fn default_ban_duration() -> u64 { - 3600 + 3600 } #[derive(Debug, Clone, Deserialize)] pub struct PowConfig { - #[serde(default)] - pub enabled: bool, - #[serde(default = "default_pow_difficulty")] - pub difficulty: u8, + #[serde(default)] + pub enabled: bool, + #[serde(default = "default_pow_difficulty")] + pub difficulty: u8, } impl Default for PowConfig { - fn default() -> Self { - Self { - enabled: false, - difficulty: default_pow_difficulty(), - } - } + fn default() -> Self { + Self { + enabled: false, + difficulty: default_pow_difficulty(), + } + } } fn default_pow_difficulty() -> u8 { - 4 + 4 } /// CIDR network allowed to send inbound PROXY protocol headers. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct TrustedProxyCidr { - network: IpAddr, - prefix_len: u8, + network: IpAddr, + prefix_len: u8, } impl TrustedProxyCidr { - #[must_use] - pub fn contains(&self, ip: IpAddr) -> bool { - match (self.network, ip) { - (IpAddr::V4(network), IpAddr::V4(ip)) => { - let mask = if self.prefix_len == 0 { - 0 - } else { - u32::MAX << (32 - self.prefix_len) - }; - u32::from(network) & mask == u32::from(ip) & mask - }, - (IpAddr::V6(network), IpAddr::V6(ip)) => { - let mask = if self.prefix_len == 0 { - 0 - } else { - u128::MAX << (128 - self.prefix_len) - }; - u128::from(network) & mask == u128::from(ip) & mask - }, - _ => false, - } - } + #[must_use] + pub fn contains(&self, ip: IpAddr) -> bool { + match (self.network, ip) { + (IpAddr::V4(network), IpAddr::V4(ip)) => { + let mask = if self.prefix_len == 0 { + 0 + } else { + u32::MAX << (32 - self.prefix_len) + }; + u32::from(network) & mask == u32::from(ip) & mask + }, + (IpAddr::V6(network), IpAddr::V6(ip)) => { + let mask = if self.prefix_len == 0 { + 0 + } else { + u128::MAX << (128 - self.prefix_len) + }; + u128::from(network) & mask == u128::from(ip) & mask + }, + _ => false, + } + } } impl FromStr for TrustedProxyCidr { - type Err = String; + type Err = String; - fn from_str(value: &str) -> Result { - let (address, prefix) = match value.split_once('/') { - Some((address, prefix)) => (address, Some(prefix)), - None => (value, None), - }; - let network = IpAddr::from_str(address).map_err(|_| format!("invalid trusted proxy CIDR: {value}"))?; - let max_prefix = if network.is_ipv4() { 32 } else { 128 }; - let prefix_len = match prefix { - Some(prefix) => prefix - .parse::() - .map_err(|_| format!("invalid trusted proxy CIDR prefix: {value}"))?, - None => max_prefix, - }; - if prefix_len > max_prefix { - return Err(format!("trusted proxy CIDR prefix is too large: {value}")); - } - let network = match network { - IpAddr::V4(ip) => IpAddr::V4(Ipv4Addr::from(u32::from(ip) & mask_v4(prefix_len))), - IpAddr::V6(ip) => IpAddr::V6(Ipv6Addr::from(u128::from(ip) & mask_v6(prefix_len))), - }; - Ok(Self { network, prefix_len }) - } + fn from_str(value: &str) -> Result { + let (address, prefix) = match value.split_once('/') { + Some((address, prefix)) => (address, Some(prefix)), + None => (value, None), + }; + let network = IpAddr::from_str(address).map_err(|_| format!("invalid trusted proxy CIDR: {value}"))?; + let max_prefix = if network.is_ipv4() { 32 } else { 128 }; + let prefix_len = match prefix { + Some(prefix) => prefix + .parse::() + .map_err(|_| format!("invalid trusted proxy CIDR prefix: {value}"))?, + None => max_prefix, + }; + if prefix_len > max_prefix { + return Err(format!("trusted proxy CIDR prefix is too large: {value}")); + } + let network = match network { + IpAddr::V4(ip) => IpAddr::V4(Ipv4Addr::from(u32::from(ip) & mask_v4(prefix_len))), + IpAddr::V6(ip) => IpAddr::V6(Ipv6Addr::from(u128::from(ip) & mask_v6(prefix_len))), + }; + Ok(Self { network, prefix_len }) + } } impl<'de> Deserialize<'de> for TrustedProxyCidr { - fn deserialize(deserializer: D) -> Result - where - D: Deserializer<'de>, - { - let value = String::deserialize(deserializer)?; - value.parse().map_err(serde::de::Error::custom) - } + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let value = String::deserialize(deserializer)?; + value.parse().map_err(serde::de::Error::custom) + } } fn mask_v4(prefix: u8) -> u32 { - if prefix == 0 { 0 } else { u32::MAX << (32 - prefix) } + if prefix == 0 { 0 } else { u32::MAX << (32 - prefix) } } fn mask_v6(prefix: u8) -> u128 { - if prefix == 0 { 0 } else { u128::MAX << (128 - prefix) } + if prefix == 0 { 0 } else { u128::MAX << (128 - prefix) } } #[derive(Debug, Clone, Deserialize)] pub struct ProxyProtocolConfig { - #[serde(default)] - pub ingress_enabled: bool, - #[serde(default)] - pub trusted_cidrs: Vec, - #[serde(default = "default_proxy_protocol_timeout_ms")] - pub ingress_timeout_ms: u64, - #[serde(default = "default_proxy_protocol_max_header_bytes")] - pub max_header_bytes: usize, + #[serde(default)] + pub ingress_enabled: bool, + #[serde(default)] + pub trusted_cidrs: Vec, + #[serde(default = "default_proxy_protocol_timeout_ms")] + pub ingress_timeout_ms: u64, + #[serde(default = "default_proxy_protocol_max_header_bytes")] + pub max_header_bytes: usize, } impl Default for ProxyProtocolConfig { - fn default() -> Self { - Self { - ingress_enabled: false, - trusted_cidrs: Vec::new(), - ingress_timeout_ms: default_proxy_protocol_timeout_ms(), - max_header_bytes: default_proxy_protocol_max_header_bytes(), - } - } + fn default() -> Self { + Self { + ingress_enabled: false, + trusted_cidrs: Vec::new(), + ingress_timeout_ms: default_proxy_protocol_timeout_ms(), + max_header_bytes: default_proxy_protocol_max_header_bytes(), + } + } } fn default_proxy_protocol_timeout_ms() -> u64 { - 750 + 750 } fn default_proxy_protocol_max_header_bytes() -> usize { - 512 + 512 } diff --git a/src/config/sections/mod.rs b/src/config/sections/mod.rs index bc11814..cbe5cb4 100644 --- a/src/config/sections/mod.rs +++ b/src/config/sections/mod.rs @@ -12,6 +12,6 @@ pub use detect::MinecraftProtocolConfig; pub use detect::ProtocolConfig; pub use detect::{DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig}; pub use edge::{ - BackendConfig, BanConfig, BindConfig, LimitsConfig, PowConfig, ProxyProtocolConfig, TrustedProxyCidr, WorkerConfig, + BackendConfig, BanConfig, BindConfig, LimitsConfig, PowConfig, ProxyProtocolConfig, TrustedProxyCidr, WorkerConfig, }; pub use platform::{LoggingConfig, MetricsConfig, StoreConfig, XdpConfig}; diff --git a/src/config/sections/platform.rs b/src/config/sections/platform.rs index 4169679..84ac02a 100644 --- a/src/config/sections/platform.rs +++ b/src/config/sections/platform.rs @@ -2,166 +2,166 @@ use serde::Deserialize; #[derive(Debug, Clone, Deserialize)] pub struct StoreConfig { - pub redis_url: Option, - #[serde(default = "default_blacklist_cache_ttl")] - pub blacklist_cache_ttl_secs: u64, - pub clickhouse_url: Option, + pub redis_url: Option, + #[serde(default = "default_blacklist_cache_ttl")] + pub blacklist_cache_ttl_secs: u64, + pub clickhouse_url: Option, } impl Default for StoreConfig { - fn default() -> Self { - Self { - redis_url: None, - blacklist_cache_ttl_secs: default_blacklist_cache_ttl(), - clickhouse_url: None, - } - } + fn default() -> Self { + Self { + redis_url: None, + blacklist_cache_ttl_secs: default_blacklist_cache_ttl(), + clickhouse_url: None, + } + } } fn default_blacklist_cache_ttl() -> u64 { - 300 + 300 } #[derive(Debug, Clone, Deserialize)] pub struct XdpConfig { - #[serde(default)] - pub enabled: bool, - #[serde(default = "default_xdp_interface")] - pub interface: String, - #[serde(default = "default_xdp_port_start")] - pub protected_port_start: u16, - #[serde(default = "default_xdp_port_end")] - pub protected_port_end: u16, - /// "pass" | "drop" | "rate-limit" → G_UDP_POLICY. - #[serde(default = "default_xdp_udp_policy")] - pub udp_policy: String, - #[serde(default = "default_xdp_udp_hit_count")] - pub udp_rate_hit_count: u32, - #[serde(default = "default_xdp_udp_window_ms")] - pub udp_rate_window_ms: u64, - #[serde(default)] - pub syn_challenge_enabled: bool, - /// 128-битный hex (16 символов) для G_CHALLENGE_SECRET; None = плейсхолдер из config.h. - #[serde(default)] - pub challenge_secret_hex: Option, - #[serde(default = "default_xdp_challenge_timeout_ms")] - pub challenge_timeout_ms: u32, - #[serde(default = "default_xdp_throttle_enabled")] - pub throttle_enabled: bool, - #[serde(default = "default_xdp_events_enabled")] - pub events_enabled: bool, - /// OPT-IN: авто-бан по ringbuf-событиям XDP. По умолчанию выключен - /// («по умолчанию безопасно»): без него события только логируются. - #[serde(default)] - pub auto_ban_enabled: bool, - /// Длительность авто-бана в секундах (для RATE_LIMIT/CONN_DROP). - #[serde(default = "default_xdp_auto_ban_duration_secs")] - pub auto_ban_duration_secs: u64, - /// Порог `conn->fails` для авто-бана по EVENT_CONN_DROP (см. universal_filter.c:368). - #[serde(default = "default_xdp_auto_ban_conn_drop_fails")] - pub auto_ban_conn_drop_fails: u8, + #[serde(default)] + pub enabled: bool, + #[serde(default = "default_xdp_interface")] + pub interface: String, + #[serde(default = "default_xdp_port_start")] + pub protected_port_start: u16, + #[serde(default = "default_xdp_port_end")] + pub protected_port_end: u16, + /// "pass" | "drop" | "rate-limit" → G_UDP_POLICY. + #[serde(default = "default_xdp_udp_policy")] + pub udp_policy: String, + #[serde(default = "default_xdp_udp_hit_count")] + pub udp_rate_hit_count: u32, + #[serde(default = "default_xdp_udp_window_ms")] + pub udp_rate_window_ms: u64, + #[serde(default)] + pub syn_challenge_enabled: bool, + /// 128-битный hex (16 символов) для G_CHALLENGE_SECRET; None = плейсхолдер из config.h. + #[serde(default)] + pub challenge_secret_hex: Option, + #[serde(default = "default_xdp_challenge_timeout_ms")] + pub challenge_timeout_ms: u32, + #[serde(default = "default_xdp_throttle_enabled")] + pub throttle_enabled: bool, + #[serde(default = "default_xdp_events_enabled")] + pub events_enabled: bool, + /// OPT-IN: авто-бан по ringbuf-событиям XDP. По умолчанию выключен + /// («по умолчанию безопасно»): без него события только логируются. + #[serde(default)] + pub auto_ban_enabled: bool, + /// Длительность авто-бана в секундах (для RATE_LIMIT/CONN_DROP). + #[serde(default = "default_xdp_auto_ban_duration_secs")] + pub auto_ban_duration_secs: u64, + /// Порог `conn->fails` для авто-бана по EVENT_CONN_DROP (см. universal_filter.c:368). + #[serde(default = "default_xdp_auto_ban_conn_drop_fails")] + pub auto_ban_conn_drop_fails: u8, } impl Default for XdpConfig { - fn default() -> Self { - Self { - enabled: false, - interface: default_xdp_interface(), - protected_port_start: default_xdp_port_start(), - protected_port_end: default_xdp_port_end(), - udp_policy: default_xdp_udp_policy(), - udp_rate_hit_count: default_xdp_udp_hit_count(), - udp_rate_window_ms: default_xdp_udp_window_ms(), - syn_challenge_enabled: false, - challenge_secret_hex: None, - challenge_timeout_ms: default_xdp_challenge_timeout_ms(), - throttle_enabled: default_xdp_throttle_enabled(), - events_enabled: default_xdp_events_enabled(), - auto_ban_enabled: false, - auto_ban_duration_secs: default_xdp_auto_ban_duration_secs(), - auto_ban_conn_drop_fails: default_xdp_auto_ban_conn_drop_fails(), - } - } + fn default() -> Self { + Self { + enabled: false, + interface: default_xdp_interface(), + protected_port_start: default_xdp_port_start(), + protected_port_end: default_xdp_port_end(), + udp_policy: default_xdp_udp_policy(), + udp_rate_hit_count: default_xdp_udp_hit_count(), + udp_rate_window_ms: default_xdp_udp_window_ms(), + syn_challenge_enabled: false, + challenge_secret_hex: None, + challenge_timeout_ms: default_xdp_challenge_timeout_ms(), + throttle_enabled: default_xdp_throttle_enabled(), + events_enabled: default_xdp_events_enabled(), + auto_ban_enabled: false, + auto_ban_duration_secs: default_xdp_auto_ban_duration_secs(), + auto_ban_conn_drop_fails: default_xdp_auto_ban_conn_drop_fails(), + } + } } fn default_xdp_interface() -> String { - "eth0".to_string() + "eth0".to_string() } fn default_xdp_port_start() -> u16 { - 1 + 1 } fn default_xdp_port_end() -> u16 { - 65535 + 65535 } fn default_xdp_udp_policy() -> String { - "pass".to_string() + "pass".to_string() } fn default_xdp_udp_hit_count() -> u32 { - 100 + 100 } fn default_xdp_udp_window_ms() -> u64 { - 1000 + 1000 } fn default_xdp_challenge_timeout_ms() -> u32 { - 3000 + 3000 } fn default_xdp_throttle_enabled() -> bool { - true + true } fn default_xdp_events_enabled() -> bool { - true + true } fn default_xdp_auto_ban_duration_secs() -> u64 { - 60 + 60 } fn default_xdp_auto_ban_conn_drop_fails() -> u8 { - 3 + 3 } #[derive(Debug, Clone, Deserialize)] pub struct LoggingConfig { - #[serde(default = "default_log_level")] - pub level: String, - #[serde(default = "default_log_format")] - pub format: String, + #[serde(default = "default_log_level")] + pub level: String, + #[serde(default = "default_log_format")] + pub format: String, } impl Default for LoggingConfig { - fn default() -> Self { - Self { - level: default_log_level(), - format: default_log_format(), - } - } + fn default() -> Self { + Self { + level: default_log_level(), + format: default_log_format(), + } + } } fn default_log_level() -> String { - "info".to_string() + "info".to_string() } fn default_log_format() -> String { - "text".to_string() + "text".to_string() } #[derive(Debug, Clone, Deserialize)] pub struct MetricsConfig { - #[serde(default = "default_metrics_enabled")] - pub enabled: bool, - #[serde(default = "default_metrics_port")] - pub port: u16, + #[serde(default = "default_metrics_enabled")] + pub enabled: bool, + #[serde(default = "default_metrics_port")] + pub port: u16, } impl Default for MetricsConfig { - fn default() -> Self { - Self { - enabled: default_metrics_enabled(), - port: default_metrics_port(), - } - } + fn default() -> Self { + Self { + enabled: default_metrics_enabled(), + port: default_metrics_port(), + } + } } fn default_metrics_enabled() -> bool { - true + true } fn default_metrics_port() -> u16 { - 9090 + 9090 } diff --git a/src/engine/challenge/difficulty.rs b/src/engine/challenge/difficulty.rs index 8e9105b..0f0c5e8 100644 --- a/src/engine/challenge/difficulty.rs +++ b/src/engine/challenge/difficulty.rs @@ -4,85 +4,85 @@ use std::time::Instant; /// Адаптирует сложность PoW к текущему темпу подключений. pub struct DifficultyAdjuster { - window: VecDeque, - min: u8, - max: u8, - current: u8, + window: VecDeque, + min: u8, + max: u8, + current: u8, } impl Default for DifficultyAdjuster { - fn default() -> Self { - Self::new(4, 10) - } + fn default() -> Self { + Self::new(4, 10) + } } impl DifficultyAdjuster { - #[must_use] - pub fn new(min: u8, max: u8) -> Self { - Self { - window: VecDeque::new(), - min: min.max(4), - max: max.min(10), - current: min.max(4), - } - } + #[must_use] + pub fn new(min: u8, max: u8) -> Self { + Self { + window: VecDeque::new(), + min: min.max(4), + max: max.min(10), + current: min.max(4), + } + } - pub fn record_connection(&mut self) { - let now = Instant::now(); - self.window.push_back(now); - while let Some(&t) = self.window.front() { - if now.duration_since(t).as_secs() >= 1 { - self.window.pop_front(); - } else { - break; - } - } - let new_diff = self.compute_difficulty(); - if self.current != new_diff { - tracing::info!( - old = self.current, - new = new_diff, - window = self.window.len(), - "pow: difficulty adjusted" - ); - self.current = new_diff; - metrics::POW_CURRENT_DIFFICULTY.set(self.current as i64); - } - } + pub fn record_connection(&mut self) { + let now = Instant::now(); + self.window.push_back(now); + while let Some(&t) = self.window.front() { + if now.duration_since(t).as_secs() >= 1 { + self.window.pop_front(); + } else { + break; + } + } + let new_diff = self.compute_difficulty(); + if self.current != new_diff { + tracing::info!( + old = self.current, + new = new_diff, + window = self.window.len(), + "pow: difficulty adjusted" + ); + self.current = new_diff; + metrics::POW_CURRENT_DIFFICULTY.set(self.current as i64); + } + } - #[must_use] - pub fn current_difficulty(&self) -> u8 { - metrics::POW_CURRENT_DIFFICULTY.set(self.current as i64); - self.current - } + #[must_use] + pub fn current_difficulty(&self) -> u8 { + metrics::POW_CURRENT_DIFFICULTY.set(self.current as i64); + self.current + } - fn compute_difficulty(&self) -> u8 { - match self.window.len() { - cps if cps > 500 => self.max.max(self.min), - cps if cps > 200 => 8, - cps if cps > 50 => 6, - _ => self.min, - } - } + fn compute_difficulty(&self) -> u8 { + match self.window.len() { + cps if cps > 500 => self.max.max(self.min), + cps if cps > 200 => 8, + cps if cps > 50 => 6, + _ => self.min, + } + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn adjuster_raises_difficulty_under_load() { - let mut adjuster = DifficultyAdjuster::new(4, 10); - for _ in 0..600 { - adjuster.record_connection(); - } - assert_eq!(adjuster.current_difficulty(), 10); - } + #[test] + fn adjuster_raises_difficulty_under_load() { + let mut adjuster = DifficultyAdjuster::new(4, 10); + for _ in 0..600 { + adjuster.record_connection(); + } + assert_eq!(adjuster.current_difficulty(), 10); + } - #[test] - fn adjuster_stays_minimal_when_idle() { - let mut adjuster = DifficultyAdjuster::new(4, 10); - adjuster.record_connection(); - assert_eq!(adjuster.current_difficulty(), 4); - } + #[test] + fn adjuster_stays_minimal_when_idle() { + let mut adjuster = DifficultyAdjuster::new(4, 10); + adjuster.record_connection(); + assert_eq!(adjuster.current_difficulty(), 4); + } } diff --git a/src/engine/challenge/pow.rs b/src/engine/challenge/pow.rs index 1d1cb40..6ba04ef 100644 --- a/src/engine/challenge/pow.rs +++ b/src/engine/challenge/pow.rs @@ -12,91 +12,91 @@ const ALLOWED_HEX_PREFIX: [u8; 4] = *b"0123"; /// Активная PoW-задача, выданная одному соединению. pub struct Challenge { - token: [u8; 32], - created_at: Instant, - difficulty: u8, - used: bool, + token: [u8; 32], + created_at: Instant, + difficulty: u8, + used: bool, } impl Challenge { - #[must_use] - pub fn generate(difficulty: u8) -> Self { - let mut token = [0u8; 32]; - rand::rng().fill_bytes(&mut token); - Self { - token, - created_at: Instant::now(), - difficulty, - used: false, - } - } + #[must_use] + pub fn generate(difficulty: u8) -> Self { + let mut token = [0u8; 32]; + rand::rng().fill_bytes(&mut token); + Self { + token, + created_at: Instant::now(), + difficulty, + used: false, + } + } - /// Challenge с явным токеном — для детерминированных тестов, где - /// случайный дайджест даёт flaky-исход. - #[must_use] - pub fn with_token(token: [u8; 32], difficulty: u8) -> Self { - Self { - token, - created_at: Instant::now(), - difficulty, - used: false, - } - } + /// Challenge с явным токеном — для детерминированных тестов, где + /// случайный дайджест даёт flaky-исход. + #[must_use] + pub fn with_token(token: [u8; 32], difficulty: u8) -> Self { + Self { + token, + created_at: Instant::now(), + difficulty, + used: false, + } + } - #[must_use] - pub fn is_expired(&self) -> bool { - self.created_at.elapsed().as_secs() >= CHALLENGE_TTL_SECS - } + #[must_use] + pub fn is_expired(&self) -> bool { + self.created_at.elapsed().as_secs() >= CHALLENGE_TTL_SECS + } - #[must_use] - pub fn challenge_string(&self) -> String { - hex::encode(self.token) - } + #[must_use] + pub fn challenge_string(&self) -> String { + hex::encode(self.token) + } - /// Проверяет nonce и помечает challenge использованным при успехе. - #[must_use] - pub fn verify(&mut self, nonce: &str) -> bool { - if self.used || self.is_expired() || nonce.len() > MAX_NONCE_LEN { - return false; - } + /// Проверяет nonce и помечает challenge использованным при успехе. + #[must_use] + pub fn verify(&mut self, nonce: &str) -> bool { + if self.used || self.is_expired() || nonce.len() > MAX_NONCE_LEN { + return false; + } - let input = format!("{}{nonce}", self.challenge_string()); - let hash = Sha256::digest(input.as_bytes()); - let hex_hash = hex::encode(hash); - let d = self.difficulty as usize; - let ok = hex_hash.as_bytes().iter().take(d).all(|c| { - let r = c.ct_eq(&ALLOWED_HEX_PREFIX[0]) - | c.ct_eq(&ALLOWED_HEX_PREFIX[1]) - | c.ct_eq(&ALLOWED_HEX_PREFIX[2]) - | c.ct_eq(&ALLOWED_HEX_PREFIX[3]); - r.unwrap_u8() == 1 - }); - if ok { - self.used = true; - } - ok - } + let input = format!("{}{nonce}", self.challenge_string()); + let hash = Sha256::digest(input.as_bytes()); + let hex_hash = hex::encode(hash); + let d = self.difficulty as usize; + let ok = hex_hash.as_bytes().iter().take(d).all(|c| { + let r = c.ct_eq(&ALLOWED_HEX_PREFIX[0]) + | c.ct_eq(&ALLOWED_HEX_PREFIX[1]) + | c.ct_eq(&ALLOWED_HEX_PREFIX[2]) + | c.ct_eq(&ALLOWED_HEX_PREFIX[3]); + r.unwrap_u8() == 1 + }); + if ok { + self.used = true; + } + ok + } } /// Переборный решатель hashcash (для клиентов и тестов). #[must_use] pub fn solve(challenge: &str, difficulty: u8) -> Option { - let d = difficulty as usize; - for nonce in 0..u64::MAX { - let nonce_str = nonce.to_string(); - let input = format!("{challenge}{nonce_str}"); - let hash = Sha256::digest(input.as_bytes()); - let hex_hash = hex::encode(hash); - if hex_hash - .as_bytes() - .iter() - .take(d) - .all(|c| ALLOWED_HEX_PREFIX.contains(c)) - { - return Some(nonce_str); - } - } - None + let d = difficulty as usize; + for nonce in 0..u64::MAX { + let nonce_str = nonce.to_string(); + let input = format!("{challenge}{nonce_str}"); + let hash = Sha256::digest(input.as_bytes()); + let hex_hash = hex::encode(hash); + if hex_hash + .as_bytes() + .iter() + .take(d) + .all(|c| ALLOWED_HEX_PREFIX.contains(c)) + { + return Some(nonce_str); + } + } + None } /// Проводит текстовый PoW-gate в потоке: выдаёт challenge и проверяет ответ. @@ -104,84 +104,84 @@ pub fn solve(challenge: &str, difficulty: u8) -> Option { /// # Errors /// Возвращает ошибку только при сбое ввода-вывода; неверное решение — `Ok(false)`. pub async fn enforce(stream: &mut TcpStream, peer_ip: IpAddr, difficulty: u8) -> anyhow::Result { - if difficulty == 0 { - tracing::debug!("pow: difficulty 0, skipping for {peer_ip}"); - return Ok(true); - } + if difficulty == 0 { + tracing::debug!("pow: difficulty 0, skipping for {peer_ip}"); + return Ok(true); + } - let mut challenge = Challenge::generate(difficulty); - let line = format!("{}\n", challenge.challenge_string()); - stream.write_all(line.as_bytes()).await?; + let mut challenge = Challenge::generate(difficulty); + let line = format!("{}\n", challenge.challenge_string()); + stream.write_all(line.as_bytes()).await?; - let mut buf = [0u8; MAX_NONCE_LEN + 1]; - let n = tokio::time::timeout(Duration::from_secs(10), stream.read(&mut buf)).await??; - if n == 0 { - tracing::debug!("pow: no response from {peer_ip}"); - return Ok(false); - } + let mut buf = [0u8; MAX_NONCE_LEN + 1]; + let n = tokio::time::timeout(Duration::from_secs(10), stream.read(&mut buf)).await??; + if n == 0 { + tracing::debug!("pow: no response from {peer_ip}"); + return Ok(false); + } - let nonce = std::str::from_utf8(&buf[..n.min(MAX_NONCE_LEN)]).unwrap_or("").trim(); - if nonce.is_empty() || nonce.len() > MAX_NONCE_LEN { - tracing::debug!("pow: invalid nonce from {peer_ip}"); - return Ok(false); - } + let nonce = std::str::from_utf8(&buf[..n.min(MAX_NONCE_LEN)]).unwrap_or("").trim(); + if nonce.is_empty() || nonce.len() > MAX_NONCE_LEN { + tracing::debug!("pow: invalid nonce from {peer_ip}"); + return Ok(false); + } - let valid = challenge.verify(nonce); - tracing::debug!( - "pow: verification {} for {peer_ip}", - if valid { "passed" } else { "failed" } - ); - Ok(valid) + let valid = challenge.verify(nonce); + tracing::debug!( + "pow: verification {} for {peer_ip}", + if valid { "passed" } else { "failed" } + ); + Ok(valid) } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn solve_then_verify_roundtrip() { - let mut challenge = Challenge::generate(2); - let nonce = solve(&challenge.challenge_string(), 2).expect("solver should find a nonce"); - assert!(challenge.verify(&nonce), "verifier must accept solver output"); - } + #[test] + fn solve_then_verify_roundtrip() { + let mut challenge = Challenge::generate(2); + let nonce = solve(&challenge.challenge_string(), 2).expect("solver should find a nonce"); + assert!(challenge.verify(&nonce), "verifier must accept solver output"); + } - #[test] - fn verify_rejects_wrong_nonce() { - let mut challenge = Challenge::generate(4); - let challenge_str = challenge.challenge_string(); + #[test] + fn verify_rejects_wrong_nonce() { + let mut challenge = Challenge::generate(4); + let challenge_str = challenge.challenge_string(); - // Подбираем nonce, который независимо рассчитанный SHA-256 - // заведомо отклоняет — тест детерминирован. - let mut wrong_nonce = None; - for i in 0..10_000u32 { - let candidate = format!("bad-{i}"); - let hex_hash = hex::encode(Sha256::digest(format!("{challenge_str}{candidate}").as_bytes())); - if !hex_hash - .as_bytes() - .iter() - .take(4) - .all(|c| ALLOWED_HEX_PREFIX.contains(c)) - { - wrong_nonce = Some(candidate); - break; - } - } - let wrong_nonce = wrong_nonce.expect("a failing nonce must exist among candidates"); - assert!(!challenge.verify(&wrong_nonce)); - } + // Подбираем nonce, который независимо рассчитанный SHA-256 + // заведомо отклоняет — тест детерминирован. + let mut wrong_nonce = None; + for i in 0..10_000u32 { + let candidate = format!("bad-{i}"); + let hex_hash = hex::encode(Sha256::digest(format!("{challenge_str}{candidate}").as_bytes())); + if !hex_hash + .as_bytes() + .iter() + .take(4) + .all(|c| ALLOWED_HEX_PREFIX.contains(c)) + { + wrong_nonce = Some(candidate); + break; + } + } + let wrong_nonce = wrong_nonce.expect("a failing nonce must exist among candidates"); + assert!(!challenge.verify(&wrong_nonce)); + } - #[test] - fn verify_rejects_replay() { - let mut challenge = Challenge::generate(2); - let nonce = solve(&challenge.challenge_string(), 2).expect("solved"); - assert!(challenge.verify(&nonce)); - assert!(!challenge.verify(&nonce), "challenge must be single-use"); - } + #[test] + fn verify_rejects_replay() { + let mut challenge = Challenge::generate(2); + let nonce = solve(&challenge.challenge_string(), 2).expect("solved"); + assert!(challenge.verify(&nonce)); + assert!(!challenge.verify(&nonce), "challenge must be single-use"); + } - #[test] - fn verify_rejects_oversized_nonce() { - let mut challenge = Challenge::generate(2); - let big_nonce = "0".repeat(MAX_NONCE_LEN + 1); - assert!(!challenge.verify(&big_nonce)); - } + #[test] + fn verify_rejects_oversized_nonce() { + let mut challenge = Challenge::generate(2); + let big_nonce = "0".repeat(MAX_NONCE_LEN + 1); + assert!(!challenge.verify(&big_nonce)); + } } diff --git a/src/engine/listener.rs b/src/engine/listener.rs index c17ffab..ddd0297 100644 --- a/src/engine/listener.rs +++ b/src/engine/listener.rs @@ -14,78 +14,78 @@ use tokio::sync::watch; /// Возвращает ошибку при невозможности забиндить адрес или падении одного /// из accept-loop'ов. pub async fn run( - config: Arc, - gateway: Arc, - hook: Arc, - shutdown: watch::Receiver, + config: Arc, + gateway: Arc, + hook: Arc, + shutdown: watch::Receiver, ) -> anyhow::Result<()> { - let addr: std::net::SocketAddr = format!("{}:{}", config.bind.address, config.bind.port).parse()?; - let workers = config.workers.count.max(1); + let addr: std::net::SocketAddr = format!("{}:{}", config.bind.address, config.bind.port).parse()?; + let workers = config.workers.count.max(1); - let mut handles = Vec::with_capacity(workers); - for _ in 0..workers { - let listener = build_listener(addr)?; - handles.push(tokio::spawn(accept_loop( - listener, - Arc::clone(&gateway), - Arc::clone(&hook), - shutdown.clone(), - ))); - } + let mut handles = Vec::with_capacity(workers); + for _ in 0..workers { + let listener = build_listener(addr)?; + handles.push(tokio::spawn(accept_loop( + listener, + Arc::clone(&gateway), + Arc::clone(&hook), + shutdown.clone(), + ))); + } - for h in handles { - h.await?; - } - Ok(()) + for h in handles { + h.await?; + } + Ok(()) } fn build_listener(addr: std::net::SocketAddr) -> anyhow::Result { - let socket = Socket::new(Domain::IPV4, Type::STREAM, None)?; - socket.set_reuse_port(true)?; - socket.set_reuse_address(true)?; - socket.set_nonblocking(true)?; - socket.bind(&addr.into())?; - socket.listen(65535)?; - Ok(TcpListener::from_std(socket.into())?) + let socket = Socket::new(Domain::IPV4, Type::STREAM, None)?; + socket.set_reuse_port(true)?; + socket.set_reuse_address(true)?; + socket.set_nonblocking(true)?; + socket.bind(&addr.into())?; + socket.listen(65535)?; + Ok(TcpListener::from_std(socket.into())?) } async fn accept_loop( - listener: TcpListener, - gateway: Arc, - hook: Arc, - mut shutdown: watch::Receiver, + listener: TcpListener, + gateway: Arc, + hook: Arc, + mut shutdown: watch::Receiver, ) { - loop { - tokio::select! { - biased; - _ = shutdown.changed() => { - if *shutdown.borrow() { - tracing::info!("shutdown signal received, stopping accept loop"); - return; - } - } - result = listener.accept() => { - let (stream, peer_addr) = match result { - Ok(conn) => conn, - Err(e) => { - tracing::error!("accept error: {e}"); - continue; - } - }; - let gateway = Arc::clone(&gateway); - let hook = Arc::clone(&hook); - tokio::spawn(async move { - // Hot path Traffic Intelligence: только атомики и DashMap. - hook.on_accept(); - let outcome = gateway.handle(stream, peer_addr).await; - if let Err(e) = outcome.result { - tracing::debug!("connection from {peer_addr}: {e}"); - } - if let Some(client_ip) = outcome.client_ip { - hook.on_connection_end(client_ip); - } - }); - } - } - } + loop { + tokio::select! { + biased; + _ = shutdown.changed() => { + if *shutdown.borrow() { + tracing::info!("shutdown signal received, stopping accept loop"); + return; + } + } + result = listener.accept() => { + let (stream, peer_addr) = match result { + Ok(conn) => conn, + Err(e) => { + tracing::error!("accept error: {e}"); + continue; + } + }; + let gateway = Arc::clone(&gateway); + let hook = Arc::clone(&hook); + tokio::spawn(async move { + // Hot path Traffic Intelligence: только атомики и DashMap. + hook.on_accept(); + let outcome = gateway.handle(stream, peer_addr).await; + if let Err(e) = outcome.result { + tracing::debug!("connection from {peer_addr}: {e}"); + } + if let Some(client_ip) = outcome.client_ip { + hook.on_connection_end(client_ip); + } + }); + } + } + } } diff --git a/src/engine/subnet/monitor.rs b/src/engine/subnet/monitor.rs index 347cc04..b4aac03 100644 --- a/src/engine/subnet/monitor.rs +++ b/src/engine/subnet/monitor.rs @@ -17,19 +17,19 @@ use std::time::Duration; use tokio::sync::watch; enum Source { - #[cfg(feature = "xdp")] - Xdp(XdpPrefixStats), - Tracker(TrackerSource), + #[cfg(feature = "xdp")] + Xdp(XdpPrefixStats), + Tracker(TrackerSource), } impl Source { - async fn snapshot(&self) -> anyhow::Result> { - match self { - #[cfg(feature = "xdp")] - Source::Xdp(xdp) => xdp.snapshot().await, - Source::Tracker(tracker) => tracker.snapshot().await, - } - } + async fn snapshot(&self) -> anyhow::Result> { + match self { + #[cfg(feature = "xdp")] + Source::Xdp(xdp) => xdp.snapshot().await, + Source::Tracker(tracker) => tracker.snapshot().await, + } + } } /// Запускает фоновый subnet-монитор, если `[detect.prefix] enabled`. @@ -37,107 +37,107 @@ impl Source { /// Приоритет источника: XDP-карта при загруженном фильтре, иначе /// юзерспейс-агрегатор. Без обоих источников монитор не запускается. pub fn spawn( - detect: &DetectPrefixConfig, - tracker: Option>, - xdp: Option>>, - mut shutdown: watch::Receiver, + detect: &DetectPrefixConfig, + tracker: Option>, + xdp: Option>>, + mut shutdown: watch::Receiver, ) { - if !detect.enabled { - return; - } - let Some(source) = build_source(tracker, xdp) else { - tracing::warn!("detect.prefix enabled but no stats source available; monitor disabled"); - return; - }; - let detector = SubnetDetector::from_config(detect); - let window = Duration::from_secs(detect.window_secs.max(1)); + if !detect.enabled { + return; + } + let Some(source) = build_source(tracker, xdp) else { + tracing::warn!("detect.prefix enabled but no stats source available; monitor disabled"); + return; + }; + let detector = SubnetDetector::from_config(detect); + let window = Duration::from_secs(detect.window_secs.max(1)); - tokio::spawn(async move { - let mut tick = tokio::time::interval(window); - tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); - loop { - tokio::select! { - biased; - _ = shutdown.changed() => { - if *shutdown.borrow() { - return; - } - } - _ = tick.tick() => { - match source.snapshot().await { - Ok(snaps) => apply_verdicts(&detector.evaluate(&snaps), &source).await, - Err(e) => tracing::debug!("prefix stats unavailable: {e}"), - } - } - } - } - }); + tokio::spawn(async move { + let mut tick = tokio::time::interval(window); + tick.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip); + loop { + tokio::select! { + biased; + _ = shutdown.changed() => { + if *shutdown.borrow() { + return; + } + } + _ = tick.tick() => { + match source.snapshot().await { + Ok(snaps) => apply_verdicts(&detector.evaluate(&snaps), &source).await, + Err(e) => tracing::debug!("prefix stats unavailable: {e}"), + } + } + } + } + }); } fn build_source(tracker: Option>, xdp: Option>>) -> Option { - #[cfg(feature = "xdp")] - if let Some(filter) = xdp { - return Some(Source::Xdp(XdpPrefixStats::new(filter))); - } - #[cfg(not(feature = "xdp"))] - let _ = xdp; - tracker.map(|t| Source::Tracker(TrackerSource { tracker: t })) + #[cfg(feature = "xdp")] + if let Some(filter) = xdp { + return Some(Source::Xdp(XdpPrefixStats::new(filter))); + } + #[cfg(not(feature = "xdp"))] + let _ = xdp; + tracker.map(|t| Source::Tracker(TrackerSource { tracker: t })) } async fn apply_verdicts(verdicts: &[PrefixVerdict], source: &Source) { - for pv in verdicts { - metrics::SUBNET_VERDICTS - .with_label_values(&[verdict_name(pv.verdict)]) - .inc(); - tracing::info!( - prefix = %pv.prefix, - syn = pv.snapshot.syn_count, - unique = pv.snapshot.unique_sources, - verdict = verdict_name(pv.verdict), - "subnet verdict" - ); - if pv.verdict == SubnetVerdict::Block { - enforce_block(source, pv).await; - } - } + for pv in verdicts { + metrics::SUBNET_VERDICTS + .with_label_values(&[verdict_name(pv.verdict)]) + .inc(); + tracing::info!( + prefix = %pv.prefix, + syn = pv.snapshot.syn_count, + unique = pv.snapshot.unique_sources, + verdict = verdict_name(pv.verdict), + "subnet verdict" + ); + if pv.verdict == SubnetVerdict::Block { + enforce_block(source, pv).await; + } + } } async fn enforce_block(source: &Source, pv: &PrefixVerdict) { - match source { - #[cfg(feature = "xdp")] - Source::Xdp(xdp) => { - let result = { - let guard = xdp.filter_lock(); - guard.ban_cidr(pv.prefix, prefix_len(pv.prefix), 3600) - }; - if let Err(e) = result { - tracing::warn!("subnet block failed for {}: {e}", pv.prefix); - } - }, - Source::Tracker(_) => { - tracing::warn!( - prefix = %pv.prefix, - "block verdict without kernel enforcement; escalate at L7" - ); - }, - } + match source { + #[cfg(feature = "xdp")] + Source::Xdp(xdp) => { + let result = { + let guard = xdp.filter_lock(); + guard.ban_cidr(pv.prefix, prefix_len(pv.prefix), 3600) + }; + if let Err(e) = result { + tracing::warn!("subnet block failed for {}: {e}", pv.prefix); + } + }, + Source::Tracker(_) => { + tracing::warn!( + prefix = %pv.prefix, + "block verdict without kernel enforcement; escalate at L7" + ); + }, + } } /// Длина префикса, соответствующая гранулярности детекции (v4 /24, v6 /64). #[cfg(feature = "xdp")] fn prefix_len(prefix: IpAddr) -> u8 { - match prefix { - IpAddr::V4(_) => 24, - IpAddr::V6(_) => 64, - } + match prefix { + IpAddr::V4(_) => 24, + IpAddr::V6(_) => 64, + } } #[must_use] fn verdict_name(verdict: SubnetVerdict) -> &'static str { - match verdict { - SubnetVerdict::Monitor => "monitor", - SubnetVerdict::StrictLimit => "strict_limit", - SubnetVerdict::Challenge => "challenge", - SubnetVerdict::Block => "block", - } + match verdict { + SubnetVerdict::Monitor => "monitor", + SubnetVerdict::StrictLimit => "strict_limit", + SubnetVerdict::Challenge => "challenge", + SubnetVerdict::Block => "block", + } } diff --git a/src/engine/subnet/tracker.rs b/src/engine/subnet/tracker.rs index d14d60e..d842a8a 100644 --- a/src/engine/subnet/tracker.rs +++ b/src/engine/subnet/tracker.rs @@ -10,122 +10,122 @@ use std::sync::Arc; use std::time::Instant; struct WindowState { - syn_count: u64, - sources: std::collections::HashSet, - started: Instant, + syn_count: u64, + sources: std::collections::HashSet, + started: Instant, } /// Агрегатор новых соединений по префиксам. `take_snapshot` дренирует /// накопленное: каждый вызов закрывает одно окно детекции. pub struct SubnetTracker { - windows: DashMap, + windows: DashMap, } impl Default for SubnetTracker { - fn default() -> Self { - Self::new() - } + fn default() -> Self { + Self::new() + } } impl SubnetTracker { - #[must_use] - pub fn new() -> Self { - Self { - windows: DashMap::new(), - } - } + #[must_use] + pub fn new() -> Self { + Self { + windows: DashMap::new(), + } + } - /// Регистрирует новое входящее соединение (юзерспейс-аналог SYN). - pub fn record_connection(&self, ip: IpAddr) { - let prefix = prefix_of(ip); - let mut state = self.windows.entry(prefix).or_insert_with(|| WindowState { - syn_count: 0, - sources: std::collections::HashSet::new(), - started: Instant::now(), - }); - state.syn_count = state.syn_count.saturating_add(1); - state.sources.insert(ip); - } + /// Регистрирует новое входящее соединение (юзерспейс-аналог SYN). + pub fn record_connection(&self, ip: IpAddr) { + let prefix = prefix_of(ip); + let mut state = self.windows.entry(prefix).or_insert_with(|| WindowState { + syn_count: 0, + sources: std::collections::HashSet::new(), + started: Instant::now(), + }); + state.syn_count = state.syn_count.saturating_add(1); + state.sources.insert(ip); + } - /// Забирает и сбрасывает агрегаты текущего окна. - #[must_use] - pub fn take_snapshot(&self) -> Vec<(IpAddr, PrefixSnapshot)> { - let mut out = Vec::new(); - // Дренируем все ключи: каждое окно начинается с чистой карты, - // память не растёт при спуфинге множества префиксов. - self.windows.retain(|prefix, state| { - if state.syn_count == 0 { - return false; - } - out.push(( - *prefix, - PrefixSnapshot { - // Юзерспейс видит только установленные соединения; - // pkt_count отражает тот же поток. - pkt_count: state.syn_count, - syn_count: state.syn_count, - last_seen_ns: state.started.elapsed().as_nanos() as u64, - unique_sources: state.sources.len() as u64, - }, - )); - false - }); - out - } + /// Забирает и сбрасывает агрегаты текущего окна. + #[must_use] + pub fn take_snapshot(&self) -> Vec<(IpAddr, PrefixSnapshot)> { + let mut out = Vec::new(); + // Дренируем все ключи: каждое окно начинается с чистой карты, + // память не растёт при спуфинге множества префиксов. + self.windows.retain(|prefix, state| { + if state.syn_count == 0 { + return false; + } + out.push(( + *prefix, + PrefixSnapshot { + // Юзерспейс видит только установленные соединения; + // pkt_count отражает тот же поток. + pkt_count: state.syn_count, + syn_count: state.syn_count, + last_seen_ns: state.started.elapsed().as_nanos() as u64, + unique_sources: state.sources.len() as u64, + }, + )); + false + }); + out + } } /// Адаптер [`SubnetTracker`] под трейт [`PrefixStatsSource`]. pub struct TrackerSource { - pub tracker: Arc, + pub tracker: Arc, } impl PrefixStatsSource for TrackerSource { - async fn snapshot(&self) -> anyhow::Result> { - Ok(self.tracker.take_snapshot()) - } + async fn snapshot(&self) -> anyhow::Result> { + Ok(self.tracker.take_snapshot()) + } } #[cfg(test)] mod tests { - use super::*; - use std::net::{Ipv4Addr, Ipv6Addr}; + use super::*; + use std::net::{Ipv4Addr, Ipv6Addr}; - fn v4(octets: [u8; 4]) -> IpAddr { - IpAddr::V4(Ipv4Addr::from(octets)) - } + fn v4(octets: [u8; 4]) -> IpAddr { + IpAddr::V4(Ipv4Addr::from(octets)) + } - #[test] - fn groups_connections_by_prefix() { - let tracker = SubnetTracker::new(); - tracker.record_connection(v4([203, 0, 113, 1])); - tracker.record_connection(v4([203, 0, 113, 2])); - tracker.record_connection(v4([198, 51, 100, 9])); - let snaps = tracker.take_snapshot(); - assert_eq!(snaps.len(), 2); - let by_prefix: std::collections::HashMap = snaps.into_iter().collect(); - assert_eq!(by_prefix[&v4([203, 0, 113, 0])].syn_count, 2); - assert_eq!(by_prefix[&v4([203, 0, 113, 0])].unique_sources, 2); - assert_eq!(by_prefix[&v4([198, 51, 100, 0])].syn_count, 1); - } + #[test] + fn groups_connections_by_prefix() { + let tracker = SubnetTracker::new(); + tracker.record_connection(v4([203, 0, 113, 1])); + tracker.record_connection(v4([203, 0, 113, 2])); + tracker.record_connection(v4([198, 51, 100, 9])); + let snaps = tracker.take_snapshot(); + assert_eq!(snaps.len(), 2); + let by_prefix: std::collections::HashMap = snaps.into_iter().collect(); + assert_eq!(by_prefix[&v4([203, 0, 113, 0])].syn_count, 2); + assert_eq!(by_prefix[&v4([203, 0, 113, 0])].unique_sources, 2); + assert_eq!(by_prefix[&v4([198, 51, 100, 0])].syn_count, 1); + } - #[test] - fn snapshot_drains_window() { - let tracker = SubnetTracker::new(); - tracker.record_connection(v4([10, 0, 0, 1])); - assert_eq!(tracker.take_snapshot().len(), 1); - assert!(tracker.take_snapshot().is_empty()); - } + #[test] + fn snapshot_drains_window() { + let tracker = SubnetTracker::new(); + tracker.record_connection(v4([10, 0, 0, 1])); + assert_eq!(tracker.take_snapshot().len(), 1); + assert!(tracker.take_snapshot().is_empty()); + } - #[test] - fn mapped_addresses_share_v4_prefix() { - let tracker = SubnetTracker::new(); - tracker.record_connection(v4([203, 0, 113, 5])); - // ::ffff:203.0.113.6 - let mapped = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xcb00, 0x7106); - tracker.record_connection(IpAddr::V6(mapped)); - let snaps = tracker.take_snapshot(); - assert_eq!(snaps.len(), 1); - assert_eq!(snaps[0].0, v4([203, 0, 113, 0])); - assert_eq!(snaps[0].1.unique_sources, 2); - } + #[test] + fn mapped_addresses_share_v4_prefix() { + let tracker = SubnetTracker::new(); + tracker.record_connection(v4([203, 0, 113, 5])); + // ::ffff:203.0.113.6 + let mapped = Ipv6Addr::new(0, 0, 0, 0, 0, 0xffff, 0xcb00, 0x7106); + tracker.record_connection(IpAddr::V6(mapped)); + let snaps = tracker.take_snapshot(); + assert_eq!(snaps.len(), 1); + assert_eq!(snaps[0].0, v4([203, 0, 113, 0])); + assert_eq!(snaps[0].1.unique_sources, 2); + } } diff --git a/src/engine/tunnel.rs b/src/engine/tunnel.rs index 39028df..ccfe46e 100644 --- a/src/engine/tunnel.rs +++ b/src/engine/tunnel.rs @@ -22,24 +22,24 @@ mod proxy; /// Общее состояние edge-движка, разделяемое между accept-loop'ами. pub struct Gateway { - pub config: Arc, - pub rate_limiter: Arc, - pub connection_limiter: ConnectionLimiter, - pub blacklist: Arc, - pub adjuster: Arc>, - pub whitelist: Arc>, - pub reputation: Arc, - pub xdp: Option>>, - pub clickhouse: Option>>, - pub allowed_1s: Arc, - pub registry: Arc, - pub subnet_tracker: Option>, - upstream_cursor: AtomicUsize, + pub config: Arc, + pub rate_limiter: Arc, + pub connection_limiter: ConnectionLimiter, + pub blacklist: Arc, + pub adjuster: Arc>, + pub whitelist: Arc>, + pub reputation: Arc, + pub xdp: Option>>, + pub clickhouse: Option>>, + pub allowed_1s: Arc, + pub registry: Arc, + pub subnet_tracker: Option>, + upstream_cursor: AtomicUsize, } /// Result of a connection attempt, retaining the verified client identity for /// post-connection traffic accounting. pub struct GatewayOutcome { - pub client_ip: Option, - pub result: anyhow::Result<()>, + pub client_ip: Option, + pub result: anyhow::Result<()>, } diff --git a/src/engine/tunnel/gateway.rs b/src/engine/tunnel/gateway.rs index 49d69a4..396956b 100644 --- a/src/engine/tunnel/gateway.rs +++ b/src/engine/tunnel/gateway.rs @@ -24,207 +24,207 @@ use tokio::net::TcpStream; use tokio::sync::Mutex as TokioMutex; impl Gateway { - #[allow(clippy::too_many_arguments)] - pub fn new( - config: Arc, - rate_limiter: Arc, - blacklist: Arc, - adjuster: Arc>, - whitelist: Arc>, - reputation: Arc, - xdp: Option>>, - clickhouse: Option>>, - allowed_1s: Arc, - registry: Arc, - subnet_tracker: Option>, - ) -> Self { - let max_connections = config.limits.max_connections_per_ip as usize; - Self { - config, - rate_limiter, - connection_limiter: ConnectionLimiter::new(max_connections), - blacklist, - adjuster, - whitelist, - reputation, - xdp, - clickhouse, - allowed_1s, - registry, - subnet_tracker, - upstream_cursor: AtomicUsize::new(0), - } - } + #[allow(clippy::too_many_arguments)] + pub fn new( + config: Arc, + rate_limiter: Arc, + blacklist: Arc, + adjuster: Arc>, + whitelist: Arc>, + reputation: Arc, + xdp: Option>>, + clickhouse: Option>>, + allowed_1s: Arc, + registry: Arc, + subnet_tracker: Option>, + ) -> Self { + let max_connections = config.limits.max_connections_per_ip as usize; + Self { + config, + rate_limiter, + connection_limiter: ConnectionLimiter::new(max_connections), + blacklist, + adjuster, + whitelist, + reputation, + xdp, + clickhouse, + allowed_1s, + registry, + subnet_tracker, + upstream_cursor: AtomicUsize::new(0), + } + } - /// Полный конвейер обработки входящего соединения. - /// - /// # Errors - /// Возвращает ошибку только при сбое ввода-вывода апстрима; блокировки - /// клиента ошибкой не считаются. - #[allow(unused_mut)] - pub async fn handle(&self, mut client: TcpStream, peer_addr: std::net::SocketAddr) -> GatewayOutcome { - let client_addr = if self.config.proxy_protocol.ingress_enabled { - #[cfg(feature = "protocol-minecraft")] - { - if !self - .config - .proxy_protocol - .trusted_cidrs - .iter() - .any(|cidr| cidr.contains(peer_addr.ip())) - { - return GatewayOutcome { - client_ip: None, - result: Err(anyhow::anyhow!("untrusted peer attempted inbound PROXY protocol")), - }; - } - match proxy::read_v2_header( - &mut client, - Duration::from_millis(self.config.proxy_protocol.ingress_timeout_ms), - self.config.proxy_protocol.max_header_bytes, - ) - .await - { - Ok(client_addr) => client_addr, - Err(error) => { - return GatewayOutcome { - client_ip: None, - result: Err(error), - }; - }, - } - } - #[cfg(not(feature = "protocol-minecraft"))] - { - return GatewayOutcome { - client_ip: None, - result: Err(anyhow::anyhow!("inbound PROXY protocol requires protocol-minecraft")), - }; - } - } else { - peer_addr - }; - let client_ip = client_addr.ip(); - let result = self.handle_client(client, peer_addr, client_addr).await; - GatewayOutcome { - client_ip: Some(client_ip), - result, - } - } + /// Полный конвейер обработки входящего соединения. + /// + /// # Errors + /// Возвращает ошибку только при сбое ввода-вывода апстрима; блокировки + /// клиента ошибкой не считаются. + #[allow(unused_mut)] + pub async fn handle(&self, mut client: TcpStream, peer_addr: std::net::SocketAddr) -> GatewayOutcome { + let client_addr = if self.config.proxy_protocol.ingress_enabled { + #[cfg(feature = "protocol-minecraft")] + { + if !self + .config + .proxy_protocol + .trusted_cidrs + .iter() + .any(|cidr| cidr.contains(peer_addr.ip())) + { + return GatewayOutcome { + client_ip: None, + result: Err(anyhow::anyhow!("untrusted peer attempted inbound PROXY protocol")), + }; + } + match proxy::read_v2_header( + &mut client, + Duration::from_millis(self.config.proxy_protocol.ingress_timeout_ms), + self.config.proxy_protocol.max_header_bytes, + ) + .await + { + Ok(client_addr) => client_addr, + Err(error) => { + return GatewayOutcome { + client_ip: None, + result: Err(error), + }; + }, + } + } + #[cfg(not(feature = "protocol-minecraft"))] + { + return GatewayOutcome { + client_ip: None, + result: Err(anyhow::anyhow!("inbound PROXY protocol requires protocol-minecraft")), + }; + } + } else { + peer_addr + }; + let client_ip = client_addr.ip(); + let result = self.handle_client(client, peer_addr, client_addr).await; + GatewayOutcome { + client_ip: Some(client_ip), + result, + } + } - async fn handle_client( - &self, - mut client: TcpStream, - peer_addr: std::net::SocketAddr, - client_addr: std::net::SocketAddr, - ) -> anyhow::Result<()> { - let peer_ip = client_addr.ip(); + async fn handle_client( + &self, + mut client: TcpStream, + peer_addr: std::net::SocketAddr, + client_addr: std::net::SocketAddr, + ) -> anyhow::Result<()> { + let peer_ip = client_addr.ip(); - if let Some(tracker) = &self.subnet_tracker { - tracker.record_connection(peer_ip); - } + if let Some(tracker) = &self.subnet_tracker { + tracker.record_connection(peer_ip); + } - if self.blacklist.is_blocked(peer_ip) { - metrics::CONNECTIONS_TOTAL.with_label_values(&["blocked"]).inc(); - return Ok(()); - } + if self.blacklist.is_blocked(peer_ip) { + metrics::CONNECTIONS_TOTAL.with_label_values(&["blocked"]).inc(); + return Ok(()); + } - let Some(_connection_permit) = self.connection_limiter.try_acquire(peer_ip) else { - self.block_rate_limit(peer_ip).await; - return Ok(()); - }; + let Some(_connection_permit) = self.connection_limiter.try_acquire(peer_ip) else { + self.block_rate_limit(peer_ip).await; + return Ok(()); + }; - if !self.pass_pow_gate(&mut client, peer_ip).await? { - return Ok(()); - } + if !self.pass_pow_gate(&mut client, peer_ip).await? { + return Ok(()); + } - if !self.rate_limiter.check(peer_ip) { - self.block_rate_limit(peer_ip).await; - return Ok(()); - } + if !self.rate_limiter.check(peer_ip) { + self.block_rate_limit(peer_ip).await; + return Ok(()); + } - let handler = self.registry.primary()?; - let handshake = match handler.handshake(&mut client).await { - Ok(handshake) => handshake, - Err(e) => { - tracing::debug!("handshake rejected from {peer_addr}: {e}"); - metrics::CONNECTIONS_TOTAL.with_label_values(&["blocked"]).inc(); - return Ok(()); - }, - }; + let handler = self.registry.primary()?; + let handshake = match handler.handshake(&mut client).await { + Ok(handshake) => handshake, + Err(e) => { + tracing::debug!("handshake rejected from {peer_addr}: {e}"); + metrics::CONNECTIONS_TOTAL.with_label_values(&["blocked"]).inc(); + return Ok(()); + }, + }; - metrics::CONNECTIONS_TOTAL.with_label_values(&["allowed"]).inc(); - self.allowed_1s.fetch_add(1, Ordering::Relaxed); - self.reputation.record_good(peer_ip); + metrics::CONNECTIONS_TOTAL.with_label_values(&["allowed"]).inc(); + self.allowed_1s.fetch_add(1, Ordering::Relaxed); + self.reputation.record_good(peer_ip); - let mut backend = TcpStream::connect(self.next_upstream(&handshake.upstream.addr)).await?; - #[cfg(feature = "protocol-minecraft")] - if self.config.protocol.minecraft.enabled && self.config.protocol.minecraft.send_proxy_protocol { - let source = client_addr; - let destination = client.local_addr()?; - backend.write_all(&proxy::protocol_v2(source, destination)?).await?; - } - if !handshake.initial_backend_data.is_empty() { - backend.write_all(&handshake.initial_backend_data).await?; - } - tokio::io::copy_bidirectional(&mut client, &mut backend).await?; - Ok(()) - } + let mut backend = TcpStream::connect(self.next_upstream(&handshake.upstream.addr)).await?; + #[cfg(feature = "protocol-minecraft")] + if self.config.protocol.minecraft.enabled && self.config.protocol.minecraft.send_proxy_protocol { + let source = client_addr; + let destination = client.local_addr()?; + backend.write_all(&proxy::protocol_v2(source, destination)?).await?; + } + if !handshake.initial_backend_data.is_empty() { + backend.write_all(&handshake.initial_backend_data).await?; + } + tokio::io::copy_bidirectional(&mut client, &mut backend).await?; + Ok(()) + } - fn next_upstream<'a>(&'a self, negotiated: &'a str) -> &'a str { - let upstreams = &self.config.backend.upstreams; - if upstreams.len() > 1 { - let idx = self.upstream_cursor.fetch_add(1, Ordering::Relaxed) % upstreams.len(); - return upstreams[idx].as_str(); - } - if let Some(first) = upstreams.first() { - return first.as_str(); - } - negotiated - } + fn next_upstream<'a>(&'a self, negotiated: &'a str) -> &'a str { + let upstreams = &self.config.backend.upstreams; + if upstreams.len() > 1 { + let idx = self.upstream_cursor.fetch_add(1, Ordering::Relaxed) % upstreams.len(); + return upstreams[idx].as_str(); + } + if let Some(first) = upstreams.first() { + return first.as_str(); + } + negotiated + } - async fn block_rate_limit(&self, ip: IpAddr) { - metrics::RATE_LIMIT_HITS.with_label_values(&["hit"]).inc(); - metrics::CONNECTIONS_TOTAL.with_label_values(&["blocked"]).inc(); - self.reputation.record_bad(ip); - if self.reputation.score(ip) < -40 { - let duration_secs = Duration::from_secs(self.config.ban.ban_duration_secs); - self.blacklist.add(ip, duration_secs, "low_reputation"); - if !self.config.proxy_protocol.ingress_enabled { - self.xdp_ban(ip, duration_secs.as_secs()); - } - self.push_event("block", ip, "low_reputation").await; - tracing::info!("low reputation ban {ip}: rate-limit abuse"); - } - } + async fn block_rate_limit(&self, ip: IpAddr) { + metrics::RATE_LIMIT_HITS.with_label_values(&["hit"]).inc(); + metrics::CONNECTIONS_TOTAL.with_label_values(&["blocked"]).inc(); + self.reputation.record_bad(ip); + if self.reputation.score(ip) < -40 { + let duration_secs = Duration::from_secs(self.config.ban.ban_duration_secs); + self.blacklist.add(ip, duration_secs, "low_reputation"); + if !self.config.proxy_protocol.ingress_enabled { + self.xdp_ban(ip, duration_secs.as_secs()); + } + self.push_event("block", ip, "low_reputation").await; + tracing::info!("low reputation ban {ip}: rate-limit abuse"); + } + } - fn xdp_ban(&self, ip: IpAddr, duration_secs: u64) { - let Some(xdp) = &self.xdp else { - return; - }; - let IpAddr::V4(ip_v4) = ip else { - return; - }; - match xdp.lock().expect("xdp lock poisoned").ban_ip(ip_v4, duration_secs) { - Ok(()) => tracing::debug!("xdp ban {ip_v4} for {duration_secs}s"), - Err(e) => tracing::warn!("xdp ban failed for {ip_v4}: {e}"), - } - } + fn xdp_ban(&self, ip: IpAddr, duration_secs: u64) { + let Some(xdp) = &self.xdp else { + return; + }; + let IpAddr::V4(ip_v4) = ip else { + return; + }; + match xdp.lock().expect("xdp lock poisoned").ban_ip(ip_v4, duration_secs) { + Ok(()) => tracing::debug!("xdp ban {ip_v4} for {duration_secs}s"), + Err(e) => tracing::warn!("xdp ban failed for {ip_v4}: {e}"), + } + } - async fn push_event(&self, event_type: &str, ip: IpAddr, data_string: &str) { - let Some(writer) = &self.clickhouse else { - return; - }; - let event = ClickHouseEvent { - timestamp: chrono::Utc::now(), - event_type: event_type.to_string(), - ip: ip.to_string(), - data_float: 0.0, - data_int: 0, - data_string: data_string.to_string(), - }; - if let Err(e) = writer.lock().await.push(event).await { - tracing::debug!("clickhouse push error: {e}"); - } - } + async fn push_event(&self, event_type: &str, ip: IpAddr, data_string: &str) { + let Some(writer) = &self.clickhouse else { + return; + }; + let event = ClickHouseEvent { + timestamp: chrono::Utc::now(), + event_type: event_type.to_string(), + ip: ip.to_string(), + data_float: 0.0, + data_int: 0, + data_string: data_string.to_string(), + }; + if let Err(e) = writer.lock().await.push(event).await { + tracing::debug!("clickhouse push error: {e}"); + } + } } diff --git a/src/engine/tunnel/gateway/challenge.rs b/src/engine/tunnel/gateway/challenge.rs index 9ba76ea..291d781 100644 --- a/src/engine/tunnel/gateway/challenge.rs +++ b/src/engine/tunnel/gateway/challenge.rs @@ -5,30 +5,30 @@ use std::net::IpAddr; use tokio::net::TcpStream; impl Gateway { - pub(super) async fn pass_pow_gate(&self, client: &mut TcpStream, peer_ip: IpAddr) -> anyhow::Result { - let pow_config = &self.config.pow; - if !(pow_config.enabled && pow_config.difficulty > 0) { - return Ok(true); - } - if self.whitelist.contains(&peer_ip) { - metrics::POW_CHALLENGES_TOTAL.with_label_values(&["skipped"]).inc(); - metrics::POW_CURRENT_DIFFICULTY.set(pow_config.difficulty as i64); - return Ok(true); - } + pub(super) async fn pass_pow_gate(&self, client: &mut TcpStream, peer_ip: IpAddr) -> anyhow::Result { + let pow_config = &self.config.pow; + if !(pow_config.enabled && pow_config.difficulty > 0) { + return Ok(true); + } + if self.whitelist.contains(&peer_ip) { + metrics::POW_CHALLENGES_TOTAL.with_label_values(&["skipped"]).inc(); + metrics::POW_CURRENT_DIFFICULTY.set(pow_config.difficulty as i64); + return Ok(true); + } - let diff = { - let mut adjuster = self.adjuster.lock().expect("adjuster lock poisoned"); - adjuster.record_connection(); - adjuster.current_difficulty() - }; - let result = enforce_pow(client, peer_ip, diff).await?; - if !result { - metrics::POW_CHALLENGES_TOTAL.with_label_values(&["failed"]).inc(); - tracing::debug!("pow: failed for {peer_ip}, dropping connection"); - return Ok(false); - } - metrics::POW_CHALLENGES_TOTAL.with_label_values(&["passed"]).inc(); - metrics::POW_CURRENT_DIFFICULTY.set(diff as i64); - Ok(true) - } + let diff = { + let mut adjuster = self.adjuster.lock().expect("adjuster lock poisoned"); + adjuster.record_connection(); + adjuster.current_difficulty() + }; + let result = enforce_pow(client, peer_ip, diff).await?; + if !result { + metrics::POW_CHALLENGES_TOTAL.with_label_values(&["failed"]).inc(); + tracing::debug!("pow: failed for {peer_ip}, dropping connection"); + return Ok(false); + } + metrics::POW_CHALLENGES_TOTAL.with_label_values(&["passed"]).inc(); + metrics::POW_CURRENT_DIFFICULTY.set(diff as i64); + Ok(true) + } } diff --git a/src/engine/tunnel/proxy.rs b/src/engine/tunnel/proxy.rs index c984f99..eb72e79 100644 --- a/src/engine/tunnel/proxy.rs +++ b/src/engine/tunnel/proxy.rs @@ -6,35 +6,35 @@ pub(super) use inbound::read_v2_header; /// Encodes a PROXY protocol v2 TCP header for the backend. /// The backend must accept connections only from trusted Rampart nodes. pub(super) fn protocol_v2(source: SocketAddr, destination: SocketAddr) -> anyhow::Result> { - const SIGNATURE: [u8; 12] = *b"\r\n\r\n\0\r\nQUIT\n"; - if source.is_ipv4() != destination.is_ipv4() { - anyhow::bail!("PROXY protocol source/destination address families differ"); - } + const SIGNATURE: [u8; 12] = *b"\r\n\r\n\0\r\nQUIT\n"; + if source.is_ipv4() != destination.is_ipv4() { + anyhow::bail!("PROXY protocol source/destination address families differ"); + } - let (family, address_len) = if source.is_ipv4() { - (0x11, 12usize) - } else { - (0x21, 36usize) - }; - let mut header = Vec::with_capacity(16 + address_len); - header.extend_from_slice(&SIGNATURE); - header.push(0x21); - header.push(family); - header.extend_from_slice(&(address_len as u16).to_be_bytes()); - match (source, destination) { - (SocketAddr::V4(src), SocketAddr::V4(dst)) => { - header.extend_from_slice(&src.ip().octets()); - header.extend_from_slice(&dst.ip().octets()); - header.extend_from_slice(&src.port().to_be_bytes()); - header.extend_from_slice(&dst.port().to_be_bytes()); - }, - (SocketAddr::V6(src), SocketAddr::V6(dst)) => { - header.extend_from_slice(&src.ip().octets()); - header.extend_from_slice(&dst.ip().octets()); - header.extend_from_slice(&src.port().to_be_bytes()); - header.extend_from_slice(&dst.port().to_be_bytes()); - }, - _ => anyhow::bail!("PROXY protocol source/destination address families differ"), - } - Ok(header) + let (family, address_len) = if source.is_ipv4() { + (0x11, 12usize) + } else { + (0x21, 36usize) + }; + let mut header = Vec::with_capacity(16 + address_len); + header.extend_from_slice(&SIGNATURE); + header.push(0x21); + header.push(family); + header.extend_from_slice(&(address_len as u16).to_be_bytes()); + match (source, destination) { + (SocketAddr::V4(src), SocketAddr::V4(dst)) => { + header.extend_from_slice(&src.ip().octets()); + header.extend_from_slice(&dst.ip().octets()); + header.extend_from_slice(&src.port().to_be_bytes()); + header.extend_from_slice(&dst.port().to_be_bytes()); + }, + (SocketAddr::V6(src), SocketAddr::V6(dst)) => { + header.extend_from_slice(&src.ip().octets()); + header.extend_from_slice(&dst.ip().octets()); + header.extend_from_slice(&src.port().to_be_bytes()); + header.extend_from_slice(&dst.port().to_be_bytes()); + }, + _ => anyhow::bail!("PROXY protocol source/destination address families differ"), + } + Ok(header) } diff --git a/src/engine/tunnel/proxy/inbound.rs b/src/engine/tunnel/proxy/inbound.rs index 4638285..e8644a5 100644 --- a/src/engine/tunnel/proxy/inbound.rs +++ b/src/engine/tunnel/proxy/inbound.rs @@ -9,62 +9,62 @@ const SIGNATURE: [u8; 12] = *b"\r\n\r\n\0\r\nQUIT\n"; const FIXED_HEADER_BYTES: usize = 16; pub(crate) async fn read_v2_header( - stream: &mut TcpStream, - timeout: Duration, - max_header_bytes: usize, + stream: &mut TcpStream, + timeout: Duration, + max_header_bytes: usize, ) -> anyhow::Result { - tokio::time::timeout(timeout, read_v2_header_inner(stream, max_header_bytes)) - .await - .map_err(|_| anyhow::anyhow!("timed out reading inbound PROXY v2 header"))? + tokio::time::timeout(timeout, read_v2_header_inner(stream, max_header_bytes)) + .await + .map_err(|_| anyhow::anyhow!("timed out reading inbound PROXY v2 header"))? } async fn read_v2_header_inner(stream: &mut TcpStream, max_header_bytes: usize) -> anyhow::Result { - let mut fixed = [0u8; FIXED_HEADER_BYTES]; - stream.read_exact(&mut fixed).await?; + let mut fixed = [0u8; FIXED_HEADER_BYTES]; + stream.read_exact(&mut fixed).await?; - if fixed[..12] != SIGNATURE { - anyhow::bail!("invalid inbound PROXY protocol signature"); - } - if fixed[12] != 0x21 { - anyhow::bail!("inbound PROXY protocol requires version 2 PROXY command"); - } + if fixed[..12] != SIGNATURE { + anyhow::bail!("invalid inbound PROXY protocol signature"); + } + if fixed[12] != 0x21 { + anyhow::bail!("inbound PROXY protocol requires version 2 PROXY command"); + } - let payload_len = usize::from(u16::from_be_bytes([fixed[14], fixed[15]])); - let total_len = FIXED_HEADER_BYTES - .checked_add(payload_len) - .ok_or_else(|| anyhow::anyhow!("inbound PROXY header length overflow"))?; - if total_len > max_header_bytes { - anyhow::bail!("inbound PROXY header exceeds configured limit"); - } + let payload_len = usize::from(u16::from_be_bytes([fixed[14], fixed[15]])); + let total_len = FIXED_HEADER_BYTES + .checked_add(payload_len) + .ok_or_else(|| anyhow::anyhow!("inbound PROXY header length overflow"))?; + if total_len > max_header_bytes { + anyhow::bail!("inbound PROXY header exceeds configured limit"); + } - let address_len = match fixed[13] { - 0x11 => 12, - 0x21 => 36, - family => anyhow::bail!("unsupported inbound PROXY address family/protocol 0x{family:02x}"), - }; - if payload_len < address_len { - anyhow::bail!("inbound PROXY header is shorter than its address block"); - } - if payload_len != address_len { - anyhow::bail!("inbound PROXY v2 TLVs are not supported"); - } + let address_len = match fixed[13] { + 0x11 => 12, + 0x21 => 36, + family => anyhow::bail!("unsupported inbound PROXY address family/protocol 0x{family:02x}"), + }; + if payload_len < address_len { + anyhow::bail!("inbound PROXY header is shorter than its address block"); + } + if payload_len != address_len { + anyhow::bail!("inbound PROXY v2 TLVs are not supported"); + } - let mut payload = vec![0u8; payload_len]; - stream.read_exact(&mut payload).await?; - match fixed[13] { - 0x11 => { - let source = Ipv4Addr::new(payload[0], payload[1], payload[2], payload[3]); - let port = u16::from_be_bytes([payload[8], payload[9]]); - Ok(SocketAddr::V4(SocketAddrV4::new(source, port))) - }, - 0x21 => { - let source_bytes: [u8; 16] = payload[..16] - .try_into() - .map_err(|_| anyhow::anyhow!("invalid inbound PROXY IPv6 source address"))?; - let source = Ipv6Addr::from(source_bytes); - let port = u16::from_be_bytes([payload[32], payload[33]]); - Ok(SocketAddr::V6(SocketAddrV6::new(source, port, 0, 0))) - }, - family => anyhow::bail!("unsupported inbound PROXY address family/protocol 0x{family:02x}"), - } + let mut payload = vec![0u8; payload_len]; + stream.read_exact(&mut payload).await?; + match fixed[13] { + 0x11 => { + let source = Ipv4Addr::new(payload[0], payload[1], payload[2], payload[3]); + let port = u16::from_be_bytes([payload[8], payload[9]]); + Ok(SocketAddr::V4(SocketAddrV4::new(source, port))) + }, + 0x21 => { + let source_bytes: [u8; 16] = payload[..16] + .try_into() + .map_err(|_| anyhow::anyhow!("invalid inbound PROXY IPv6 source address"))?; + let source = Ipv6Addr::from(source_bytes); + let port = u16::from_be_bytes([payload[32], payload[33]]); + Ok(SocketAddr::V6(SocketAddrV6::new(source, port, 0, 0))) + }, + family => anyhow::bail!("unsupported inbound PROXY address family/protocol 0x{family:02x}"), + } } diff --git a/src/filter/blacklist.rs b/src/filter/blacklist.rs index bc68192..f578906 100644 --- a/src/filter/blacklist.rs +++ b/src/filter/blacklist.rs @@ -8,173 +8,173 @@ const LOCAL_BAN_EVENT_CAPACITY: usize = 4096; #[derive(Clone, Debug)] pub struct LocalBanEvent { - pub ip: IpAddr, - pub expires_at_unix: i64, - pub reason: String, + pub ip: IpAddr, + pub expires_at_unix: i64, + pub reason: String, } struct BanEntry { - expires: Instant, - _reason: String, + expires: Instant, + _reason: String, } pub struct Blacklist { - entries: Arc>, - redis_entries: Arc>, - local_ban_events: broadcast::Sender, + entries: Arc>, + redis_entries: Arc>, + local_ban_events: broadcast::Sender, } impl Default for Blacklist { - fn default() -> Self { - Self::new() - } + fn default() -> Self { + Self::new() + } } impl Blacklist { - pub fn new() -> Self { - let (local_ban_events, _) = broadcast::channel(LOCAL_BAN_EVENT_CAPACITY); - Self { - entries: Arc::new(DashMap::new()), - redis_entries: Arc::new(DashMap::new()), - local_ban_events, - } - } + pub fn new() -> Self { + let (local_ban_events, _) = broadcast::channel(LOCAL_BAN_EVENT_CAPACITY); + Self { + entries: Arc::new(DashMap::new()), + redis_entries: Arc::new(DashMap::new()), + local_ban_events, + } + } - pub fn is_blocked(&self, ip: IpAddr) -> bool { - Self::is_blocked_in(&self.entries, ip) || Self::is_blocked_in(&self.redis_entries, ip) - } + pub fn is_blocked(&self, ip: IpAddr) -> bool { + Self::is_blocked_in(&self.entries, ip) || Self::is_blocked_in(&self.redis_entries, ip) + } - pub fn add(&self, ip: IpAddr, duration: Duration, reason: &str) { - let now = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap_or_default() - .as_secs(); - let expires_at_unix = now.saturating_add(duration.as_secs()).min(i64::MAX as u64) as i64; - self.entries.insert( - ip, - BanEntry { - expires: Instant::now() + duration, - _reason: reason.to_string(), - }, - ); - let _ = self.local_ban_events.send(LocalBanEvent { - ip, - expires_at_unix, - reason: reason.to_string(), - }); - } + pub fn add(&self, ip: IpAddr, duration: Duration, reason: &str) { + let now = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_secs(); + let expires_at_unix = now.saturating_add(duration.as_secs()).min(i64::MAX as u64) as i64; + self.entries.insert( + ip, + BanEntry { + expires: Instant::now() + duration, + _reason: reason.to_string(), + }, + ); + let _ = self.local_ban_events.send(LocalBanEvent { + ip, + expires_at_unix, + reason: reason.to_string(), + }); + } - pub fn subscribe_local_bans(&self) -> broadcast::Receiver { - self.local_ban_events.subscribe() - } + pub fn subscribe_local_bans(&self) -> broadcast::Receiver { + self.local_ban_events.subscribe() + } - pub fn local_snapshot(&self) -> Vec { - self.entries - .iter() - .filter(|entry| entry.expires > Instant::now()) - .map(|entry| LocalBanEvent { - ip: *entry.key(), - expires_at_unix: std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap_or_default() - .as_secs() - .saturating_add(entry.expires.saturating_duration_since(Instant::now()).as_secs()) - .min(i64::MAX as u64) as i64, - reason: entry._reason.clone(), - }) - .collect() - } + pub fn local_snapshot(&self) -> Vec { + self.entries + .iter() + .filter(|entry| entry.expires > Instant::now()) + .map(|entry| LocalBanEvent { + ip: *entry.key(), + expires_at_unix: std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_secs() + .saturating_add(entry.expires.saturating_duration_since(Instant::now()).as_secs()) + .min(i64::MAX as u64) as i64, + reason: entry._reason.clone(), + }) + .collect() + } - pub fn remove(&self, ip: IpAddr) { - self.entries.remove(&ip); - } + pub fn remove(&self, ip: IpAddr) { + self.entries.remove(&ip); + } - pub fn add_redis(&self, ip: IpAddr, duration: Duration, reason: &str) { - self.redis_entries.insert( - ip, - BanEntry { - expires: Instant::now() + duration, - _reason: reason.to_string(), - }, - ); - } + pub fn add_redis(&self, ip: IpAddr, duration: Duration, reason: &str) { + self.redis_entries.insert( + ip, + BanEntry { + expires: Instant::now() + duration, + _reason: reason.to_string(), + }, + ); + } - pub fn remove_redis(&self, ip: IpAddr) { - self.redis_entries.remove(&ip); - } + pub fn remove_redis(&self, ip: IpAddr) { + self.redis_entries.remove(&ip); + } - /// Replace Redis-managed bans while preserving local detector bans. - pub fn replace_redis(&self, entries: I) - where - I: IntoIterator, - { - self.redis_entries.clear(); - for (ip, duration, reason) in entries { - self.add_redis(ip, duration, &reason); - } - } + /// Replace Redis-managed bans while preserving local detector bans. + pub fn replace_redis(&self, entries: I) + where + I: IntoIterator, + { + self.redis_entries.clear(); + for (ip, duration, reason) in entries { + self.add_redis(ip, duration, &reason); + } + } - pub fn len(&self) -> usize { - self.entries.len() + self.redis_entries.len() - } + pub fn len(&self) -> usize { + self.entries.len() + self.redis_entries.len() + } - pub fn is_empty(&self) -> bool { - self.entries.is_empty() && self.redis_entries.is_empty() - } + pub fn is_empty(&self) -> bool { + self.entries.is_empty() && self.redis_entries.is_empty() + } - pub fn clear_expired(&self) { - self.entries.retain(|_, entry| entry.expires > Instant::now()); - self.redis_entries.retain(|_, entry| entry.expires > Instant::now()); - } + pub fn clear_expired(&self) { + self.entries.retain(|_, entry| entry.expires > Instant::now()); + self.redis_entries.retain(|_, entry| entry.expires > Instant::now()); + } - fn is_blocked_in(entries: &DashMap, ip: IpAddr) -> bool { - if let Some(entry) = entries.get(&ip) { - if entry.expires > Instant::now() { - return true; - } - drop(entry); - entries.remove(&ip); - } - false - } + fn is_blocked_in(entries: &DashMap, ip: IpAddr) -> bool { + if let Some(entry) = entries.get(&ip) { + if entry.expires > Instant::now() { + return true; + } + drop(entry); + entries.remove(&ip); + } + false + } } #[cfg(test)] mod tests { - use super::*; - use std::net::{IpAddr, Ipv4Addr}; + use super::*; + use std::net::{IpAddr, Ipv4Addr}; - fn ip(octets: [u8; 4]) -> IpAddr { - IpAddr::V4(Ipv4Addr::from(octets)) - } + fn ip(octets: [u8; 4]) -> IpAddr { + IpAddr::V4(Ipv4Addr::from(octets)) + } - #[test] - fn test_blacklist_block() { - let bl = Blacklist::new(); - bl.add(ip([1, 2, 3, 4]), Duration::from_secs(60), "test"); - assert!(bl.is_blocked(ip([1, 2, 3, 4]))); - } + #[test] + fn test_blacklist_block() { + let bl = Blacklist::new(); + bl.add(ip([1, 2, 3, 4]), Duration::from_secs(60), "test"); + assert!(bl.is_blocked(ip([1, 2, 3, 4]))); + } - #[test] - fn test_blacklist_not_blocked() { - let bl = Blacklist::new(); - bl.add(ip([1, 2, 3, 4]), Duration::from_secs(60), "test"); - assert!(!bl.is_blocked(ip([5, 6, 7, 8]))); - } + #[test] + fn test_blacklist_not_blocked() { + let bl = Blacklist::new(); + bl.add(ip([1, 2, 3, 4]), Duration::from_secs(60), "test"); + assert!(!bl.is_blocked(ip([5, 6, 7, 8]))); + } - #[test] - fn test_blacklist_expired() { - let bl = Blacklist::new(); - bl.add(ip([1, 2, 3, 4]), Duration::from_millis(1), "test"); - std::thread::sleep(Duration::from_millis(2)); - assert!(!bl.is_blocked(ip([1, 2, 3, 4]))); - } + #[test] + fn test_blacklist_expired() { + let bl = Blacklist::new(); + bl.add(ip([1, 2, 3, 4]), Duration::from_millis(1), "test"); + std::thread::sleep(Duration::from_millis(2)); + assert!(!bl.is_blocked(ip([1, 2, 3, 4]))); + } - #[test] - fn test_blacklist_remove() { - let bl = Blacklist::new(); - bl.add(ip([1, 2, 3, 4]), Duration::from_secs(60), "test"); - bl.remove(ip([1, 2, 3, 4])); - assert!(!bl.is_blocked(ip([1, 2, 3, 4]))); - } + #[test] + fn test_blacklist_remove() { + let bl = Blacklist::new(); + bl.add(ip([1, 2, 3, 4]), Duration::from_secs(60), "test"); + bl.remove(ip([1, 2, 3, 4])); + assert!(!bl.is_blocked(ip([1, 2, 3, 4]))); + } } diff --git a/src/filter/connection_limit/mod.rs b/src/filter/connection_limit/mod.rs index bf07117..157b8f1 100644 --- a/src/filter/connection_limit/mod.rs +++ b/src/filter/connection_limit/mod.rs @@ -5,55 +5,55 @@ use std::sync::atomic::{AtomicUsize, Ordering}; /// Caps simultaneous in-flight connections per source IP. pub struct ConnectionLimiter { - counts: Arc>>, - limit: usize, + counts: Arc>>, + limit: usize, } impl ConnectionLimiter { - #[must_use] - pub fn new(limit: usize) -> Self { - Self { - counts: Arc::new(DashMap::new()), - limit: limit.max(1), - } - } + #[must_use] + pub fn new(limit: usize) -> Self { + Self { + counts: Arc::new(DashMap::new()), + limit: limit.max(1), + } + } - pub fn try_acquire(&self, ip: IpAddr) -> Option { - let entry = self.counts.entry(ip).or_insert_with(|| Arc::new(AtomicUsize::new(0))); - let count = Arc::clone(entry.value()); - let current = count.fetch_add(1, Ordering::AcqRel); - drop(entry); - if current >= self.limit { - count.fetch_sub(1, Ordering::AcqRel); - self.remove_if_idle(ip, &count); - return None; - } - Some(ConnectionPermit { - ip, - count, - counts: Arc::clone(&self.counts), - }) - } + pub fn try_acquire(&self, ip: IpAddr) -> Option { + let entry = self.counts.entry(ip).or_insert_with(|| Arc::new(AtomicUsize::new(0))); + let count = Arc::clone(entry.value()); + let current = count.fetch_add(1, Ordering::AcqRel); + drop(entry); + if current >= self.limit { + count.fetch_sub(1, Ordering::AcqRel); + self.remove_if_idle(ip, &count); + return None; + } + Some(ConnectionPermit { + ip, + count, + counts: Arc::clone(&self.counts), + }) + } - fn remove_if_idle(&self, ip: IpAddr, count: &Arc) { - self.counts.remove_if(&ip, |_, current| { - Arc::ptr_eq(current, count) && current.load(Ordering::Acquire) == 0 - }); - } + fn remove_if_idle(&self, ip: IpAddr, count: &Arc) { + self.counts.remove_if(&ip, |_, current| { + Arc::ptr_eq(current, count) && current.load(Ordering::Acquire) == 0 + }); + } } pub struct ConnectionPermit { - ip: IpAddr, - count: Arc, - counts: Arc>>, + ip: IpAddr, + count: Arc, + counts: Arc>>, } impl Drop for ConnectionPermit { - fn drop(&mut self) { - if self.count.fetch_sub(1, Ordering::AcqRel) == 1 { - self.counts.remove_if(&self.ip, |_, current| { - Arc::ptr_eq(current, &self.count) && current.load(Ordering::Acquire) == 0 - }); - } - } + fn drop(&mut self) { + if self.count.fetch_sub(1, Ordering::AcqRel) == 1 { + self.counts.remove_if(&self.ip, |_, current| { + Arc::ptr_eq(current, &self.count) && current.load(Ordering::Acquire) == 0 + }); + } + } } diff --git a/src/filter/geo.rs b/src/filter/geo.rs index 85490b4..0e34c92 100644 --- a/src/filter/geo.rs +++ b/src/filter/geo.rs @@ -1,35 +1,35 @@ #[cfg(feature = "geoip")] pub struct GeoIp { - #[allow(dead_code)] - reader: maxminddb::Reader>, + #[allow(dead_code)] + reader: maxminddb::Reader>, } #[cfg(feature = "geoip")] impl GeoIp { - pub fn new(db_path: &str) -> anyhow::Result { - let reader = maxminddb::Reader::open_readfile(db_path)?; - Ok(Self { reader }) - } + pub fn new(db_path: &str) -> anyhow::Result { + let reader = maxminddb::Reader::open_readfile(db_path)?; + Ok(Self { reader }) + } } pub enum IpCategory { - Residential, - Datacenter, - Mobile, - Vpn, - Tor, - Unknown, + Residential, + Datacenter, + Mobile, + Vpn, + Tor, + Unknown, } impl std::fmt::Display for IpCategory { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - match self { - Self::Residential => write!(f, "residential"), - Self::Datacenter => write!(f, "datacenter"), - Self::Mobile => write!(f, "mobile"), - Self::Vpn => write!(f, "vpn"), - Self::Tor => write!(f, "tor"), - Self::Unknown => write!(f, "unknown"), - } - } + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { + Self::Residential => write!(f, "residential"), + Self::Datacenter => write!(f, "datacenter"), + Self::Mobile => write!(f, "mobile"), + Self::Vpn => write!(f, "vpn"), + Self::Tor => write!(f, "tor"), + Self::Unknown => write!(f, "unknown"), + } + } } diff --git a/src/filter/rate_limit.rs b/src/filter/rate_limit.rs index 6ddee1e..4d71031 100644 --- a/src/filter/rate_limit.rs +++ b/src/filter/rate_limit.rs @@ -9,144 +9,144 @@ const EVICTION_IDLE: Duration = Duration::from_secs(600); const SWEEP_INTERVAL: Duration = Duration::from_secs(60); struct Bucket { - tokens: f64, - last_refill: Instant, - last_access: Instant, + tokens: f64, + last_refill: Instant, + last_access: Instant, } pub struct RateLimiter { - buckets: Arc>, - max_tokens: f64, - refill_rate: f64, - _refill_interval: Duration, - epoch: Instant, - last_sweep_elapsed: AtomicU64, - eviction_idle: Duration, + buckets: Arc>, + max_tokens: f64, + refill_rate: f64, + _refill_interval: Duration, + epoch: Instant, + last_sweep_elapsed: AtomicU64, + eviction_idle: Duration, } impl RateLimiter { - pub fn new(rate_per_sec: f64, burst: f64) -> Self { - Self::with_eviction(rate_per_sec, burst, EVICTION_IDLE) - } + pub fn new(rate_per_sec: f64, burst: f64) -> Self { + Self::with_eviction(rate_per_sec, burst, EVICTION_IDLE) + } - fn with_eviction(rate_per_sec: f64, burst: f64, eviction_idle: Duration) -> Self { - Self { - buckets: Arc::new(DashMap::new()), - max_tokens: burst, - refill_rate: rate_per_sec, - _refill_interval: Duration::from_secs(1), - epoch: Instant::now(), - last_sweep_elapsed: AtomicU64::new(0), - eviction_idle, - } - } + fn with_eviction(rate_per_sec: f64, burst: f64, eviction_idle: Duration) -> Self { + Self { + buckets: Arc::new(DashMap::new()), + max_tokens: burst, + refill_rate: rate_per_sec, + _refill_interval: Duration::from_secs(1), + epoch: Instant::now(), + last_sweep_elapsed: AtomicU64::new(0), + eviction_idle, + } + } - pub fn check(&self, ip: IpAddr) -> bool { - let now = Instant::now(); - let mut entry = self.buckets.entry(ip).or_insert_with(|| Bucket { - tokens: self.max_tokens, - last_refill: now, - last_access: now, - }); + pub fn check(&self, ip: IpAddr) -> bool { + let now = Instant::now(); + let mut entry = self.buckets.entry(ip).or_insert_with(|| Bucket { + tokens: self.max_tokens, + last_refill: now, + last_access: now, + }); - let elapsed = now.duration_since(entry.last_refill); - let refill = elapsed.as_secs_f64() * self.refill_rate; - entry.tokens = (entry.tokens + refill).min(self.max_tokens); - entry.last_refill = now; - entry.last_access = now; + let elapsed = now.duration_since(entry.last_refill); + let refill = elapsed.as_secs_f64() * self.refill_rate; + entry.tokens = (entry.tokens + refill).min(self.max_tokens); + entry.last_refill = now; + entry.last_access = now; - if entry.tokens >= 1.0 { - entry.tokens -= 1.0; - true - } else { - false - } - } + if entry.tokens >= 1.0 { + entry.tokens -= 1.0; + true + } else { + false + } + } - pub fn len(&self) -> usize { - self.buckets.len() - } + pub fn len(&self) -> usize { + self.buckets.len() + } - pub fn is_empty(&self) -> bool { - self.buckets.is_empty() - } + pub fn is_empty(&self) -> bool { + self.buckets.is_empty() + } - /// Эвиктит простаивающие бакеты. Запускается, когда бакетов больше - /// MAX_BUCKETS либо по расписанию (раз в SWEEP_INTERVAL). - pub fn sweep(&self) { - let now = Instant::now(); - let elapsed_secs = now.duration_since(self.epoch).as_secs(); - let last = self.last_sweep_elapsed.load(Ordering::Relaxed); - let due = last == 0 || elapsed_secs.saturating_sub(last) >= SWEEP_INTERVAL.as_secs(); - let over_cap = self.buckets.len() > MAX_BUCKETS; - if !over_cap && !due { - return; - } - self.buckets - .retain(|_, b| now.duration_since(b.last_access) < self.eviction_idle); - self.last_sweep_elapsed.store(elapsed_secs, Ordering::Relaxed); - } + /// Эвиктит простаивающие бакеты. Запускается, когда бакетов больше + /// MAX_BUCKETS либо по расписанию (раз в SWEEP_INTERVAL). + pub fn sweep(&self) { + let now = Instant::now(); + let elapsed_secs = now.duration_since(self.epoch).as_secs(); + let last = self.last_sweep_elapsed.load(Ordering::Relaxed); + let due = last == 0 || elapsed_secs.saturating_sub(last) >= SWEEP_INTERVAL.as_secs(); + let over_cap = self.buckets.len() > MAX_BUCKETS; + if !over_cap && !due { + return; + } + self.buckets + .retain(|_, b| now.duration_since(b.last_access) < self.eviction_idle); + self.last_sweep_elapsed.store(elapsed_secs, Ordering::Relaxed); + } } #[cfg(test)] mod tests { - use super::*; - use std::net::{IpAddr, Ipv4Addr}; + use super::*; + use std::net::{IpAddr, Ipv4Addr}; - fn test_ip(octet: u8) -> IpAddr { - IpAddr::V4(Ipv4Addr::new(10, 0, 0, octet)) - } + fn test_ip(octet: u8) -> IpAddr { + IpAddr::V4(Ipv4Addr::new(10, 0, 0, octet)) + } - #[test] - fn test_rate_limit_under() { - let limiter = RateLimiter::new(10.0, 10.0); - assert!(limiter.check(test_ip(1))); - } + #[test] + fn test_rate_limit_under() { + let limiter = RateLimiter::new(10.0, 10.0); + assert!(limiter.check(test_ip(1))); + } - #[test] - fn test_rate_limit_over() { - let limiter = RateLimiter::new(1.0, 1.0); - assert!(limiter.check(test_ip(1))); - assert!(!limiter.check(test_ip(1))); - } + #[test] + fn test_rate_limit_over() { + let limiter = RateLimiter::new(1.0, 1.0); + assert!(limiter.check(test_ip(1))); + assert!(!limiter.check(test_ip(1))); + } - #[test] - fn test_rate_limit_burst() { - let limiter = RateLimiter::new(1.0, 5.0); - for _ in 0..5 { - assert!(limiter.check(test_ip(2))); - } - assert!(!limiter.check(test_ip(2))); - } + #[test] + fn test_rate_limit_burst() { + let limiter = RateLimiter::new(1.0, 5.0); + for _ in 0..5 { + assert!(limiter.check(test_ip(2))); + } + assert!(!limiter.check(test_ip(2))); + } - #[test] - fn test_rate_limit_refill() { - let limiter = RateLimiter::new(100.0, 1.0); - assert!(limiter.check(test_ip(3))); - assert!(!limiter.check(test_ip(3))); - std::thread::sleep(Duration::from_millis(20)); - assert!(limiter.check(test_ip(3))); - } + #[test] + fn test_rate_limit_refill() { + let limiter = RateLimiter::new(100.0, 1.0); + assert!(limiter.check(test_ip(3))); + assert!(!limiter.check(test_ip(3))); + std::thread::sleep(Duration::from_millis(20)); + assert!(limiter.check(test_ip(3))); + } - #[test] - fn test_sweep_removes_idle_keeps_active() { - let limiter = RateLimiter::with_eviction(1.0, 10.0, Duration::from_millis(20)); - limiter.check(test_ip(1)); - limiter.check(test_ip(2)); - std::thread::sleep(Duration::from_millis(50)); - limiter.check(test_ip(2)); - limiter.sweep(); - assert_eq!(limiter.len(), 1); - assert!(!limiter.buckets.contains_key(&test_ip(1))); - assert!(limiter.buckets.contains_key(&test_ip(2))); - } + #[test] + fn test_sweep_removes_idle_keeps_active() { + let limiter = RateLimiter::with_eviction(1.0, 10.0, Duration::from_millis(20)); + limiter.check(test_ip(1)); + limiter.check(test_ip(2)); + std::thread::sleep(Duration::from_millis(50)); + limiter.check(test_ip(2)); + limiter.sweep(); + assert_eq!(limiter.len(), 1); + assert!(!limiter.buckets.contains_key(&test_ip(1))); + assert!(limiter.buckets.contains_key(&test_ip(2))); + } - #[test] - fn test_sweep_does_not_remove_active() { - let limiter = RateLimiter::with_eviction(1.0, 10.0, Duration::from_millis(50)); - limiter.check(test_ip(1)); - limiter.sweep(); - assert_eq!(limiter.len(), 1); - assert!(limiter.buckets.contains_key(&test_ip(1))); - } + #[test] + fn test_sweep_does_not_remove_active() { + let limiter = RateLimiter::with_eviction(1.0, 10.0, Duration::from_millis(50)); + limiter.check(test_ip(1)); + limiter.sweep(); + assert_eq!(limiter.len(), 1); + assert!(limiter.buckets.contains_key(&test_ip(1))); + } } diff --git a/src/manager/api/auth.rs b/src/manager/api/auth.rs index bfbc31b..8c0e491 100644 --- a/src/manager/api/auth.rs +++ b/src/manager/api/auth.rs @@ -1,15 +1,15 @@ use crate::manager::AppState; use axum::{ - Json, - extract::{ConnectInfo, State}, - http::StatusCode, + Json, + extract::{ConnectInfo, State}, + http::StatusCode, }; use dashmap::DashMap; use serde::Deserialize; use std::{ - net::{IpAddr, SocketAddr}, - sync::Arc, - time::{Duration, Instant}, + net::{IpAddr, SocketAddr}, + sync::Arc, + time::{Duration, Instant}, }; use subtle::ConstantTimeEq; @@ -18,87 +18,87 @@ const LOGIN_MAX_ATTEMPTS: u32 = 5; #[derive(Deserialize)] pub struct LoginRequest { - pub password: String, + pub password: String, } pub async fn login( - State(state): State>, - ConnectInfo(addr): ConnectInfo, - Json(req): Json, + State(state): State>, + ConnectInfo(addr): ConnectInfo, + Json(req): Json, ) -> Result, (StatusCode, Json)> { - if !allow_login_attempt(&state.login_limiter, addr.ip()) { - return Err(( - StatusCode::TOO_MANY_REQUESTS, - Json(serde_json::json!({"error": "too many requests"})), - )); - } + if !allow_login_attempt(&state.login_limiter, addr.ip()) { + return Err(( + StatusCode::TOO_MANY_REQUESTS, + Json(serde_json::json!({"error": "too many requests"})), + )); + } - if !verify_password(&req.password, &state.api_password) { - return Err(( - StatusCode::UNAUTHORIZED, - Json(serde_json::json!({"error": "invalid password"})), - )); - } + if !verify_password(&req.password, &state.api_password) { + return Err(( + StatusCode::UNAUTHORIZED, + Json(serde_json::json!({"error": "invalid password"})), + )); + } - match crate::manager::auth::create_token(&state.jwt_secret, state.jwt_expiration, &state.jwt_audience) { - Ok(token) => Ok(Json(serde_json::json!({"token": token}))), - Err(_) => Err(( - StatusCode::INTERNAL_SERVER_ERROR, - Json(serde_json::json!({"error": "token creation failed"})), - )), - } + match crate::manager::auth::create_token(&state.jwt_secret, state.jwt_expiration, &state.jwt_audience) { + Ok(token) => Ok(Json(serde_json::json!({"token": token}))), + Err(_) => Err(( + StatusCode::INTERNAL_SERVER_ERROR, + Json(serde_json::json!({"error": "token creation failed"})), + )), + } } fn verify_password(provided: &str, expected: &str) -> bool { - let provided = provided.as_bytes(); - let expected = expected.as_bytes(); - let len_match = (provided.len() as u64).ct_eq(&(expected.len() as u64)); - let min_len = provided.len().min(expected.len()); - let bytes_match = provided[..min_len].ct_eq(&expected[..min_len]); - bool::from(len_match & bytes_match) + let provided = provided.as_bytes(); + let expected = expected.as_bytes(); + let len_match = (provided.len() as u64).ct_eq(&(expected.len() as u64)); + let min_len = provided.len().min(expected.len()); + let bytes_match = provided[..min_len].ct_eq(&expected[..min_len]); + bool::from(len_match & bytes_match) } fn allow_login_attempt(limiter: &DashMap, ip: IpAddr) -> bool { - let now = Instant::now(); - let mut slot = limiter.entry(ip).or_insert((now, 0)); - let (last_reset, attempts) = &mut *slot; - if now.duration_since(*last_reset) >= LOGIN_WINDOW { - *last_reset = now; - *attempts = 1; - } else if *attempts >= LOGIN_MAX_ATTEMPTS { - return false; - } else { - *attempts += 1; - } - true + let now = Instant::now(); + let mut slot = limiter.entry(ip).or_insert((now, 0)); + let (last_reset, attempts) = &mut *slot; + if now.duration_since(*last_reset) >= LOGIN_WINDOW { + *last_reset = now; + *attempts = 1; + } else if *attempts >= LOGIN_MAX_ATTEMPTS { + return false; + } else { + *attempts += 1; + } + true } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn verify_password_matches() { - assert!(verify_password("s3cret-pass", "s3cret-pass")); - } + #[test] + fn verify_password_matches() { + assert!(verify_password("s3cret-pass", "s3cret-pass")); + } - #[test] - fn verify_password_rejects_wrong() { - assert!(!verify_password("wrong-pass", "s3cret-pass")); - } + #[test] + fn verify_password_rejects_wrong() { + assert!(!verify_password("wrong-pass", "s3cret-pass")); + } - #[test] - fn verify_password_rejects_different_length() { - assert!(!verify_password("short", "a-longer-password")); - } + #[test] + fn verify_password_rejects_different_length() { + assert!(!verify_password("short", "a-longer-password")); + } - #[test] - fn allow_login_attempt_respects_limit() { - let limiter = DashMap::new(); - let ip = IpAddr::from([127, 0, 0, 1]); - for _ in 0..LOGIN_MAX_ATTEMPTS { - assert!(allow_login_attempt(&limiter, ip)); - } - assert!(!allow_login_attempt(&limiter, ip)); - } + #[test] + fn allow_login_attempt_respects_limit() { + let limiter = DashMap::new(); + let ip = IpAddr::from([127, 0, 0, 1]); + for _ in 0..LOGIN_MAX_ATTEMPTS { + assert!(allow_login_attempt(&limiter, ip)); + } + assert!(!allow_login_attempt(&limiter, ip)); + } } diff --git a/src/manager/api/blacklist.rs b/src/manager/api/blacklist.rs index 2f02bee..cc8cfd5 100644 --- a/src/manager/api/blacklist.rs +++ b/src/manager/api/blacklist.rs @@ -2,33 +2,33 @@ use serde::{Deserialize, Serialize}; #[derive(Debug, Serialize, Deserialize)] pub struct BlacklistEntry { - pub target: String, - #[serde(rename = "type")] - pub entry_type: String, - pub reason: String, - pub created_at: String, - pub expires_at: Option, + pub target: String, + #[serde(rename = "type")] + pub entry_type: String, + pub reason: String, + pub created_at: String, + pub expires_at: Option, } #[derive(Serialize)] pub struct BlacklistResponse { - pub items: Vec, - pub total: usize, + pub items: Vec, + pub total: usize, } #[derive(Deserialize)] #[allow(dead_code)] pub struct AddBlacklistRequest { - pub target: String, - #[serde(rename = "type")] - pub entry_type: String, - pub reason: String, - pub duration_secs: Option, + pub target: String, + #[serde(rename = "type")] + pub entry_type: String, + pub reason: String, + pub duration_secs: Option, } #[derive(Deserialize)] pub struct RemoveBlacklistRequest { - pub target: String, + pub target: String, } #[cfg(feature = "store-redis")] diff --git a/src/manager/api/blacklist/common.rs b/src/manager/api/blacklist/common.rs index 16b72e6..a3195c8 100644 --- a/src/manager/api/blacklist/common.rs +++ b/src/manager/api/blacklist/common.rs @@ -3,18 +3,18 @@ use serde::{Deserialize, Serialize}; #[derive(Serialize)] pub(super) struct BlacklistEvent<'a> { - ip: &'a str, - action: &'a str, - duration_secs: u64, - #[serde(skip_serializing_if = "Option::is_none")] - expires_at_unix: Option, + ip: &'a str, + action: &'a str, + duration_secs: u64, + #[serde(skip_serializing_if = "Option::is_none")] + expires_at_unix: Option, } #[derive(Clone, Debug, Serialize, Deserialize)] pub(super) struct BlacklistMetadata { - pub created_at_unix: i64, - pub expires_at_unix: i64, - pub reason: String, + pub created_at_unix: i64, + pub expires_at_unix: i64, + pub reason: String, } pub(super) const BLACKLIST_KEY: &str = "rampart:blacklist"; @@ -27,49 +27,49 @@ pub(super) const ADD_BAN_SCRIPT: &str = "redis.call('HSET', KEYS[2], ARGV[1], AR pub(super) const REMOVE_BAN_SCRIPT: &str = "redis.call('SREM', KEYS[1], ARGV[1]); redis.call('HDEL', KEYS[2], ARGV[1]); redis.call('PUBLISH', KEYS[3], ARGV[2]); return 1"; pub(super) fn legacy_metadata(now: i64) -> BlacklistMetadata { - BlacklistMetadata { - created_at_unix: now, - expires_at_unix: now.saturating_add(LEGACY_BAN_DURATION_SECS as i64), - reason: "legacy_unverified".to_string(), - } + BlacklistMetadata { + created_at_unix: now, + expires_at_unix: now.saturating_add(LEGACY_BAN_DURATION_SECS as i64), + reason: "legacy_unverified".to_string(), + } } pub(super) fn format_timestamp(timestamp: i64) -> String { - chrono::DateTime::from_timestamp(timestamp, 0) - .map(|value| value.to_rfc3339()) - .unwrap_or_else(|| chrono::Utc::now().to_rfc3339()) + chrono::DateTime::from_timestamp(timestamp, 0) + .map(|value| value.to_rfc3339()) + .unwrap_or_else(|| chrono::Utc::now().to_rfc3339()) } pub(super) fn event_payload( - ip: &str, - action: &str, - duration_secs: u64, - expires_at_unix: Option, + ip: &str, + action: &str, + duration_secs: u64, + expires_at_unix: Option, ) -> Result)> { - serde_json::to_string(&BlacklistEvent { - ip, - action, - duration_secs, - expires_at_unix, - }) - .map_err(|_| api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to serialize blacklist event")) + serde_json::to_string(&BlacklistEvent { + ip, + action, + duration_secs, + expires_at_unix, + }) + .map_err(|_| api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to serialize blacklist event")) } pub(super) fn parse_ip(target: &str) -> Result)> { - target - .parse() - .map_err(|_| api_error(StatusCode::BAD_REQUEST, "target must be an IP address")) + target + .parse() + .map_err(|_| api_error(StatusCode::BAD_REQUEST, "target must be an IP address")) } pub(super) fn api_error(status: StatusCode, message: &str) -> (StatusCode, Json) { - (status, Json(serde_json::json!({"error": message}))) + (status, Json(serde_json::json!({"error": message}))) } pub(super) fn redis_unavailable(_: redis::RedisError) -> (StatusCode, Json) { - api_error(StatusCode::SERVICE_UNAVAILABLE, "redis unavailable") + api_error(StatusCode::SERVICE_UNAVAILABLE, "redis unavailable") } pub(super) fn redis_error(error: redis::RedisError) -> (StatusCode, Json) { - tracing::error!("Blacklist Redis operation failed: {error}"); - api_error(StatusCode::SERVICE_UNAVAILABLE, "redis operation failed") + tracing::error!("Blacklist Redis operation failed: {error}"); + api_error(StatusCode::SERVICE_UNAVAILABLE, "redis operation failed") } diff --git a/src/manager/api/blacklist/list.rs b/src/manager/api/blacklist/list.rs index 3120764..043cdeb 100644 --- a/src/manager/api/blacklist/list.rs +++ b/src/manager/api/blacklist/list.rs @@ -1,6 +1,6 @@ use super::common::{ - BLACKLIST_KEY, BLACKLIST_METADATA_KEY, BlacklistMetadata, format_timestamp, legacy_metadata, redis_error, - redis_unavailable, + BLACKLIST_KEY, BLACKLIST_METADATA_KEY, BlacklistMetadata, format_timestamp, legacy_metadata, redis_error, + redis_unavailable, }; use super::{BlacklistEntry, BlacklistResponse}; use crate::manager::AppState; @@ -10,70 +10,70 @@ use std::collections::HashMap; use std::sync::Arc; pub async fn list_blacklist( - State(state): State>, + State(state): State>, ) -> Result, (StatusCode, Json)> { - let mut conn = state - .redis_client - .get_multiplexed_async_connection() - .await - .map_err(redis_unavailable)?; - let members: Vec = redis::cmd("SMEMBERS") - .arg(BLACKLIST_KEY) - .query_async(&mut conn) - .await - .map_err(redis_error)?; - let metadata: HashMap = conn.hgetall(BLACKLIST_METADATA_KEY).await.map_err(redis_error)?; - let now = chrono::Utc::now().timestamp(); - let mut items = Vec::with_capacity(members.len()); + let mut conn = state + .redis_client + .get_multiplexed_async_connection() + .await + .map_err(redis_unavailable)?; + let members: Vec = redis::cmd("SMEMBERS") + .arg(BLACKLIST_KEY) + .query_async(&mut conn) + .await + .map_err(redis_error)?; + let metadata: HashMap = conn.hgetall(BLACKLIST_METADATA_KEY).await.map_err(redis_error)?; + let now = chrono::Utc::now().timestamp(); + let mut items = Vec::with_capacity(members.len()); - for target in members { - let Ok(ip) = target.parse::() else { - continue; - }; - let record = match metadata.get(&target) { - Some(encoded) => match serde_json::from_str::(encoded) { - Ok(record) => record, - Err(_) => continue, - }, - None => { - let legacy = legacy_metadata(now); - let encoded = serde_json::to_string(&legacy).map_err(|_| { - super::common::api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to encode blacklist metadata") - })?; - let inserted: i64 = redis::cmd("HSETNX") - .arg(BLACKLIST_METADATA_KEY) - .arg(&target) - .arg(encoded) - .query_async(&mut conn) - .await - .map_err(redis_error)?; - if inserted == 1 { - legacy - } else { - let current: Option = - conn.hget(BLACKLIST_METADATA_KEY, &target).await.map_err(redis_error)?; - match current.and_then(|value| serde_json::from_str(&value).ok()) { - Some(record) => record, - None => continue, - } - } - }, - }; - if record.expires_at_unix <= now - || chrono::DateTime::from_timestamp(record.created_at_unix, 0).is_none() - || chrono::DateTime::from_timestamp(record.expires_at_unix, 0).is_none() - { - continue; - } - items.push(BlacklistEntry { - target: ip.to_string(), - entry_type: "ip".to_string(), - reason: record.reason, - created_at: format_timestamp(record.created_at_unix), - expires_at: Some(format_timestamp(record.expires_at_unix)), - }); - } + for target in members { + let Ok(ip) = target.parse::() else { + continue; + }; + let record = match metadata.get(&target) { + Some(encoded) => match serde_json::from_str::(encoded) { + Ok(record) => record, + Err(_) => continue, + }, + None => { + let legacy = legacy_metadata(now); + let encoded = serde_json::to_string(&legacy).map_err(|_| { + super::common::api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to encode blacklist metadata") + })?; + let inserted: i64 = redis::cmd("HSETNX") + .arg(BLACKLIST_METADATA_KEY) + .arg(&target) + .arg(encoded) + .query_async(&mut conn) + .await + .map_err(redis_error)?; + if inserted == 1 { + legacy + } else { + let current: Option = + conn.hget(BLACKLIST_METADATA_KEY, &target).await.map_err(redis_error)?; + match current.and_then(|value| serde_json::from_str(&value).ok()) { + Some(record) => record, + None => continue, + } + } + }, + }; + if record.expires_at_unix <= now + || chrono::DateTime::from_timestamp(record.created_at_unix, 0).is_none() + || chrono::DateTime::from_timestamp(record.expires_at_unix, 0).is_none() + { + continue; + } + items.push(BlacklistEntry { + target: ip.to_string(), + entry_type: "ip".to_string(), + reason: record.reason, + created_at: format_timestamp(record.created_at_unix), + expires_at: Some(format_timestamp(record.expires_at_unix)), + }); + } - let total = items.len(); - Ok(Json(BlacklistResponse { items, total })) + let total = items.len(); + Ok(Json(BlacklistResponse { items, total })) } diff --git a/src/manager/api/blacklist/mutate.rs b/src/manager/api/blacklist/mutate.rs index a3244a7..ceaa5e5 100644 --- a/src/manager/api/blacklist/mutate.rs +++ b/src/manager/api/blacklist/mutate.rs @@ -1,6 +1,6 @@ use super::common::{ - ADD_BAN_SCRIPT, BLACKLIST_CHANNEL, BLACKLIST_KEY, BLACKLIST_METADATA_KEY, DEFAULT_BAN_DURATION_SECS, - MAX_BAN_DURATION_SECS, REMOVE_BAN_SCRIPT, api_error, event_payload, parse_ip, redis_error, redis_unavailable, + ADD_BAN_SCRIPT, BLACKLIST_CHANNEL, BLACKLIST_KEY, BLACKLIST_METADATA_KEY, DEFAULT_BAN_DURATION_SECS, + MAX_BAN_DURATION_SECS, REMOVE_BAN_SCRIPT, api_error, event_payload, parse_ip, redis_error, redis_unavailable, }; use super::{AddBlacklistRequest, RemoveBlacklistRequest}; use crate::manager::AppState; @@ -8,91 +8,91 @@ use axum::{Json, extract::State, http::StatusCode}; use std::sync::Arc; pub async fn add_blacklist( - State(state): State>, - Json(req): Json, + State(state): State>, + Json(req): Json, ) -> Result, (StatusCode, Json)> { - let ip = parse_ip(&req.target)?; - if req.entry_type != "ip" { - return Err(api_error( - StatusCode::BAD_REQUEST, - "only IP blacklist entries are supported", - )); - } - let duration_secs = req.duration_secs.unwrap_or(DEFAULT_BAN_DURATION_SECS); - if duration_secs == 0 { - return Err(api_error( - StatusCode::BAD_REQUEST, - "duration_secs must be greater than zero", - )); - } - if duration_secs > MAX_BAN_DURATION_SECS { - return Err(api_error( - StatusCode::BAD_REQUEST, - "duration_secs must not exceed one year", - )); - } + let ip = parse_ip(&req.target)?; + if req.entry_type != "ip" { + return Err(api_error( + StatusCode::BAD_REQUEST, + "only IP blacklist entries are supported", + )); + } + let duration_secs = req.duration_secs.unwrap_or(DEFAULT_BAN_DURATION_SECS); + if duration_secs == 0 { + return Err(api_error( + StatusCode::BAD_REQUEST, + "duration_secs must be greater than zero", + )); + } + if duration_secs > MAX_BAN_DURATION_SECS { + return Err(api_error( + StatusCode::BAD_REQUEST, + "duration_secs must not exceed one year", + )); + } - let target = ip.to_string(); - let created_at_unix = chrono::Utc::now().timestamp(); - let metadata = super::common::BlacklistMetadata { - created_at_unix, - expires_at_unix: created_at_unix + duration_secs as i64, - reason: req.reason.clone(), - }; - let encoded_metadata = serde_json::to_string(&metadata) - .map_err(|_| api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to encode blacklist metadata"))?; - let event = event_payload(&target, "ban", duration_secs, Some(metadata.expires_at_unix))?; - let mut conn = state - .redis_client - .get_multiplexed_async_connection() - .await - .map_err(redis_unavailable)?; - let _: i64 = redis::cmd("EVAL") - .arg(ADD_BAN_SCRIPT) - .arg(3) - .arg(BLACKLIST_KEY) - .arg(BLACKLIST_METADATA_KEY) - .arg(BLACKLIST_CHANNEL) - .arg(&target) - .arg(encoded_metadata) - .arg(event) - .query_async(&mut conn) - .await - .map_err(redis_error)?; + let target = ip.to_string(); + let created_at_unix = chrono::Utc::now().timestamp(); + let metadata = super::common::BlacklistMetadata { + created_at_unix, + expires_at_unix: created_at_unix + duration_secs as i64, + reason: req.reason.clone(), + }; + let encoded_metadata = serde_json::to_string(&metadata) + .map_err(|_| api_error(StatusCode::INTERNAL_SERVER_ERROR, "failed to encode blacklist metadata"))?; + let event = event_payload(&target, "ban", duration_secs, Some(metadata.expires_at_unix))?; + let mut conn = state + .redis_client + .get_multiplexed_async_connection() + .await + .map_err(redis_unavailable)?; + let _: i64 = redis::cmd("EVAL") + .arg(ADD_BAN_SCRIPT) + .arg(3) + .arg(BLACKLIST_KEY) + .arg(BLACKLIST_METADATA_KEY) + .arg(BLACKLIST_CHANNEL) + .arg(&target) + .arg(encoded_metadata) + .arg(event) + .query_async(&mut conn) + .await + .map_err(redis_error)?; - tracing::info!("Added to blacklist: {} ({})", target, req.reason); - Ok(Json(serde_json::json!({ - "status": "added", - "target": target, - "reason": req.reason, - "duration_secs": duration_secs - }))) + tracing::info!("Added to blacklist: {} ({})", target, req.reason); + Ok(Json(serde_json::json!({ + "status": "added", + "target": target, + "reason": req.reason, + "duration_secs": duration_secs + }))) } pub async fn remove_blacklist( - State(state): State>, - Json(req): Json, + State(state): State>, + Json(req): Json, ) -> Result, (StatusCode, Json)> { - let ip = parse_ip(&req.target)?; - let target = ip.to_string(); - let event = event_payload(&target, "unban", 0, None)?; - let mut conn = state - .redis_client - .get_multiplexed_async_connection() - .await - .map_err(redis_unavailable)?; - let _: i64 = redis::cmd("EVAL") - .arg(REMOVE_BAN_SCRIPT) - .arg(3) - .arg(BLACKLIST_KEY) - .arg(BLACKLIST_METADATA_KEY) - .arg(BLACKLIST_CHANNEL) - .arg(&target) - .arg(event) - .query_async(&mut conn) - .await - .map_err(redis_error)?; + let ip = parse_ip(&req.target)?; + let target = ip.to_string(); + let event = event_payload(&target, "unban", 0, None)?; + let mut conn = state + .redis_client + .get_multiplexed_async_connection() + .await + .map_err(redis_unavailable)?; + let _: i64 = redis::cmd("EVAL") + .arg(REMOVE_BAN_SCRIPT) + .arg(3) + .arg(BLACKLIST_KEY) + .arg(BLACKLIST_METADATA_KEY) + .arg(BLACKLIST_CHANNEL) + .arg(&target) + .arg(event) + .query_async(&mut conn) + .await + .map_err(redis_error)?; - tracing::info!("Removed from blacklist: {target}"); - Ok(Json(serde_json::json!({"status": "removed", "target": target}))) + tracing::info!("Removed from blacklist: {target}"); + Ok(Json(serde_json::json!({"status": "removed", "target": target}))) } diff --git a/src/manager/api/inventory/health.rs b/src/manager/api/inventory/health.rs index ca52182..491662a 100644 --- a/src/manager/api/inventory/health.rs +++ b/src/manager/api/inventory/health.rs @@ -6,13 +6,13 @@ use std::sync::Arc; #[derive(Serialize)] pub struct HealthResponse { - pub status: String, - pub version: String, + pub status: String, + pub version: String, } pub async fn health_check(State(_state): State>) -> Json { - Json(HealthResponse { - status: "healthy".to_string(), - version: env!("CARGO_PKG_VERSION").to_string(), - }) + Json(HealthResponse { + status: "healthy".to_string(), + version: env!("CARGO_PKG_VERSION").to_string(), + }) } diff --git a/src/manager/api/inventory/nodes.rs b/src/manager/api/inventory/nodes.rs index bbc3ccb..73ec5c7 100644 --- a/src/manager/api/inventory/nodes.rs +++ b/src/manager/api/inventory/nodes.rs @@ -10,39 +10,39 @@ use std::sync::Arc; #[derive(Debug, Serialize, Deserialize)] pub struct NodeInfo { - pub id: String, - pub role: String, - pub ip: String, - pub status: String, - pub last_heartbeat: String, + pub id: String, + pub role: String, + pub ip: String, + pub status: String, + pub last_heartbeat: String, } #[derive(Serialize)] pub struct NodesResponse { - pub nodes: Vec, + pub nodes: Vec, } #[cfg(feature = "store-redis")] pub async fn list_nodes(State(state): State>) -> Json { - let mut conn = match state.redis_client.get_multiplexed_async_connection().await { - Ok(c) => c, - Err(_) => return Json(NodesResponse { nodes: vec![] }), - }; + let mut conn = match state.redis_client.get_multiplexed_async_connection().await { + Ok(c) => c, + Err(_) => return Json(NodesResponse { nodes: vec![] }), + }; - let keys: Vec = match redis::cmd("KEYS").arg("rampart:nodes:*").query_async(&mut conn).await { - Ok(k) => k, - Err(_) => return Json(NodesResponse { nodes: vec![] }), - }; + let keys: Vec = match redis::cmd("KEYS").arg("rampart:nodes:*").query_async(&mut conn).await { + Ok(k) => k, + Err(_) => return Json(NodesResponse { nodes: vec![] }), + }; - let mut nodes = Vec::with_capacity(keys.len()); - for key in &keys { - let raw: Option = conn.get(key).await.unwrap_or(None); - if let Some(json) = raw - && let Ok(node) = serde_json::from_str::(&json) - { - nodes.push(node); - } - } + let mut nodes = Vec::with_capacity(keys.len()); + for key in &keys { + let raw: Option = conn.get(key).await.unwrap_or(None); + if let Some(json) = raw + && let Ok(node) = serde_json::from_str::(&json) + { + nodes.push(node); + } + } - Json(NodesResponse { nodes }) + Json(NodesResponse { nodes }) } diff --git a/src/manager/api/inventory/servers.rs b/src/manager/api/inventory/servers.rs index 6c2ccbc..fa009a1 100644 --- a/src/manager/api/inventory/servers.rs +++ b/src/manager/api/inventory/servers.rs @@ -10,40 +10,40 @@ use std::sync::Arc; #[derive(Debug, Serialize, Deserialize)] pub struct ServerEntry { - pub name: String, - #[serde(rename = "type")] - pub server_type: String, - pub ip: String, - pub port: u16, - pub status: String, + pub name: String, + #[serde(rename = "type")] + pub server_type: String, + pub ip: String, + pub port: u16, + pub status: String, } #[derive(Serialize)] pub struct ServersResponse { - pub servers: Vec, + pub servers: Vec, } #[cfg(feature = "store-redis")] pub async fn list_servers(State(state): State>) -> Json { - let mut conn = match state.redis_client.get_multiplexed_async_connection().await { - Ok(c) => c, - Err(_) => return Json(ServersResponse { servers: vec![] }), - }; + let mut conn = match state.redis_client.get_multiplexed_async_connection().await { + Ok(c) => c, + Err(_) => return Json(ServersResponse { servers: vec![] }), + }; - let keys: Vec = match redis::cmd("KEYS").arg("rampart:servers:*").query_async(&mut conn).await { - Ok(k) => k, - Err(_) => return Json(ServersResponse { servers: vec![] }), - }; + let keys: Vec = match redis::cmd("KEYS").arg("rampart:servers:*").query_async(&mut conn).await { + Ok(k) => k, + Err(_) => return Json(ServersResponse { servers: vec![] }), + }; - let mut servers = Vec::with_capacity(keys.len()); - for key in &keys { - let raw: Option = conn.get(key).await.unwrap_or(None); - if let Some(json) = raw - && let Ok(server) = serde_json::from_str::(&json) - { - servers.push(server); - } - } + let mut servers = Vec::with_capacity(keys.len()); + for key in &keys { + let raw: Option = conn.get(key).await.unwrap_or(None); + if let Some(json) = raw + && let Ok(server) = serde_json::from_str::(&json) + { + servers.push(server); + } + } - Json(ServersResponse { servers }) + Json(ServersResponse { servers }) } diff --git a/src/manager/auth.rs b/src/manager/auth.rs index 6b972ef..8818aa0 100644 --- a/src/manager/auth.rs +++ b/src/manager/auth.rs @@ -10,94 +10,94 @@ use std::sync::Arc; #[derive(Debug, Serialize, Deserialize)] pub struct Claims { - pub sub: String, - pub aud: String, - pub role: String, - pub exp: usize, - pub iat: usize, + pub sub: String, + pub aud: String, + pub role: String, + pub exp: usize, + pub iat: usize, } pub fn create_token(secret: &str, expiration: u64, audience: &str) -> Result { - let now = chrono::Utc::now().timestamp() as usize; - let claims = Claims { - sub: "rampart-admin".to_string(), - aud: audience.to_string(), - role: "admin".to_string(), - exp: now + expiration as usize, - iat: now, - }; - encode(&Header::default(), &claims, &EncodingKey::from_secret(secret.as_ref())) + let now = chrono::Utc::now().timestamp() as usize; + let claims = Claims { + sub: "rampart-admin".to_string(), + aud: audience.to_string(), + role: "admin".to_string(), + exp: now + expiration as usize, + iat: now, + }; + encode(&Header::default(), &claims, &EncodingKey::from_secret(secret.as_ref())) } pub fn verify_token(token: &str, secret: &str, audience: &str) -> Result { - let mut validation = Validation::default(); - validation.set_audience(&[audience]); - let token_data = decode::(token, &DecodingKey::from_secret(secret.as_ref()), &validation)?; - Ok(token_data.claims) + let mut validation = Validation::default(); + validation.set_audience(&[audience]); + let token_data = decode::(token, &DecodingKey::from_secret(secret.as_ref()), &validation)?; + Ok(token_data.claims) } pub async fn auth_middleware( - State(state): State>, - request: Request, - next: Next, + State(state): State>, + request: Request, + next: Next, ) -> Result)> { - let auth_header = request - .headers() - .get(axum::http::header::AUTHORIZATION) - .and_then(|value| value.to_str().ok()) - .and_then(|value| value.strip_prefix("Bearer ")); + let auth_header = request + .headers() + .get(axum::http::header::AUTHORIZATION) + .and_then(|value| value.to_str().ok()) + .and_then(|value| value.strip_prefix("Bearer ")); - let token = match auth_header { - Some(t) => t, - None => { - return Err(( - StatusCode::UNAUTHORIZED, - Json(serde_json::json!({"error": "unauthorized"})), - )); - }, - }; + let token = match auth_header { + Some(t) => t, + None => { + return Err(( + StatusCode::UNAUTHORIZED, + Json(serde_json::json!({"error": "unauthorized"})), + )); + }, + }; - if verify_token(token, &state.jwt_secret, &state.jwt_audience).is_err() { - return Err(( - StatusCode::UNAUTHORIZED, - Json(serde_json::json!({"error": "unauthorized"})), - )); - } + if verify_token(token, &state.jwt_secret, &state.jwt_audience).is_err() { + return Err(( + StatusCode::UNAUTHORIZED, + Json(serde_json::json!({"error": "unauthorized"})), + )); + } - Ok(next.run(request).await) + Ok(next.run(request).await) } #[cfg(test)] mod tests { - use super::*; + use super::*; - fn valid_secret() -> String { - "this-is-a-test-secret-32-bytes-long!".to_string() - } + fn valid_secret() -> String { + "this-is-a-test-secret-32-bytes-long!".to_string() + } - #[test] - fn create_verify_roundtrip_passes() { - let secret = valid_secret(); - let token = create_token(&secret, 3600, "rampart").expect("token creation should succeed"); - let claims = verify_token(&token, &secret, "rampart").expect("verification should succeed"); - assert_eq!(claims.sub, "rampart-admin"); - assert_eq!(claims.aud, "rampart"); - assert_eq!(claims.role, "admin"); - assert!(claims.exp > claims.iat); - } + #[test] + fn create_verify_roundtrip_passes() { + let secret = valid_secret(); + let token = create_token(&secret, 3600, "rampart").expect("token creation should succeed"); + let claims = verify_token(&token, &secret, "rampart").expect("verification should succeed"); + assert_eq!(claims.sub, "rampart-admin"); + assert_eq!(claims.aud, "rampart"); + assert_eq!(claims.role, "admin"); + assert!(claims.exp > claims.iat); + } - #[test] - fn verify_rejects_wrong_audience() { - let secret = valid_secret(); - let token = create_token(&secret, 3600, "rampart").expect("token creation should succeed"); - assert!(verify_token(&token, &secret, "other").is_err()); - } + #[test] + fn verify_rejects_wrong_audience() { + let secret = valid_secret(); + let token = create_token(&secret, 3600, "rampart").expect("token creation should succeed"); + assert!(verify_token(&token, &secret, "other").is_err()); + } - #[test] - fn verify_rejects_wrong_secret() { - let secret = valid_secret(); - let other_secret = "another-test-secret-also-32-bytes-long!".to_string(); - let token = create_token(&secret, 3600, "rampart").expect("token creation should succeed"); - assert!(verify_token(&token, &other_secret, "rampart").is_err()); - } + #[test] + fn verify_rejects_wrong_secret() { + let secret = valid_secret(); + let other_secret = "another-test-secret-also-32-bytes-long!".to_string(); + let token = create_token(&secret, 3600, "rampart").expect("token creation should succeed"); + assert!(verify_token(&token, &other_secret, "rampart").is_err()); + } } diff --git a/src/manager/mod.rs b/src/manager/mod.rs index 2f89a26..7cc941d 100644 --- a/src/manager/mod.rs +++ b/src/manager/mod.rs @@ -10,15 +10,15 @@ use std::time::Instant; /// Общее состояние management-API. pub struct AppState { - /// Redis-клиент управления состоянием; присутствует только при собранной - /// фиче `store-redis` (manager требует её на старте — см. bin/rampart-manager). - #[cfg(feature = "store-redis")] - pub redis_client: redis::Client, - pub jwt_secret: String, - pub jwt_audience: String, - pub jwt_expiration: u64, - pub api_password: String, - pub login_limiter: DashMap, + /// Redis-клиент управления состоянием; присутствует только при собранной + /// фиче `store-redis` (manager требует её на старте — см. bin/rampart-manager). + #[cfg(feature = "store-redis")] + pub redis_client: redis::Client, + pub jwt_secret: String, + pub jwt_audience: String, + pub jwt_expiration: u64, + pub api_password: String, + pub login_limiter: DashMap, } pub type SharedState = Arc; diff --git a/src/manager/sync/heartbeat.rs b/src/manager/sync/heartbeat.rs index f369bd6..c55dcae 100644 --- a/src/manager/sync/heartbeat.rs +++ b/src/manager/sync/heartbeat.rs @@ -23,45 +23,45 @@ const NODE_TTL_SECS: i64 = 60; #[cfg(feature = "store-redis")] pub async fn start_heartbeat_check(state: Arc) { - let mut ticker = interval(Duration::from_secs(30)); - loop { - ticker.tick().await; - if let Err(e) = check_nodes(&state).await { - tracing::warn!("heartbeat check failed: {e}"); - } - } + let mut ticker = interval(Duration::from_secs(30)); + loop { + ticker.tick().await; + if let Err(e) = check_nodes(&state).await { + tracing::warn!("heartbeat check failed: {e}"); + } + } } #[cfg(feature = "store-redis")] async fn check_nodes(state: &AppState) -> anyhow::Result<()> { - let mut conn = state.redis_client.get_multiplexed_async_connection().await?; - let keys = collect_node_keys(&mut conn).await?; + let mut conn = state.redis_client.get_multiplexed_async_connection().await?; + let keys = collect_node_keys(&mut conn).await?; - let now = chrono::Utc::now().timestamp(); + let now = chrono::Utc::now().timestamp(); - for key in &keys { - let raw: Option = conn.get(key).await?; - let Some(updated) = raw.and_then(|json| offline_update(&json, now)) else { - continue; - }; - tracing::warn!("Node {key} is offline (heartbeat expired)"); - let _: () = conn.set(key.as_str(), updated).await.unwrap_or_default(); - } - Ok(()) + for key in &keys { + let raw: Option = conn.get(key).await?; + let Some(updated) = raw.and_then(|json| offline_update(&json, now)) else { + continue; + }; + tracing::warn!("Node {key} is offline (heartbeat expired)"); + let _: () = conn.set(key.as_str(), updated).await.unwrap_or_default(); + } + Ok(()) } /// Incrementally iterates the keyspace via SCAN (cursor-based, non-blocking). #[cfg(feature = "store-redis")] async fn collect_node_keys(conn: &mut redis::aio::MultiplexedConnection) -> anyhow::Result> { - let opts = ScanOptions::default() - .with_pattern(NODES_KEY_PATTERN) - .with_count(SCAN_BATCH); - let mut iter = conn.scan_options::(opts).await?; - let mut keys = Vec::new(); - while let Some(key) = iter.next().await { - keys.push(key?); - } - Ok(keys) + let opts = ScanOptions::default() + .with_pattern(NODES_KEY_PATTERN) + .with_count(SCAN_BATCH); + let mut iter = conn.scan_options::(opts).await?; + let mut keys = Vec::new(); + while let Some(key) = iter.next().await { + keys.push(key?); + } + Ok(keys) } /// Pure decision: returns the updated node JSON with `status: "offline"` when @@ -70,67 +70,67 @@ async fn collect_node_keys(conn: &mut redis::aio::MultiplexedConnection) -> anyh /// `None` when the node is fresh, unparsable, or not a JSON object. #[cfg(any(feature = "store-redis", test))] fn offline_update(raw: &str, now: i64) -> Option { - let mut node = serde_json::from_str::(raw).ok()?; - let hb = node["last_heartbeat"] - .as_str() - .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok()) - .map(|t| t.timestamp()) - .unwrap_or(0); - if now - hb <= NODE_TTL_SECS { - return None; - } - node.as_object_mut()? - .insert("status".to_string(), serde_json::Value::String("offline".to_string())); - serde_json::to_string(&node).ok() + let mut node = serde_json::from_str::(raw).ok()?; + let hb = node["last_heartbeat"] + .as_str() + .and_then(|s| chrono::DateTime::parse_from_rfc3339(s).ok()) + .map(|t| t.timestamp()) + .unwrap_or(0); + if now - hb <= NODE_TTL_SECS { + return None; + } + node.as_object_mut()? + .insert("status".to_string(), serde_json::Value::String("offline".to_string())); + serde_json::to_string(&node).ok() } #[cfg(test)] mod tests { - use super::*; + use super::*; - fn rfc3339(ts: i64) -> String { - chrono::DateTime::from_timestamp(ts, 0) - .expect("in-range timestamp") - .to_rfc3339() - } + fn rfc3339(ts: i64) -> String { + chrono::DateTime::from_timestamp(ts, 0) + .expect("in-range timestamp") + .to_rfc3339() + } - #[test] - fn expired_heartbeat_is_marked_offline() { - let now = 2_000_000_i64; - let raw = format!( - r#"{{"name":"edge1","last_heartbeat":"{}","status":"online"}}"#, - rfc3339(now - 120) - ); - let updated = offline_update(&raw, now).expect("expired node should be marked offline"); - assert!(updated.contains("offline")); - assert!(updated.contains("edge1")); - } + #[test] + fn expired_heartbeat_is_marked_offline() { + let now = 2_000_000_i64; + let raw = format!( + r#"{{"name":"edge1","last_heartbeat":"{}","status":"online"}}"#, + rfc3339(now - 120) + ); + let updated = offline_update(&raw, now).expect("expired node should be marked offline"); + assert!(updated.contains("offline")); + assert!(updated.contains("edge1")); + } - #[test] - fn fresh_heartbeat_is_left_untouched() { - let now = 2_000_000_i64; - let raw = format!(r#"{{"last_heartbeat":"{}","status":"online"}}"#, rfc3339(now - 5)); - assert!(offline_update(&raw, now).is_none()); - } + #[test] + fn fresh_heartbeat_is_left_untouched() { + let now = 2_000_000_i64; + let raw = format!(r#"{{"last_heartbeat":"{}","status":"online"}}"#, rfc3339(now - 5)); + assert!(offline_update(&raw, now).is_none()); + } - #[test] - fn missing_or_broken_timestamp_counts_as_expired() { - let now = 2_000_000_i64; - let updated = offline_update(r#"{"status":"online"}"#, now).expect("missing heartbeat counts as expired"); - assert!(updated.contains("offline")); - let updated = offline_update(r#"{"last_heartbeat":"garbage","status":"online"}"#, now) - .expect("unparseable heartbeat counts as expired"); - assert!(updated.contains("offline")); - } + #[test] + fn missing_or_broken_timestamp_counts_as_expired() { + let now = 2_000_000_i64; + let updated = offline_update(r#"{"status":"online"}"#, now).expect("missing heartbeat counts as expired"); + assert!(updated.contains("offline")); + let updated = offline_update(r#"{"last_heartbeat":"garbage","status":"online"}"#, now) + .expect("unparseable heartbeat counts as expired"); + assert!(updated.contains("offline")); + } - #[test] - fn invalid_json_is_ignored() { - assert!(offline_update("not json", 2_000_000).is_none()); - } + #[test] + fn invalid_json_is_ignored() { + assert!(offline_update("not json", 2_000_000).is_none()); + } - #[cfg(feature = "store-redis")] - #[test] - fn node_key_pattern_targets_rampart_nodes() { - assert_eq!(NODES_KEY_PATTERN, "rampart:nodes:*"); - } + #[cfg(feature = "store-redis")] + #[test] + fn node_key_pattern_targets_rampart_nodes() { + assert_eq!(NODES_KEY_PATTERN, "rampart:nodes:*"); + } } diff --git a/src/metrics.rs b/src/metrics.rs index d9fd2c9..4a2471c 100644 --- a/src/metrics.rs +++ b/src/metrics.rs @@ -1,105 +1,105 @@ use prometheus::{ - Encoder, IntCounter, IntCounterVec, IntGauge, register_int_counter, register_int_counter_vec, register_int_gauge, + Encoder, IntCounter, IntCounterVec, IntGauge, register_int_counter, register_int_counter_vec, register_int_gauge, }; use std::sync::LazyLock; use tokio::io::{AsyncReadExt, AsyncWriteExt}; use tokio::net::TcpListener; pub static CONNECTIONS_TOTAL: LazyLock = LazyLock::new(|| { - register_int_counter_vec!("rampart_connections_total", "Total connections handled", &["result"]) - .expect("CONNECTIONS_TOTAL") + register_int_counter_vec!("rampart_connections_total", "Total connections handled", &["result"]) + .expect("CONNECTIONS_TOTAL") }); pub static RATE_LIMIT_HITS: LazyLock = LazyLock::new(|| { - register_int_counter_vec!("rampart_rate_limit_hits", "Rate limit hits", &["action"]).expect("RATE_LIMIT_HITS") + register_int_counter_vec!("rampart_rate_limit_hits", "Rate limit hits", &["action"]).expect("RATE_LIMIT_HITS") }); pub static POW_CHALLENGES_TOTAL: LazyLock = LazyLock::new(|| { - register_int_counter_vec!("rampart_pow_challenges_total", "PoW challenges issued", &["result"]) - .expect("POW_CHALLENGES_TOTAL") + register_int_counter_vec!("rampart_pow_challenges_total", "PoW challenges issued", &["result"]) + .expect("POW_CHALLENGES_TOTAL") }); pub static POW_CURRENT_DIFFICULTY: LazyLock = LazyLock::new(|| { - register_int_gauge!("rampart_pow_current_difficulty", "Current PoW difficulty").expect("POW_CURRENT_DIFFICULTY") + register_int_gauge!("rampart_pow_current_difficulty", "Current PoW difficulty").expect("POW_CURRENT_DIFFICULTY") }); pub static ATTACK_STATUS: LazyLock = LazyLock::new(|| { - register_int_gauge!( - "rampart_attack_status", - "Attack detector status (0=normal, 1=suspicious, 2=under attack)" - ) - .expect("ATTACK_STATUS") + register_int_gauge!( + "rampart_attack_status", + "Attack detector status (0=normal, 1=suspicious, 2=under attack)" + ) + .expect("ATTACK_STATUS") }); pub static SUBNET_VERDICTS: LazyLock = LazyLock::new(|| { - register_int_counter_vec!( - "rampart_subnet_verdicts_total", - "Subnet detector verdicts", - &["verdict"] - ) - .expect("SUBNET_VERDICTS") + register_int_counter_vec!( + "rampart_subnet_verdicts_total", + "Subnet detector verdicts", + &["verdict"] + ) + .expect("SUBNET_VERDICTS") }); pub static AUTO_BANS_TOTAL: LazyLock = LazyLock::new(|| { - register_int_counter_vec!( - "rampart_auto_bans_total", - "Auto-bans issued by Traffic Intelligence", - &["reason"] - ) - .expect("AUTO_BANS_TOTAL") + register_int_counter_vec!( + "rampart_auto_bans_total", + "Auto-bans issued by Traffic Intelligence", + &["reason"] + ) + .expect("AUTO_BANS_TOTAL") }); pub static INTEL_RATE_LIMIT_DROPS_TOTAL: LazyLock = LazyLock::new(|| { - register_int_counter!( - "rampart_intel_rate_limit_drops_total", - "Connections dropped by rate limit" - ) - .expect("INTEL_RATE_LIMIT_DROPS_TOTAL") + register_int_counter!( + "rampart_intel_rate_limit_drops_total", + "Connections dropped by rate limit" + ) + .expect("INTEL_RATE_LIMIT_DROPS_TOTAL") }); pub static INTEL_CPS: LazyLock = - LazyLock::new(|| register_int_gauge!("rampart_intel_cps", "New connections per second window").expect("INTEL_CPS")); + LazyLock::new(|| register_int_gauge!("rampart_intel_cps", "New connections per second window").expect("INTEL_CPS")); pub static INTEL_ALERTS_TOTAL: LazyLock = LazyLock::new(|| { - register_int_counter!("rampart_intel_alerts_total", "Attack state-transition alerts emitted") - .expect("INTEL_ALERTS_TOTAL") + register_int_counter!("rampart_intel_alerts_total", "Attack state-transition alerts emitted") + .expect("INTEL_ALERTS_TOTAL") }); /// Отдаёт Prometheus-метрики по голому HTTP/0.9-совместимому ответу. pub async fn run_metrics_server(addr: &str) { - let listener = match TcpListener::bind(addr).await { - Ok(l) => l, - Err(e) => { - tracing::error!("Failed to bind metrics server: {e}"); - return; - }, - }; - loop { - let (mut stream, _) = match listener.accept().await { - Ok(s) => s, - Err(e) => { - tracing::error!("Metrics accept error: {e}"); - continue; - }, - }; - tokio::spawn(async move { - let mut buf = [0u8; 1024]; - if stream.read(&mut buf).await.is_err() { - return; - } - let metric_families = prometheus::gather(); - let encoder = prometheus::TextEncoder::new(); - let mut payload = Vec::new(); - if encoder.encode(&metric_families, &mut payload).is_err() { - return; - } - let header = format!( - "HTTP/1.1 200 OK\r\nContent-Type: text/plain; version=0.0.4\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", - payload.len() - ); - let mut response = header.into_bytes(); - response.extend_from_slice(&payload); - let _ = stream.write_all(&response).await; - }); - } + let listener = match TcpListener::bind(addr).await { + Ok(l) => l, + Err(e) => { + tracing::error!("Failed to bind metrics server: {e}"); + return; + }, + }; + loop { + let (mut stream, _) = match listener.accept().await { + Ok(s) => s, + Err(e) => { + tracing::error!("Metrics accept error: {e}"); + continue; + }, + }; + tokio::spawn(async move { + let mut buf = [0u8; 1024]; + if stream.read(&mut buf).await.is_err() { + return; + } + let metric_families = prometheus::gather(); + let encoder = prometheus::TextEncoder::new(); + let mut payload = Vec::new(); + if encoder.encode(&metric_families, &mut payload).is_err() { + return; + } + let header = format!( + "HTTP/1.1 200 OK\r\nContent-Type: text/plain; version=0.0.4\r\nContent-Length: {}\r\nConnection: close\r\n\r\n", + payload.len() + ); + let mut response = header.into_bytes(); + response.extend_from_slice(&payload); + let _ = stream.write_all(&response).await; + }); + } } diff --git a/src/protocol/http/mod.rs b/src/protocol/http/mod.rs index 35751d9..ac536b8 100644 --- a/src/protocol/http/mod.rs +++ b/src/protocol/http/mod.rs @@ -17,95 +17,95 @@ use tokio::net::TcpStream; /// Обработчик HTTP/1.1: verdict Allow → tunnel на upstream, Reject → drop. pub struct HttpProtocolHandler { - policy: parser::Policy, - timeout: Duration, - upstream: String, + policy: parser::Policy, + timeout: Duration, + upstream: String, } impl HttpProtocolHandler { - /// Собирает обработчик из конфига `[protocol.http]` и списка upstream'ов. - #[must_use] - pub fn new(http: &HttpProtocolConfig, upstreams: &[String]) -> Self { - Self { - policy: parser::Policy { - max_header_bytes: http.max_header_bytes, - blocked_paths: http.blocked_paths.clone(), - require_user_agent: http.require_user_agent, - }, - timeout: Duration::from_secs(http.timeout_secs), - upstream: upstreams.first().cloned().unwrap_or_else(|| "127.0.0.1:80".to_string()), - } - } + /// Собирает обработчик из конфига `[protocol.http]` и списка upstream'ов. + #[must_use] + pub fn new(http: &HttpProtocolConfig, upstreams: &[String]) -> Self { + Self { + policy: parser::Policy { + max_header_bytes: http.max_header_bytes, + blocked_paths: http.blocked_paths.clone(), + require_user_agent: http.require_user_agent, + }, + timeout: Duration::from_secs(http.timeout_secs), + upstream: upstreams.first().cloned().unwrap_or_else(|| "127.0.0.1:80".to_string()), + } + } - /// Накапливает request-head без повторного чтения одного и того же префикса. - /// - /// # Errors - /// Таймаут, закрытие клиента, превышение `max_header_bytes` или ошибка I/O. - async fn read_head(&self, stream: &mut TcpStream) -> anyhow::Result> { - let limit = self.policy.max_header_bytes; - if limit == 0 { - anyhow::bail!("protocol.http.max_header_bytes must be positive"); - } - let mut buf = Vec::with_capacity(limit); - let accumulate = async { - loop { - if parser::scan_head(&buf).is_some() { - return Ok(buf); - } - if buf.len() >= limit { - anyhow::bail!("request head exceeds {limit} bytes"); - } - let mut byte = [0u8; 1]; - stream.read_exact(&mut byte).await?; - buf.push(byte[0]); - } - }; - match tokio::time::timeout(self.timeout, accumulate).await { - Ok(result) => result, - Err(_) => anyhow::bail!("timed out reading request head"), - } - } + /// Накапливает request-head без повторного чтения одного и того же префикса. + /// + /// # Errors + /// Таймаут, закрытие клиента, превышение `max_header_bytes` или ошибка I/O. + async fn read_head(&self, stream: &mut TcpStream) -> anyhow::Result> { + let limit = self.policy.max_header_bytes; + if limit == 0 { + anyhow::bail!("protocol.http.max_header_bytes must be positive"); + } + let mut buf = Vec::with_capacity(limit); + let accumulate = async { + loop { + if parser::scan_head(&buf).is_some() { + return Ok(buf); + } + if buf.len() >= limit { + anyhow::bail!("request head exceeds {limit} bytes"); + } + let mut byte = [0u8; 1]; + stream.read_exact(&mut byte).await?; + buf.push(byte[0]); + } + }; + match tokio::time::timeout(self.timeout, accumulate).await { + Ok(result) => result, + Err(_) => anyhow::bail!("timed out reading request head"), + } + } } impl ProtocolHandler for HttpProtocolHandler { - fn name(&self) -> &'static str { - "http" - } + fn name(&self) -> &'static str { + "http" + } - fn handshake<'a>( - &'a self, - stream: &'a mut TcpStream, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - let head = self.read_head(stream).await?; - match parser::evaluate(&head, &self.policy) { - parser::Verdict::Allow { .. } => Ok(HandshakeResult::with_initial_data( - Upstream::new(self.upstream.clone()), - head, - )), - parser::Verdict::Reject { reason } => Err(anyhow::anyhow!("http: {reason}")), - } - }) - } + fn handshake<'a>( + &'a self, + stream: &'a mut TcpStream, + ) -> Pin> + Send + 'a>> { + Box::pin(async move { + let head = self.read_head(stream).await?; + match parser::evaluate(&head, &self.policy) { + parser::Verdict::Allow { .. } => Ok(HandshakeResult::with_initial_data( + Upstream::new(self.upstream.clone()), + head, + )), + parser::Verdict::Reject { reason } => Err(anyhow::anyhow!("http: {reason}")), + } + }) + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[tokio::test] - async fn zero_limit_fails_fast_without_io() { - let config = HttpProtocolConfig::default(); - let mut broken = config.clone(); - broken.max_header_bytes = 0; - let handler = HttpProtocolHandler::new(&broken, &[]); - let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("bind"); - let client = tokio::net::TcpStream::connect(listener.local_addr().expect("addr")) - .await - .expect("connect"); - let (mut server, _) = listener.accept().await.expect("accept"); - drop(listener); - assert!(handler.read_head(&mut server).await.is_err()); - drop(client); - } + #[tokio::test] + async fn zero_limit_fails_fast_without_io() { + let config = HttpProtocolConfig::default(); + let mut broken = config.clone(); + broken.max_header_bytes = 0; + let handler = HttpProtocolHandler::new(&broken, &[]); + let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("bind"); + let client = tokio::net::TcpStream::connect(listener.local_addr().expect("addr")) + .await + .expect("connect"); + let (mut server, _) = listener.accept().await.expect("accept"); + drop(listener); + assert!(handler.read_head(&mut server).await.is_err()); + drop(client); + } } diff --git a/src/protocol/http/parser.rs b/src/protocol/http/parser.rs index c7c5a69..6612491 100644 --- a/src/protocol/http/parser.rs +++ b/src/protocol/http/parser.rs @@ -6,16 +6,16 @@ /// Политика проверки, снятая с секции `[protocol.http]`. #[derive(Debug, Clone)] pub struct Policy { - pub max_header_bytes: usize, - pub blocked_paths: Vec, - pub require_user_agent: bool, + pub max_header_bytes: usize, + pub blocked_paths: Vec, + pub require_user_agent: bool, } /// Результат проверки головы запроса. #[derive(Debug, Clone, PartialEq, Eq)] pub enum Verdict { - Allow { method: String, path: String, host: String }, - Reject { reason: String }, + Allow { method: String, path: String, host: String }, + Reject { reason: String }, } const ALLOWED_METHODS: [&str; 7] = ["GET", "POST", "PUT", "DELETE", "HEAD", "OPTIONS", "PATCH"]; @@ -24,173 +24,173 @@ const HEADER_TERMINATOR: &[u8] = b"\r\n\r\n"; /// Ищет конец головы запроса (`\r\n\r\n`) и возвращает её полную длину. #[must_use] pub fn scan_head(buf: &[u8]) -> Option { - buf.windows(HEADER_TERMINATOR.len()) - .position(|window| window == HEADER_TERMINATOR) - .map(|pos| pos + HEADER_TERMINATOR.len()) + buf.windows(HEADER_TERMINATOR.len()) + .position(|window| window == HEADER_TERMINATOR) + .map(|pos| pos + HEADER_TERMINATOR.len()) } /// Разбирает и валидирует голову запроса согласно политике. #[must_use] pub fn evaluate(head: &[u8], policy: &Policy) -> Verdict { - let Ok(text) = std::str::from_utf8(head) else { - return reject("request head is not valid utf-8"); - }; - let mut lines = text.split("\r\n"); - let Some(request_line) = lines.next().filter(|line| !line.is_empty()) else { - return reject("empty request line"); - }; + let Ok(text) = std::str::from_utf8(head) else { + return reject("request head is not valid utf-8"); + }; + let mut lines = text.split("\r\n"); + let Some(request_line) = lines.next().filter(|line| !line.is_empty()) else { + return reject("empty request line"); + }; - let mut parts = request_line.split(' '); - let (Some(method), Some(target), Some(version)) = (parts.next(), parts.next(), parts.next()) else { - return reject("malformed request line"); - }; - if parts.next().is_some() { - return reject("malformed request line"); - } - if !matches!(version, "HTTP/1.0" | "HTTP/1.1") { - return reject("unsupported http version"); - } - if !ALLOWED_METHODS.contains(&method) { - return reject("method not allowed"); - } + let mut parts = request_line.split(' '); + let (Some(method), Some(target), Some(version)) = (parts.next(), parts.next(), parts.next()) else { + return reject("malformed request line"); + }; + if parts.next().is_some() { + return reject("malformed request line"); + } + if !matches!(version, "HTTP/1.0" | "HTTP/1.1") { + return reject("unsupported http version"); + } + if !ALLOWED_METHODS.contains(&method) { + return reject("method not allowed"); + } - let mut host: Option<&str> = None; - let mut user_agent: Option<&str> = None; - for line in lines { - if line.is_empty() { - continue; - } - let Some((name, value)) = line.split_once(':') else { - return reject("malformed header line"); - }; - let value = value.trim(); - if name.eq_ignore_ascii_case("host") { - host = Some(value); - } else if name.eq_ignore_ascii_case("user-agent") { - user_agent = Some(value); - } - } + let mut host: Option<&str> = None; + let mut user_agent: Option<&str> = None; + for line in lines { + if line.is_empty() { + continue; + } + let Some((name, value)) = line.split_once(':') else { + return reject("malformed header line"); + }; + let value = value.trim(); + if name.eq_ignore_ascii_case("host") { + host = Some(value); + } else if name.eq_ignore_ascii_case("user-agent") { + user_agent = Some(value); + } + } - let path = match target.split_once('?') { - Some((path, _)) => path, - None => target, - }; - if policy - .blocked_paths - .iter() - .any(|prefix| path.starts_with(prefix.as_str())) - { - return reject("path is blocklisted"); - } + let path = match target.split_once('?') { + Some((path, _)) => path, + None => target, + }; + if policy + .blocked_paths + .iter() + .any(|prefix| path.starts_with(prefix.as_str())) + { + return reject("path is blocklisted"); + } - let Some(host) = host.filter(|value| !value.is_empty()) else { - return reject("missing host header"); - }; - if policy.require_user_agent && user_agent.is_none_or(str::is_empty) { - return reject("missing user-agent header"); - } + let Some(host) = host.filter(|value| !value.is_empty()) else { + return reject("missing host header"); + }; + if policy.require_user_agent && user_agent.is_none_or(str::is_empty) { + return reject("missing user-agent header"); + } - Verdict::Allow { - method: method.to_string(), - path: path.to_string(), - host: host.to_string(), - } + Verdict::Allow { + method: method.to_string(), + path: path.to_string(), + host: host.to_string(), + } } fn reject(reason: &str) -> Verdict { - Verdict::Reject { - reason: reason.to_string(), - } + Verdict::Reject { + reason: reason.to_string(), + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - fn policy() -> Policy { - Policy { - max_header_bytes: 8192, - blocked_paths: Vec::new(), - require_user_agent: false, - } - } + fn policy() -> Policy { + Policy { + max_header_bytes: 8192, + blocked_paths: Vec::new(), + require_user_agent: false, + } + } - #[test] - fn scan_finds_full_head_length() { - assert_eq!(scan_head(b"GET / HTTP/1.1\r\n\r\n"), Some(18)); - assert_eq!(scan_head(b"GET / HTTP/1.1\r\n"), None); - } + #[test] + fn scan_finds_full_head_length() { + assert_eq!(scan_head(b"GET / HTTP/1.1\r\n\r\n"), Some(18)); + assert_eq!(scan_head(b"GET / HTTP/1.1\r\n"), None); + } - #[test] - fn valid_request_is_allowed() { - let head = b"POST /api/items?limit=5 HTTP/1.1\r\nHost: example.com\r\n\r\n"; - let verdict = evaluate(head, &policy()); - assert_eq!( - verdict, - Verdict::Allow { - method: "POST".to_string(), - path: "/api/items".to_string(), - host: "example.com".to_string() - } - ); - } + #[test] + fn valid_request_is_allowed() { + let head = b"POST /api/items?limit=5 HTTP/1.1\r\nHost: example.com\r\n\r\n"; + let verdict = evaluate(head, &policy()); + assert_eq!( + verdict, + Verdict::Allow { + method: "POST".to_string(), + path: "/api/items".to_string(), + host: "example.com".to_string() + } + ); + } - #[test] - fn unknown_method_is_rejected() { - let head = b"TRACE / HTTP/1.1\r\nHost: h\r\n\r\n"; - assert!(matches!(evaluate(head, &policy()), Verdict::Reject { .. })); - } + #[test] + fn unknown_method_is_rejected() { + let head = b"TRACE / HTTP/1.1\r\nHost: h\r\n\r\n"; + assert!(matches!(evaluate(head, &policy()), Verdict::Reject { .. })); + } - #[test] - fn missing_host_is_rejected() { - let head = b"GET / HTTP/1.1\r\nUser-Agent: t\r\n\r\n"; - assert!(matches!(evaluate(head, &policy()), Verdict::Reject { .. })); - } + #[test] + fn missing_host_is_rejected() { + let head = b"GET / HTTP/1.1\r\nUser-Agent: t\r\n\r\n"; + assert!(matches!(evaluate(head, &policy()), Verdict::Reject { .. })); + } - #[test] - fn http2_version_is_rejected() { - let head = b"GET / HTTP/2.0\r\nHost: h\r\n\r\n"; - assert!(matches!(evaluate(head, &policy()), Verdict::Reject { .. })); - } + #[test] + fn http2_version_is_rejected() { + let head = b"GET / HTTP/2.0\r\nHost: h\r\n\r\n"; + assert!(matches!(evaluate(head, &policy()), Verdict::Reject { .. })); + } - #[test] - fn malformed_line_is_rejected() { - assert!(matches!( - evaluate(b"nonsense\r\n\r\n", &policy()), - Verdict::Reject { .. } - )); - assert!(matches!( - evaluate(b"GET / HTTP/1.1\r\nbroken\r\n\r\n", &policy()), - Verdict::Reject { .. } - )); - } + #[test] + fn malformed_line_is_rejected() { + assert!(matches!( + evaluate(b"nonsense\r\n\r\n", &policy()), + Verdict::Reject { .. } + )); + assert!(matches!( + evaluate(b"GET / HTTP/1.1\r\nbroken\r\n\r\n", &policy()), + Verdict::Reject { .. } + )); + } - #[test] - fn non_utf8_head_is_rejected() { - assert!(matches!(evaluate(&[0xff, 0xfe], &policy()), Verdict::Reject { .. })); - } + #[test] + fn non_utf8_head_is_rejected() { + assert!(matches!(evaluate(&[0xff, 0xfe], &policy()), Verdict::Reject { .. })); + } - #[test] - fn blocked_path_prefix_is_rejected() { - let mut custom = policy(); - custom.blocked_paths = vec!["/admin".to_string()]; - assert!(matches!( - evaluate(b"GET /admin/panel HTTP/1.1\r\nHost: h\r\n\r\n", &custom), - Verdict::Reject { .. } - )); - assert!(matches!( - evaluate(b"GET /public HTTP/1.1\r\nHost: h\r\n\r\n", &custom), - Verdict::Allow { .. } - )); - } + #[test] + fn blocked_path_prefix_is_rejected() { + let mut custom = policy(); + custom.blocked_paths = vec!["/admin".to_string()]; + assert!(matches!( + evaluate(b"GET /admin/panel HTTP/1.1\r\nHost: h\r\n\r\n", &custom), + Verdict::Reject { .. } + )); + assert!(matches!( + evaluate(b"GET /public HTTP/1.1\r\nHost: h\r\n\r\n", &custom), + Verdict::Allow { .. } + )); + } - #[test] - fn required_user_agent_enforced() { - let mut custom = policy(); - custom.require_user_agent = true; - let head = b"GET / HTTP/1.1\r\nHost: h\r\n\r\n"; - assert!(matches!(evaluate(head, &custom), Verdict::Reject { .. })); - let head_with_ua = b"GET / HTTP/1.1\r\nHost: h\r\nUser-Agent: curl/8\r\n\r\n"; - assert!(matches!(evaluate(head_with_ua, &custom), Verdict::Allow { .. })); - } + #[test] + fn required_user_agent_enforced() { + let mut custom = policy(); + custom.require_user_agent = true; + let head = b"GET / HTTP/1.1\r\nHost: h\r\n\r\n"; + assert!(matches!(evaluate(head, &custom), Verdict::Reject { .. })); + let head_with_ua = b"GET / HTTP/1.1\r\nHost: h\r\nUser-Agent: curl/8\r\n\r\n"; + assert!(matches!(evaluate(head_with_ua, &custom), Verdict::Allow { .. })); + } } diff --git a/src/protocol/minecraft/mod.rs b/src/protocol/minecraft/mod.rs index d75fb6c..6907621 100644 --- a/src/protocol/minecraft/mod.rs +++ b/src/protocol/minecraft/mod.rs @@ -11,75 +11,75 @@ use tokio::io::AsyncReadExt; use tokio::net::TcpStream; pub struct MinecraftProtocolHandler { - upstream: String, - max_frame_bytes: usize, - timeout: Duration, + upstream: String, + max_frame_bytes: usize, + timeout: Duration, } impl MinecraftProtocolHandler { - #[must_use] - pub fn new(config: &MinecraftProtocolConfig, upstreams: &[String]) -> Self { - Self { - // Config validation requires exactly one backend when this handler is enabled. - upstream: upstreams.first().cloned().unwrap_or_default(), - max_frame_bytes: config.max_frame_bytes, - timeout: Duration::from_secs(config.timeout_secs), - } - } + #[must_use] + pub fn new(config: &MinecraftProtocolConfig, upstreams: &[String]) -> Self { + Self { + // Config validation requires exactly one backend when this handler is enabled. + upstream: upstreams.first().cloned().unwrap_or_default(), + max_frame_bytes: config.max_frame_bytes, + timeout: Duration::from_secs(config.timeout_secs), + } + } - async fn read_handshake(&self, stream: &mut TcpStream) -> anyhow::Result> { - let mut frame = Vec::with_capacity(64); - let mut frame_len = 0usize; - for index in 0..5 { - let mut byte = [0u8; 1]; - stream.read_exact(&mut byte).await?; - frame.push(byte[0]); - if index == 4 && byte[0] & 0xf0 != 0 { - anyhow::bail!("Minecraft frame length VarInt exceeds 32 bits"); - } - if byte[0] & 0x80 == 0 { - let (decoded, prefix_len) = parser::decode_frame_length(&frame)?; - frame_len = decoded; - if frame_len == 0 || frame_len > self.max_frame_bytes { - anyhow::bail!("Minecraft handshake frame length {frame_len} is outside allowed range"); - } - if prefix_len != frame.len() { - anyhow::bail!("invalid Minecraft frame length prefix"); - } - break; - } - if index == 4 { - anyhow::bail!("Minecraft frame length VarInt exceeds five bytes"); - } - } - if frame_len == 0 { - anyhow::bail!("invalid empty Minecraft handshake frame"); - } - let prefix_len = frame.len(); - frame.resize(prefix_len + frame_len, 0); - stream.read_exact(&mut frame[prefix_len..]).await?; - parser::parse_frame(&frame, self.max_frame_bytes)?; - Ok(frame) - } + async fn read_handshake(&self, stream: &mut TcpStream) -> anyhow::Result> { + let mut frame = Vec::with_capacity(64); + let mut frame_len = 0usize; + for index in 0..5 { + let mut byte = [0u8; 1]; + stream.read_exact(&mut byte).await?; + frame.push(byte[0]); + if index == 4 && byte[0] & 0xf0 != 0 { + anyhow::bail!("Minecraft frame length VarInt exceeds 32 bits"); + } + if byte[0] & 0x80 == 0 { + let (decoded, prefix_len) = parser::decode_frame_length(&frame)?; + frame_len = decoded; + if frame_len == 0 || frame_len > self.max_frame_bytes { + anyhow::bail!("Minecraft handshake frame length {frame_len} is outside allowed range"); + } + if prefix_len != frame.len() { + anyhow::bail!("invalid Minecraft frame length prefix"); + } + break; + } + if index == 4 { + anyhow::bail!("Minecraft frame length VarInt exceeds five bytes"); + } + } + if frame_len == 0 { + anyhow::bail!("invalid empty Minecraft handshake frame"); + } + let prefix_len = frame.len(); + frame.resize(prefix_len + frame_len, 0); + stream.read_exact(&mut frame[prefix_len..]).await?; + parser::parse_frame(&frame, self.max_frame_bytes)?; + Ok(frame) + } } impl ProtocolHandler for MinecraftProtocolHandler { - fn name(&self) -> &'static str { - "minecraft" - } + fn name(&self) -> &'static str { + "minecraft" + } - fn handshake<'a>( - &'a self, - stream: &'a mut TcpStream, - ) -> Pin> + Send + 'a>> { - Box::pin(async move { - let frame = tokio::time::timeout(self.timeout, self.read_handshake(stream)) - .await - .map_err(|_| anyhow::anyhow!("timed out reading Minecraft handshake"))??; - Ok(HandshakeResult::with_initial_data( - Upstream::new(self.upstream.clone()), - frame, - )) - }) - } + fn handshake<'a>( + &'a self, + stream: &'a mut TcpStream, + ) -> Pin> + Send + 'a>> { + Box::pin(async move { + let frame = tokio::time::timeout(self.timeout, self.read_handshake(stream)) + .await + .map_err(|_| anyhow::anyhow!("timed out reading Minecraft handshake"))??; + Ok(HandshakeResult::with_initial_data( + Upstream::new(self.upstream.clone()), + frame, + )) + }) + } } diff --git a/src/protocol/minecraft/parser.rs b/src/protocol/minecraft/parser.rs index 38a6177..5a9fa61 100644 --- a/src/protocol/minecraft/parser.rs +++ b/src/protocol/minecraft/parser.rs @@ -6,89 +6,89 @@ const MAX_HOST_BYTES: usize = 255; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub(super) enum NextState { - Status, - Login, + Status, + Login, } pub(super) fn decode_frame_length(prefix: &[u8]) -> anyhow::Result<(usize, usize)> { - let (length, bytes_read) = decode_varint(prefix, 0)?; - let length = usize::try_from(length).map_err(|_| anyhow::anyhow!("negative frame length"))?; - Ok((length, bytes_read)) + let (length, bytes_read) = decode_varint(prefix, 0)?; + let length = usize::try_from(length).map_err(|_| anyhow::anyhow!("negative frame length"))?; + Ok((length, bytes_read)) } /// Validates a complete length-prefixed handshake frame and returns its state. pub(super) fn parse_frame(frame: &[u8], max_frame_bytes: usize) -> anyhow::Result { - let (frame_len, prefix_len) = decode_varint(frame, 0)?; - let frame_len = usize::try_from(frame_len).map_err(|_| anyhow::anyhow!("negative frame length"))?; - if frame_len == 0 || frame_len > max_frame_bytes { - anyhow::bail!("Minecraft handshake frame length {frame_len} is outside allowed range"); - } - if frame.len() != prefix_len + frame_len { - anyhow::bail!("Minecraft handshake frame length does not match packet"); - } + let (frame_len, prefix_len) = decode_varint(frame, 0)?; + let frame_len = usize::try_from(frame_len).map_err(|_| anyhow::anyhow!("negative frame length"))?; + if frame_len == 0 || frame_len > max_frame_bytes { + anyhow::bail!("Minecraft handshake frame length {frame_len} is outside allowed range"); + } + if frame.len() != prefix_len + frame_len { + anyhow::bail!("Minecraft handshake frame length does not match packet"); + } - let body = &frame[prefix_len..]; - let (packet_id, mut cursor) = decode_varint(body, 0)?; - if packet_id != HANDSHAKE_PACKET_ID { - anyhow::bail!("unexpected Minecraft packet id {packet_id} in handshake state"); - } + let body = &frame[prefix_len..]; + let (packet_id, mut cursor) = decode_varint(body, 0)?; + if packet_id != HANDSHAKE_PACKET_ID { + anyhow::bail!("unexpected Minecraft packet id {packet_id} in handshake state"); + } - let (protocol_version, next) = decode_varint(body, cursor)?; - if protocol_version < 0 { - anyhow::bail!("Minecraft protocol version must be non-negative"); - } - cursor = next; + let (protocol_version, next) = decode_varint(body, cursor)?; + if protocol_version < 0 { + anyhow::bail!("Minecraft protocol version must be non-negative"); + } + cursor = next; - let (host_len, next) = decode_varint(body, cursor)?; - let host_len = usize::try_from(host_len).map_err(|_| anyhow::anyhow!("negative host length"))?; - if host_len == 0 || host_len > MAX_HOST_BYTES { - anyhow::bail!("Minecraft handshake hostname length is outside allowed range"); - } - cursor = next; - let host_end = cursor - .checked_add(host_len) - .ok_or_else(|| anyhow::anyhow!("hostname length overflow"))?; - let host_bytes = body - .get(cursor..host_end) - .ok_or_else(|| anyhow::anyhow!("truncated Minecraft handshake hostname"))?; - std::str::from_utf8(host_bytes).map_err(|_| anyhow::anyhow!("Minecraft handshake hostname is not UTF-8"))?; - cursor = host_end; + let (host_len, next) = decode_varint(body, cursor)?; + let host_len = usize::try_from(host_len).map_err(|_| anyhow::anyhow!("negative host length"))?; + if host_len == 0 || host_len > MAX_HOST_BYTES { + anyhow::bail!("Minecraft handshake hostname length is outside allowed range"); + } + cursor = next; + let host_end = cursor + .checked_add(host_len) + .ok_or_else(|| anyhow::anyhow!("hostname length overflow"))?; + let host_bytes = body + .get(cursor..host_end) + .ok_or_else(|| anyhow::anyhow!("truncated Minecraft handshake hostname"))?; + std::str::from_utf8(host_bytes).map_err(|_| anyhow::anyhow!("Minecraft handshake hostname is not UTF-8"))?; + cursor = host_end; - let port_end = cursor - .checked_add(2) - .ok_or_else(|| anyhow::anyhow!("port length overflow"))?; - if body.get(cursor..port_end).is_none() { - anyhow::bail!("truncated Minecraft handshake port"); - } - cursor = port_end; + let port_end = cursor + .checked_add(2) + .ok_or_else(|| anyhow::anyhow!("port length overflow"))?; + if body.get(cursor..port_end).is_none() { + anyhow::bail!("truncated Minecraft handshake port"); + } + cursor = port_end; - let (state, next) = decode_varint(body, cursor)?; - cursor = next; - if cursor != body.len() { - anyhow::bail!("unexpected trailing bytes in Minecraft handshake"); - } + let (state, next) = decode_varint(body, cursor)?; + cursor = next; + if cursor != body.len() { + anyhow::bail!("unexpected trailing bytes in Minecraft handshake"); + } - match state { - 1 => Ok(NextState::Status), - 2 => Ok(NextState::Login), - _ => anyhow::bail!("unsupported Minecraft next state {state}; expected status or login"), - } + match state { + 1 => Ok(NextState::Status), + 2 => Ok(NextState::Login), + _ => anyhow::bail!("unsupported Minecraft next state {state}; expected status or login"), + } } /// Decodes signed Minecraft VarInt from a packet, returning value and next offset. fn decode_varint(bytes: &[u8], start: usize) -> anyhow::Result<(i32, usize)> { - let mut value = 0u32; - for index in 0..MAX_VARINT_BYTES { - let byte = *bytes - .get(start + index) - .ok_or_else(|| anyhow::anyhow!("truncated Minecraft VarInt"))?; - if index == 4 && byte & 0xf0 != 0 { - anyhow::bail!("Minecraft VarInt exceeds 32 bits"); - } - value |= u32::from(byte & 0x7f) << (index * 7); - if byte & 0x80 == 0 { - return Ok((value as i32, start + index + 1)); - } - } - anyhow::bail!("Minecraft VarInt exceeds five bytes") + let mut value = 0u32; + for index in 0..MAX_VARINT_BYTES { + let byte = *bytes + .get(start + index) + .ok_or_else(|| anyhow::anyhow!("truncated Minecraft VarInt"))?; + if index == 4 && byte & 0xf0 != 0 { + anyhow::bail!("Minecraft VarInt exceeds 32 bits"); + } + value |= u32::from(byte & 0x7f) << (index * 7); + if byte & 0x80 == 0 { + return Ok((value as i32, start + index + 1)); + } + } + anyhow::bail!("Minecraft VarInt exceeds five bytes") } diff --git a/src/protocol/mod.rs b/src/protocol/mod.rs index 6eb0a1a..0710a38 100644 --- a/src/protocol/mod.rs +++ b/src/protocol/mod.rs @@ -11,38 +11,38 @@ use tokio::net::TcpStream; /// на который нужно проксировать соединение. #[derive(Debug, Clone, PartialEq, Eq)] pub struct Upstream { - pub addr: String, + pub addr: String, } impl Upstream { - #[must_use] - pub fn new(addr: impl Into) -> Self { - Self { addr: addr.into() } - } + #[must_use] + pub fn new(addr: impl Into) -> Self { + Self { addr: addr.into() } + } } #[derive(Debug, Clone, PartialEq, Eq)] pub struct HandshakeResult { - pub upstream: Upstream, - pub initial_backend_data: Vec, + pub upstream: Upstream, + pub initial_backend_data: Vec, } impl HandshakeResult { - #[must_use] - pub fn new(upstream: Upstream) -> Self { - Self { - upstream, - initial_backend_data: Vec::new(), - } - } + #[must_use] + pub fn new(upstream: Upstream) -> Self { + Self { + upstream, + initial_backend_data: Vec::new(), + } + } - #[must_use] - pub fn with_initial_data(upstream: Upstream, initial_backend_data: Vec) -> Self { - Self { - upstream, - initial_backend_data, - } - } + #[must_use] + pub fn with_initial_data(upstream: Upstream, initial_backend_data: Vec) -> Self { + Self { + upstream, + initial_backend_data, + } + } } /// Точка расширения платформы: реализация для конкретного L7-протокола. @@ -55,105 +55,105 @@ impl HandshakeResult { /// Метод асинхронен через boxed future, чтобы трейт оставался /// dyn-совместимым (`ProtocolRegistry` хранит `Box`). pub trait ProtocolHandler: Send + Sync { - /// Имя протокола (для метрик, логов и реестра). - fn name(&self) -> &'static str; + /// Имя протокола (для метрик, логов и реестра). + fn name(&self) -> &'static str; - /// Проводит handshake с клиентом и определяет upstream. - /// - /// # Errors - /// Возвращает ошибку при невалидном клиентском потоке или отказе в доступе. - fn handshake<'a>( - &'a self, - stream: &'a mut TcpStream, - ) -> Pin> + Send + 'a>>; + /// Проводит handshake с клиентом и определяет upstream. + /// + /// # Errors + /// Возвращает ошибку при невалидном клиентском потоке или отказе в доступе. + fn handshake<'a>( + &'a self, + stream: &'a mut TcpStream, + ) -> Pin> + Send + 'a>>; } /// Реестр скомпилированных протокольных обработчиков. #[derive(Default)] pub struct ProtocolRegistry { - handlers: Vec>, + handlers: Vec>, } impl ProtocolRegistry { - #[must_use] - pub fn new() -> Self { - Self::default() - } + #[must_use] + pub fn new() -> Self { + Self::default() + } - pub fn register(&mut self, handler: Box) { - self.handlers.push(handler); - } + pub fn register(&mut self, handler: Box) { + self.handlers.push(handler); + } - #[must_use] - pub fn is_empty(&self) -> bool { - self.handlers.is_empty() - } + #[must_use] + pub fn is_empty(&self) -> bool { + self.handlers.is_empty() + } - #[must_use] - pub fn len(&self) -> usize { - self.handlers.len() - } + #[must_use] + pub fn len(&self) -> usize { + self.handlers.len() + } - #[must_use] - pub fn names(&self) -> Vec<&'static str> { - self.handlers.iter().map(|h| h.name()).collect() - } + #[must_use] + pub fn names(&self) -> Vec<&'static str> { + self.handlers.iter().map(|h| h.name()).collect() + } - #[must_use] - pub fn get(&self, name: &str) -> Option<&dyn ProtocolHandler> { - self.handlers.iter().find(|h| h.name() == name).map(|h| h.as_ref()) - } + #[must_use] + pub fn get(&self, name: &str) -> Option<&dyn ProtocolHandler> { + self.handlers.iter().find(|h| h.name() == name).map(|h| h.as_ref()) + } - /// Возвращает основной обработчик. - /// - /// # Errors - /// Возвращает ошибку, если ни один протокол не скомпилирован — - /// edge-нода обязана fail-fast на старте в этом случае. - pub fn primary(&self) -> anyhow::Result<&dyn ProtocolHandler> { - let Some(handler) = self.handlers.first() else { - anyhow::bail!( - "no protocol plugins compiled; build with --features protocol-http \ + /// Возвращает основной обработчик. + /// + /// # Errors + /// Возвращает ошибку, если ни один протокол не скомпилирован — + /// edge-нода обязана fail-fast на старте в этом случае. + pub fn primary(&self) -> anyhow::Result<&dyn ProtocolHandler> { + let Some(handler) = self.handlers.first() else { + anyhow::bail!( + "no protocol plugins compiled; build with --features protocol-http \ or link an external ProtocolHandler implementation" - ); - }; - Ok(handler.as_ref()) - } + ); + }; + Ok(handler.as_ref()) + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - struct DummyHandler; + struct DummyHandler; - impl ProtocolHandler for DummyHandler { - fn name(&self) -> &'static str { - "dummy" - } + impl ProtocolHandler for DummyHandler { + fn name(&self) -> &'static str { + "dummy" + } - fn handshake<'a>( - &'a self, - _stream: &'a mut TcpStream, - ) -> Pin> + 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> + Send + 'a>> { + Box::pin(async { Ok(HandshakeResult::new(Upstream::new("127.0.0.1:9000"))) }) + } + } - #[test] - fn empty_registry_fails_fast() { - let registry = ProtocolRegistry::new(); - assert!(registry.is_empty()); - assert!(registry.primary().is_err()); - } + #[test] + fn empty_registry_fails_fast() { + let registry = ProtocolRegistry::new(); + assert!(registry.is_empty()); + assert!(registry.primary().is_err()); + } - #[test] - fn registered_handler_is_resolvable() { - let mut registry = ProtocolRegistry::new(); - registry.register(Box::new(DummyHandler)); - assert_eq!(registry.len(), 1); - assert_eq!(registry.names(), vec!["dummy"]); - assert!(registry.primary().is_ok()); - assert!(registry.get("dummy").is_some()); - assert!(registry.get("missing").is_none()); - } + #[test] + fn registered_handler_is_resolvable() { + let mut registry = ProtocolRegistry::new(); + registry.register(Box::new(DummyHandler)); + assert_eq!(registry.len(), 1); + assert_eq!(registry.names(), vec!["dummy"]); + assert!(registry.primary().is_ok()); + assert!(registry.get("dummy").is_some()); + assert!(registry.get("missing").is_none()); + } } diff --git a/src/store/clickhouse.rs b/src/store/clickhouse.rs index 3b31442..fd1530b 100644 --- a/src/store/clickhouse.rs +++ b/src/store/clickhouse.rs @@ -10,80 +10,80 @@ const FLUSH_INTERVAL: Duration = Duration::from_secs(1); #[derive(Debug, Clone, Serialize)] pub struct ClickHouseEvent { - pub timestamp: DateTime, - pub event_type: String, - pub ip: String, - pub data_float: f64, - pub data_int: i64, - pub data_string: String, + pub timestamp: DateTime, + pub event_type: String, + pub ip: String, + pub data_float: f64, + pub data_int: i64, + pub data_string: String, } pub struct ClickHouseWriter { - url: String, - client: reqwest::Client, - buffer: Vec, + url: String, + client: reqwest::Client, + buffer: Vec, } impl ClickHouseWriter { - pub fn new(url: &str) -> Self { - Self { - url: url.to_string(), - client: reqwest::Client::new(), - buffer: Vec::with_capacity(BATCH_SIZE), - } - } + pub fn new(url: &str) -> Self { + Self { + url: url.to_string(), + client: reqwest::Client::new(), + buffer: Vec::with_capacity(BATCH_SIZE), + } + } - pub async fn push(&mut self, event: ClickHouseEvent) -> anyhow::Result<()> { - self.buffer.push(event); - if self.buffer.len() >= BATCH_SIZE { - self.flush().await?; - } - Ok(()) - } + pub async fn push(&mut self, event: ClickHouseEvent) -> anyhow::Result<()> { + self.buffer.push(event); + if self.buffer.len() >= BATCH_SIZE { + self.flush().await?; + } + Ok(()) + } - pub async fn flush(&mut self) -> anyhow::Result<()> { - if self.buffer.is_empty() { - return Ok(()); - } - let events = std::mem::take(&mut self.buffer); - let json = serde_json::to_string(&events)?; - let response = self - .client - .post(&self.url) - .query(&[("query", "INSERT INTO rampart_events FORMAT JSONEachRow")]) - .header("Content-Type", "application/json") - .body(json) - .send() - .await?; - let status = response.status(); - if !status.is_success() { - let text = response.text().await?; - anyhow::bail!("clickhouse insert failed ({}): {}", status, text); - } - tracing::debug!("flushed {} events to clickhouse", events.len()); - Ok(()) - } + pub async fn flush(&mut self) -> anyhow::Result<()> { + if self.buffer.is_empty() { + return Ok(()); + } + let events = std::mem::take(&mut self.buffer); + let json = serde_json::to_string(&events)?; + let response = self + .client + .post(&self.url) + .query(&[("query", "INSERT INTO rampart_events FORMAT JSONEachRow")]) + .header("Content-Type", "application/json") + .body(json) + .send() + .await?; + let status = response.status(); + if !status.is_success() { + let text = response.text().await?; + anyhow::bail!("clickhouse insert failed ({}): {}", status, text); + } + tracing::debug!("flushed {} events to clickhouse", events.len()); + Ok(()) + } } pub fn start_flush_task(writer: Arc>, mut shutdown: watch::Receiver) { - tokio::spawn(async move { - loop { - tokio::select! { - _ = tokio::time::sleep(FLUSH_INTERVAL) => { - if let Err(e) = writer.lock().await.flush().await { - tracing::error!("clickhouse flush error: {e}"); - } - } - _ = shutdown.changed() => { - if *shutdown.borrow() { - tracing::info!("flushing clickhouse on shutdown"); - if let Err(e) = writer.lock().await.flush().await { - tracing::error!("clickhouse final flush error: {e}"); - } - return; - } - } - } - } - }); + tokio::spawn(async move { + loop { + tokio::select! { + _ = tokio::time::sleep(FLUSH_INTERVAL) => { + if let Err(e) = writer.lock().await.flush().await { + tracing::error!("clickhouse flush error: {e}"); + } + } + _ = shutdown.changed() => { + if *shutdown.borrow() { + tracing::info!("flushing clickhouse on shutdown"); + if let Err(e) = writer.lock().await.flush().await { + tracing::error!("clickhouse final flush error: {e}"); + } + return; + } + } + } + } + }); } diff --git a/src/store/mod.rs b/src/store/mod.rs index f731027..c645f35 100644 --- a/src/store/mod.rs +++ b/src/store/mod.rs @@ -8,19 +8,19 @@ pub mod clickhouse; /// Общий контракт внешнего хранилища состояния. #[allow(async_fn_in_trait)] pub trait StateStore: Send + Sync { - /// # Errors - /// Возвращает ошибку при недоступности хранилища. - async fn get(&self, key: &str) -> anyhow::Result>; + /// # Errors + /// Возвращает ошибку при недоступности хранилища. + async fn get(&self, key: &str) -> anyhow::Result>; - /// # Errors - /// Возвращает ошибку при недоступности хранилища. - async fn set(&self, key: &str, value: &str) -> anyhow::Result<()>; + /// # Errors + /// Возвращает ошибку при недоступности хранилища. + async fn set(&self, key: &str, value: &str) -> anyhow::Result<()>; - /// # Errors - /// Возвращает ошибку при недоступности хранилища. - async fn del(&self, key: &str) -> anyhow::Result<()>; + /// # Errors + /// Возвращает ошибку при недоступности хранилища. + async fn del(&self, key: &str) -> anyhow::Result<()>; - /// # Errors - /// Возвращает ошибку при недоступности хранилища. - async fn publish(&self, channel: &str, message: &str) -> anyhow::Result<()>; + /// # Errors + /// Возвращает ошибку при недоступности хранилища. + async fn publish(&self, channel: &str, message: &str) -> anyhow::Result<()>; } diff --git a/src/store/redis.rs b/src/store/redis.rs index 19f2b3e..721b912 100644 --- a/src/store/redis.rs +++ b/src/store/redis.rs @@ -5,37 +5,37 @@ mod sync; pub use sync::{start_blacklist_sync, start_local_ban_publisher}; pub struct RedisStore { - client: redis::Client, + client: redis::Client, } impl RedisStore { - pub fn new(url: &str) -> anyhow::Result { - let client = redis::Client::open(url)?; - Ok(Self { client }) - } + pub fn new(url: &str) -> anyhow::Result { + let client = redis::Client::open(url)?; + Ok(Self { client }) + } } impl StateStore for RedisStore { - async fn get(&self, key: &str) -> anyhow::Result> { - let mut conn = self.client.get_multiplexed_async_connection().await?; - Ok(conn.get(key).await?) - } + async fn get(&self, key: &str) -> anyhow::Result> { + let mut conn = self.client.get_multiplexed_async_connection().await?; + Ok(conn.get(key).await?) + } - async fn set(&self, key: &str, value: &str) -> anyhow::Result<()> { - let mut conn = self.client.get_multiplexed_async_connection().await?; - let _: () = conn.set(key, value).await?; - Ok(()) - } + async fn set(&self, key: &str, value: &str) -> anyhow::Result<()> { + let mut conn = self.client.get_multiplexed_async_connection().await?; + let _: () = conn.set(key, value).await?; + Ok(()) + } - async fn del(&self, key: &str) -> anyhow::Result<()> { - let mut conn = self.client.get_multiplexed_async_connection().await?; - let _: () = conn.del(key).await?; - Ok(()) - } + async fn del(&self, key: &str) -> anyhow::Result<()> { + let mut conn = self.client.get_multiplexed_async_connection().await?; + let _: () = conn.del(key).await?; + Ok(()) + } - async fn publish(&self, channel: &str, message: &str) -> anyhow::Result<()> { - let mut conn = self.client.get_multiplexed_async_connection().await?; - let _: () = conn.publish(channel, message).await?; - Ok(()) - } + async fn publish(&self, channel: &str, message: &str) -> anyhow::Result<()> { + let mut conn = self.client.get_multiplexed_async_connection().await?; + let _: () = conn.publish(channel, message).await?; + Ok(()) + } } diff --git a/src/store/redis/sync.rs b/src/store/redis/sync.rs index 2728d40..8c25d4d 100644 --- a/src/store/redis/sync.rs +++ b/src/store/redis/sync.rs @@ -15,123 +15,123 @@ const BACKOFF_MIN: Duration = Duration::from_secs(1); const BACKOFF_MAX: Duration = Duration::from_secs(30); fn next_backoff(prev: Duration, max: Duration) -> Duration { - prev.saturating_mul(2).min(max) + prev.saturating_mul(2).min(max) } enum Flow { - Stop, - Retry, + Stop, + Retry, } async fn wait_for_shutdown(shutdown: &mut watch::Receiver) { - loop { - if shutdown.changed().await.is_err() || *shutdown.borrow_and_update() { - return; - } - } + loop { + if shutdown.changed().await.is_err() || *shutdown.borrow_and_update() { + return; + } + } } pub async fn start_blacklist_sync( - client: &redis::Client, - blacklist: Arc, - mut shutdown: watch::Receiver, + client: &redis::Client, + blacklist: Arc, + mut shutdown: watch::Receiver, ) { - let mut backoff = BACKOFF_MIN; - loop { - match subscribe_once(client, &blacklist, &mut shutdown, &mut backoff).await { - Flow::Stop => { - tracing::info!("shutting down blacklist subscriber"); - return; - }, - Flow::Retry => {}, - } - tokio::select! { - _ = tokio::time::sleep(backoff) => {}, - () = wait_for_shutdown(&mut shutdown) => { - tracing::info!("shutting down blacklist subscriber"); - return; - }, - } - backoff = next_backoff(backoff, BACKOFF_MAX); - } + let mut backoff = BACKOFF_MIN; + loop { + match subscribe_once(client, &blacklist, &mut shutdown, &mut backoff).await { + Flow::Stop => { + tracing::info!("shutting down blacklist subscriber"); + return; + }, + Flow::Retry => {}, + } + tokio::select! { + _ = tokio::time::sleep(backoff) => {}, + () = wait_for_shutdown(&mut shutdown) => { + tracing::info!("shutting down blacklist subscriber"); + return; + }, + } + backoff = next_backoff(backoff, BACKOFF_MAX); + } } async fn subscribe_once( - client: &redis::Client, - blacklist: &Blacklist, - shutdown: &mut watch::Receiver, - backoff: &mut Duration, + client: &redis::Client, + blacklist: &Blacklist, + shutdown: &mut watch::Receiver, + backoff: &mut Duration, ) -> Flow { - let mut pubsub = tokio::select! { - connected = client.get_async_pubsub() => match connected { - Ok(pubsub) => pubsub, - Err(e) => { - tracing::error!("failed to connect to Redis for blacklist sync: {e}"); - return Flow::Retry; - }, - }, - () = wait_for_shutdown(shutdown) => return Flow::Stop, - }; + let mut pubsub = tokio::select! { + connected = client.get_async_pubsub() => match connected { + Ok(pubsub) => pubsub, + Err(e) => { + tracing::error!("failed to connect to Redis for blacklist sync: {e}"); + return Flow::Retry; + }, + }, + () = wait_for_shutdown(shutdown) => return Flow::Stop, + }; - tokio::select! { - subscribed = pubsub.subscribe(BLACKLIST_CHANNEL) => match subscribed { - Ok(()) => tracing::info!("subscribed to {BLACKLIST_CHANNEL}"), - Err(e) => { - tracing::error!("failed to subscribe to blacklist events: {e}"); - return Flow::Retry; - }, - }, - () = wait_for_shutdown(shutdown) => return Flow::Stop, - } + tokio::select! { + subscribed = pubsub.subscribe(BLACKLIST_CHANNEL) => match subscribed { + Ok(()) => tracing::info!("subscribed to {BLACKLIST_CHANNEL}"), + Err(e) => { + tracing::error!("failed to subscribe to blacklist events: {e}"); + return Flow::Retry; + }, + }, + () = wait_for_shutdown(shutdown) => return Flow::Stop, + } - tokio::select! { - loaded = snapshot::reconcile(client, blacklist) => match loaded { - Ok(()) => tracing::info!("blacklist snapshot reconciled from Redis"), - Err(e) => { - tracing::error!("failed to reconcile blacklist snapshot: {e}"); - return Flow::Retry; - }, - }, - () = wait_for_shutdown(shutdown) => return Flow::Stop, - } + tokio::select! { + loaded = snapshot::reconcile(client, blacklist) => match loaded { + Ok(()) => tracing::info!("blacklist snapshot reconciled from Redis"), + Err(e) => { + tracing::error!("failed to reconcile blacklist snapshot: {e}"); + return Flow::Retry; + }, + }, + () = wait_for_shutdown(shutdown) => return Flow::Stop, + } - let mut stream = pubsub.on_message(); - loop { - tokio::select! { - maybe_msg = stream.next() => match maybe_msg { - Some(msg) => { - if let Err(e) = event::handle(&msg, blacklist) { - tracing::error!("blacklist event error: {e}"); - } else { - *backoff = BACKOFF_MIN; - } - }, - None => { - tracing::error!("blacklist pubsub stream ended; resubscribing"); - return Flow::Retry; - }, - }, - () = wait_for_shutdown(shutdown) => return Flow::Stop, - } - } + let mut stream = pubsub.on_message(); + loop { + tokio::select! { + maybe_msg = stream.next() => match maybe_msg { + Some(msg) => { + if let Err(e) = event::handle(&msg, blacklist) { + tracing::error!("blacklist event error: {e}"); + } else { + *backoff = BACKOFF_MIN; + } + }, + None => { + tracing::error!("blacklist pubsub stream ended; resubscribing"); + return Flow::Retry; + }, + }, + () = wait_for_shutdown(shutdown) => return Flow::Stop, + } + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn backoff_doubles_until_cap() { - let mut b = BACKOFF_MIN; - for expected_secs in [2, 4, 8, 16, 30, 30] { - b = next_backoff(b, BACKOFF_MAX); - assert_eq!(b, Duration::from_secs(expected_secs)); - } - } + #[test] + fn backoff_doubles_until_cap() { + let mut b = BACKOFF_MIN; + for expected_secs in [2, 4, 8, 16, 30, 30] { + b = next_backoff(b, BACKOFF_MAX); + assert_eq!(b, Duration::from_secs(expected_secs)); + } + } - #[test] - fn backoff_never_exceeds_max_even_with_huge_prev() { - let b = next_backoff(Duration::from_secs(u64::MAX / 2), BACKOFF_MAX); - assert!(b <= BACKOFF_MAX); - } + #[test] + fn backoff_never_exceeds_max_even_with_huge_prev() { + let b = next_backoff(Duration::from_secs(u64::MAX / 2), BACKOFF_MAX); + assert!(b <= BACKOFF_MAX); + } } diff --git a/src/store/redis/sync/event.rs b/src/store/redis/sync/event.rs index 88dc376..15befe3 100644 --- a/src/store/redis/sync/event.rs +++ b/src/store/redis/sync/event.rs @@ -7,51 +7,51 @@ const MAX_BAN_DURATION_SECS: u64 = 31_536_000; #[derive(Deserialize)] struct BlacklistEvent { - ip: String, - action: String, - #[serde(default = "default_duration")] - duration_secs: u64, - #[serde(default)] - expires_at_unix: Option, + ip: String, + action: String, + #[serde(default = "default_duration")] + duration_secs: u64, + #[serde(default)] + expires_at_unix: Option, } fn default_duration() -> u64 { - 300 + 300 } pub(super) fn handle(msg: &Msg, blacklist: &Blacklist) -> anyhow::Result<()> { - let payload: String = msg.get_payload()?; - let event: BlacklistEvent = serde_json::from_str(&payload)?; - let ip: std::net::IpAddr = event.ip.parse()?; + let payload: String = msg.get_payload()?; + let event: BlacklistEvent = serde_json::from_str(&payload)?; + let ip: std::net::IpAddr = event.ip.parse()?; - match event.action.as_str() { - "ban" => { - let duration = match event.expires_at_unix { - Some(expires_at) => { - if chrono::DateTime::from_timestamp(expires_at, 0).is_none() { - anyhow::bail!("invalid blacklist event expiry timestamp"); - } - let remaining = expires_at.saturating_sub(chrono::Utc::now().timestamp()); - if remaining <= 0 { - blacklist.remove_redis(ip); - return Ok(()); - } - let remaining = u64::try_from(remaining)?; - if remaining > MAX_BAN_DURATION_SECS { - anyhow::bail!("blacklist event expiry exceeds maximum duration"); - } - Duration::from_secs(remaining) - }, - None => Duration::from_secs(event.duration_secs), - }; - blacklist.add_redis(ip, duration, "manager_event"); - tracing::info!("blacklist add via Redis: {}", event.ip); - }, - "unban" => { - blacklist.remove_redis(ip); - tracing::info!("blacklist remove via Redis: {}", event.ip); - }, - action => anyhow::bail!("unknown action: {action}"), - } - Ok(()) + match event.action.as_str() { + "ban" => { + let duration = match event.expires_at_unix { + Some(expires_at) => { + if chrono::DateTime::from_timestamp(expires_at, 0).is_none() { + anyhow::bail!("invalid blacklist event expiry timestamp"); + } + let remaining = expires_at.saturating_sub(chrono::Utc::now().timestamp()); + if remaining <= 0 { + blacklist.remove_redis(ip); + return Ok(()); + } + let remaining = u64::try_from(remaining)?; + if remaining > MAX_BAN_DURATION_SECS { + anyhow::bail!("blacklist event expiry exceeds maximum duration"); + } + Duration::from_secs(remaining) + }, + None => Duration::from_secs(event.duration_secs), + }; + blacklist.add_redis(ip, duration, "manager_event"); + tracing::info!("blacklist add via Redis: {}", event.ip); + }, + "unban" => { + blacklist.remove_redis(ip); + tracing::info!("blacklist remove via Redis: {}", event.ip); + }, + action => anyhow::bail!("unknown action: {action}"), + } + Ok(()) } diff --git a/src/store/redis/sync/publisher.rs b/src/store/redis/sync/publisher.rs index 8508455..e1e685c 100644 --- a/src/store/redis/sync/publisher.rs +++ b/src/store/redis/sync/publisher.rs @@ -10,110 +10,110 @@ const STORE_BAN_SCRIPT: &str = "redis.call('HSET', KEYS[2], ARGV[1], ARGV[2]); r #[derive(Serialize)] struct BanMetadata<'a> { - created_at_unix: i64, - expires_at_unix: i64, - reason: &'a str, + created_at_unix: i64, + expires_at_unix: i64, + reason: &'a str, } #[derive(Serialize)] struct BanEvent<'a> { - ip: String, - action: &'static str, - duration_secs: u64, - expires_at_unix: i64, - reason: &'a str, + ip: String, + action: &'static str, + duration_secs: u64, + expires_at_unix: i64, + reason: &'a str, } pub async fn start_local_ban_publisher( - client: redis::Client, - blacklist: std::sync::Arc, - mut events: broadcast::Receiver, - mut shutdown: watch::Receiver, + client: redis::Client, + blacklist: std::sync::Arc, + mut events: broadcast::Receiver, + mut shutdown: watch::Receiver, ) { - for event in blacklist.local_snapshot() { - if !publish_with_retry(&client, event, &mut shutdown).await { - return; - } - } + for event in blacklist.local_snapshot() { + if !publish_with_retry(&client, event, &mut shutdown).await { + return; + } + } - loop { - tokio::select! { - received = events.recv() => match received { - Ok(event) => { - if !publish_with_retry(&client, event, &mut shutdown).await { - return; - } - }, - Err(broadcast::error::RecvError::Lagged(skipped)) => { - tracing::warn!(skipped, "local ban publisher lagged; reconciling active local bans"); - for event in blacklist.local_snapshot() { - if !publish_with_retry(&client, event, &mut shutdown).await { - return; - } - } - }, - Err(broadcast::error::RecvError::Closed) => return, - }, - changed = shutdown.changed() => { - if changed.is_err() || *shutdown.borrow_and_update() { - return; - } - }, - } - } + loop { + tokio::select! { + received = events.recv() => match received { + Ok(event) => { + if !publish_with_retry(&client, event, &mut shutdown).await { + return; + } + }, + Err(broadcast::error::RecvError::Lagged(skipped)) => { + tracing::warn!(skipped, "local ban publisher lagged; reconciling active local bans"); + for event in blacklist.local_snapshot() { + if !publish_with_retry(&client, event, &mut shutdown).await { + return; + } + } + }, + Err(broadcast::error::RecvError::Closed) => return, + }, + changed = shutdown.changed() => { + if changed.is_err() || *shutdown.borrow_and_update() { + return; + } + }, + } + } } async fn publish_with_retry( - client: &redis::Client, - event: LocalBanEvent, - shutdown: &mut watch::Receiver, + client: &redis::Client, + event: LocalBanEvent, + shutdown: &mut watch::Receiver, ) -> bool { - let mut delay = Duration::from_secs(1); - loop { - match publish_ban(client, &event).await { - Ok(()) => return true, - Err(error) => tracing::warn!(%error, ip = %event.ip, "failed to persist local ban; retrying"), - } - tokio::select! { - _ = tokio::time::sleep(delay) => delay = (delay * 2).min(Duration::from_secs(30)), - changed = shutdown.changed() => { - if changed.is_err() || *shutdown.borrow_and_update() { - return false; - } - }, - } - } + let mut delay = Duration::from_secs(1); + loop { + match publish_ban(client, &event).await { + Ok(()) => return true, + Err(error) => tracing::warn!(%error, ip = %event.ip, "failed to persist local ban; retrying"), + } + tokio::select! { + _ = tokio::time::sleep(delay) => delay = (delay * 2).min(Duration::from_secs(30)), + changed = shutdown.changed() => { + if changed.is_err() || *shutdown.borrow_and_update() { + return false; + } + }, + } + } } async fn publish_ban(client: &redis::Client, event: &LocalBanEvent) -> anyhow::Result<()> { - let now = chrono::Utc::now().timestamp(); - let remaining = event.expires_at_unix.saturating_sub(now); - if remaining <= 0 { - return Ok(()); - } - let metadata = serde_json::to_string(&BanMetadata { - created_at_unix: now, - expires_at_unix: event.expires_at_unix, - reason: &event.reason, - })?; - let payload = serde_json::to_string(&BanEvent { - ip: event.ip.to_string(), - action: "ban", - duration_secs: u64::try_from(remaining)?, - expires_at_unix: event.expires_at_unix, - reason: &event.reason, - })?; - let mut conn = client.get_multiplexed_async_connection().await?; - let _: i64 = redis::cmd("EVAL") - .arg(STORE_BAN_SCRIPT) - .arg(3) - .arg(BLACKLIST_KEY) - .arg(BLACKLIST_METADATA_KEY) - .arg(BLACKLIST_CHANNEL) - .arg(event.ip.to_string()) - .arg(metadata) - .arg(payload) - .query_async(&mut conn) - .await?; - Ok(()) + let now = chrono::Utc::now().timestamp(); + let remaining = event.expires_at_unix.saturating_sub(now); + if remaining <= 0 { + return Ok(()); + } + let metadata = serde_json::to_string(&BanMetadata { + created_at_unix: now, + expires_at_unix: event.expires_at_unix, + reason: &event.reason, + })?; + let payload = serde_json::to_string(&BanEvent { + ip: event.ip.to_string(), + action: "ban", + duration_secs: u64::try_from(remaining)?, + expires_at_unix: event.expires_at_unix, + reason: &event.reason, + })?; + let mut conn = client.get_multiplexed_async_connection().await?; + let _: i64 = redis::cmd("EVAL") + .arg(STORE_BAN_SCRIPT) + .arg(3) + .arg(BLACKLIST_KEY) + .arg(BLACKLIST_METADATA_KEY) + .arg(BLACKLIST_CHANNEL) + .arg(event.ip.to_string()) + .arg(metadata) + .arg(payload) + .query_async(&mut conn) + .await?; + Ok(()) } diff --git a/src/store/redis/sync/snapshot.rs b/src/store/redis/sync/snapshot.rs index aefd132..70ae343 100644 --- a/src/store/redis/sync/snapshot.rs +++ b/src/store/redis/sync/snapshot.rs @@ -11,67 +11,67 @@ const MAX_BAN_DURATION_SECS: i64 = 31_536_000; #[derive(Deserialize, Serialize)] struct BlacklistMetadata { - created_at_unix: i64, - expires_at_unix: i64, - reason: String, + created_at_unix: i64, + expires_at_unix: i64, + reason: String, } /// Restore current durable bans after subscribing to the event channel. pub(super) async fn reconcile(client: &redis::Client, blacklist: &Blacklist) -> anyhow::Result<()> { - let mut conn = client.get_multiplexed_async_connection().await?; - let members: Vec = redis::cmd("SMEMBERS").arg(BLACKLIST_KEY).query_async(&mut conn).await?; - let metadata: HashMap = conn.hgetall(BLACKLIST_METADATA_KEY).await?; - let now = chrono::Utc::now().timestamp(); - let mut active = Vec::with_capacity(members.len()); + let mut conn = client.get_multiplexed_async_connection().await?; + let members: Vec = redis::cmd("SMEMBERS").arg(BLACKLIST_KEY).query_async(&mut conn).await?; + let metadata: HashMap = conn.hgetall(BLACKLIST_METADATA_KEY).await?; + let now = chrono::Utc::now().timestamp(); + let mut active = Vec::with_capacity(members.len()); - for target in members { - let ip: std::net::IpAddr = match target.parse() { - Ok(ip) => ip, - Err(_) => continue, - }; - let record = match metadata.get(&target) { - Some(encoded) => match serde_json::from_str::(encoded) { - Ok(record) => record, - Err(_) => continue, - }, - None => match legacy_record(&mut conn, &target, now).await? { - Some(record) => record, - None => continue, - }, - }; - if record.expires_at_unix <= now - || chrono::DateTime::from_timestamp(record.created_at_unix, 0).is_none() - || chrono::DateTime::from_timestamp(record.expires_at_unix, 0).is_none() - || record.expires_at_unix.saturating_sub(now) > MAX_BAN_DURATION_SECS - { - continue; - } - let remaining = u64::try_from(record.expires_at_unix - now)?; - active.push((ip, Duration::from_secs(remaining), record.reason)); - } - blacklist.replace_redis(active); - Ok(()) + for target in members { + let ip: std::net::IpAddr = match target.parse() { + Ok(ip) => ip, + Err(_) => continue, + }; + let record = match metadata.get(&target) { + Some(encoded) => match serde_json::from_str::(encoded) { + Ok(record) => record, + Err(_) => continue, + }, + None => match legacy_record(&mut conn, &target, now).await? { + Some(record) => record, + None => continue, + }, + }; + if record.expires_at_unix <= now + || chrono::DateTime::from_timestamp(record.created_at_unix, 0).is_none() + || chrono::DateTime::from_timestamp(record.expires_at_unix, 0).is_none() + || record.expires_at_unix.saturating_sub(now) > MAX_BAN_DURATION_SECS + { + continue; + } + let remaining = u64::try_from(record.expires_at_unix - now)?; + active.push((ip, Duration::from_secs(remaining), record.reason)); + } + blacklist.replace_redis(active); + Ok(()) } async fn legacy_record( - conn: &mut redis::aio::MultiplexedConnection, - target: &str, - now: i64, + conn: &mut redis::aio::MultiplexedConnection, + target: &str, + now: i64, ) -> anyhow::Result> { - let legacy = BlacklistMetadata { - created_at_unix: now, - expires_at_unix: now.saturating_add(LEGACY_BAN_DURATION_SECS), - reason: "legacy_unverified".to_string(), - }; - let inserted: i64 = redis::cmd("HSETNX") - .arg(BLACKLIST_METADATA_KEY) - .arg(target) - .arg(serde_json::to_string(&legacy)?) - .query_async(conn) - .await?; - if inserted == 1 { - return Ok(Some(legacy)); - } - let current: Option = conn.hget(BLACKLIST_METADATA_KEY, target).await?; - Ok(current.and_then(|value| serde_json::from_str(&value).ok())) + let legacy = BlacklistMetadata { + created_at_unix: now, + expires_at_unix: now.saturating_add(LEGACY_BAN_DURATION_SECS), + reason: "legacy_unverified".to_string(), + }; + let inserted: i64 = redis::cmd("HSETNX") + .arg(BLACKLIST_METADATA_KEY) + .arg(target) + .arg(serde_json::to_string(&legacy)?) + .query_async(conn) + .await?; + if inserted == 1 { + return Ok(Some(legacy)); + } + let current: Option = conn.hget(BLACKLIST_METADATA_KEY, target).await?; + Ok(current.and_then(|value| serde_json::from_str(&value).ok())) } diff --git a/src/traffic/hook.rs b/src/traffic/hook.rs index 6463d37..7485aa9 100644 --- a/src/traffic/hook.rs +++ b/src/traffic/hook.rs @@ -20,200 +20,200 @@ const BAN_REASON_ATTACK: &str = "attack_detector"; /// События: новое соединение (`on_accept`), завершение обработки соединения /// (`on_connection_end`), эскалация детектора атак (`ban_offenders`). pub struct TrafficHook { - reputation: Arc, - blacklist: Arc, - autoban: DetectAutobanConfig, - ban_ttl_secs: u64, - conn_window: AtomicU64, + reputation: Arc, + blacklist: Arc, + autoban: DetectAutobanConfig, + ban_ttl_secs: u64, + conn_window: AtomicU64, } impl TrafficHook { - pub fn new( - reputation: Arc, - blacklist: Arc, - autoban: DetectAutobanConfig, - ban_ttl_secs: u64, - ) -> Self { - Self { - reputation, - blacklist, - autoban, - ban_ttl_secs, - conn_window: AtomicU64::new(0), - } - } + pub fn new( + reputation: Arc, + blacklist: Arc, + autoban: DetectAutobanConfig, + ban_ttl_secs: u64, + ) -> Self { + Self { + reputation, + blacklist, + autoban, + ban_ttl_secs, + conn_window: AtomicU64::new(0), + } + } - /// Новое соединение принято accept-loop'ом. Только счётчик окна cps. - pub fn on_accept(&self) { - self.conn_window.fetch_add(1, Ordering::Relaxed); - } + /// Новое соединение принято accept-loop'ом. Только счётчик окна cps. + pub fn on_accept(&self) { + self.conn_window.fetch_add(1, Ordering::Relaxed); + } - /// Соединение обработано. Если источник попал под rate-limit (репутация - /// упала до порога) — авто-бан с TTL из конфига. - pub fn on_connection_end(&self, ip: IpAddr) { - if !self.autoban.enabled || self.blacklist.is_blocked(ip) { - return; - } - self.autoban_if_toxic(ip, BAN_REASON_LOW_REPUTATION); - } + /// Соединение обработано. Если источник попал под rate-limit (репутация + /// упала до порога) — авто-бан с TTL из конфига. + pub fn on_connection_end(&self, ip: IpAddr) { + if !self.autoban.enabled || self.blacklist.is_blocked(ip) { + return; + } + self.autoban_if_toxic(ip, BAN_REASON_LOW_REPUTATION); + } - /// Эскалация детектора атак: бан всех источников ниже порога репутации. - /// Вызывается один раз на переход в `UnderAttack`, не на каждый тик. - pub fn ban_offenders(&self) -> usize { - if !self.autoban.enabled { - return 0; - } - let offenders = self.reputation.offenders_below(self.autoban.reputation_threshold); - let mut banned = 0; - for ip in offenders { - if self.blacklist.is_blocked(ip) { - continue; - } - self.ban(ip, BAN_REASON_ATTACK); - banned += 1; - } - banned - } + /// Эскалация детектора атак: бан всех источников ниже порога репутации. + /// Вызывается один раз на переход в `UnderAttack`, не на каждый тик. + pub fn ban_offenders(&self) -> usize { + if !self.autoban.enabled { + return 0; + } + let offenders = self.reputation.offenders_below(self.autoban.reputation_threshold); + let mut banned = 0; + for ip in offenders { + if self.blacklist.is_blocked(ip) { + continue; + } + self.ban(ip, BAN_REASON_ATTACK); + banned += 1; + } + banned + } - /// Забирает накопленное окно новых соединений за секунду (cps). - pub fn take_cps(&self) -> u64 { - self.conn_window.swap(0, Ordering::Relaxed) - } + /// Забирает накопленное окно новых соединений за секунду (cps). + pub fn take_cps(&self) -> u64 { + self.conn_window.swap(0, Ordering::Relaxed) + } - fn autoban_if_toxic(&self, ip: IpAddr, reason: &str) { - if self.reputation.score(ip) > self.autoban.reputation_threshold { - return; - } - self.ban(ip, reason); - } + fn autoban_if_toxic(&self, ip: IpAddr, reason: &str) { + if self.reputation.score(ip) > self.autoban.reputation_threshold { + return; + } + self.ban(ip, reason); + } - fn ban(&self, ip: IpAddr, reason: &str) { - self.blacklist.add(ip, Duration::from_secs(self.ban_ttl_secs), reason); - metrics::AUTO_BANS_TOTAL.with_label_values(&[reason]).inc(); - tracing::warn!(%ip, reason, ttl_secs = self.ban_ttl_secs, "auto-ban issued by traffic intelligence"); - } + fn ban(&self, ip: IpAddr, reason: &str) { + self.blacklist.add(ip, Duration::from_secs(self.ban_ttl_secs), reason); + metrics::AUTO_BANS_TOTAL.with_label_values(&[reason]).inc(); + tracing::warn!(%ip, reason, ttl_secs = self.ban_ttl_secs, "auto-ban issued by traffic intelligence"); + } } #[cfg(test)] mod tests { - use super::*; - use std::net::{IpAddr, Ipv4Addr}; + use super::*; + use std::net::{IpAddr, Ipv4Addr}; - fn ip(octets: [u8; 4]) -> IpAddr { - IpAddr::V4(Ipv4Addr::from(octets)) - } + fn ip(octets: [u8; 4]) -> IpAddr { + IpAddr::V4(Ipv4Addr::from(octets)) + } - fn hook(rep: &Arc, bl: &Arc) -> TrafficHook { - TrafficHook::new( - Arc::clone(rep), - Arc::clone(bl), - DetectAutobanConfig { - enabled: true, - reputation_threshold: -50, - }, - 60, - ) - } + fn hook(rep: &Arc, bl: &Arc) -> TrafficHook { + TrafficHook::new( + Arc::clone(rep), + Arc::clone(bl), + DetectAutobanConfig { + enabled: true, + reputation_threshold: -50, + }, + 60, + ) + } - #[test] - fn test_cps_window_counts_and_resets() { - let rep = Arc::new(IpReputation::new()); - let bl = Arc::new(Blacklist::new()); - let hook = hook(&rep, &bl); - hook.on_accept(); - hook.on_accept(); - hook.on_accept(); - assert_eq!(hook.take_cps(), 3); - assert_eq!(hook.take_cps(), 0); - } + #[test] + fn test_cps_window_counts_and_resets() { + let rep = Arc::new(IpReputation::new()); + let bl = Arc::new(Blacklist::new()); + let hook = hook(&rep, &bl); + hook.on_accept(); + hook.on_accept(); + hook.on_accept(); + assert_eq!(hook.take_cps(), 3); + assert_eq!(hook.take_cps(), 0); + } - #[test] - fn test_reputation_fall_triggers_autoban() { - let rep = Arc::new(IpReputation::new()); - let bl = Arc::new(Blacklist::new()); - let hook = hook(&rep, &bl); - let target = ip([10, 1, 0, 1]); - for _ in 0..6 { - rep.record_bad(target); - } - assert_eq!(rep.score(target), -60); - assert!(!bl.is_blocked(target)); - hook.on_connection_end(target); - assert!(bl.is_blocked(target)); - } + #[test] + fn test_reputation_fall_triggers_autoban() { + let rep = Arc::new(IpReputation::new()); + let bl = Arc::new(Blacklist::new()); + let hook = hook(&rep, &bl); + let target = ip([10, 1, 0, 1]); + for _ in 0..6 { + rep.record_bad(target); + } + assert_eq!(rep.score(target), -60); + assert!(!bl.is_blocked(target)); + hook.on_connection_end(target); + assert!(bl.is_blocked(target)); + } - #[test] - fn test_no_autoban_above_threshold() { - let rep = Arc::new(IpReputation::new()); - let bl = Arc::new(Blacklist::new()); - let hook = hook(&rep, &bl); - let target = ip([10, 1, 0, 2]); - for _ in 0..4 { - rep.record_bad(target); - } - assert_eq!(rep.score(target), -40); - hook.on_connection_end(target); - assert!(!bl.is_blocked(target)); - } + #[test] + fn test_no_autoban_above_threshold() { + let rep = Arc::new(IpReputation::new()); + let bl = Arc::new(Blacklist::new()); + let hook = hook(&rep, &bl); + let target = ip([10, 1, 0, 2]); + for _ in 0..4 { + rep.record_bad(target); + } + assert_eq!(rep.score(target), -40); + hook.on_connection_end(target); + assert!(!bl.is_blocked(target)); + } - #[test] - fn test_disabled_autoban_never_bans() { - let rep = Arc::new(IpReputation::new()); - let bl = Arc::new(Blacklist::new()); - let hook = TrafficHook::new( - Arc::clone(&rep), - Arc::clone(&bl), - DetectAutobanConfig { - enabled: false, - reputation_threshold: -50, - }, - 60, - ); - let target = ip([10, 1, 0, 3]); - for _ in 0..20 { - rep.record_bad(target); - } - hook.on_connection_end(target); - assert!(hook.ban_offenders() == 0); - assert!(!bl.is_blocked(target)); - } + #[test] + fn test_disabled_autoban_never_bans() { + let rep = Arc::new(IpReputation::new()); + let bl = Arc::new(Blacklist::new()); + let hook = TrafficHook::new( + Arc::clone(&rep), + Arc::clone(&bl), + DetectAutobanConfig { + enabled: false, + reputation_threshold: -50, + }, + 60, + ); + let target = ip([10, 1, 0, 3]); + for _ in 0..20 { + rep.record_bad(target); + } + hook.on_connection_end(target); + assert!(hook.ban_offenders() == 0); + assert!(!bl.is_blocked(target)); + } - #[test] - fn test_ban_offenders_bans_only_below_threshold() { - let rep = Arc::new(IpReputation::new()); - let bl = Arc::new(Blacklist::new()); - let hook = hook(&rep, &bl); - let bad = ip([10, 2, 0, 1]); - let ok = ip([10, 2, 0, 2]); - for _ in 0..8 { - rep.record_bad(bad); - } - rep.record_good(ok); - assert_eq!(hook.ban_offenders(), 1); - assert!(bl.is_blocked(bad)); - assert!(!bl.is_blocked(ok)); - assert_eq!(hook.ban_offenders(), 0); - } + #[test] + fn test_ban_offenders_bans_only_below_threshold() { + let rep = Arc::new(IpReputation::new()); + let bl = Arc::new(Blacklist::new()); + let hook = hook(&rep, &bl); + let bad = ip([10, 2, 0, 1]); + let ok = ip([10, 2, 0, 2]); + for _ in 0..8 { + rep.record_bad(bad); + } + rep.record_good(ok); + assert_eq!(hook.ban_offenders(), 1); + assert!(bl.is_blocked(bad)); + assert!(!bl.is_blocked(ok)); + assert_eq!(hook.ban_offenders(), 0); + } - #[test] - fn test_autoban_ttl_expires() { - let rep = Arc::new(IpReputation::new()); - let bl = Arc::new(Blacklist::new()); - let hook = TrafficHook::new( - Arc::clone(&rep), - Arc::clone(&bl), - DetectAutobanConfig { - enabled: true, - reputation_threshold: -50, - }, - // Короткий TTL как мок времени: бан жив, потом истекает. - 0, - ); - let target = ip([10, 3, 0, 1]); - for _ in 0..20 { - rep.record_bad(target); - } - hook.on_connection_end(target); - assert!(!bl.is_blocked(target), "zero TTL must not produce an active ban"); - } + #[test] + fn test_autoban_ttl_expires() { + let rep = Arc::new(IpReputation::new()); + let bl = Arc::new(Blacklist::new()); + let hook = TrafficHook::new( + Arc::clone(&rep), + Arc::clone(&bl), + DetectAutobanConfig { + enabled: true, + reputation_threshold: -50, + }, + // Короткий TTL как мок времени: бан жив, потом истекает. + 0, + ); + let target = ip([10, 3, 0, 1]); + for _ in 0..20 { + rep.record_bad(target); + } + hook.on_connection_end(target); + assert!(!bl.is_blocked(target), "zero TTL must not produce an active ban"); + } } diff --git a/src/traffic/intel/detector.rs b/src/traffic/intel/detector.rs index 27a4c63..121e863 100644 --- a/src/traffic/intel/detector.rs +++ b/src/traffic/intel/detector.rs @@ -2,109 +2,109 @@ use crate::traffic::profiler::TrafficProfiler; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum AttackStatus { - Normal, - Suspicious, - UnderAttack, + Normal, + Suspicious, + UnderAttack, } pub struct AttackDetector { - pps_profiler: TrafficProfiler, - cps_profiler: TrafficProfiler, - consecutive_anomalies: u32, + pps_profiler: TrafficProfiler, + cps_profiler: TrafficProfiler, + consecutive_anomalies: u32, } impl Default for AttackDetector { - fn default() -> Self { - Self::new() - } + fn default() -> Self { + Self::new() + } } impl AttackDetector { - pub fn new() -> Self { - Self { - pps_profiler: TrafficProfiler::new(), - cps_profiler: TrafficProfiler::new(), - consecutive_anomalies: 0, - } - } + pub fn new() -> Self { + Self { + pps_profiler: TrafficProfiler::new(), + cps_profiler: TrafficProfiler::new(), + consecutive_anomalies: 0, + } + } - /// Анализирует окно метрик (пакеты/с и новые соединения/с) относительно - /// накопленных профилей. Аномалией считается всплеск любой из метрик. - pub fn analyze(&mut self, pps: f64, cps: f64) -> AttackStatus { - self.pps_profiler.record(pps); - self.cps_profiler.record(cps); - let score = self - .pps_profiler - .anomaly_score(pps) - .max(self.cps_profiler.anomaly_score(cps)); + /// Анализирует окно метрик (пакеты/с и новые соединения/с) относительно + /// накопленных профилей. Аномалией считается всплеск любой из метрик. + pub fn analyze(&mut self, pps: f64, cps: f64) -> AttackStatus { + self.pps_profiler.record(pps); + self.cps_profiler.record(cps); + let score = self + .pps_profiler + .anomaly_score(pps) + .max(self.cps_profiler.anomaly_score(cps)); - if score > 3.0 { - self.consecutive_anomalies += 1; - } else { - self.consecutive_anomalies = 0; - } + if score > 3.0 { + self.consecutive_anomalies += 1; + } else { + self.consecutive_anomalies = 0; + } - if self.consecutive_anomalies >= 3 { - AttackStatus::UnderAttack - } else if score > 2.0 { - AttackStatus::Suspicious - } else { - AttackStatus::Normal - } - } + if self.consecutive_anomalies >= 3 { + AttackStatus::UnderAttack + } else if score > 2.0 { + AttackStatus::Suspicious + } else { + AttackStatus::Normal + } + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn test_attack_status_normal() { - let mut d = AttackDetector::new(); - for _ in 0..10 { - d.analyze(100.0, 10.0); - } - assert_eq!(d.analyze(100.0, 10.0), AttackStatus::Normal); - } + #[test] + fn test_attack_status_normal() { + let mut d = AttackDetector::new(); + for _ in 0..10 { + d.analyze(100.0, 10.0); + } + assert_eq!(d.analyze(100.0, 10.0), AttackStatus::Normal); + } - #[test] - fn test_attack_status_suspicious_pps_spike() { - let mut d = AttackDetector::new(); - for _ in 0..10 { - d.analyze(1.0, 1.0); - } - assert_eq!(d.analyze(5.0, 1.0), AttackStatus::Suspicious); - } + #[test] + fn test_attack_status_suspicious_pps_spike() { + let mut d = AttackDetector::new(); + for _ in 0..10 { + d.analyze(1.0, 1.0); + } + assert_eq!(d.analyze(5.0, 1.0), AttackStatus::Suspicious); + } - #[test] - fn test_attack_status_suspicious_cps_spike() { - let mut d = AttackDetector::new(); - for _ in 0..10 { - d.analyze(1.0, 1.0); - } - assert_eq!(d.analyze(1.0, 5.0), AttackStatus::Suspicious); - } + #[test] + fn test_attack_status_suspicious_cps_spike() { + let mut d = AttackDetector::new(); + for _ in 0..10 { + d.analyze(1.0, 1.0); + } + assert_eq!(d.analyze(1.0, 5.0), AttackStatus::Suspicious); + } - #[test] - fn test_attack_status_under_attack() { - let mut d = AttackDetector::new(); - for _ in 0..10 { - d.analyze(1.0, 1.0); - } - d.analyze(10_000.0, 100.0); - d.analyze(10_000.0, 100.0); - assert_eq!(d.analyze(10_000.0, 100.0), AttackStatus::UnderAttack); - } + #[test] + fn test_attack_status_under_attack() { + let mut d = AttackDetector::new(); + for _ in 0..10 { + d.analyze(1.0, 1.0); + } + d.analyze(10_000.0, 100.0); + d.analyze(10_000.0, 100.0); + assert_eq!(d.analyze(10_000.0, 100.0), AttackStatus::UnderAttack); + } - #[test] - fn test_consecutive_resets_on_normal() { - let mut d = AttackDetector::new(); - for _ in 0..10 { - d.analyze(1.0, 1.0); - } - d.analyze(100.0, 10.0); - d.analyze(100.0, 10.0); - d.analyze(1.0, 1.0); - assert_eq!(d.analyze(1.0, 1.0), AttackStatus::Normal); - } + #[test] + fn test_consecutive_resets_on_normal() { + let mut d = AttackDetector::new(); + for _ in 0..10 { + d.analyze(1.0, 1.0); + } + d.analyze(100.0, 10.0); + d.analyze(100.0, 10.0); + d.analyze(1.0, 1.0); + assert_eq!(d.analyze(1.0, 1.0), AttackStatus::Normal); + } } diff --git a/src/traffic/intel/ewma.rs b/src/traffic/intel/ewma.rs index 630b078..74a1b8c 100644 --- a/src/traffic/intel/ewma.rs +++ b/src/traffic/intel/ewma.rs @@ -1,57 +1,57 @@ use std::time::Instant; pub struct Ewma { - value: f64, - last: Instant, - alpha: f64, + value: f64, + last: Instant, + alpha: f64, } impl Ewma { - pub fn new(alpha: f64) -> Self { - Self { - value: 0.0, - last: Instant::now(), - alpha, - } - } + pub fn new(alpha: f64) -> Self { + Self { + value: 0.0, + last: Instant::now(), + alpha, + } + } - pub fn update(&mut self, sample: f64) { - let now = Instant::now(); - let elapsed = now.duration_since(self.last).as_secs_f64(); - let steps = elapsed.max(1.0); - let weight = (1.0 - self.alpha).powf(steps); - self.value = self.value * weight + sample * (1.0 - weight); - self.last = now; - } + pub fn update(&mut self, sample: f64) { + let now = Instant::now(); + let elapsed = now.duration_since(self.last).as_secs_f64(); + let steps = elapsed.max(1.0); + let weight = (1.0 - self.alpha).powf(steps); + self.value = self.value * weight + sample * (1.0 - weight); + self.last = now; + } - pub fn value(&self) -> f64 { - self.value - } + pub fn value(&self) -> f64 { + self.value + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn test_ewma_initial() { - let ewma = Ewma::new(0.125); - assert_eq!(ewma.value(), 0.0); - } + #[test] + fn test_ewma_initial() { + let ewma = Ewma::new(0.125); + assert_eq!(ewma.value(), 0.0); + } - #[test] - fn test_ewma_update() { - let mut ewma = Ewma::new(1.0); - ewma.update(100.0); - assert!((ewma.value() - 100.0).abs() < 1.0); - } + #[test] + fn test_ewma_update() { + let mut ewma = Ewma::new(1.0); + ewma.update(100.0); + assert!((ewma.value() - 100.0).abs() < 1.0); + } - #[test] - fn test_ewma_convergence() { - let mut ewma = Ewma::new(0.5); - for _ in 0..10 { - ewma.update(50.0); - } - assert!((ewma.value() - 50.0).abs() < 1.0); - } + #[test] + fn test_ewma_convergence() { + let mut ewma = Ewma::new(0.5); + for _ in 0..10 { + ewma.update(50.0); + } + assert!((ewma.value() - 50.0).abs() < 1.0); + } } diff --git a/src/traffic/intel/reputation.rs b/src/traffic/intel/reputation.rs index dba19f6..3a3d0d9 100644 --- a/src/traffic/intel/reputation.rs +++ b/src/traffic/intel/reputation.rs @@ -3,136 +3,136 @@ use std::net::IpAddr; use std::sync::Arc; pub struct IpReputation { - scores: Arc>, + scores: Arc>, } impl Default for IpReputation { - fn default() -> Self { - Self::new() - } + fn default() -> Self { + Self::new() + } } impl IpReputation { - pub fn new() -> Self { - Self { - scores: Arc::new(DashMap::new()), - } - } + pub fn new() -> Self { + Self { + scores: Arc::new(DashMap::new()), + } + } - pub fn record_good(&self, ip: IpAddr) { - let mut entry = self.scores.entry(ip).or_insert(0); - *entry = (*entry + 1).min(100); - } + pub fn record_good(&self, ip: IpAddr) { + let mut entry = self.scores.entry(ip).or_insert(0); + *entry = (*entry + 1).min(100); + } - pub fn record_bad(&self, ip: IpAddr) { - let mut entry = self.scores.entry(ip).or_insert(0); - *entry = (*entry - 10).max(-100); - } + pub fn record_bad(&self, ip: IpAddr) { + let mut entry = self.scores.entry(ip).or_insert(0); + *entry = (*entry - 10).max(-100); + } - pub fn score(&self, ip: IpAddr) -> i32 { - self.scores.get(&ip).map(|v| *v).unwrap_or(0) - } + pub fn score(&self, ip: IpAddr) -> i32 { + self.scores.get(&ip).map(|v| *v).unwrap_or(0) + } - /// Возвращает источники со скором не выше `threshold` (нарушители). - pub fn offenders_below(&self, threshold: i32) -> Vec { - self.scores - .iter() - .filter(|entry| *entry.value() <= threshold) - .map(|entry| *entry.key()) - .collect() - } + /// Возвращает источники со скором не выше `threshold` (нарушители). + pub fn offenders_below(&self, threshold: i32) -> Vec { + self.scores + .iter() + .filter(|entry| *entry.value() <= threshold) + .map(|entry| *entry.key()) + .collect() + } - pub fn is_trusted(&self, ip: IpAddr) -> bool { - self.score(ip) > 50 - } + pub fn is_trusted(&self, ip: IpAddr) -> bool { + self.score(ip) > 50 + } } #[cfg(test)] mod tests { - use super::*; - use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; + use super::*; + use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; - fn v4(octets: [u8; 4]) -> IpAddr { - IpAddr::V4(Ipv4Addr::from(octets)) - } + fn v4(octets: [u8; 4]) -> IpAddr { + IpAddr::V4(Ipv4Addr::from(octets)) + } - #[test] - fn test_reputation_initial_score() { - let rep = IpReputation::new(); - assert_eq!(rep.score(v4([192, 168, 1, 1])), 0); - } + #[test] + fn test_reputation_initial_score() { + let rep = IpReputation::new(); + assert_eq!(rep.score(v4([192, 168, 1, 1])), 0); + } - #[test] - fn test_reputation_good() { - let rep = IpReputation::new(); - let ip = v4([10, 0, 0, 1]); - rep.record_good(ip); - assert_eq!(rep.score(ip), 1); - } + #[test] + fn test_reputation_good() { + let rep = IpReputation::new(); + let ip = v4([10, 0, 0, 1]); + rep.record_good(ip); + assert_eq!(rep.score(ip), 1); + } - #[test] - fn test_reputation_bad() { - let rep = IpReputation::new(); - let ip = v4([10, 0, 0, 2]); - rep.record_bad(ip); - assert_eq!(rep.score(ip), -10); - } + #[test] + fn test_reputation_bad() { + let rep = IpReputation::new(); + let ip = v4([10, 0, 0, 2]); + rep.record_bad(ip); + assert_eq!(rep.score(ip), -10); + } - #[test] - fn test_reputation_cap_positive() { - let rep = IpReputation::new(); - let ip = v4([10, 0, 0, 3]); - for _ in 0..200 { - rep.record_good(ip); - } - assert_eq!(rep.score(ip), 100); - } + #[test] + fn test_reputation_cap_positive() { + let rep = IpReputation::new(); + let ip = v4([10, 0, 0, 3]); + for _ in 0..200 { + rep.record_good(ip); + } + assert_eq!(rep.score(ip), 100); + } - #[test] - fn test_reputation_cap_negative() { - let rep = IpReputation::new(); - let ip = v4([10, 0, 0, 4]); - for _ in 0..20 { - rep.record_bad(ip); - } - assert_eq!(rep.score(ip), -100); - } + #[test] + fn test_reputation_cap_negative() { + let rep = IpReputation::new(); + let ip = v4([10, 0, 0, 4]); + for _ in 0..20 { + rep.record_bad(ip); + } + assert_eq!(rep.score(ip), -100); + } - #[test] - fn test_is_trusted() { - let rep = IpReputation::new(); - let ip = v4([10, 0, 0, 5]); - assert!(!rep.is_trusted(ip)); - for _ in 0..51 { - rep.record_good(ip); - } - assert!(rep.is_trusted(ip)); - } + #[test] + fn test_is_trusted() { + let rep = IpReputation::new(); + let ip = v4([10, 0, 0, 5]); + assert!(!rep.is_trusted(ip)); + for _ in 0..51 { + rep.record_good(ip); + } + assert!(rep.is_trusted(ip)); + } - #[test] - fn test_reputation_v6() { - let rep = IpReputation::new(); - let ip = IpAddr::V6(Ipv6Addr::LOCALHOST); - rep.record_bad(ip); - assert_eq!(rep.score(ip), -10); - } + #[test] + fn test_reputation_v6() { + let rep = IpReputation::new(); + let ip = IpAddr::V6(Ipv6Addr::LOCALHOST); + rep.record_bad(ip); + assert_eq!(rep.score(ip), -10); + } - #[test] - fn test_offenders_below_threshold() { - let rep = IpReputation::new(); - let bad = v4([10, 0, 0, 1]); - let good = v4([10, 0, 0, 2]); - for _ in 0..6 { - rep.record_bad(bad); - } - rep.record_good(good); - let offenders = rep.offenders_below(-50); - assert_eq!(offenders, vec![bad]); - } + #[test] + fn test_offenders_below_threshold() { + let rep = IpReputation::new(); + let bad = v4([10, 0, 0, 1]); + let good = v4([10, 0, 0, 2]); + for _ in 0..6 { + rep.record_bad(bad); + } + rep.record_good(good); + let offenders = rep.offenders_below(-50); + assert_eq!(offenders, vec![bad]); + } - #[test] - fn test_offenders_empty_when_none_below() { - let rep = IpReputation::new(); - assert!(rep.offenders_below(-50).is_empty()); - } + #[test] + fn test_offenders_empty_when_none_below() { + let rep = IpReputation::new(); + assert!(rep.offenders_below(-50).is_empty()); + } } diff --git a/src/traffic/prefix/key.rs b/src/traffic/prefix/key.rs index b75c789..5f52866 100644 --- a/src/traffic/prefix/key.rs +++ b/src/traffic/prefix/key.rs @@ -9,83 +9,83 @@ pub const PREFIX_FAMILY_V6: u8 = 6; #[repr(C)] #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] pub struct PrefixKey { - pub family: u8, - pub pad: [u8; 7], - pub addr: [u8; 16], + pub family: u8, + pub pad: [u8; 7], + pub addr: [u8; 16], } impl PrefixKey { - /// Строит ключ префикса для адреса (v4 → /24 в первых 4 байтах, v6 → /64). - #[must_use] - pub fn new(ip: IpAddr) -> Self { - let mut key = Self::default(); - match ip { - IpAddr::V4(v4) => { - key.family = PREFIX_FAMILY_V4; - key.addr[..4].copy_from_slice(&masked_v4(v4).octets()); - }, - IpAddr::V6(v6) => { - key.family = PREFIX_FAMILY_V6; - key.addr.copy_from_slice(&masked_v6_segments(v6)); - }, - } - key - } + /// Строит ключ префикса для адреса (v4 → /24 в первых 4 байтах, v6 → /64). + #[must_use] + pub fn new(ip: IpAddr) -> Self { + let mut key = Self::default(); + match ip { + IpAddr::V4(v4) => { + key.family = PREFIX_FAMILY_V4; + key.addr[..4].copy_from_slice(&masked_v4(v4).octets()); + }, + IpAddr::V6(v6) => { + key.family = PREFIX_FAMILY_V6; + key.addr.copy_from_slice(&masked_v6_segments(v6)); + }, + } + key + } - /// Префикс как IP-адрес (маскированный). - #[must_use] - pub fn to_prefix(self) -> Option { - match self.family { - PREFIX_FAMILY_V4 => Some(IpAddr::V4(Ipv4Addr::new( - self.addr[0], - self.addr[1], - self.addr[2], - self.addr[3], - ))), - PREFIX_FAMILY_V6 => Some(IpAddr::V6(Ipv6Addr::from(self.addr))), - _ => None, - } - } + /// Префикс как IP-адрес (маскированный). + #[must_use] + pub fn to_prefix(self) -> Option { + match self.family { + PREFIX_FAMILY_V4 => Some(IpAddr::V4(Ipv4Addr::new( + self.addr[0], + self.addr[1], + self.addr[2], + self.addr[3], + ))), + PREFIX_FAMILY_V6 => Some(IpAddr::V6(Ipv6Addr::from(self.addr))), + _ => None, + } + } - #[must_use] - pub fn from_bytes(bytes: [u8; 24]) -> Self { - Self { - family: bytes[0], - pad: bytes[1..8].try_into().expect("7 pad bytes"), - addr: bytes[8..24].try_into().expect("16 addr bytes"), - } - } + #[must_use] + pub fn from_bytes(bytes: [u8; 24]) -> Self { + Self { + family: bytes[0], + pad: bytes[1..8].try_into().expect("7 pad bytes"), + addr: bytes[8..24].try_into().expect("16 addr bytes"), + } + } - #[must_use] - pub fn to_bytes(self) -> [u8; 24] { - let mut out = [0u8; 24]; - out[0] = self.family; - out[1..8].copy_from_slice(&self.pad); - out[8..24].copy_from_slice(&self.addr); - out - } + #[must_use] + pub fn to_bytes(self) -> [u8; 24] { + let mut out = [0u8; 24]; + out[0] = self.family; + out[1..8].copy_from_slice(&self.pad); + out[8..24].copy_from_slice(&self.addr); + out + } } /// Возвращает префикс адреса: IPv4 и IPv4-mapped → /24, IPv6 → /64. #[must_use] pub fn prefix_of(ip: IpAddr) -> IpAddr { - match ip { - IpAddr::V4(v4) => IpAddr::V4(masked_v4(v4)), - IpAddr::V6(v6) => match v6.to_ipv4_mapped() { - // ::ffff:a.b.c.d живёт в том же /24-пространстве, что и a.b.c.d. - Some(v4) => IpAddr::V4(masked_v4(v4)), - None => IpAddr::V6(Ipv6Addr::from(masked_v6_segments(v6))), - }, - } + match ip { + IpAddr::V4(v4) => IpAddr::V4(masked_v4(v4)), + IpAddr::V6(v6) => match v6.to_ipv4_mapped() { + // ::ffff:a.b.c.d живёт в том же /24-пространстве, что и a.b.c.d. + Some(v4) => IpAddr::V4(masked_v4(v4)), + None => IpAddr::V6(Ipv6Addr::from(masked_v6_segments(v6))), + }, + } } fn masked_v4(ip: Ipv4Addr) -> Ipv4Addr { - let o = ip.octets(); - Ipv4Addr::new(o[0], o[1], o[2], 0) + let o = ip.octets(); + Ipv4Addr::new(o[0], o[1], o[2], 0) } fn masked_v6_segments(ip: Ipv6Addr) -> [u8; 16] { - let mut segs = ip.octets(); - segs[8..].fill(0); - segs + let mut segs = ip.octets(); + segs[8..].fill(0); + segs } diff --git a/src/traffic/prefix/stats.rs b/src/traffic/prefix/stats.rs index 1c63844..1574e7f 100644 --- a/src/traffic/prefix/stats.rs +++ b/src/traffic/prefix/stats.rs @@ -6,33 +6,33 @@ use std::net::IpAddr; #[repr(C)] #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] pub struct PrefixStatsVal { - pub syn_count: u64, - pub pkt_count: u64, - pub last_seen_ns: u64, + pub syn_count: u64, + pub pkt_count: u64, + pub last_seen_ns: u64, } impl PrefixStatsVal { - /// Разбирает сырые 24 байта значения карты. - #[must_use] - pub fn from_bytes(bytes: [u8; 24]) -> Self { - let read_u64 = - |range: std::ops::Range| u64::from_le_bytes(bytes[range].try_into().expect("8-byte field")); - Self { - syn_count: read_u64(0..8), - pkt_count: read_u64(8..16), - last_seen_ns: read_u64(16..24), - } - } + /// Разбирает сырые 24 байта значения карты. + #[must_use] + pub fn from_bytes(bytes: [u8; 24]) -> Self { + let read_u64 = + |range: std::ops::Range| u64::from_le_bytes(bytes[range].try_into().expect("8-byte field")); + Self { + syn_count: read_u64(0..8), + pkt_count: read_u64(8..16), + last_seen_ns: read_u64(16..24), + } + } - /// Сериализует значение в сырые 24 байта карты. - #[must_use] - pub fn to_bytes(self) -> [u8; 24] { - let mut out = [0u8; 24]; - out[0..8].copy_from_slice(&self.syn_count.to_le_bytes()); - out[8..16].copy_from_slice(&self.pkt_count.to_le_bytes()); - out[16..24].copy_from_slice(&self.last_seen_ns.to_le_bytes()); - out - } + /// Сериализует значение в сырые 24 байта карты. + #[must_use] + pub fn to_bytes(self) -> [u8; 24] { + let mut out = [0u8; 24]; + out[0..8].copy_from_slice(&self.syn_count.to_le_bytes()); + out[8..16].copy_from_slice(&self.pkt_count.to_le_bytes()); + out[16..24].copy_from_slice(&self.last_seen_ns.to_le_bytes()); + out + } } /// Агрегат по одному префиксу за окно детекции. @@ -41,36 +41,36 @@ impl PrefixStatsVal { /// (XDP-путь); spoof-gate в этом случае Block не подтверждает. #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)] pub struct PrefixSnapshot { - pub syn_count: u64, - pub pkt_count: u64, - pub last_seen_ns: u64, - pub unique_sources: u64, + pub syn_count: u64, + pub pkt_count: u64, + pub last_seen_ns: u64, + pub unique_sources: u64, } /// Источник агрегатов по префиксам. Позволяет тестам работать без ядра. pub trait PrefixStatsSource { - /// Снимок агрегатов за текущее окно. - /// - /// # Errors - /// Ошибка чтения источника (карта не загружена, BPF-сбой и т.п.). - fn snapshot(&self) -> impl Future>> + Send; + /// Снимок агрегатов за текущее окно. + /// + /// # Errors + /// Ошибка чтения источника (карта не загружена, BPF-сбой и т.п.). + fn snapshot(&self) -> impl Future>> + Send; } /// Эскалация вердиктов subnet-level детектора. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum SubnetVerdict { - Monitor, - StrictLimit, - Challenge, - Block, + Monitor, + StrictLimit, + Challenge, + Block, } /// Вердикт по одному префиксу. #[derive(Debug, Clone, PartialEq, Eq)] pub struct PrefixVerdict { - pub prefix: IpAddr, - pub verdict: SubnetVerdict, - pub snapshot: PrefixSnapshot, + pub prefix: IpAddr, + pub verdict: SubnetVerdict, + pub snapshot: PrefixSnapshot, } /// Детектор распределённых атак по префиксам. @@ -81,59 +81,59 @@ pub struct PrefixVerdict { /// уникальных IP — защита от ложного бана CGNAT/спуфинга). #[derive(Debug, Clone)] pub struct SubnetDetector { - syn_threshold: u64, - min_unique_sources: u64, + syn_threshold: u64, + min_unique_sources: u64, } impl SubnetDetector { - #[must_use] - pub fn new(syn_threshold: u64, min_unique_sources: u64) -> Self { - Self { - syn_threshold: syn_threshold.max(1), - min_unique_sources, - } - } + #[must_use] + pub fn new(syn_threshold: u64, min_unique_sources: u64) -> Self { + Self { + syn_threshold: syn_threshold.max(1), + min_unique_sources, + } + } - #[must_use] - pub fn from_config(config: &crate::config::DetectPrefixConfig) -> Self { - Self::new(config.syn_threshold, config.min_unique_sources) - } + #[must_use] + pub fn from_config(config: &crate::config::DetectPrefixConfig) -> Self { + Self::new(config.syn_threshold, config.min_unique_sources) + } - /// Оценивает снимок и возвращает вердикты по активным префиксам. - #[must_use] - pub fn evaluate(&self, snapshots: &[(IpAddr, PrefixSnapshot)]) -> Vec { - snapshots - .iter() - .filter(|(_, snap)| snap.syn_count > 0) - .map(|(prefix, snap)| PrefixVerdict { - prefix: *prefix, - verdict: self.verdict_for(snap), - snapshot: *snap, - }) - .collect() - } + /// Оценивает снимок и возвращает вердикты по активным префиксам. + #[must_use] + pub fn evaluate(&self, snapshots: &[(IpAddr, PrefixSnapshot)]) -> Vec { + snapshots + .iter() + .filter(|(_, snap)| snap.syn_count > 0) + .map(|(prefix, snap)| PrefixVerdict { + prefix: *prefix, + verdict: self.verdict_for(snap), + snapshot: *snap, + }) + .collect() + } - #[must_use] - fn verdict_for(&self, snap: &PrefixSnapshot) -> SubnetVerdict { - let t = self.syn_threshold; - if snap.syn_count < t { - return SubnetVerdict::Monitor; - } - if snap.syn_count < t.saturating_mul(2) { - return SubnetVerdict::StrictLimit; - } - let extreme = snap.syn_count >= t.saturating_mul(4); - if extreme && self.spoof_gate_passed(snap) { - return SubnetVerdict::Block; - } - SubnetVerdict::Challenge - } + #[must_use] + fn verdict_for(&self, snap: &PrefixSnapshot) -> SubnetVerdict { + let t = self.syn_threshold; + if snap.syn_count < t { + return SubnetVerdict::Monitor; + } + if snap.syn_count < t.saturating_mul(2) { + return SubnetVerdict::StrictLimit; + } + let extreme = snap.syn_count >= t.saturating_mul(4); + if extreme && self.spoof_gate_passed(snap) { + return SubnetVerdict::Block; + } + SubnetVerdict::Challenge + } - #[must_use] - fn spoof_gate_passed(&self, snap: &PrefixSnapshot) -> bool { - // gate отключён (min_unique_sources == 0) либо подтверждено разнообразие. - self.min_unique_sources == 0 || snap.unique_sources >= self.min_unique_sources - } + #[must_use] + fn spoof_gate_passed(&self, snap: &PrefixSnapshot) -> bool { + // gate отключён (min_unique_sources == 0) либо подтверждено разнообразие. + self.min_unique_sources == 0 || snap.unique_sources >= self.min_unique_sources + } } /// Реализация [`PrefixStatsSource`] поверх XDP-фильтра (feature `xdp`). @@ -141,59 +141,59 @@ impl SubnetDetector { /// поэтому spoof-gate на этом пути Block не подтверждает. #[cfg(feature = "xdp")] pub struct XdpPrefixStats { - filter: std::sync::Arc>, + filter: std::sync::Arc>, } #[cfg(feature = "xdp")] impl XdpPrefixStats { - #[must_use] - pub fn new(filter: std::sync::Arc>) -> Self { - Self { filter } - } + #[must_use] + pub fn new(filter: std::sync::Arc>) -> Self { + Self { filter } + } - /// Блокирует мьютекс фильтра (для kernel-enforcement вердиктов). - /// - /// # Panics - /// Если мьютекс отравлен (паника в другом потоке во время удержания). - pub fn filter_lock(&self) -> std::sync::MutexGuard<'_, crate::xdp::XdpFilter> { - self.filter.lock().expect("xdp lock poisoned") - } + /// Блокирует мьютекс фильтра (для kernel-enforcement вердиктов). + /// + /// # Panics + /// Если мьютекс отравлен (паника в другом потоке во время удержания). + pub fn filter_lock(&self) -> std::sync::MutexGuard<'_, crate::xdp::XdpFilter> { + self.filter.lock().expect("xdp lock poisoned") + } } #[cfg(feature = "xdp")] impl PrefixStatsSource for XdpPrefixStats { - async fn snapshot(&self) -> Result> { - let raw = self.filter_lock().read_prefix_stats()?; - Ok(raw - .into_iter() - .filter_map(|(key, val)| { - let prefix = key.to_prefix()?; - Some(( - prefix, - PrefixSnapshot { - syn_count: val.syn_count, - pkt_count: val.pkt_count, - last_seen_ns: val.last_seen_ns, - unique_sources: 0, - }, - )) - }) - .collect()) - } + async fn snapshot(&self) -> Result> { + let raw = self.filter_lock().read_prefix_stats()?; + Ok(raw + .into_iter() + .filter_map(|(key, val)| { + let prefix = key.to_prefix()?; + Some(( + prefix, + PrefixSnapshot { + syn_count: val.syn_count, + pkt_count: val.pkt_count, + last_seen_ns: val.last_seen_ns, + unique_sources: 0, + }, + )) + }) + .collect()) + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn stats_val_roundtrip() { - let val = PrefixStatsVal { - syn_count: 42, - pkt_count: 100, - last_seen_ns: 1_234_567_890, - }; - assert_eq!(PrefixStatsVal::from_bytes(val.to_bytes()), val); - assert_eq!(size_of::(), 24); - } + #[test] + fn stats_val_roundtrip() { + let val = PrefixStatsVal { + syn_count: 42, + pkt_count: 100, + last_seen_ns: 1_234_567_890, + }; + assert_eq!(PrefixStatsVal::from_bytes(val.to_bytes()), val); + assert_eq!(size_of::(), 24); + } } diff --git a/src/traffic/profile/alert.rs b/src/traffic/profile/alert.rs index 221c7c5..3b73d2f 100644 --- a/src/traffic/profile/alert.rs +++ b/src/traffic/profile/alert.rs @@ -7,53 +7,53 @@ use crate::traffic::detector::AttackStatus; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum AlertLevel { - Info, - Warning, - Critical, + Info, + Warning, + Critical, } impl fmt::Display for AlertLevel { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match self { - AlertLevel::Info => write!(f, "INFO"), - AlertLevel::Warning => write!(f, "WARNING"), - AlertLevel::Critical => write!(f, "CRITICAL"), - } - } + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match self { + AlertLevel::Info => write!(f, "INFO"), + AlertLevel::Warning => write!(f, "WARNING"), + AlertLevel::Critical => write!(f, "CRITICAL"), + } + } } #[derive(Debug, Clone, PartialEq)] pub struct Alert { - pub level: AlertLevel, - pub message: String, - pub ip: Option, - pub pps: f64, - pub timestamp: Instant, + pub level: AlertLevel, + pub message: String, + pub ip: Option, + pub pps: f64, + pub timestamp: Instant, } impl Alert { - pub fn new(level: AlertLevel, message: String, ip: Option, pps: f64) -> Self { - Self { - level, - message, - ip, - pps, - timestamp: Instant::now(), - } - } + pub fn new(level: AlertLevel, message: String, ip: Option, pps: f64) -> Self { + Self { + level, + message, + ip, + pps, + timestamp: Instant::now(), + } + } } impl fmt::Display for Alert { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - match &self.ip { - Some(ip) => write!( - f, - "[{}] {} | IP: {} | PPS: {:.2}", - self.level, self.message, ip, self.pps - ), - None => write!(f, "[{}] {} | PPS: {:.2}", self.level, self.message, self.pps), - } - } + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + match &self.ip { + Some(ip) => write!( + f, + "[{}] {} | IP: {} | PPS: {:.2}", + self.level, self.message, ip, self.pps + ), + None => write!(f, "[{}] {} | PPS: {:.2}", self.level, self.message, self.pps), + } + } } /// Дедуплицирующий диспетчер алертов: алерт выдаётся только на переходе @@ -61,109 +61,109 @@ impl fmt::Display for Alert { /// тике. Логика — poll-and-persist (LNVPS issue #331). #[derive(Default)] pub struct AlertDispatcher { - previous: Mutex>, + previous: Mutex>, } impl AlertDispatcher { - pub fn new() -> Self { - Self::default() - } + pub fn new() -> Self { + Self::default() + } - /// Возвращает `Some(Alert)` только при переходе через границу атаки: - /// вход в `UnderAttack` («attack started») или выход из него - /// («attack ended»). Первое наблюдение алерта не порождает. - pub fn on_status(&self, status: AttackStatus) -> Option { - let mut previous = self.previous.lock().expect("alert dispatcher lock poisoned"); - if *previous == Some(status) { - return None; - } - let was_under_attack = *previous == Some(AttackStatus::UnderAttack); - *previous = Some(status); - match (was_under_attack, status) { - (false, AttackStatus::UnderAttack) => { - Some(Alert::new(AlertLevel::Critical, "attack started".into(), None, 0.0)) - }, - (true, _) => Some(Alert::new(AlertLevel::Info, "attack ended".into(), None, 0.0)), - _ => None, - } - } + /// Возвращает `Some(Alert)` только при переходе через границу атаки: + /// вход в `UnderAttack` («attack started») или выход из него + /// («attack ended»). Первое наблюдение алерта не порождает. + pub fn on_status(&self, status: AttackStatus) -> Option { + let mut previous = self.previous.lock().expect("alert dispatcher lock poisoned"); + if *previous == Some(status) { + return None; + } + let was_under_attack = *previous == Some(AttackStatus::UnderAttack); + *previous = Some(status); + match (was_under_attack, status) { + (false, AttackStatus::UnderAttack) => { + Some(Alert::new(AlertLevel::Critical, "attack started".into(), None, 0.0)) + }, + (true, _) => Some(Alert::new(AlertLevel::Info, "attack ended".into(), None, 0.0)), + _ => None, + } + } } /// Отправляет алерт на webhook (fire-and-forget, с таймаутом). /// /// Вызывать следует из фоновых задач: сетевой ввод-вывод недопустим в hot path. pub async fn send_webhook(url: String, alert: Alert) { - let payload = serde_json::json!({ - "level": alert.level.to_string(), - "message": alert.message, - "pps": alert.pps, - }); - let client = reqwest::Client::builder().timeout(Duration::from_secs(5)).build(); - let client = match client { - Ok(c) => c, - Err(e) => { - tracing::warn!("webhook client build failed: {e}"); - return; - }, - }; - if let Err(e) = client.post(url).json(&payload).send().await { - tracing::warn!("webhook delivery failed: {e}"); - } + let payload = serde_json::json!({ + "level": alert.level.to_string(), + "message": alert.message, + "pps": alert.pps, + }); + let client = reqwest::Client::builder().timeout(Duration::from_secs(5)).build(); + let client = match client { + Ok(c) => c, + Err(e) => { + tracing::warn!("webhook client build failed: {e}"); + return; + }, + }; + if let Err(e) = client.post(url).json(&payload).send().await { + tracing::warn!("webhook delivery failed: {e}"); + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn test_alert_display_with_ip() { - let alert = Alert::new( - AlertLevel::Critical, - "possible attack".into(), - Some(Ipv4Addr::new(192, 168, 1, 1)), - 100500.0, - ); - let s = alert.to_string(); - assert!(s.contains("CRITICAL")); - assert!(s.contains("192.168.1.1")); - } + #[test] + fn test_alert_display_with_ip() { + let alert = Alert::new( + AlertLevel::Critical, + "possible attack".into(), + Some(Ipv4Addr::new(192, 168, 1, 1)), + 100500.0, + ); + let s = alert.to_string(); + assert!(s.contains("CRITICAL")); + assert!(s.contains("192.168.1.1")); + } - #[test] - fn test_alert_display_without_ip() { - let alert = Alert::new(AlertLevel::Info, "traffic spike".into(), None, 5000.0); - let s = alert.to_string(); - assert!(s.contains("INFO")); - assert!(s.contains("traffic spike")); - } + #[test] + fn test_alert_display_without_ip() { + let alert = Alert::new(AlertLevel::Info, "traffic spike".into(), None, 5000.0); + let s = alert.to_string(); + assert!(s.contains("INFO")); + assert!(s.contains("traffic spike")); + } - #[test] - fn test_dispatcher_two_transitions_two_alerts() { - let dispatcher = AlertDispatcher::new(); - assert_eq!(dispatcher.on_status(AttackStatus::Normal), None); - assert_eq!(dispatcher.on_status(AttackStatus::Suspicious), None); - let started = dispatcher.on_status(AttackStatus::UnderAttack); - assert_eq!(dispatcher.on_status(AttackStatus::UnderAttack), None); - assert_eq!(dispatcher.on_status(AttackStatus::UnderAttack), None); - let ended = dispatcher.on_status(AttackStatus::Normal); - assert_eq!(dispatcher.on_status(AttackStatus::Normal), None); - assert!(started.is_some()); - assert!(ended.is_some()); - assert!( - started.expect("started alert").message.contains("attack started") - && ended.expect("ended alert").message.contains("attack ended") - ); - } + #[test] + fn test_dispatcher_two_transitions_two_alerts() { + let dispatcher = AlertDispatcher::new(); + assert_eq!(dispatcher.on_status(AttackStatus::Normal), None); + assert_eq!(dispatcher.on_status(AttackStatus::Suspicious), None); + let started = dispatcher.on_status(AttackStatus::UnderAttack); + assert_eq!(dispatcher.on_status(AttackStatus::UnderAttack), None); + assert_eq!(dispatcher.on_status(AttackStatus::UnderAttack), None); + let ended = dispatcher.on_status(AttackStatus::Normal); + assert_eq!(dispatcher.on_status(AttackStatus::Normal), None); + assert!(started.is_some()); + assert!(ended.is_some()); + assert!( + started.expect("started alert").message.contains("attack started") + && ended.expect("ended alert").message.contains("attack ended") + ); + } - #[test] - fn test_dispatcher_suspicious_does_not_flap_alerts() { - let dispatcher = AlertDispatcher::new(); - for status in [ - AttackStatus::Normal, - AttackStatus::Suspicious, - AttackStatus::Normal, - AttackStatus::Suspicious, - ] { - assert_eq!(dispatcher.on_status(status), None); - } - } + #[test] + fn test_dispatcher_suspicious_does_not_flap_alerts() { + let dispatcher = AlertDispatcher::new(); + for status in [ + AttackStatus::Normal, + AttackStatus::Suspicious, + AttackStatus::Normal, + AttackStatus::Suspicious, + ] { + assert_eq!(dispatcher.on_status(status), None); + } + } } diff --git a/src/traffic/profile/profiler.rs b/src/traffic/profile/profiler.rs index 3da2c58..64d5697 100644 --- a/src/traffic/profile/profiler.rs +++ b/src/traffic/profile/profiler.rs @@ -2,84 +2,84 @@ use crate::traffic::ewma::Ewma; use std::time::Instant; pub struct TrafficProfiler { - slots: [Ewma; 168], - current_slot: usize, - epoch: Instant, + slots: [Ewma; 168], + current_slot: usize, + epoch: Instant, } impl Default for TrafficProfiler { - fn default() -> Self { - Self::new() - } + fn default() -> Self { + Self::new() + } } impl TrafficProfiler { - pub fn new() -> Self { - Self { - slots: std::array::from_fn(|_| Ewma::new(0.125)), - current_slot: 0, - epoch: Instant::now(), - } - } + pub fn new() -> Self { + Self { + slots: std::array::from_fn(|_| Ewma::new(0.125)), + current_slot: 0, + epoch: Instant::now(), + } + } - fn slot_index(&self) -> usize { - (self.epoch.elapsed().as_secs() / 3600) as usize % 168 - } + fn slot_index(&self) -> usize { + (self.epoch.elapsed().as_secs() / 3600) as usize % 168 + } - pub fn record(&mut self, pps: f64) { - self.current_slot = self.slot_index(); - self.slots[self.current_slot].update(pps); - } + pub fn record(&mut self, pps: f64) { + self.current_slot = self.slot_index(); + self.slots[self.current_slot].update(pps); + } - pub fn baseline(&self) -> f64 { - self.slots[self.slot_index()].value() - } + pub fn baseline(&self) -> f64 { + self.slots[self.slot_index()].value() + } - pub fn anomaly_score(&self, pps: f64) -> f64 { - let base = self.baseline(); - if base <= 0.0 { - return 0.0; - } - (pps / base).min(10.0) - } + pub fn anomaly_score(&self, pps: f64) -> f64 { + let base = self.baseline(); + if base <= 0.0 { + return 0.0; + } + (pps / base).min(10.0) + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn test_profiler_record_and_baseline() { - let mut p = TrafficProfiler::new(); - p.record(1000.0); - p.record(1100.0); - let base = p.baseline(); - assert!(base > 0.0); - } + #[test] + fn test_profiler_record_and_baseline() { + let mut p = TrafficProfiler::new(); + p.record(1000.0); + p.record(1100.0); + let base = p.baseline(); + assert!(base > 0.0); + } - #[test] - fn test_anomaly_score_normal() { - let mut p = TrafficProfiler::new(); - for _ in 0..10 { - p.record(100.0); - } - let score = p.anomaly_score(100.0); - assert!(score < 2.0); - } + #[test] + fn test_anomaly_score_normal() { + let mut p = TrafficProfiler::new(); + for _ in 0..10 { + p.record(100.0); + } + let score = p.anomaly_score(100.0); + assert!(score < 2.0); + } - #[test] - fn test_anomaly_score_capped() { - let mut p = TrafficProfiler::new(); - for _ in 0..10 { - p.record(1.0); - } - let score = p.anomaly_score(1_000_000.0); - assert!((score - 10.0).abs() < 0.001); - } + #[test] + fn test_anomaly_score_capped() { + let mut p = TrafficProfiler::new(); + for _ in 0..10 { + p.record(1.0); + } + let score = p.anomaly_score(1_000_000.0); + assert!((score - 10.0).abs() < 0.001); + } - #[test] - fn test_anomaly_score_zero_baseline() { - let p = TrafficProfiler::new(); - assert_eq!(p.anomaly_score(100.0), 0.0); - } + #[test] + fn test_anomaly_score_zero_baseline() { + let p = TrafficProfiler::new(); + assert_eq!(p.anomaly_score(100.0), 0.0); + } } diff --git a/src/tui/app.rs b/src/tui/app.rs index 968dd2d..0ce99f9 100644 --- a/src/tui/app.rs +++ b/src/tui/app.rs @@ -13,42 +13,42 @@ use crate::tui::ui; /// Управляемые пользователем команды (клавиши). #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Command { - Quit, - Refresh, + Quit, + Refresh, } /// Маппинг клавиш: `q`/`Esc` — выход, `r` — обновить немедленно. #[must_use] pub fn handle_key(code: crossterm::event::KeyCode) -> Option { - match code { - crossterm::event::KeyCode::Char('q') | crossterm::event::KeyCode::Esc => Some(Command::Quit), - crossterm::event::KeyCode::Char('r') => Some(Command::Refresh), - _ => None, - } + match code { + crossterm::event::KeyCode::Char('q') | crossterm::event::KeyCode::Esc => Some(Command::Quit), + crossterm::event::KeyCode::Char('r') => Some(Command::Refresh), + _ => None, + } } /// Приводит результат fetch к виду для [`AppState::apply_fetch`]. pub fn normalize(result: Result) -> Result { - match result { - Ok(body) => Ok(parse(&body)), - Err(FetchError::Network(message)) => Err(message), - Err(FetchError::Status(status)) => Err(format!("http status {status}")), - } + match result { + Ok(body) => Ok(parse(&body)), + Err(FetchError::Network(message)) => Err(message), + Err(FetchError::Status(status)) => Err(format!("http status {status}")), + } } /// Фоновая задача: fetch → [`AppState`]. Ошибки сети пишутся в снапшот баннером. pub async fn spawn_fetch_loop(fetcher: Arc, state: Arc, refresh: Duration, notify: Arc) { - loop { - let started = std::time::Instant::now(); - let result = normalize(fetcher.fetch().await); - let elapsed_secs = started.elapsed().as_secs_f64(); - state.apply_fetch(result, elapsed_secs); + loop { + let started = std::time::Instant::now(); + let result = normalize(fetcher.fetch().await); + let elapsed_secs = started.elapsed().as_secs_f64(); + state.apply_fetch(result, elapsed_secs); - tokio::select! { - () = tokio::time::sleep(refresh) => {}, - () = notify.notified() => {}, - } - } + tokio::select! { + () = tokio::time::sleep(refresh) => {}, + () = notify.notified() => {}, + } + } } /// UI-цикл: рисует кадр каждые ~100 мс, обрабатывает клавиши. @@ -56,31 +56,31 @@ pub async fn spawn_fetch_loop(fetcher: Arc, state: Arc, r /// # Errors /// Возвращает ошибку терминала (draw/poll) — вызывающий восстанавливает TTY. pub async fn run_ui( - terminal: &mut ratatui::Terminal>, - state: Arc, - notify: Arc, + terminal: &mut ratatui::Terminal>, + state: Arc, + notify: Arc, ) -> std::io::Result<()> { - loop { - terminal.draw(|frame| ui::render(frame, &state.frame_data()))?; - if let Some(command) = poll_command(Duration::from_millis(100))? { - match command { - Command::Quit => return Ok(()), - Command::Refresh => notify.notify_one(), - } - } - } + loop { + terminal.draw(|frame| ui::render(frame, &state.frame_data()))?; + if let Some(command) = poll_command(Duration::from_millis(100))? { + match command { + Command::Quit => return Ok(()), + Command::Refresh => notify.notify_one(), + } + } + } } /// Неблокирующее ожидание клавиши в течение `timeout`. fn poll_command(timeout: Duration) -> std::io::Result> { - if !crossterm::event::poll(timeout)? { - return Ok(None); - } - if let crossterm::event::Event::Key(key) = crossterm::event::read()? { - // Реагируем только на нажатие (не автоповтор/отпускание). - if key.kind == crossterm::event::KeyEventKind::Press { - return Ok(handle_key(key.code)); - } - } - Ok(None) + if !crossterm::event::poll(timeout)? { + return Ok(None); + } + if let crossterm::event::Event::Key(key) = crossterm::event::read()? { + // Реагируем только на нажатие (не автоповтор/отпускание). + if key.kind == crossterm::event::KeyEventKind::Press { + return Ok(handle_key(key.code)); + } + } + Ok(None) } diff --git a/src/tui/metrics/fetch.rs b/src/tui/metrics/fetch.rs index 4bac643..38d939e 100644 --- a/src/tui/metrics/fetch.rs +++ b/src/tui/metrics/fetch.rs @@ -8,58 +8,58 @@ use thiserror::Error; /// Ошибка загрузки метрик. #[derive(Debug, Error, Clone)] pub enum FetchError { - /// Сетевая ошибка / DNS / таймаут. - #[error("network error: {0}")] - Network(String), - /// Endpoint ответил не-200 статусом. - #[error("http status {0}")] - Status(u16), + /// Сетевая ошибка / DNS / таймаут. + #[error("network error: {0}")] + Network(String), + /// Endpoint ответил не-200 статусом. + #[error("http status {0}")] + Status(u16), } /// Абстракция источника exposition-текста Prometheus. pub trait Fetcher: Send + Sync { - /// Загружает текущий срез метрик. - /// - /// # Errors - /// Возвращает [`FetchError`] при сетевом сбое или плохом HTTP-статусе. - fn fetch(&self) -> BoxFuture<'_, Result>; + /// Загружает текущий срез метрик. + /// + /// # Errors + /// Возвращает [`FetchError`] при сетевом сбое или плохом HTTP-статусе. + fn fetch(&self) -> BoxFuture<'_, Result>; } /// Реализация [`Fetcher`] поверх reqwest GET. pub struct HttpFetcher { - url: String, - client: reqwest::Client, + url: String, + client: reqwest::Client, } impl HttpFetcher { - /// Создаёт fetcher с таймаутом запроса 5 секунд. - pub fn new(url: impl Into) -> Option { - let client = reqwest::Client::builder() - .timeout(Duration::from_secs(5)) - .build() - .ok()?; - Some(Self { - url: url.into(), - client, - }) - } + /// Создаёт fetcher с таймаутом запроса 5 секунд. + pub fn new(url: impl Into) -> Option { + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(5)) + .build() + .ok()?; + Some(Self { + url: url.into(), + client, + }) + } } impl Fetcher for HttpFetcher { - fn fetch(&self) -> BoxFuture<'_, Result> { - let url = self.url.clone(); - let client = self.client.clone(); - Box::pin(async move { - let response = client - .get(&url) - .send() - .await - .map_err(|e| FetchError::Network(e.to_string()))?; - let status = response.status(); - if !status.is_success() { - return Err(FetchError::Status(status.as_u16())); - } - response.text().await.map_err(|e| FetchError::Network(e.to_string())) - }) - } + fn fetch(&self) -> BoxFuture<'_, Result> { + let url = self.url.clone(); + let client = self.client.clone(); + Box::pin(async move { + let response = client + .get(&url) + .send() + .await + .map_err(|e| FetchError::Network(e.to_string()))?; + let status = response.status(); + if !status.is_success() { + return Err(FetchError::Status(status.as_u16())); + } + response.text().await.map_err(|e| FetchError::Network(e.to_string())) + }) + } } diff --git a/src/tui/metrics/prometheus.rs b/src/tui/metrics/prometheus.rs index 6fe62c0..52f5ed5 100644 --- a/src/tui/metrics/prometheus.rs +++ b/src/tui/metrics/prometheus.rs @@ -9,39 +9,39 @@ use std::collections::BTreeMap; /// Один сэмпл из exposition-формата Prometheus. #[derive(Debug, Clone, PartialEq)] pub struct MetricSample { - pub name: String, - pub labels: BTreeMap, - pub value: f64, + pub name: String, + pub labels: BTreeMap, + pub value: f64, } /// Набор сэмплов одного ответа `/metrics`. #[derive(Debug, Default, Clone, PartialEq)] pub struct MetricSet { - samples: Vec, + samples: Vec, } impl MetricSet { - /// Сумма значений всех серий с данным именем (для counter/gauge vec). - /// Отсутствующая метрика даёт `0.0`. - #[must_use] - pub fn sum(&self, name: &str) -> f64 { - self.samples.iter().filter(|s| s.name == name).map(|s| s.value).sum() - } + /// Сумма значений всех серий с данным именем (для counter/gauge vec). + /// Отсутствующая метрика даёт `0.0`. + #[must_use] + pub fn sum(&self, name: &str) -> f64 { + self.samples.iter().filter(|s| s.name == name).map(|s| s.value).sum() + } - /// Значение серии с именем и одной меткой; `None`, если не найдено. - #[must_use] - pub fn labeled(&self, name: &str, label: &str, value: &str) -> Option { - self.samples - .iter() - .find(|s| s.name == name && s.labels.get(label).map(String::as_str) == Some(value)) - .map(|s| s.value) - } + /// Значение серии с именем и одной меткой; `None`, если не найдено. + #[must_use] + pub fn labeled(&self, name: &str, label: &str, value: &str) -> Option { + self.samples + .iter() + .find(|s| s.name == name && s.labels.get(label).map(String::as_str) == Some(value)) + .map(|s| s.value) + } - /// Все сэмплы (для тестов и отладки). - #[must_use] - pub fn samples(&self) -> &[MetricSample] { - &self.samples - } + /// Все сэмплы (для тестов и отладки). + #[must_use] + pub fn samples(&self) -> &[MetricSample] { + &self.samples + } } /// Парсит тело ответа `/metrics`. @@ -50,189 +50,189 @@ impl MetricSet { /// повреждён — TUI не должен падать на этом). #[must_use] pub fn parse(input: &str) -> MetricSet { - let mut samples = Vec::new(); - for line in input.lines() { - if let Some(sample) = parse_line(line) { - samples.push(sample); - } - } - MetricSet { samples } + let mut samples = Vec::new(); + for line in input.lines() { + if let Some(sample) = parse_line(line) { + samples.push(sample); + } + } + MetricSet { samples } } fn parse_line(line: &str) -> Option { - let line = line.trim(); - if line.is_empty() || line.starts_with('#') { - return None; - } - // Формат: metric[{labels}] value [timestamp]; значения меток могут - // содержать пробелы, поэтому голову отрезаем с учётом кавычек. - let (head, rest) = split_head_and_rest(line); - let value_str = rest.split_whitespace().next()?; - // Timestamp после value игнорируем. + let line = line.trim(); + if line.is_empty() || line.starts_with('#') { + return None; + } + // Формат: metric[{labels}] value [timestamp]; значения меток могут + // содержать пробелы, поэтому голову отрезаем с учётом кавычек. + let (head, rest) = split_head_and_rest(line); + let value_str = rest.split_whitespace().next()?; + // Timestamp после value игнорируем. - let (name, labels) = split_metric(head)?; - let value = parse_value(value_str)?; - Some(MetricSample { name, labels, value }) + let (name, labels) = split_metric(head)?; + let value = parse_value(value_str)?; + Some(MetricSample { name, labels, value }) } /// Отделяет `metric{...}` от хвоста `value [timestamp]`. fn split_head_and_rest(line: &str) -> (&str, &str) { - let Some(open) = line.find('{') else { - return match line.find(char::is_whitespace) { - Some(space) => (&line[..space], &line[space..]), - None => (line, ""), - }; - }; - match find_closing_brace(line, open + 1) { - Some(close) => (&line[..=close], &line[close + 1..]), - None => match line.find(char::is_whitespace) { - Some(space) => (&line[..space.min(open)], &line[space.min(open)..]), - None => (line, ""), - }, - } + let Some(open) = line.find('{') else { + return match line.find(char::is_whitespace) { + Some(space) => (&line[..space], &line[space..]), + None => (line, ""), + }; + }; + match find_closing_brace(line, open + 1) { + Some(close) => (&line[..=close], &line[close + 1..]), + None => match line.find(char::is_whitespace) { + Some(space) => (&line[..space.min(open)], &line[space.min(open)..]), + None => (line, ""), + }, + } } /// Индекс `}` вне кавычек, начиная с позиции `from`. fn find_closing_brace(line: &str, from: usize) -> Option { - let mut in_quotes = false; - let mut escaped = false; - for (idx, ch) in line[from..].char_indices() { - match ch { - '\\' if in_quotes => escaped = !escaped, - '"' if !escaped => in_quotes = !in_quotes, - '}' if !in_quotes => return Some(from + idx), - _ => {}, - } - if ch != '\\' { - escaped = false; - } - } - None + let mut in_quotes = false; + let mut escaped = false; + for (idx, ch) in line[from..].char_indices() { + match ch { + '\\' if in_quotes => escaped = !escaped, + '"' if !escaped => in_quotes = !in_quotes, + '}' if !in_quotes => return Some(from + idx), + _ => {}, + } + if ch != '\\' { + escaped = false; + } + } + None } fn split_metric(head: &str) -> Option<(String, BTreeMap)> { - match head.find('{') { - None => Some((head.to_owned(), BTreeMap::new())), - Some(open) => { - if !head.ends_with('}') || open == 0 { - return None; - } - let name = head[..open].trim().to_owned(); - let inner = &head[open + 1..head.len() - 1]; - Some((name, parse_labels(inner))) - }, - } + match head.find('{') { + None => Some((head.to_owned(), BTreeMap::new())), + Some(open) => { + if !head.ends_with('}') || open == 0 { + return None; + } + let name = head[..open].trim().to_owned(); + let inner = &head[open + 1..head.len() - 1]; + Some((name, parse_labels(inner))) + }, + } } fn parse_labels(inner: &str) -> BTreeMap { - let mut labels = BTreeMap::new(); - for pair in split_label_pairs(inner) { - if let Some(eq) = pair.find('=') { - let key = pair[..eq].trim(); - let raw_value = pair[eq + 1..].trim(); - if let Some(unquoted) = raw_value.strip_prefix('"').and_then(|v| v.strip_suffix('"')) { - labels.insert(key.to_owned(), unescape_label(unquoted)); - } - } - } - labels + let mut labels = BTreeMap::new(); + for pair in split_label_pairs(inner) { + if let Some(eq) = pair.find('=') { + let key = pair[..eq].trim(); + let raw_value = pair[eq + 1..].trim(); + if let Some(unquoted) = raw_value.strip_prefix('"').and_then(|v| v.strip_suffix('"')) { + labels.insert(key.to_owned(), unescape_label(unquoted)); + } + } + } + labels } /// Разбивает `a="1", b="2"` по запятым вне кавычек. fn split_label_pairs(inner: &str) -> Vec<&str> { - let mut parts = Vec::new(); - let mut in_quotes = false; - let mut escaped = false; - let mut start = 0; - for (idx, ch) in inner.char_indices() { - match ch { - '\\' if in_quotes => escaped = !escaped, - '"' if !escaped => in_quotes = !in_quotes, - ',' if !in_quotes => { - parts.push(&inner[start..idx]); - start = idx + 1; - }, - _ => {}, - } - if ch != '\\' { - escaped = false; - } - } - parts.push(&inner[start..]); - parts + let mut parts = Vec::new(); + let mut in_quotes = false; + let mut escaped = false; + let mut start = 0; + for (idx, ch) in inner.char_indices() { + match ch { + '\\' if in_quotes => escaped = !escaped, + '"' if !escaped => in_quotes = !in_quotes, + ',' if !in_quotes => { + parts.push(&inner[start..idx]); + start = idx + 1; + }, + _ => {}, + } + if ch != '\\' { + escaped = false; + } + } + parts.push(&inner[start..]); + parts } fn unescape_label(value: &str) -> String { - let mut out = String::with_capacity(value.len()); - let mut chars = value.chars(); - while let Some(ch) = chars.next() { - if ch == '\\' { - match chars.next() { - Some('n') => out.push('\n'), - Some(next) => out.push(next), - None => {}, - } - } else { - out.push(ch); - } - } - out + let mut out = String::with_capacity(value.len()); + let mut chars = value.chars(); + while let Some(ch) = chars.next() { + if ch == '\\' { + match chars.next() { + Some('n') => out.push('\n'), + Some(next) => out.push(next), + None => {}, + } + } else { + out.push(ch); + } + } + out } fn parse_value(value: &str) -> Option { - match value { - "+Inf" | "Inf" => Some(f64::INFINITY), - "-Inf" => Some(f64::NEG_INFINITY), - "NaN" => Some(f64::NAN), - v => v.parse::().ok(), - } + match value { + "+Inf" | "Inf" => Some(f64::INFINITY), + "-Inf" => Some(f64::NEG_INFINITY), + "NaN" => Some(f64::NAN), + v => v.parse::().ok(), + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn parses_simple_and_labeled_lines() { - let set = parse("up 1\nxdp_total{iface=\"eth0\"} 42\n"); - assert_eq!(set.sum("up"), 1.0); - assert_eq!(set.labeled("xdp_total", "iface", "eth0"), Some(42.0)); - } + #[test] + fn parses_simple_and_labeled_lines() { + let set = parse("up 1\nxdp_total{iface=\"eth0\"} 42\n"); + assert_eq!(set.sum("up"), 1.0); + assert_eq!(set.labeled("xdp_total", "iface", "eth0"), Some(42.0)); + } - #[test] - fn skips_comments_help_type_and_empty_lines() { - let input = "# HELP rampart_xdp_total Total\n# TYPE rampart_xdp_total gauge\n\nrampart_xdp_total 7\n"; - let set = parse(input); - assert_eq!(set.samples().len(), 1); - assert_eq!(set.sum("rampart_xdp_total"), 7.0); - } + #[test] + fn skips_comments_help_type_and_empty_lines() { + let input = "# HELP rampart_xdp_total Total\n# TYPE rampart_xdp_total gauge\n\nrampart_xdp_total 7\n"; + let set = parse(input); + assert_eq!(set.samples().len(), 1); + assert_eq!(set.sum("rampart_xdp_total"), 7.0); + } - #[test] - fn ignores_timestamp_and_special_values() { - let set = parse("m1 10 1700000000000\nm2 +Inf\nm3 NaN\nbroken_line_no_value\nbad{} \nm4 -2.5e3\n"); - assert_eq!(set.sum("m1"), 10.0); - assert_eq!(set.sum("m2"), f64::INFINITY); - assert!(set.labeled("m3", "x", "y").is_none()); - assert_eq!(set.sum("m4"), -2500.0); - } + #[test] + fn ignores_timestamp_and_special_values() { + let set = parse("m1 10 1700000000000\nm2 +Inf\nm3 NaN\nbroken_line_no_value\nbad{} \nm4 -2.5e3\n"); + assert_eq!(set.sum("m1"), 10.0); + assert_eq!(set.sum("m2"), f64::INFINITY); + assert!(set.labeled("m3", "x", "y").is_none()); + assert_eq!(set.sum("m4"), -2500.0); + } - #[test] - fn sums_series_with_same_name() { - let input = "bans{reason=\"cps\"} 3\nbans{reason=\"syn\"} 4\nbans 5\n"; - assert_eq!(parse(input).sum("bans"), 12.0); - } + #[test] + fn sums_series_with_same_name() { + let input = "bans{reason=\"cps\"} 3\nbans{reason=\"syn\"} 4\nbans 5\n"; + assert_eq!(parse(input).sum("bans"), 12.0); + } - #[test] - fn handles_spaces_in_label_values() { - let set = parse("m{k=\"a b\", j=\"v w\"} 1\n"); - assert_eq!(set.labeled("m", "k", "a b"), Some(1.0)); - assert_eq!(set.labeled("m", "j", "v w"), Some(1.0)); - } + #[test] + fn handles_spaces_in_label_values() { + let set = parse("m{k=\"a b\", j=\"v w\"} 1\n"); + assert_eq!(set.labeled("m", "k", "a b"), Some(1.0)); + assert_eq!(set.labeled("m", "j", "v w"), Some(1.0)); + } - #[test] - fn handles_escaped_quotes_and_backslashes_in_labels() { - let set = parse("m{q=\"a\\\"b\", s=\"c\\\\d\"} 1\n"); - assert_eq!(set.labeled("m", "q", "a\"b"), Some(1.0)); - assert_eq!(set.labeled("m", "s", "c\\d"), Some(1.0)); - } + #[test] + fn handles_escaped_quotes_and_backslashes_in_labels() { + let set = parse("m{q=\"a\\\"b\", s=\"c\\\\d\"} 1\n"); + assert_eq!(set.labeled("m", "q", "a\"b"), Some(1.0)); + assert_eq!(set.labeled("m", "s", "c\\d"), Some(1.0)); + } } diff --git a/src/tui/state.rs b/src/tui/state.rs index 4410d12..70b5cfa 100644 --- a/src/tui/state.rs +++ b/src/tui/state.rs @@ -12,142 +12,142 @@ pub const HISTORY_CAPACITY: usize = 120; /// Один сэмпл истории (значения — rates, единиц/сек). #[derive(Debug, Clone, Copy, PartialEq)] pub struct HistoryPoint { - pub packets_per_sec: f64, - pub drops_per_sec: f64, + pub packets_per_sec: f64, + pub drops_per_sec: f64, } /// Скользящее окно истории фиксированной ёмкости. #[derive(Debug, Clone)] pub struct History { - points: VecDeque, + points: VecDeque, } impl Default for History { - fn default() -> Self { - Self { - points: VecDeque::with_capacity(HISTORY_CAPACITY), - } - } + fn default() -> Self { + Self { + points: VecDeque::with_capacity(HISTORY_CAPACITY), + } + } } impl History { - /// Добавляет точку, вытесняя старейшую при переполнении окна. - pub fn push(&mut self, point: HistoryPoint) { - if self.points.len() == HISTORY_CAPACITY { - self.points.pop_front(); - } - self.points.push_back(point); - } + /// Добавляет точку, вытесняя старейшую при переполнении окна. + pub fn push(&mut self, point: HistoryPoint) { + if self.points.len() == HISTORY_CAPACITY { + self.points.pop_front(); + } + self.points.push_back(point); + } - /// Точки в хронологическом порядке. - #[must_use] - pub fn points(&self) -> &VecDeque { - &self.points - } + /// Точки в хронологическом порядке. + #[must_use] + pub fn points(&self) -> &VecDeque { + &self.points + } } /// Состояние приложения, общее между fetch-потоком и UI-циклом. #[derive(Debug)] pub struct AppState { - url: String, - snapshot: Mutex, - history: Mutex, - started_at: Instant, + url: String, + snapshot: Mutex, + history: Mutex, + started_at: Instant, } impl AppState { - /// Создаёт состояние с URL источника метрик (для статус-панели). - #[must_use] - pub fn new(url: impl Into) -> Self { - Self { - url: url.into(), - snapshot: Mutex::new(Snapshot::default()), - history: Mutex::new(History::default()), - started_at: Instant::now(), - } - } + /// Создаёт состояние с URL источника метрик (для статус-панели). + #[must_use] + pub fn new(url: impl Into) -> Self { + Self { + url: url.into(), + snapshot: Mutex::new(Snapshot::default()), + history: Mutex::new(History::default()), + started_at: Instant::now(), + } + } - /// URL источника метрик. - #[must_use] - pub fn url(&self) -> &str { - &self.url - } + /// URL источника метрик. + #[must_use] + pub fn url(&self) -> &str { + &self.url + } } /// Последний успешный/неуспешный результат fetch. #[derive(Debug, Default, Clone)] pub struct Snapshot { - pub metrics: Option, - pub fetched_at: Option, - pub error: Option, + pub metrics: Option, + pub fetched_at: Option, + pub error: Option, } impl AppState { - /// Записывает результат очередного fetch и обновляет историю rate. - pub fn apply_fetch(&self, result: Result, elapsed_secs: f64) { - let mut snapshot = match self.snapshot.lock() { - Ok(guard) => guard, - Err(poisoned) => poisoned.into_inner(), - }; - match result { - Ok(metrics) => { - let mut history = match self.history.lock() { - Ok(guard) => guard, - Err(poisoned) => poisoned.into_inner(), - }; - let previous = snapshot.metrics.take(); - let point = HistoryPoint { - packets_per_sec: counter_rate( - previous.as_ref().map(|p| p.sum("rampart_xdp_total")), - Some(metrics.sum("rampart_xdp_total")), - elapsed_secs, - ), - drops_per_sec: counter_rate( - previous.as_ref().map(|p| p.sum("rampart_xdp_dropped")), - Some(metrics.sum("rampart_xdp_dropped")), - elapsed_secs, - ), - }; - history.push(point); - snapshot.metrics = Some(metrics); - snapshot.fetched_at = Some(Instant::now()); - snapshot.error = None; - }, - Err(message) => { - snapshot.error = Some(message); - }, - } - } + /// Записывает результат очередного fetch и обновляет историю rate. + pub fn apply_fetch(&self, result: Result, elapsed_secs: f64) { + let mut snapshot = match self.snapshot.lock() { + Ok(guard) => guard, + Err(poisoned) => poisoned.into_inner(), + }; + match result { + Ok(metrics) => { + let mut history = match self.history.lock() { + Ok(guard) => guard, + Err(poisoned) => poisoned.into_inner(), + }; + let previous = snapshot.metrics.take(); + let point = HistoryPoint { + packets_per_sec: counter_rate( + previous.as_ref().map(|p| p.sum("rampart_xdp_total")), + Some(metrics.sum("rampart_xdp_total")), + elapsed_secs, + ), + drops_per_sec: counter_rate( + previous.as_ref().map(|p| p.sum("rampart_xdp_dropped")), + Some(metrics.sum("rampart_xdp_dropped")), + elapsed_secs, + ), + }; + history.push(point); + snapshot.metrics = Some(metrics); + snapshot.fetched_at = Some(Instant::now()); + snapshot.error = None; + }, + Err(message) => { + snapshot.error = Some(message); + }, + } + } - /// Копия среза метрик + истории для отрисовки кадра. - /// - /// UI не держит лок — рисуем по снимку. - #[must_use] - pub fn frame_data(&self) -> FrameData { - let snapshot = self.snapshot.lock().unwrap_or_else(std::sync::PoisonError::into_inner); - let history = self - .history - .lock() - .unwrap_or_else(std::sync::PoisonError::into_inner) - .clone(); - FrameData { - url: self.url.clone(), - snapshot: snapshot.clone(), - history, - uptime_secs: self.started_at.elapsed().as_secs(), - } - } + /// Копия среза метрик + истории для отрисовки кадра. + /// + /// UI не держит лок — рисуем по снимку. + #[must_use] + pub fn frame_data(&self) -> FrameData { + let snapshot = self.snapshot.lock().unwrap_or_else(std::sync::PoisonError::into_inner); + let history = self + .history + .lock() + .unwrap_or_else(std::sync::PoisonError::into_inner) + .clone(); + FrameData { + url: self.url.clone(), + snapshot: snapshot.clone(), + history, + uptime_secs: self.started_at.elapsed().as_secs(), + } + } } /// Снимок для одного кадра UI. #[derive(Debug, Default, Clone)] pub struct FrameData { - /// URL источника метрик. - pub url: String, - pub snapshot: Snapshot, - pub history: History, - /// Время работы TUI (сек). - pub uptime_secs: u64, + /// URL источника метрик. + pub url: String, + pub snapshot: Snapshot, + pub history: History, + /// Время работы TUI (сек). + pub uptime_secs: u64, } /// Rate счётчика из двух сэмплов: `(current - previous) / dt`. @@ -156,11 +156,11 @@ pub struct FrameData { /// (`current < previous`) трактуетcя как рестарт процесса → 0.0. #[must_use] pub fn counter_rate(previous: Option, current: Option, elapsed_secs: f64) -> f64 { - let (Some(previous), Some(current)) = (previous, current) else { - return 0.0; - }; - if !(elapsed_secs > 0.0 && current.is_finite()) || current < previous { - return 0.0; - } - (current - previous) / elapsed_secs + let (Some(previous), Some(current)) = (previous, current) else { + return 0.0; + }; + if !(elapsed_secs > 0.0 && current.is_finite()) || current < previous { + return 0.0; + } + (current - previous) / elapsed_secs } diff --git a/src/tui/ui.rs b/src/tui/ui.rs index e412485..8b6e177 100644 --- a/src/tui/ui.rs +++ b/src/tui/ui.rs @@ -11,169 +11,169 @@ use crate::tui::state::{FrameData, HistoryPoint}; /// Имена метрик edge/manager (см. src/metrics.rs и src/xdp/metrics.rs). mod names { - pub const XDP_TOTAL: &str = "rampart_xdp_total"; - pub const XDP_TCP: &str = "rampart_xdp_tcp"; - pub const XDP_UDP: &str = "rampart_xdp_udp"; - pub const XDP_PASSED: &str = "rampart_xdp_passed"; - pub const XDP_DROPPED: &str = "rampart_xdp_dropped"; - pub const XDP_THROTTLE: &str = "rampart_xdp_syn_throttle"; - pub const XDP_RATE_LIMIT: &str = "rampart_xdp_rate_limit"; - pub const XDP_BLACKLIST: &str = "rampart_xdp_blacklist"; - pub const RATE_LIMIT_HITS: &str = "rampart_rate_limit_hits"; - pub const AUTO_BANS_TOTAL: &str = "rampart_auto_bans_total"; - pub const INTEL_DROPS: &str = "rampart_intel_rate_limit_drops_total"; - pub const INTEL_CPS: &str = "rampart_intel_cps"; - pub const INTEL_ALERTS: &str = "rampart_intel_alerts_total"; - pub const ATTACK_STATUS: &str = "rampart_attack_status"; + pub const XDP_TOTAL: &str = "rampart_xdp_total"; + pub const XDP_TCP: &str = "rampart_xdp_tcp"; + pub const XDP_UDP: &str = "rampart_xdp_udp"; + pub const XDP_PASSED: &str = "rampart_xdp_passed"; + pub const XDP_DROPPED: &str = "rampart_xdp_dropped"; + pub const XDP_THROTTLE: &str = "rampart_xdp_syn_throttle"; + pub const XDP_RATE_LIMIT: &str = "rampart_xdp_rate_limit"; + pub const XDP_BLACKLIST: &str = "rampart_xdp_blacklist"; + pub const RATE_LIMIT_HITS: &str = "rampart_rate_limit_hits"; + pub const AUTO_BANS_TOTAL: &str = "rampart_auto_bans_total"; + pub const INTEL_DROPS: &str = "rampart_intel_rate_limit_drops_total"; + pub const INTEL_CPS: &str = "rampart_intel_cps"; + pub const INTEL_ALERTS: &str = "rampart_intel_alerts_total"; + pub const ATTACK_STATUS: &str = "rampart_attack_status"; } /// Рисует весь кадр. pub fn render(frame: &mut Frame, data: &FrameData) { - let [header, body, help] = - Layout::vertical([Constraint::Length(3), Constraint::Min(3), Constraint::Length(1)]).areas(frame.area()); - render_header(frame, header, data); - let [table_area, chart_area] = - Layout::vertical([Constraint::Percentage(55), Constraint::Percentage(45)]).areas(body); - render_table(frame, table_area, data); - render_chart(frame, chart_area, data); - render_help(frame, help); + let [header, body, help] = + Layout::vertical([Constraint::Length(3), Constraint::Min(3), Constraint::Length(1)]).areas(frame.area()); + render_header(frame, header, data); + let [table_area, chart_area] = + Layout::vertical([Constraint::Percentage(55), Constraint::Percentage(45)]).areas(body); + render_table(frame, table_area, data); + render_chart(frame, chart_area, data); + render_help(frame, help); } fn status_color(data: &FrameData) -> Color { - match data.snapshot.error { - Some(_) => Color::Red, - None if data.snapshot.fetched_at.is_some() => Color::Green, - None => Color::Yellow, - } + match data.snapshot.error { + Some(_) => Color::Red, + None if data.snapshot.fetched_at.is_some() => Color::Green, + None => Color::Yellow, + } } fn render_header(frame: &mut Frame, area: Rect, data: &FrameData) { - let dot = Span::styled( - "● ", - Style::default().fg(status_color(data)).add_modifier(Modifier::BOLD), - ); - let title = Span::styled(" Rampart live metrics", Style::default().add_modifier(Modifier::BOLD)); - let state_text = match (&data.snapshot.error, data.snapshot.fetched_at) { - (Some(err), _) => format!("ERROR: {err}"), - (_, Some(at)) => format!("OK, last update {}s ago", at.elapsed().as_secs()), - (None, None) => "waiting for first fetch...".to_owned(), - }; - let line = Line::from(vec![ - dot, - title, - Span::raw(format!( - " {} | uptime {}s | {state_text}", - data.url, data.uptime_secs - )), - ]); - frame.render_widget(Paragraph::new(line).block(Block::new().borders(Borders::ALL)), area); + let dot = Span::styled( + "● ", + Style::default().fg(status_color(data)).add_modifier(Modifier::BOLD), + ); + let title = Span::styled(" Rampart live metrics", Style::default().add_modifier(Modifier::BOLD)); + let state_text = match (&data.snapshot.error, data.snapshot.fetched_at) { + (Some(err), _) => format!("ERROR: {err}"), + (_, Some(at)) => format!("OK, last update {}s ago", at.elapsed().as_secs()), + (None, None) => "waiting for first fetch...".to_owned(), + }; + let line = Line::from(vec![ + dot, + title, + Span::raw(format!( + " {} | uptime {}s | {state_text}", + data.url, data.uptime_secs + )), + ]); + frame.render_widget(Paragraph::new(line).block(Block::new().borders(Borders::ALL)), area); } /// Пары «подпись → имя метрики» для таблицы. const COUNTER_ROWS: &[(&str, &str)] = &[ - ("XDP total", names::XDP_TOTAL), - ("XDP tcp", names::XDP_TCP), - ("XDP udp", names::XDP_UDP), - ("XDP passed", names::XDP_PASSED), - ("XDP dropped", names::XDP_DROPPED), - ("SYN throttle", names::XDP_THROTTLE), - ("Rate limited", names::XDP_RATE_LIMIT), - ("Blacklisted", names::XDP_BLACKLIST), - ("HTTP rate-limit hits", names::RATE_LIMIT_HITS), - ("Auto bans", names::AUTO_BANS_TOTAL), - ("Intel rl drops", names::INTEL_DROPS), - ("Intel cps", names::INTEL_CPS), - ("Intel alerts", names::INTEL_ALERTS), + ("XDP total", names::XDP_TOTAL), + ("XDP tcp", names::XDP_TCP), + ("XDP udp", names::XDP_UDP), + ("XDP passed", names::XDP_PASSED), + ("XDP dropped", names::XDP_DROPPED), + ("SYN throttle", names::XDP_THROTTLE), + ("Rate limited", names::XDP_RATE_LIMIT), + ("Blacklisted", names::XDP_BLACKLIST), + ("HTTP rate-limit hits", names::RATE_LIMIT_HITS), + ("Auto bans", names::AUTO_BANS_TOTAL), + ("Intel rl drops", names::INTEL_DROPS), + ("Intel cps", names::INTEL_CPS), + ("Intel alerts", names::INTEL_ALERTS), ]; fn attack_status_label(value: Option) -> String { - match value { - None => "-".to_owned(), - Some(v) if v <= 0.0 => "normal".to_owned(), - Some(v) if v < 2.0 => "suspicious".to_owned(), - Some(_) => "under attack".to_owned(), - } + match value { + None => "-".to_owned(), + Some(v) if v <= 0.0 => "normal".to_owned(), + Some(v) if v < 2.0 => "suspicious".to_owned(), + Some(_) => "under attack".to_owned(), + } } fn render_table(frame: &mut Frame, area: Rect, data: &FrameData) { - let rows: Vec = COUNTER_ROWS - .iter() - .map(|(label, metric)| { - let value = data.snapshot.metrics.as_ref().map(|m| m.sum(metric)); - Row::new(vec![(*label).to_owned(), fmt_value(value)]) - }) - .chain(std::iter::once(Row::new(vec![ - "Attack status".to_owned(), - attack_status_label(data.snapshot.metrics.as_ref().map(|m| m.sum(names::ATTACK_STATUS))), - ]))) - .collect(); + let rows: Vec = COUNTER_ROWS + .iter() + .map(|(label, metric)| { + let value = data.snapshot.metrics.as_ref().map(|m| m.sum(metric)); + Row::new(vec![(*label).to_owned(), fmt_value(value)]) + }) + .chain(std::iter::once(Row::new(vec![ + "Attack status".to_owned(), + attack_status_label(data.snapshot.metrics.as_ref().map(|m| m.sum(names::ATTACK_STATUS))), + ]))) + .collect(); - let table = Table::new(rows, [Constraint::Percentage(60), Constraint::Percentage(40)]) - .block(Block::new().borders(Borders::ALL).title(" Counters ")) - .header(Row::new(vec!["metric", "value"]).style(Style::default().add_modifier(Modifier::BOLD))); - frame.render_widget(table, area); + let table = Table::new(rows, [Constraint::Percentage(60), Constraint::Percentage(40)]) + .block(Block::new().borders(Borders::ALL).title(" Counters ")) + .header(Row::new(vec!["metric", "value"]).style(Style::default().add_modifier(Modifier::BOLD))); + frame.render_widget(table, area); } #[allow(clippy::float_arithmetic)] fn fmt_value(value: Option) -> String { - match value { - None => "-".to_owned(), - Some(v) if !v.is_finite() => format!("{v}"), - Some(v) if v.fract() == 0.0 => format!("{}", v as u64), - Some(v) => format!("{v:.1}"), - } + match value { + None => "-".to_owned(), + Some(v) if !v.is_finite() => format!("{v}"), + Some(v) if v.fract() == 0.0 => format!("{}", v as u64), + Some(v) => format!("{v:.1}"), + } } fn history_series(history: &[HistoryPoint], pick: impl Fn(&HistoryPoint) -> f64) -> Vec<(f64, f64)> { - history - .iter() - .enumerate() - .map(|(idx, point)| (f64::from(idx as u16), pick(point))) - .collect() + history + .iter() + .enumerate() + .map(|(idx, point)| (f64::from(idx as u16), pick(point))) + .collect() } fn render_chart(frame: &mut Frame, area: Rect, data: &FrameData) { - let points: Vec = data.history.points().iter().copied().collect(); - let pps_series = history_series(&points, |p| p.packets_per_sec); - let drops_series = history_series(&points, |p| p.drops_per_sec); - let pps = Dataset::default() - .name("pps") - .marker(symbols::Marker::Braille) - .graph_type(GraphType::Line) - .style(Style::default().fg(Color::Cyan)) - .data(&pps_series); - let drops = Dataset::default() - .name("drops/s") - .marker(symbols::Marker::Braille) - .graph_type(GraphType::Line) - .style(Style::default().fg(Color::Red)) - .data(&drops_series); + let points: Vec = data.history.points().iter().copied().collect(); + let pps_series = history_series(&points, |p| p.packets_per_sec); + let drops_series = history_series(&points, |p| p.drops_per_sec); + let pps = Dataset::default() + .name("pps") + .marker(symbols::Marker::Braille) + .graph_type(GraphType::Line) + .style(Style::default().fg(Color::Cyan)) + .data(&pps_series); + let drops = Dataset::default() + .name("drops/s") + .marker(symbols::Marker::Braille) + .graph_type(GraphType::Line) + .style(Style::default().fg(Color::Red)) + .data(&drops_series); - let x_max = points.len().max(2) as f64 - 1.0; - let y_max = points - .iter() - .flat_map(|p| [p.packets_per_sec, p.drops_per_sec]) - .fold(1.0_f64, f64::max); + let x_max = points.len().max(2) as f64 - 1.0; + let y_max = points + .iter() + .flat_map(|p| [p.packets_per_sec, p.drops_per_sec]) + .fold(1.0_f64, f64::max); - let chart = Chart::new(vec![pps, drops]) - .block( - Block::new() - .borders(Borders::ALL) - .title(" pps / drops (last 120 samples) "), - ) - .x_axis(Axis::default().bounds([0.0, x_max])) - .y_axis(Axis::default().bounds([0.0, y_max])); - frame.render_widget(chart, area); + let chart = Chart::new(vec![pps, drops]) + .block( + Block::new() + .borders(Borders::ALL) + .title(" pps / drops (last 120 samples) "), + ) + .x_axis(Axis::default().bounds([0.0, x_max])) + .y_axis(Axis::default().bounds([0.0, y_max])); + frame.render_widget(chart, area); } fn render_help(frame: &mut Frame, area: Rect) { - frame.render_widget( - Paragraph::new(Line::from(vec![ - Span::styled("q", Style::default().add_modifier(Modifier::BOLD)), - Span::raw(" quit "), - Span::styled("r", Style::default().add_modifier(Modifier::BOLD)), - Span::raw(" refresh now"), - ])), - area, - ); + frame.render_widget( + Paragraph::new(Line::from(vec![ + Span::styled("q", Style::default().add_modifier(Modifier::BOLD)), + Span::raw(" quit "), + Span::styled("r", Style::default().add_modifier(Modifier::BOLD)), + Span::raw(" refresh now"), + ])), + area, + ); } diff --git a/src/xdp/filter/attach.rs b/src/xdp/filter/attach.rs index fe8bd5d..820b5b6 100644 --- a/src/xdp/filter/attach.rs +++ b/src/xdp/filter/attach.rs @@ -15,46 +15,46 @@ use super::events::{AutoBanConfig, auto_ban_decision, parse_xdp_event}; /// Rejects interface names containing an interior NUL byte instead of /// silently truncating at it (the `&str`-as-`*const c_char` UB we removed). pub(super) fn interface_cstr(name: &str) -> Result { - CString::new(name).with_context(|| format!("interface name {name:?} contains an interior NUL byte")) + CString::new(name).with_context(|| format!("interface name {name:?} contains an interior NUL byte")) } /// Внутренний data-map `.rodata` ищется по суффиксу: libbpf именует его /// `.rodata`, а имя объекта при `open_memory` без явного `.name()` /// вообще `memory` — точное сравнение ломалось на живом ядре (smoke-тест). pub(super) fn is_rodata_map(name: &str) -> bool { - name.ends_with(".rodata") + name.ends_with(".rodata") } /// Патчит карту `*.rodata` (volatile const глобалы) ДО загрузки объекта. pub(super) fn patch_rodata(open_obj: &mut OpenObject, globals: &XdpGlobals) -> Result<()> { - let image = globals.build_rodata_image(); - if !open_obj - .maps_mut() - .any(|m| m.name().to_str().is_some_and(is_rodata_map)) - { - let names: Vec = open_obj - .maps() - .map(|m| m.name().to_string_lossy().into_owned()) - .collect(); - bail!("no .rodata map ('{RODATA_MAP_NAME}') in XDP object, maps: {names:?}"); - } - let mut map = open_obj - .maps_mut() - .find(|m| m.name().to_str().is_some_and(is_rodata_map)) - .context("rodata map vanished between passes")?; - map.set_initial_value(&image) - .with_context(|| format!("failed to set initial value of '{RODATA_MAP_NAME}'")) + let image = globals.build_rodata_image(); + if !open_obj + .maps_mut() + .any(|m| m.name().to_str().is_some_and(is_rodata_map)) + { + let names: Vec = open_obj + .maps() + .map(|m| m.name().to_string_lossy().into_owned()) + .collect(); + bail!("no .rodata map ('{RODATA_MAP_NAME}') in XDP object, maps: {names:?}"); + } + let mut map = open_obj + .maps_mut() + .find(|m| m.name().to_str().is_some_and(is_rodata_map)) + .context("rodata map vanished between passes")?; + map.set_initial_value(&image) + .with_context(|| format!("failed to set initial value of '{RODATA_MAP_NAME}'")) } /// Честное имя режима attach по `attach_mode` из `bpf_xdp_query_opts` /// (kernel `enum xdp_attached_mode`: NONE=0, DRV=1, OFFLOAD=2, SKB=3). pub(super) fn xdp_attach_mode_name(mode: u8) -> &'static str { - match mode { - 1 => "native (drv)", - 2 => "hardware offload", - 3 => "generic (skb)", - _ => "none", - } + match mode { + 1 => "native (drv)", + 2 => "hardware offload", + 3 => "generic (skb)", + _ => "none", + } } /// Собирает ringbuf-колбэк для `events_map`. @@ -65,89 +65,89 @@ pub(super) fn xdp_attach_mode_name(mode: u8) -> &'static str { /// логируются структурированно; баны не пишутся. В горячем пути нет `format!` — /// `tracing`-поля и `&'static str` причины. pub(super) fn build_ringbuf( - obj: &Object, - blacklist: Option>, - cfg: AutoBanConfig, + obj: &Object, + blacklist: Option>, + cfg: AutoBanConfig, ) -> Result> { - let map = obj - .maps() - .find(|m| m.name() == "events_map") - .context("events_map not found")?; - let mut builder = RingBufferBuilder::new(); - builder.add(&map, move |data: &[u8]| { - let Some(event) = parse_xdp_event(data) else { - tracing::debug!( - len = data.len(), - "xdp ringbuf frame ignored (too short or unknown type)" - ); - return 0; - }; - tracing::debug!( - kind = ?event.kind, - src_ip = %event.src_ip, - metadata = event.metadata, - "xdp event" - ); - let Some(blacklist) = &blacklist else { - return 0; - }; - if let Some(ban) = auto_ban_decision(&event, &cfg) { - let addr = IpAddr::V4(ban.ip); - // `Blacklist::add` возвращает `()` (DashMap::insert игнорируется), а - // править blacklist.rs вне нашей зоны нельзя — поэтому «новый ли бан» - // определяем через публичный `is_blocked` ДО перезаписи. Это дедуп - // лога/метрики по активному бану, а не по факту вставки. - let already_banned = blacklist.is_blocked(addr); - blacklist.add(addr, Duration::from_secs(ban.duration_secs), ban.reason); - if already_banned { - tracing::debug!(src_ip = %ban.ip, reason = ban.reason, "xdp auto-ban refreshed"); - } else { - XDP_AUTOBANS_TOTAL.inc(); - tracing::info!( - src_ip = %ban.ip, - reason = ban.reason, - duration_secs = ban.duration_secs, - "xdp auto-ban issued" - ); - } - } - 0 - })?; - Ok(builder.build()?) + let map = obj + .maps() + .find(|m| m.name() == "events_map") + .context("events_map not found")?; + let mut builder = RingBufferBuilder::new(); + builder.add(&map, move |data: &[u8]| { + let Some(event) = parse_xdp_event(data) else { + tracing::debug!( + len = data.len(), + "xdp ringbuf frame ignored (too short or unknown type)" + ); + return 0; + }; + tracing::debug!( + kind = ?event.kind, + src_ip = %event.src_ip, + metadata = event.metadata, + "xdp event" + ); + let Some(blacklist) = &blacklist else { + return 0; + }; + if let Some(ban) = auto_ban_decision(&event, &cfg) { + let addr = IpAddr::V4(ban.ip); + // `Blacklist::add` возвращает `()` (DashMap::insert игнорируется), а + // править blacklist.rs вне нашей зоны нельзя — поэтому «новый ли бан» + // определяем через публичный `is_blocked` ДО перезаписи. Это дедуп + // лога/метрики по активному бану, а не по факту вставки. + let already_banned = blacklist.is_blocked(addr); + blacklist.add(addr, Duration::from_secs(ban.duration_secs), ban.reason); + if already_banned { + tracing::debug!(src_ip = %ban.ip, reason = ban.reason, "xdp auto-ban refreshed"); + } else { + XDP_AUTOBANS_TOTAL.inc(); + tracing::info!( + src_ip = %ban.ip, + reason = ban.reason, + duration_secs = ban.duration_secs, + "xdp auto-ban issued" + ); + } + } + 0 + })?; + Ok(builder.build()?) } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn interface_cstr_accepts_plain_names() { - let c = interface_cstr("eth0").expect("valid interface name"); - assert_eq!(c.as_bytes(), b"eth0"); - assert_eq!(c.as_bytes_with_nul(), b"eth0\0"); - } + #[test] + fn interface_cstr_accepts_plain_names() { + let c = interface_cstr("eth0").expect("valid interface name"); + assert_eq!(c.as_bytes(), b"eth0"); + assert_eq!(c.as_bytes_with_nul(), b"eth0\0"); + } - #[test] - fn interface_cstr_rejects_interior_nul() { - assert!(interface_cstr("et\0h0").is_err()); - } + #[test] + fn interface_cstr_rejects_interior_nul() { + assert!(interface_cstr("et\0h0").is_err()); + } - #[test] - fn rodata_map_matches_libbpf_naming() { - // libbpf строит имя `
` без замены точки (libbpf.c ~1911), - // при open_memory без name объект называется "memory": - assert!(is_rodata_map("rampart.rodata")); - assert!(is_rodata_map("memory.rodata")); - assert!(is_rodata_map(".rodata")); - assert!(!is_rodata_map("rampart.bss")); - assert!(!is_rodata_map("stats_map")); - } + #[test] + fn rodata_map_matches_libbpf_naming() { + // libbpf строит имя `
` без замены точки (libbpf.c ~1911), + // при open_memory без name объект называется "memory": + assert!(is_rodata_map("rampart.rodata")); + assert!(is_rodata_map("memory.rodata")); + assert!(is_rodata_map(".rodata")); + assert!(!is_rodata_map("rampart.bss")); + assert!(!is_rodata_map("stats_map")); + } - #[test] - fn attach_mode_names_are_honest() { - assert_eq!(xdp_attach_mode_name(1), "native (drv)"); - assert_eq!(xdp_attach_mode_name(3), "generic (skb)"); - assert_eq!(xdp_attach_mode_name(2), "hardware offload"); - assert_eq!(xdp_attach_mode_name(0), "none"); - } + #[test] + fn attach_mode_names_are_honest() { + assert_eq!(xdp_attach_mode_name(1), "native (drv)"); + assert_eq!(xdp_attach_mode_name(3), "generic (skb)"); + assert_eq!(xdp_attach_mode_name(2), "hardware offload"); + assert_eq!(xdp_attach_mode_name(0), "none"); + } } diff --git a/src/xdp/filter/events.rs b/src/xdp/filter/events.rs index 4c56788..261dccb 100644 --- a/src/xdp/filter/events.rs +++ b/src/xdp/filter/events.rs @@ -15,43 +15,43 @@ pub const XDP_EVENT_LEN: usize = 24; /// Тип события из `enum event_type` (`common.h:54-59`). #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum XdpEventKind { - /// `EVENT_BAN` — пакет уже был в blacklist_map и сброшен ядром. - Ban, - /// `EVENT_RATE_LIMIT` — превышен порог троттлинга (SYN/UDP). - RateLimit, - /// `EVENT_POLICY_DROP` — статичная политика (UDP drop / вредоносные TCP-флаги). - PolicyDrop, - /// `EVENT_CONN_DROP` — flow сброшен (несоответствие seq или verdict хука). - ConnDrop, + /// `EVENT_BAN` — пакет уже был в blacklist_map и сброшен ядром. + Ban, + /// `EVENT_RATE_LIMIT` — превышен порог троттлинга (SYN/UDP). + RateLimit, + /// `EVENT_POLICY_DROP` — статичная политика (UDP drop / вредоносные TCP-флаги). + PolicyDrop, + /// `EVENT_CONN_DROP` — flow сброшен (несоответствие seq или verdict хука). + ConnDrop, } impl XdpEventKind { - /// Декодирует числовое значение из C-enum. Неизвестный тип → `None` + debug. - fn from_u32(raw: u32) -> Option { - match raw { - 0 => Some(Self::Ban), - 1 => Some(Self::RateLimit), - 2 => Some(Self::PolicyDrop), - 3 => Some(Self::ConnDrop), - other => { - tracing::debug!(event_type = other, "xdp event: unknown type, dropped"); - None - }, - } - } + /// Декодирует числовое значение из C-enum. Неизвестный тип → `None` + debug. + fn from_u32(raw: u32) -> Option { + match raw { + 0 => Some(Self::Ban), + 1 => Some(Self::RateLimit), + 2 => Some(Self::PolicyDrop), + 3 => Some(Self::ConnDrop), + other => { + tracing::debug!(event_type = other, "xdp event: unknown type, dropped"); + None + }, + } + } } /// Разобранное событие ringbuf. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct XdpEvent { - pub kind: XdpEventKind, - /// IPv4 источника (для IPv4-mapped IPv6 ядро кладёт в `src_ip` младший u32). - pub src_ip: Ipv4Addr, - /// Поле `__u32 metadata`: для `RateLimit` — порог срабатывания троттлинга, - /// для `ConnDrop` — счётчик `conn->fails`, иначе `0`. - pub metadata: u32, - /// `bpf_ktime_get_ns()` на момент генерации (monotonic, не wall-clock). - pub timestamp_ns: u64, + pub kind: XdpEventKind, + /// IPv4 источника (для IPv4-mapped IPv6 ядро кладёт в `src_ip` младший u32). + pub src_ip: Ipv4Addr, + /// Поле `__u32 metadata`: для `RateLimit` — порог срабатывания троттлинга, + /// для `ConnDrop` — счётчик `conn->fails`, иначе `0`. + pub metadata: u32, + /// `bpf_ktime_get_ns()` на момент генерации (monotonic, не wall-clock). + pub timestamp_ns: u64, } /// Разбирает 24-байтовый кадр `struct xdp_event`. @@ -71,56 +71,56 @@ pub struct XdpEvent { /// /// Возвращает `None`, если кадр короче `XDP_EVENT_LEN` или тип неизвестен. pub fn parse_xdp_event(bytes: &[u8]) -> Option { - let raw: &[u8; XDP_EVENT_LEN] = bytes.get(..XDP_EVENT_LEN)?.try_into().ok()?; - let kind = XdpEventKind::from_u32(u32::from_ne_bytes(raw[0..4].try_into().ok()?))?; - let src_ip = Ipv4Addr::new(raw[4], raw[5], raw[6], raw[7]); - let metadata = u32::from_ne_bytes(raw[8..12].try_into().ok()?); - // raw[12..16] — выравнивающий padding под __u64, не читаем (он не инициализирован). - let timestamp_ns = u64::from_ne_bytes(raw[16..24].try_into().ok()?); - Some(XdpEvent { - kind, - src_ip, - metadata, - timestamp_ns, - }) + let raw: &[u8; XDP_EVENT_LEN] = bytes.get(..XDP_EVENT_LEN)?.try_into().ok()?; + let kind = XdpEventKind::from_u32(u32::from_ne_bytes(raw[0..4].try_into().ok()?))?; + let src_ip = Ipv4Addr::new(raw[4], raw[5], raw[6], raw[7]); + let metadata = u32::from_ne_bytes(raw[8..12].try_into().ok()?); + // raw[12..16] — выравнивающий padding под __u64, не читаем (он не инициализирован). + let timestamp_ns = u64::from_ne_bytes(raw[16..24].try_into().ok()?); + Some(XdpEvent { + kind, + src_ip, + metadata, + timestamp_ns, + }) } /// Параметры авто-бана, резолвинг из секции `[xdp]`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct AutoBanConfig { - pub enabled: bool, - pub duration_secs: u64, - pub conn_drop_fails: u8, + pub enabled: bool, + pub duration_secs: u64, + pub conn_drop_fails: u8, } impl Default for AutoBanConfig { - fn default() -> Self { - Self { - enabled: false, - duration_secs: 60, - conn_drop_fails: 3, - } - } + fn default() -> Self { + Self { + enabled: false, + duration_secs: 60, + conn_drop_fails: 3, + } + } } impl AutoBanConfig { - /// Берёт значения из `[xdp]`-секции конфига (единственный источник истины). - pub fn from_xdp(cfg: &XdpConfig) -> Self { - Self { - enabled: cfg.auto_ban_enabled, - duration_secs: cfg.auto_ban_duration_secs, - conn_drop_fails: cfg.auto_ban_conn_drop_fails, - } - } + /// Берёт значения из `[xdp]`-секции конфига (единственный источник истины). + pub fn from_xdp(cfg: &XdpConfig) -> Self { + Self { + enabled: cfg.auto_ban_enabled, + duration_secs: cfg.auto_ban_duration_secs, + conn_drop_fails: cfg.auto_ban_conn_drop_fails, + } + } } /// Готовый бан для применения к userspace-`Blacklist`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct BanAction { - pub ip: Ipv4Addr, - pub duration_secs: u64, - /// Статичная причина (без аллокаций в горячем пути). - pub reason: &'static str, + pub ip: Ipv4Addr, + pub duration_secs: u64, + /// Статичная причина (без аллокаций в горячем пути). + pub reason: &'static str, } /// Чистое решение: банить ли источник события и на сколько. @@ -143,23 +143,23 @@ pub struct BanAction { /// (`:418`) и ниже порога, т.е. не банится. #[must_use] pub fn auto_ban_decision(event: &XdpEvent, config: &AutoBanConfig) -> Option { - if !config.enabled { - return None; - } - match event.kind { - XdpEventKind::Ban | XdpEventKind::PolicyDrop => None, - XdpEventKind::RateLimit => Some(BanAction { - ip: event.src_ip, - duration_secs: config.duration_secs, - reason: "xdp-rate-limit", - }), - XdpEventKind::ConnDrop if event.metadata >= u32::from(config.conn_drop_fails) => Some(BanAction { - ip: event.src_ip, - duration_secs: config.duration_secs, - reason: "xdp-conn-drop", - }), - XdpEventKind::ConnDrop => None, - } + if !config.enabled { + return None; + } + match event.kind { + XdpEventKind::Ban | XdpEventKind::PolicyDrop => None, + XdpEventKind::RateLimit => Some(BanAction { + ip: event.src_ip, + duration_secs: config.duration_secs, + reason: "xdp-rate-limit", + }), + XdpEventKind::ConnDrop if event.metadata >= u32::from(config.conn_drop_fails) => Some(BanAction { + ip: event.src_ip, + duration_secs: config.duration_secs, + reason: "xdp-conn-drop", + }), + XdpEventKind::ConnDrop => None, + } } // Покрытие парсера и политики — в `tests/xdp_events.rs` (держим модуль под diff --git a/src/xdp/filter/maps.rs b/src/xdp/filter/maps.rs index c07ac2b..eb59cc1 100644 --- a/src/xdp/filter/maps.rs +++ b/src/xdp/filter/maps.rs @@ -4,74 +4,74 @@ use libbpf_rs::{MapCore, MapFlags}; use std::net::{IpAddr, Ipv4Addr}; pub(super) fn unix_ns() -> u64 { - std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .unwrap_or_default() - .as_nanos() as u64 + std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap_or_default() + .as_nanos() as u64 } /// Encodes an LPM-trie key for `blacklist_map`: prefix length in byte 0 and the /// four IPv4 octets in bytes 4..8 (bytes 1..3 are padding the kernel ignores). pub(super) fn blacklist_key(prefix_len: u8, v4: &[u8; 4]) -> [u8; 8] { - let mut key = [0u8; 8]; - key[0] = prefix_len; - key[4..8].copy_from_slice(v4); - key + let mut key = [0u8; 8]; + key[0] = prefix_len; + key[4..8].copy_from_slice(v4); + key } /// Absolute ban expiry in ns-since-epoch, saturating so an absurd duration /// clamps to `u64::MAX` rather than wrapping into the past. pub(super) fn blacklist_expiry_ns(now_ns: u64, duration_secs: u64) -> u64 { - now_ns.saturating_add(duration_secs.saturating_mul(1_000_000_000)) + now_ns.saturating_add(duration_secs.saturating_mul(1_000_000_000)) } impl XdpFilter { - pub fn ban_ip(&self, ip: Ipv4Addr, duration_secs: u64) -> Result<()> { - self.blacklist_update(32, &ip.octets(), duration_secs) - } + pub fn ban_ip(&self, ip: Ipv4Addr, duration_secs: u64) -> Result<()> { + self.blacklist_update(32, &ip.octets(), duration_secs) + } - /// Adds a CIDR ban to the LPM trie. IPv6 enforcement is not supported yet. - pub fn ban_cidr(&self, prefix: IpAddr, prefix_len: u8, duration_secs: u64) -> Result<()> { - let IpAddr::V4(net) = prefix else { - bail!("ipv6 cidr bans not supported yet"); - }; - self.blacklist_update(prefix_len, &net.octets(), duration_secs) - } + /// Adds a CIDR ban to the LPM trie. IPv6 enforcement is not supported yet. + pub fn ban_cidr(&self, prefix: IpAddr, prefix_len: u8, duration_secs: u64) -> Result<()> { + let IpAddr::V4(net) = prefix else { + bail!("ipv6 cidr bans not supported yet"); + }; + self.blacklist_update(prefix_len, &net.octets(), duration_secs) + } - fn blacklist_update(&self, prefix_len: u8, v4: &[u8; 4], duration_secs: u64) -> Result<()> { - let map = self.find_map("blacklist_map")?; - let key = blacklist_key(prefix_len, v4); - let expiry_ns = blacklist_expiry_ns(unix_ns(), duration_secs); - map.update(&key, &expiry_ns.to_le_bytes(), MapFlags::ANY)?; - Ok(()) - } + fn blacklist_update(&self, prefix_len: u8, v4: &[u8; 4], duration_secs: u64) -> Result<()> { + let map = self.find_map("blacklist_map")?; + let key = blacklist_key(prefix_len, v4); + let expiry_ns = blacklist_expiry_ns(unix_ns(), duration_secs); + map.update(&key, &expiry_ns.to_le_bytes(), MapFlags::ANY)?; + Ok(()) + } - pub fn unban_ip(&self, ip: Ipv4Addr) -> Result<()> { - let map = self.find_map("blacklist_map")?; - let key = blacklist_key(32, &ip.octets()); - map.delete(&key)?; - Ok(()) - } + pub fn unban_ip(&self, ip: Ipv4Addr) -> Result<()> { + let map = self.find_map("blacklist_map")?; + let key = blacklist_key(32, &ip.octets()); + map.delete(&key)?; + Ok(()) + } } #[cfg(test)] mod tests { - use super::*; + use super::*; - #[test] - fn blacklist_key_puts_prefix_len_first_and_octets_last() { - assert_eq!(blacklist_key(24, &[10, 0, 1, 200]), [24, 0, 0, 0, 10, 0, 1, 200]); - assert_eq!(blacklist_key(32, &[127, 0, 0, 1]), [32, 0, 0, 0, 127, 0, 0, 1]); - } + #[test] + fn blacklist_key_puts_prefix_len_first_and_octets_last() { + assert_eq!(blacklist_key(24, &[10, 0, 1, 200]), [24, 0, 0, 0, 10, 0, 1, 200]); + assert_eq!(blacklist_key(32, &[127, 0, 0, 1]), [32, 0, 0, 0, 127, 0, 0, 1]); + } - #[test] - fn blacklist_expiry_converts_secs_to_ns() { - assert_eq!(blacklist_expiry_ns(1_000, 2), 1_000 + 2_000_000_000); - } + #[test] + fn blacklist_expiry_converts_secs_to_ns() { + assert_eq!(blacklist_expiry_ns(1_000, 2), 1_000 + 2_000_000_000); + } - #[test] - fn blacklist_expiry_saturates_instead_of_wrapping() { - assert_eq!(blacklist_expiry_ns(u64::MAX, 1), u64::MAX); - assert_eq!(blacklist_expiry_ns(0, u64::MAX), u64::MAX); - } + #[test] + fn blacklist_expiry_saturates_instead_of_wrapping() { + assert_eq!(blacklist_expiry_ns(u64::MAX, 1), u64::MAX); + assert_eq!(blacklist_expiry_ns(0, u64::MAX), u64::MAX); + } } diff --git a/src/xdp/filter/mod.rs b/src/xdp/filter/mod.rs index d5655c9..736956a 100644 --- a/src/xdp/filter/mod.rs +++ b/src/xdp/filter/mod.rs @@ -17,200 +17,200 @@ pub(crate) mod events; mod maps; pub struct XdpFilter { - obj: Option, - ringbuf: Option>, - ifindex: i32, - interface: String, - globals: XdpGlobals, - blacklist: Option>, - autoban: AutoBanConfig, + obj: Option, + ringbuf: Option>, + ifindex: i32, + interface: String, + globals: XdpGlobals, + blacklist: Option>, + autoban: AutoBanConfig, } impl XdpFilter { - pub fn new(interface: &str) -> Self { - Self { - obj: None, - ringbuf: None, - ifindex: 0, - interface: interface.to_string(), - globals: XdpGlobals::default(), - blacklist: None, - autoban: AutoBanConfig::default(), - } - } + pub fn new(interface: &str) -> Self { + Self { + obj: None, + ringbuf: None, + ifindex: 0, + interface: interface.to_string(), + globals: XdpGlobals::default(), + blacklist: None, + autoban: AutoBanConfig::default(), + } + } - /// Задаёт глобалы для патчинга `.rodata` при следующем `load()`. - pub fn set_globals(&mut self, globals: XdpGlobals) { - self.globals = globals; - } + /// Задаёт глобалы для патчинга `.rodata` при следующем `load()`. + pub fn set_globals(&mut self, globals: XdpGlobals) { + self.globals = globals; + } - /// Подключает OPT-IN авто-бан по ringbuf-событиям к userspace-`Blacklist`. - /// - /// До вызова `load()`. Политика читается из `[xdp]`-секции; если - /// `auto_ban_enabled = false` (по умолчанию), колбэк лишь логирует события и - /// не трогает blacklist. - pub fn set_autoban(&mut self, blacklist: Arc, config: &XdpConfig) { - self.blacklist = Some(blacklist); - self.autoban = AutoBanConfig::from_xdp(config); - } + /// Подключает OPT-IN авто-бан по ringbuf-событиям к userspace-`Blacklist`. + /// + /// До вызова `load()`. Политика читается из `[xdp]`-секции; если + /// `auto_ban_enabled = false` (по умолчанию), колбэк лишь логирует события и + /// не трогает blacklist. + pub fn set_autoban(&mut self, blacklist: Arc, config: &XdpConfig) { + self.blacklist = Some(blacklist); + self.autoban = AutoBanConfig::from_xdp(config); + } - pub fn load(&mut self) -> Result<()> { - // Диагностика ДО загрузки: fail-fast на неподдерживаемом ядре/драйвере. - super::probe::preflight(&self.interface)?; + pub fn load(&mut self) -> Result<()> { + // Диагностика ДО загрузки: fail-fast на неподдерживаемом ядре/драйвере. + super::probe::preflight(&self.interface)?; - let bpf_obj = include_bytes!(concat!(env!("OUT_DIR"), "/universal_filter.o")); - // Имя объекта задаётся ЯВНО: при open_memory libbpf не знает имени файла, - // а по нему именуются внутренние maps ("rampart_.rodata" в patch_rodata). - let mut open_obj = ObjectBuilder::default() - .name("rampart") - .context("failed to set BPF object name")? - .open_memory(bpf_obj) - .context("Failed to open XDP object")?; - patch_rodata(&mut open_obj, &self.globals)?; - let obj = open_obj.load().context("Failed to load XDP object (verifier error?)")?; + let bpf_obj = include_bytes!(concat!(env!("OUT_DIR"), "/universal_filter.o")); + // Имя объекта задаётся ЯВНО: при open_memory libbpf не знает имени файла, + // а по нему именуются внутренние maps ("rampart_.rodata" в patch_rodata). + let mut open_obj = ObjectBuilder::default() + .name("rampart") + .context("failed to set BPF object name")? + .open_memory(bpf_obj) + .context("Failed to open XDP object")?; + patch_rodata(&mut open_obj, &self.globals)?; + let obj = open_obj.load().context("Failed to load XDP object (verifier error?)")?; - let c_interface = interface_cstr(&self.interface)?; - // SAFETY: `c_interface` is a valid, NUL-terminated C string and is kept - // alive until the end of this scope (past the `if_nametoindex` call), so - // the raw pointer satisfies the `const char *` contract of the libc FFI. - // Rust `&str` is NOT NUL-terminated, hence the `CString` conversion above. - let ifindex = unsafe { libc::if_nametoindex(c_interface.as_ptr()) }; - if ifindex == 0 { - let err = std::io::Error::last_os_error(); - bail!("interface '{}' not found: {err}", self.interface); - } + let c_interface = interface_cstr(&self.interface)?; + // SAFETY: `c_interface` is a valid, NUL-terminated C string and is kept + // alive until the end of this scope (past the `if_nametoindex` call), so + // the raw pointer satisfies the `const char *` contract of the libc FFI. + // Rust `&str` is NOT NUL-terminated, hence the `CString` conversion above. + let ifindex = unsafe { libc::if_nametoindex(c_interface.as_ptr()) }; + if ifindex == 0 { + let err = std::io::Error::last_os_error(); + bail!("interface '{}' not found: {err}", self.interface); + } - let prog = obj - .progs() - .find(|p| p.name() == "rampart_universal_filter") - .context("XDP program 'rampart_universal_filter' not found")?; - let xdp = Xdp::new(prog.as_fd()); - // Лестница режимов: пробуем native (drv); если драйвер не тянет — - // честный fallback в generic (skb) с предупреждением (вывод №1 из - // конкурентного анализа: печатать режим как есть, без вранья). - let ifindex = ifindex as i32; - if let Err(e) = xdp.attach(ifindex, XdpFlags::NONE) { - tracing::warn!( - interface = %self.interface, - error = %e, - "native XDP attach failed, falling back to generic (skb) mode" - ); - xdp.attach(ifindex, XdpFlags::SKB_MODE) - .context("XDP attach failed in both native and generic modes")?; - } - let mode = xdp - .query(ifindex, XdpFlags::NONE) - .map(|q| xdp_attach_mode_name(q.attach_mode)) - .unwrap_or("unknown"); + let prog = obj + .progs() + .find(|p| p.name() == "rampart_universal_filter") + .context("XDP program 'rampart_universal_filter' not found")?; + let xdp = Xdp::new(prog.as_fd()); + // Лестница режимов: пробуем native (drv); если драйвер не тянет — + // честный fallback в generic (skb) с предупреждением (вывод №1 из + // конкурентного анализа: печатать режим как есть, без вранья). + let ifindex = ifindex as i32; + if let Err(e) = xdp.attach(ifindex, XdpFlags::NONE) { + tracing::warn!( + interface = %self.interface, + error = %e, + "native XDP attach failed, falling back to generic (skb) mode" + ); + xdp.attach(ifindex, XdpFlags::SKB_MODE) + .context("XDP attach failed in both native and generic modes")?; + } + let mode = xdp + .query(ifindex, XdpFlags::NONE) + .map(|q| xdp_attach_mode_name(q.attach_mode)) + .unwrap_or("unknown"); - super::metrics::init(); - let rbuf = build_ringbuf(&obj, self.blacklist.clone(), self.autoban)?; + super::metrics::init(); + let rbuf = build_ringbuf(&obj, self.blacklist.clone(), self.autoban)?; - self.obj = Some(obj); - self.ringbuf = Some(rbuf); - self.ifindex = ifindex; - tracing::info!("XDP filter attached to {} (mode: {mode})", self.interface); - Ok(()) - } + self.obj = Some(obj); + self.ringbuf = Some(rbuf); + self.ifindex = ifindex; + tracing::info!("XDP filter attached to {} (mode: {mode})", self.interface); + Ok(()) + } - pub fn unload(&mut self) -> Result<()> { - let was_attached = self.obj.is_some(); - let mut result = Ok(()); - if let Some(obj) = self.obj.as_ref() { - result = self.detach_program(obj); - } - self.ringbuf = None; - self.obj = None; - self.ifindex = 0; - if was_attached { - tracing::info!("XDP filter detached from {}", self.interface); - } - result - } + pub fn unload(&mut self) -> Result<()> { + let was_attached = self.obj.is_some(); + let mut result = Ok(()); + if let Some(obj) = self.obj.as_ref() { + result = self.detach_program(obj); + } + self.ringbuf = None; + self.obj = None; + self.ifindex = 0; + if was_attached { + tracing::info!("XDP filter detached from {}", self.interface); + } + result + } - /// Detaches the XDP program using the real program fd owned by the loaded - /// `Object` (mirroring `load`'s `Xdp::new(prog.as_fd()).attach(..)`). A - /// detach failure while a filter is active is surfaced loudly and returned, - /// never swallowed — otherwise the kernel keeps dropping packets we no - /// longer intend to filter. - fn detach_program(&self, obj: &Object) -> Result<()> { - let prog = obj - .progs() - .find(|p| p.name() == "rampart_universal_filter") - .context("XDP program 'rampart_universal_filter' not found while detaching")?; - if let Err(e) = Xdp::new(prog.as_fd()).detach(self.ifindex, XdpFlags::NONE) { - tracing::error!( - interface = %self.interface, - ifindex = self.ifindex, - error = %e, - "XDP detach failed while filter was active" - ); - return Err(e).with_context(|| format!("failed to detach XDP from '{}'", self.interface)); - } - Ok(()) - } + /// Detaches the XDP program using the real program fd owned by the loaded + /// `Object` (mirroring `load`'s `Xdp::new(prog.as_fd()).attach(..)`). A + /// detach failure while a filter is active is surfaced loudly and returned, + /// never swallowed — otherwise the kernel keeps dropping packets we no + /// longer intend to filter. + fn detach_program(&self, obj: &Object) -> Result<()> { + let prog = obj + .progs() + .find(|p| p.name() == "rampart_universal_filter") + .context("XDP program 'rampart_universal_filter' not found while detaching")?; + if let Err(e) = Xdp::new(prog.as_fd()).detach(self.ifindex, XdpFlags::NONE) { + tracing::error!( + interface = %self.interface, + ifindex = self.ifindex, + error = %e, + "XDP detach failed while filter was active" + ); + return Err(e).with_context(|| format!("failed to detach XDP from '{}'", self.interface)); + } + Ok(()) + } - pub fn drain_events(&self) { - if let Some(rb) = &self.ringbuf { - let _ = rb.consume(); - } - } + pub fn drain_events(&self) { + if let Some(rb) = &self.ringbuf { + let _ = rb.consume(); + } + } - fn find_map<'a>(&'a self, name: &str) -> Result { - self.obj - .as_ref() - .context("XDP not loaded")? - .maps() - .find(|m| m.name() == name) - .with_context(|| format!("map '{}' not found", name)) - } + fn find_map<'a>(&'a self, name: &str) -> Result { + self.obj + .as_ref() + .context("XDP not loaded")? + .maps() + .find(|m| m.name() == name) + .with_context(|| format!("map '{}' not found", name)) + } - /// Читает карту `prefix_stats` (агрегаты по префиксам /24 и /64). - /// - /// # Errors - /// XDP не загружен, карта отсутствует в объекте или ошибка BPF-чтения. - pub fn read_prefix_stats(&self) -> Result> { - let map = self.find_map("prefix_stats")?; - let mut out = Vec::new(); - for key in map.keys() { - let Ok(kb) = <[u8; 24]>::try_from(key.as_slice()) else { - continue; - }; - let Some(val) = map.lookup(&kb, MapFlags::ANY).context("prefix_stats lookup failed")? else { - continue; - }; - let Ok(vb) = <[u8; 24]>::try_from(val.as_slice()) else { - continue; - }; - out.push((PrefixKey::from_bytes(kb), PrefixStatsVal::from_bytes(vb))); - } - Ok(out) - } + /// Читает карту `prefix_stats` (агрегаты по префиксам /24 и /64). + /// + /// # Errors + /// XDP не загружен, карта отсутствует в объекте или ошибка BPF-чтения. + pub fn read_prefix_stats(&self) -> Result> { + let map = self.find_map("prefix_stats")?; + let mut out = Vec::new(); + for key in map.keys() { + let Ok(kb) = <[u8; 24]>::try_from(key.as_slice()) else { + continue; + }; + let Some(val) = map.lookup(&kb, MapFlags::ANY).context("prefix_stats lookup failed")? else { + continue; + }; + let Ok(vb) = <[u8; 24]>::try_from(val.as_slice()) else { + continue; + }; + out.push((PrefixKey::from_bytes(kb), PrefixStatsVal::from_bytes(vb))); + } + Ok(out) + } - pub fn get_stats(&self) -> Result { - let map = self.find_map("stats_map")?; - let sum = |idx: u32| -> u64 { - let key = idx.to_le_bytes(); - match map.lookup(&key, MapFlags::ANY) { - Ok(Some(v)) => v - .chunks_exact(8) - .map(|c| u64::from_le_bytes(c.try_into().expect("chunk size 8"))) - .sum(), - _ => 0, - } - }; - Ok(XdpStats { - total: sum(0), - tcp: sum(1), - whitelist: sum(2), - blacklist: sum(3), - syn_throttle: sum(4), - passed: sum(5), - dropped: sum(6), - udp: sum(7), - rate_limit: sum(8), - }) - } + pub fn get_stats(&self) -> Result { + let map = self.find_map("stats_map")?; + let sum = |idx: u32| -> u64 { + let key = idx.to_le_bytes(); + match map.lookup(&key, MapFlags::ANY) { + Ok(Some(v)) => v + .chunks_exact(8) + .map(|c| u64::from_le_bytes(c.try_into().expect("chunk size 8"))) + .sum(), + _ => 0, + } + }; + Ok(XdpStats { + total: sum(0), + tcp: sum(1), + whitelist: sum(2), + blacklist: sum(3), + syn_throttle: sum(4), + passed: sum(5), + dropped: sum(6), + udp: sum(7), + rate_limit: sum(8), + }) + } } // SAFETY: `XdpFilter` is only ever accessed from the single thread that owns it, @@ -221,7 +221,7 @@ impl XdpFilter { unsafe impl Send for XdpFilter {} impl Drop for XdpFilter { - fn drop(&mut self) { - let _ = self.unload(); - } + fn drop(&mut self) { + let _ = self.unload(); + } } diff --git a/src/xdp/globals.rs b/src/xdp/globals.rs index 1ed6521..61fc095 100644 --- a/src/xdp/globals.rs +++ b/src/xdp/globals.rs @@ -50,137 +50,137 @@ const DEFAULT_CHALLENGE_SECRET: u64 = 0xA5A5_A5A5_A5A5_A5A5; /// Runtime-значения глобалов XDP-программы; `Default` совпадает с config.h. #[derive(Debug, Clone, PartialEq, Eq)] pub struct XdpGlobals { - pub start_port: u16, - pub end_port: u16, - pub syn_hit_count: u32, - pub syn_window_ns: u64, - pub syn_ban_duration_ns: u64, - pub conntrack_idle_ns: u64, - pub player_idle_ns: u64, - pub ban_duration_ns: u64, - pub max_out_of_order: u8, - pub udp_policy: u8, - pub udp_hit_count: u32, - pub udp_window_ns: u64, - pub feature_syn_throttle: bool, - pub feature_events: bool, - pub syn_challenge_enabled: bool, - pub challenge_secret: u64, - pub challenge_timeout_ms: u32, - pub challenge_verified_ttl_ns: u64, + pub start_port: u16, + pub end_port: u16, + pub syn_hit_count: u32, + pub syn_window_ns: u64, + pub syn_ban_duration_ns: u64, + pub conntrack_idle_ns: u64, + pub player_idle_ns: u64, + pub ban_duration_ns: u64, + pub max_out_of_order: u8, + pub udp_policy: u8, + pub udp_hit_count: u32, + pub udp_window_ns: u64, + pub feature_syn_throttle: bool, + pub feature_events: bool, + pub syn_challenge_enabled: bool, + pub challenge_secret: u64, + pub challenge_timeout_ms: u32, + pub challenge_verified_ttl_ns: u64, } impl Default for XdpGlobals { - fn default() -> Self { - Self { - start_port: 1, - end_port: 65535, - syn_hit_count: 10, - syn_window_ns: 3_000_000_000, - syn_ban_duration_ns: 60_000_000_000, - conntrack_idle_ns: 30_000_000_000, - player_idle_ns: 120_000_000_000, - ban_duration_ns: 300_000_000_000, - max_out_of_order: 4, - udp_policy: UDP_POLICY_PASS, - udp_hit_count: 100, - udp_window_ns: 1_000_000_000, - feature_syn_throttle: true, - feature_events: true, - syn_challenge_enabled: false, - challenge_secret: DEFAULT_CHALLENGE_SECRET, - challenge_timeout_ms: 3000, - challenge_verified_ttl_ns: 300_000_000_000, - } - } + fn default() -> Self { + Self { + start_port: 1, + end_port: 65535, + syn_hit_count: 10, + syn_window_ns: 3_000_000_000, + syn_ban_duration_ns: 60_000_000_000, + conntrack_idle_ns: 30_000_000_000, + player_idle_ns: 120_000_000_000, + ban_duration_ns: 300_000_000_000, + max_out_of_order: 4, + udp_policy: UDP_POLICY_PASS, + udp_hit_count: 100, + udp_window_ns: 1_000_000_000, + feature_syn_throttle: true, + feature_events: true, + syn_challenge_enabled: false, + challenge_secret: DEFAULT_CHALLENGE_SECRET, + challenge_timeout_ms: 3000, + challenge_verified_ttl_ns: 300_000_000_000, + } + } } impl XdpGlobals { - /// Собирает байтовый образ `.rodata` в порядке объявления глобалов - /// в `xdp/core/config.h` с естественным выравниванием каждого поля. - /// - /// RISK: раскладка предполагает, что линкер кладёт статические переменные - /// в секцию `.rodata` в порядке объявления с natural alignment — на - /// практике это так (каждая `static volatile const` получает своё - /// выравнивание, padding виден в смещениях ниже), но стандарт C этого не - /// гарантирует. TODO: верифицировать смещения на сервере через BTF-dump - /// карты `rampart_.rodata` (`bpftool btf dump`) и зафиксировать их здесь. - pub fn build_rodata_image(&self) -> Vec { - let mut img = vec![0u8; RODATA_SIZE]; - // u16 ×2 без padding: смещения 0..4. - img[0..2].copy_from_slice(&self.start_port.to_le_bytes()); - img[2..4].copy_from_slice(&self.end_port.to_le_bytes()); - // u32, align 4: 4..8. - img[4..8].copy_from_slice(&self.syn_hit_count.to_le_bytes()); - // u64, align 8: 8..48 (SYN throttle + idle timeouts + ban duration). - img[8..16].copy_from_slice(&self.syn_window_ns.to_le_bytes()); - img[16..24].copy_from_slice(&self.syn_ban_duration_ns.to_le_bytes()); - img[24..32].copy_from_slice(&self.conntrack_idle_ns.to_le_bytes()); - img[32..40].copy_from_slice(&self.player_idle_ns.to_le_bytes()); - img[40..48].copy_from_slice(&self.ban_duration_ns.to_le_bytes()); - // u8 ×3 подряд: 48, 49, 50 (max_out_of_order, udp_policy, —). - img[48] = self.max_out_of_order; - img[49] = self.udp_policy; - // u32 после u8: padding 50..52, значение 52..56. - img[52..56].copy_from_slice(&self.udp_hit_count.to_le_bytes()); - // u64, align 8: 56..64. - img[56..64].copy_from_slice(&self.udp_window_ns.to_le_bytes()); - // u8 ×3 (feature flags + challenge flag): 64, 65, 66. - img[64] = u8::from(self.feature_syn_throttle); - img[65] = u8::from(self.feature_events); - img[66] = u8::from(self.syn_challenge_enabled); - // u64 после u8: padding 67..72, значение 72..80. - img[72..80].copy_from_slice(&self.challenge_secret.to_le_bytes()); - // u32: 80..84. - img[80..84].copy_from_slice(&self.challenge_timeout_ms.to_le_bytes()); - // u64 после u32: padding 84..88, значение 88..96. - img[88..96].copy_from_slice(&self.challenge_verified_ttl_ns.to_le_bytes()); - img - } + /// Собирает байтовый образ `.rodata` в порядке объявления глобалов + /// в `xdp/core/config.h` с естественным выравниванием каждого поля. + /// + /// RISK: раскладка предполагает, что линкер кладёт статические переменные + /// в секцию `.rodata` в порядке объявления с natural alignment — на + /// практике это так (каждая `static volatile const` получает своё + /// выравнивание, padding виден в смещениях ниже), но стандарт C этого не + /// гарантирует. TODO: верифицировать смещения на сервере через BTF-dump + /// карты `rampart_.rodata` (`bpftool btf dump`) и зафиксировать их здесь. + pub fn build_rodata_image(&self) -> Vec { + let mut img = vec![0u8; RODATA_SIZE]; + // u16 ×2 без padding: смещения 0..4. + img[0..2].copy_from_slice(&self.start_port.to_le_bytes()); + img[2..4].copy_from_slice(&self.end_port.to_le_bytes()); + // u32, align 4: 4..8. + img[4..8].copy_from_slice(&self.syn_hit_count.to_le_bytes()); + // u64, align 8: 8..48 (SYN throttle + idle timeouts + ban duration). + img[8..16].copy_from_slice(&self.syn_window_ns.to_le_bytes()); + img[16..24].copy_from_slice(&self.syn_ban_duration_ns.to_le_bytes()); + img[24..32].copy_from_slice(&self.conntrack_idle_ns.to_le_bytes()); + img[32..40].copy_from_slice(&self.player_idle_ns.to_le_bytes()); + img[40..48].copy_from_slice(&self.ban_duration_ns.to_le_bytes()); + // u8 ×3 подряд: 48, 49, 50 (max_out_of_order, udp_policy, —). + img[48] = self.max_out_of_order; + img[49] = self.udp_policy; + // u32 после u8: padding 50..52, значение 52..56. + img[52..56].copy_from_slice(&self.udp_hit_count.to_le_bytes()); + // u64, align 8: 56..64. + img[56..64].copy_from_slice(&self.udp_window_ns.to_le_bytes()); + // u8 ×3 (feature flags + challenge flag): 64, 65, 66. + img[64] = u8::from(self.feature_syn_throttle); + img[65] = u8::from(self.feature_events); + img[66] = u8::from(self.syn_challenge_enabled); + // u64 после u8: padding 67..72, значение 72..80. + img[72..80].copy_from_slice(&self.challenge_secret.to_le_bytes()); + // u32: 80..84. + img[80..84].copy_from_slice(&self.challenge_timeout_ms.to_le_bytes()); + // u64 после u32: padding 84..88, значение 88..96. + img[88..96].copy_from_slice(&self.challenge_verified_ttl_ns.to_le_bytes()); + img + } - /// Строит глобалы из секции `[xdp]` конфига. - /// - /// # Errors - /// Неизвестное значение `udp_policy`; некорректный `challenge_secret_hex` - /// (не hex или не 8 байт); `protected_port_end < protected_port_start`. - pub fn from_config(cfg: &XdpConfig) -> Result { - let mut g = Self { - start_port: cfg.protected_port_start, - end_port: cfg.protected_port_end, - udp_hit_count: cfg.udp_rate_hit_count, - udp_window_ns: cfg.udp_rate_window_ms.saturating_mul(1_000_000), - feature_syn_throttle: cfg.throttle_enabled, - feature_events: cfg.events_enabled, - syn_challenge_enabled: cfg.syn_challenge_enabled, - challenge_timeout_ms: cfg.challenge_timeout_ms, - ..Self::default() - }; - if g.end_port < g.start_port { - bail!( - "xdp.protected_port_end ({}) < xdp.protected_port_start ({})", - g.end_port, - g.start_port - ); - } - g.udp_policy = match cfg.udp_policy.as_str() { - "pass" => UDP_POLICY_PASS, - "drop" => UDP_POLICY_DROP, - "rate-limit" => UDP_POLICY_RATE_LIMIT, - other => bail!("invalid xdp.udp_policy '{other}' (expected pass|drop|rate-limit)"), - }; - if let Some(secret) = cfg.challenge_secret_hex.as_deref() { - g.challenge_secret = parse_secret_hex(secret)?; - } - Ok(g) - } + /// Строит глобалы из секции `[xdp]` конфига. + /// + /// # Errors + /// Неизвестное значение `udp_policy`; некорректный `challenge_secret_hex` + /// (не hex или не 8 байт); `protected_port_end < protected_port_start`. + pub fn from_config(cfg: &XdpConfig) -> Result { + let mut g = Self { + start_port: cfg.protected_port_start, + end_port: cfg.protected_port_end, + udp_hit_count: cfg.udp_rate_hit_count, + udp_window_ns: cfg.udp_rate_window_ms.saturating_mul(1_000_000), + feature_syn_throttle: cfg.throttle_enabled, + feature_events: cfg.events_enabled, + syn_challenge_enabled: cfg.syn_challenge_enabled, + challenge_timeout_ms: cfg.challenge_timeout_ms, + ..Self::default() + }; + if g.end_port < g.start_port { + bail!( + "xdp.protected_port_end ({}) < xdp.protected_port_start ({})", + g.end_port, + g.start_port + ); + } + g.udp_policy = match cfg.udp_policy.as_str() { + "pass" => UDP_POLICY_PASS, + "drop" => UDP_POLICY_DROP, + "rate-limit" => UDP_POLICY_RATE_LIMIT, + other => bail!("invalid xdp.udp_policy '{other}' (expected pass|drop|rate-limit)"), + }; + if let Some(secret) = cfg.challenge_secret_hex.as_deref() { + g.challenge_secret = parse_secret_hex(secret)?; + } + Ok(g) + } } /// Парсит 128-битный hex (16 символов, опциональный префикс `0x`) в u64 (big-endian). fn parse_secret_hex(s: &str) -> Result { - let cleaned = s.trim().trim_start_matches("0x").replace(['_', ':', '-'], ""); - let bytes = hex::decode(&cleaned).with_context(|| format!("invalid xdp.challenge_secret_hex '{s}'"))?; - let arr: [u8; 8] = bytes - .try_into() - .map_err(|v: Vec| anyhow::anyhow!("xdp.challenge_secret_hex must be exactly 8 bytes, got {}", v.len()))?; - Ok(u64::from_be_bytes(arr)) + let cleaned = s.trim().trim_start_matches("0x").replace(['_', ':', '-'], ""); + let bytes = hex::decode(&cleaned).with_context(|| format!("invalid xdp.challenge_secret_hex '{s}'"))?; + let arr: [u8; 8] = bytes + .try_into() + .map_err(|v: Vec| anyhow::anyhow!("xdp.challenge_secret_hex must be exactly 8 bytes, got {}", v.len()))?; + Ok(u64::from_be_bytes(arr)) } diff --git a/src/xdp/metrics.rs b/src/xdp/metrics.rs index fab4ce9..ab3815f 100644 --- a/src/xdp/metrics.rs +++ b/src/xdp/metrics.rs @@ -10,11 +10,11 @@ use std::sync::LazyLock; /// Сколько раз событие XDP-ringbuf привело к userspace-авто-бану /// (счётчик инкрементится только на НОВЫЙ бан, не на продление). pub static XDP_AUTOBANS_TOTAL: LazyLock = LazyLock::new(|| { - register_int_counter!("rampart_xdp_autobans_total", "Auto-bans issued from XDP ringbuf events") - .expect("XDP_AUTOBANS_TOTAL") + register_int_counter!("rampart_xdp_autobans_total", "Auto-bans issued from XDP ringbuf events") + .expect("XDP_AUTOBANS_TOTAL") }); /// Форсирует регистрацию счётчика (для вызова на старте загрузки XDP). pub fn init() { - LazyLock::force(&XDP_AUTOBANS_TOTAL); + LazyLock::force(&XDP_AUTOBANS_TOTAL); } diff --git a/src/xdp/mod.rs b/src/xdp/mod.rs index 15147c0..578ad3a 100644 --- a/src/xdp/mod.rs +++ b/src/xdp/mod.rs @@ -2,8 +2,8 @@ mod probe; pub use probe::{ - AttachMode, EnvironmentReport, FilesystemProbe, KernelVersion, MIN_KERNEL, SystemProbe, XdpStats, - driver_supports_native_xdp, + AttachMode, EnvironmentReport, FilesystemProbe, KernelVersion, MIN_KERNEL, SystemProbe, XdpStats, + driver_supports_native_xdp, }; #[cfg(feature = "xdp")] @@ -20,7 +20,7 @@ mod filter; pub use filter::XdpFilter; #[cfg(feature = "xdp")] pub use filter::events::{ - AutoBanConfig, BanAction, XDP_EVENT_LEN, XdpEvent, XdpEventKind, auto_ban_decision, parse_xdp_event, + AutoBanConfig, BanAction, XDP_EVENT_LEN, XdpEvent, XdpEventKind, auto_ban_decision, parse_xdp_event, }; #[cfg(feature = "xdp")] diff --git a/src/xdp/noop.rs b/src/xdp/noop.rs index 9cb050f..252e55d 100644 --- a/src/xdp/noop.rs +++ b/src/xdp/noop.rs @@ -6,35 +6,35 @@ use crate::traffic::prefix::{PrefixKey, PrefixStatsVal}; pub struct XdpFilter; impl XdpFilter { - pub fn new(_interface: &str) -> Self { - Self - } - pub fn load(&mut self) -> Result<()> { - Ok(()) - } - pub fn unload(&mut self) -> Result<()> { - Ok(()) - } - pub fn drain_events(&self) {} - pub fn ban_ip(&self, _ip: Ipv4Addr, _duration_secs: u64) -> Result<()> { - Ok(()) - } - pub fn ban_cidr(&self, _prefix: IpAddr, _prefix_len: u8, _duration_secs: u64) -> Result<()> { - Ok(()) - } - pub fn unban_ip(&self, _ip: Ipv4Addr) -> Result<()> { - Ok(()) - } + pub fn new(_interface: &str) -> Self { + Self + } + pub fn load(&mut self) -> Result<()> { + Ok(()) + } + pub fn unload(&mut self) -> Result<()> { + Ok(()) + } + pub fn drain_events(&self) {} + pub fn ban_ip(&self, _ip: Ipv4Addr, _duration_secs: u64) -> Result<()> { + Ok(()) + } + pub fn ban_cidr(&self, _prefix: IpAddr, _prefix_len: u8, _duration_secs: u64) -> Result<()> { + Ok(()) + } + pub fn unban_ip(&self, _ip: Ipv4Addr) -> Result<()> { + Ok(()) + } - /// Честная ошибка: чтение `prefix_stats` не подключено без feature `xdp`. - /// - /// # Errors - /// Всегда — сборка без XDP не имеет доступа к картам ядра. - pub fn read_prefix_stats(&self) -> Result> { - anyhow::bail!("prefix_stats reading not wired yet: built without xdp feature") - } + /// Честная ошибка: чтение `prefix_stats` не подключено без feature `xdp`. + /// + /// # Errors + /// Всегда — сборка без XDP не имеет доступа к картам ядра. + pub fn read_prefix_stats(&self) -> Result> { + anyhow::bail!("prefix_stats reading not wired yet: built without xdp feature") + } - pub fn get_stats(&self) -> Result { - Ok(super::XdpStats::default()) - } + pub fn get_stats(&self) -> Result { + Ok(super::XdpStats::default()) + } } diff --git a/src/xdp/probe/diagnostics/report.rs b/src/xdp/probe/diagnostics/report.rs index 1e8a951..fa1699f 100644 --- a/src/xdp/probe/diagnostics/report.rs +++ b/src/xdp/probe/diagnostics/report.rs @@ -1,105 +1,105 @@ use anyhow::{Result, bail}; use super::types::{ - AttachMode, BTF_PATH, KernelVersion, MIN_KERNEL, OSRELEASE_PATH, SystemProbe, driver_from_link, - driver_supports_native_xdp, + AttachMode, BTF_PATH, KernelVersion, MIN_KERNEL, OSRELEASE_PATH, SystemProbe, driver_from_link, + driver_supports_native_xdp, }; /// Структурированный отчёт о пригодности окружения для XDP. pub struct EnvironmentReport { - pub kernel_version: Option, - pub btf_available: bool, - pub privileged: bool, - pub driver_name: Option, - pub warnings: Vec, + pub kernel_version: Option, + pub btf_available: bool, + pub privileged: bool, + pub driver_name: Option, + pub warnings: Vec, } impl EnvironmentReport { - /// Собирает отчёт через произвольную реализацию [`SystemProbe`]. - #[must_use] - pub fn collect(probe: &dyn SystemProbe, interface: &str) -> Self { - let kernel_version = probe - .read_file(OSRELEASE_PATH) - .ok() - .and_then(|r| KernelVersion::parse(r.trim())); - let btf_available = probe.path_exists(BTF_PATH); - let privileged = probe.effective_uid() == 0; - let driver_link = probe.symlink_target(&format!("/sys/class/net/{interface}/device/driver")); - let driver_name = driver_link.as_deref().and_then(driver_from_link); + /// Собирает отчёт через произвольную реализацию [`SystemProbe`]. + #[must_use] + pub fn collect(probe: &dyn SystemProbe, interface: &str) -> Self { + let kernel_version = probe + .read_file(OSRELEASE_PATH) + .ok() + .and_then(|r| KernelVersion::parse(r.trim())); + let btf_available = probe.path_exists(BTF_PATH); + let privileged = probe.effective_uid() == 0; + let driver_link = probe.symlink_target(&format!("/sys/class/net/{interface}/device/driver")); + let driver_name = driver_link.as_deref().and_then(driver_from_link); - let mut warnings = Vec::new(); - if !privileged { - warnings.push( - "процесс не от root: CAP_BPF/CAP_NET_ADMIN не подтверждены, \ + let mut warnings = Vec::new(); + if !privileged { + warnings.push( + "процесс не от root: CAP_BPF/CAP_NET_ADMIN не подтверждены, \ attach скорее всего завершится EPERM" - .to_owned(), - ); - } - if !btf_available { - warnings.push(format!( - "{BTF_PATH} недоступен: CO-RE релокации невозможны, переносимость BPF-программы ограничена" - )); - } - if kernel_version.is_some_and(|v| v < KernelVersion::new(5, 11, 0)) { - warnings.push( - "ядро < 5.11: память BPF-карт ограничена RLIMIT_MEMLOCK — увеличьте `ulimit -l` или обновите ядро" - .to_owned(), - ); - } - if driver_name.is_none() { - warnings.push(format!( - "драйвер интерфейса '{interface}' не определён (нет device/driver symlink): ожидается generic mode" - )); - } + .to_owned(), + ); + } + if !btf_available { + warnings.push(format!( + "{BTF_PATH} недоступен: CO-RE релокации невозможны, переносимость BPF-программы ограничена" + )); + } + if kernel_version.is_some_and(|v| v < KernelVersion::new(5, 11, 0)) { + warnings.push( + "ядро < 5.11: память BPF-карт ограничена RLIMIT_MEMLOCK — увеличьте `ulimit -l` или обновите ядро" + .to_owned(), + ); + } + if driver_name.is_none() { + warnings.push(format!( + "драйвер интерфейса '{interface}' не определён (нет device/driver symlink): ожидается generic mode" + )); + } - Self { - kernel_version, - btf_available, - privileged, - driver_name, - warnings, - } - } + Self { + kernel_version, + btf_available, + privileged, + driver_name, + warnings, + } + } - /// Ожидаемый режим attach по таблице драйверов. - #[must_use] - pub fn attach_mode(&self) -> AttachMode { - match self.driver_name.as_deref() { - Some(driver) if driver_supports_native_xdp(driver) => AttachMode::Native, - _ => AttachMode::Generic, - } - } + /// Ожидаемый режим attach по таблице драйверов. + #[must_use] + pub fn attach_mode(&self) -> AttachMode { + match self.driver_name.as_deref() { + Some(driver) if driver_supports_native_xdp(driver) => AttachMode::Native, + _ => AttachMode::Generic, + } + } - /// Человекочитаемое объяснение вердикта. - #[must_use] - pub fn verdict(&self) -> String { - let kernel = self - .kernel_version - .map_or_else(|| "неизвестна".to_owned(), |v| v.to_string()); - match (self.attach_mode(), self.driver_name.as_deref()) { - (AttachMode::Native, Some(driver)) => format!( - "ядро {kernel}: драйвер '{driver}' поддерживает native XDP — программа работает в драйвере, минимальные накладные расходы" - ), - (_, driver) => format!( - "ядро {kernel}: драйвер '{}' не поддерживает native XDP → будет generic mode, CPU дороже", - driver.unwrap_or("неизвестный") - ), - } - } + /// Человекочитаемое объяснение вердикта. + #[must_use] + pub fn verdict(&self) -> String { + let kernel = self + .kernel_version + .map_or_else(|| "неизвестна".to_owned(), |v| v.to_string()); + match (self.attach_mode(), self.driver_name.as_deref()) { + (AttachMode::Native, Some(driver)) => format!( + "ядро {kernel}: драйвер '{driver}' поддерживает native XDP — программа работает в драйвере, минимальные накладные расходы" + ), + (_, driver) => format!( + "ядро {kernel}: драйвер '{}' не поддерживает native XDP → будет generic mode, CPU дороже", + driver.unwrap_or("неизвестный") + ), + } + } - /// Fail-fast проверка минимальной версии ядра. - /// - /// # Errors - /// Версия ядра не определена или ниже [`MIN_KERNEL`]. - pub fn validate(&self) -> Result<()> { - let Some(version) = self.kernel_version else { - bail!("не удалось определить версию ядра ({OSRELEASE_PATH}) — XDP attach отклонён"); - }; - if version < MIN_KERNEL { - bail!("ядро {version} ниже минимально поддерживаемой {MIN_KERNEL}: XDP attach отклонён, обновите ядро"); - } - Ok(()) - } + /// Fail-fast проверка минимальной версии ядра. + /// + /// # Errors + /// Версия ядра не определена или ниже [`MIN_KERNEL`]. + pub fn validate(&self) -> Result<()> { + let Some(version) = self.kernel_version else { + bail!("не удалось определить версию ядра ({OSRELEASE_PATH}) — XDP attach отклонён"); + }; + if version < MIN_KERNEL { + bail!("ядро {version} ниже минимально поддерживаемой {MIN_KERNEL}: XDP attach отклонён, обновите ядро"); + } + Ok(()) + } } /// Предстартовая диагностика перед загрузкой XDP-программы: @@ -109,24 +109,24 @@ impl EnvironmentReport { /// См. [`EnvironmentReport::validate`]. #[cfg(feature = "xdp")] pub(crate) fn preflight(interface: &str) -> Result<()> { - use super::types::FilesystemProbe; + use super::types::FilesystemProbe; - let report = EnvironmentReport::collect(&FilesystemProbe, interface); - let kernel = report - .kernel_version - .map_or_else(|| "unknown".to_owned(), |v| v.to_string()); - tracing::info!( - interface, - kernel = %kernel, - btf = report.btf_available, - privileged = report.privileged, - driver = report.driver_name.as_deref().unwrap_or("unknown"), - mode = %report.attach_mode(), - "XDP environment: {}", - report.verdict() - ); - for warning in &report.warnings { - tracing::warn!(interface, "{warning}"); - } - report.validate() + let report = EnvironmentReport::collect(&FilesystemProbe, interface); + let kernel = report + .kernel_version + .map_or_else(|| "unknown".to_owned(), |v| v.to_string()); + tracing::info!( + interface, + kernel = %kernel, + btf = report.btf_available, + privileged = report.privileged, + driver = report.driver_name.as_deref().unwrap_or("unknown"), + mode = %report.attach_mode(), + "XDP environment: {}", + report.verdict() + ); + for warning in &report.warnings { + tracing::warn!(interface, "{warning}"); + } + report.validate() } diff --git a/src/xdp/probe/diagnostics/types.rs b/src/xdp/probe/diagnostics/types.rs index 64663fd..5546cd9 100644 --- a/src/xdp/probe/diagnostics/types.rs +++ b/src/xdp/probe/diagnostics/types.rs @@ -11,144 +11,144 @@ const STATUS_PATH: &str = "/proc/self/status"; /// матриц upstream-ядра). Отсутствие в списке не означает отсутствие поддержки, /// но для таких драйверов предсказываем generic mode. const NATIVE_XDP_DRIVERS: &[&str] = &[ - "virtio_net", - "ixgbe", - "ixgbevf", - "i40e", - "iavf", - "ice", - "mlx4_core", - "mlx5_core", - "igb", - "igc", - "e1000e", - "vmxnet3", - "bnxt_en", - "nfp", - "sfc", - "ena", - "hv_netvsc", - "macvlan", + "virtio_net", + "ixgbe", + "ixgbevf", + "i40e", + "iavf", + "ice", + "mlx4_core", + "mlx5_core", + "igb", + "igc", + "e1000e", + "vmxnet3", + "bnxt_en", + "nfp", + "sfc", + "ena", + "hv_netvsc", + "macvlan", ]; /// Версия ядра Linux, пригодная для сравнения (`major.minor.patch`). #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)] pub struct KernelVersion { - pub major: u16, - pub minor: u16, - pub patch: u16, + pub major: u16, + pub minor: u16, + pub patch: u16, } impl KernelVersion { - #[must_use] - pub const fn new(major: u16, minor: u16, patch: u16) -> Self { - Self { major, minor, patch } - } + #[must_use] + pub const fn new(major: u16, minor: u16, patch: u16) -> Self { + Self { major, minor, patch } + } - /// Парсит строку формата `uname -r`. Берёт первые три числовых компонента, - /// дистрибутивные суффиксы (`6.8.0-45-generic`, `5.15.0-rc2`) отбрасываются. - /// Строка без цифр не парсится. - #[must_use] - pub fn parse(release: &str) -> Option { - let mut nums = release - .split(|c: char| !c.is_ascii_digit()) - .filter_map(|part| part.parse::().ok()); - let major = nums.next()?; - let minor = nums.next().unwrap_or(0); - let patch = nums.next().unwrap_or(0); - Some(Self::new(major, minor, patch)) - } + /// Парсит строку формата `uname -r`. Берёт первые три числовых компонента, + /// дистрибутивные суффиксы (`6.8.0-45-generic`, `5.15.0-rc2`) отбрасываются. + /// Строка без цифр не парсится. + #[must_use] + pub fn parse(release: &str) -> Option { + let mut nums = release + .split(|c: char| !c.is_ascii_digit()) + .filter_map(|part| part.parse::().ok()); + let major = nums.next()?; + let minor = nums.next().unwrap_or(0); + let patch = nums.next().unwrap_or(0); + Some(Self::new(major, minor, patch)) + } } impl fmt::Display for KernelVersion { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - write!(f, "{}.{}.{}", self.major, self.minor, self.patch) - } + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + write!(f, "{}.{}.{}", self.major, self.minor, self.patch) + } } /// Режим присоединения XDP-программы к интерфейсу. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum AttachMode { - /// Программа исполняется в контексте драйвера NIC — минимальные накладные расходы. - Native, - /// Программа вызывается из сетевого стека после ingress — работает везде, дороже по CPU. - Generic, - /// Аппаратная разгрузка в NIC — требует явного включения и поддержки железа, - /// автоматически не выбирается. - Offload, + /// Программа исполняется в контексте драйвера NIC — минимальные накладные расходы. + Native, + /// Программа вызывается из сетевого стека после ingress — работает везде, дороже по CPU. + Generic, + /// Аппаратная разгрузка в NIC — требует явного включения и поддержки железа, + /// автоматически не выбирается. + Offload, } impl fmt::Display for AttachMode { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.write_str(match self { - Self::Native => "native", - Self::Generic => "generic", - Self::Offload => "offload", - }) - } + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.write_str(match self { + Self::Native => "native", + Self::Generic => "generic", + Self::Offload => "offload", + }) + } } /// Абстракция над procfs/sysfs: реальная реализация — [`FilesystemProbe`], /// в тестах — мок. Изолирует диагностику от реального ядра. pub trait SystemProbe { - /// Читает файл целиком. - /// - /// # Errors - /// Проксирует ошибку чтения файла. - fn read_file(&self, path: &str) -> std::io::Result; + /// Читает файл целиком. + /// + /// # Errors + /// Проксирует ошибку чтения файла. + fn read_file(&self, path: &str) -> std::io::Result; - #[must_use] - fn path_exists(&self, path: &str) -> bool; + #[must_use] + fn path_exists(&self, path: &str) -> bool; - #[must_use] - fn symlink_target(&self, path: &str) -> Option; + #[must_use] + fn symlink_target(&self, path: &str) -> Option; - #[must_use] - fn effective_uid(&self) -> u32; + #[must_use] + fn effective_uid(&self) -> u32; } /// Реальная реализация [`SystemProbe`] поверх `std::fs`. pub struct FilesystemProbe; impl SystemProbe for FilesystemProbe { - fn read_file(&self, path: &str) -> std::io::Result { - std::fs::read_to_string(path) - } + fn read_file(&self, path: &str) -> std::io::Result { + std::fs::read_to_string(path) + } - fn path_exists(&self, path: &str) -> bool { - std::path::Path::new(path).exists() - } + fn path_exists(&self, path: &str) -> bool { + std::path::Path::new(path).exists() + } - fn symlink_target(&self, path: &str) -> Option { - Some(std::fs::read_link(path).ok()?.to_string_lossy().into_owned()) - } + fn symlink_target(&self, path: &str) -> Option { + Some(std::fs::read_link(path).ok()?.to_string_lossy().into_owned()) + } - /// Эвристика: эффективный uid берётся из `/proc/self/status`. - /// root почти всегда имеет CAP_BPF/CAP_NET_ADMIN (если явно не урезаны); - /// для не-root подтверждение возможно только попыткой attach. - /// Нечитаемый статус трактуем как непривилегированный процесс. - fn effective_uid(&self) -> u32 { - std::fs::read_to_string(STATUS_PATH) - .ok() - .and_then(|status| parse_euid(&status)) - .unwrap_or(1) - } + /// Эвристика: эффективный uid берётся из `/proc/self/status`. + /// root почти всегда имеет CAP_BPF/CAP_NET_ADMIN (если явно не урезаны); + /// для не-root подтверждение возможно только попыткой attach. + /// Нечитаемый статус трактуем как непривилегированный процесс. + fn effective_uid(&self) -> u32 { + std::fs::read_to_string(STATUS_PATH) + .ok() + .and_then(|status| parse_euid(&status)) + .unwrap_or(1) + } } fn parse_euid(status: &str) -> Option { - status.lines().find_map(|line| { - let mut fields = line.strip_prefix("Uid:")?.split_whitespace(); - fields.nth(1)?.parse().ok() - }) + status.lines().find_map(|line| { + let mut fields = line.strip_prefix("Uid:")?.split_whitespace(); + fields.nth(1)?.parse().ok() + }) } pub(super) fn driver_from_link(target: &str) -> Option { - let name = target.rsplit('/').next()?; - (!name.is_empty()).then(|| name.to_owned()) + let name = target.rsplit('/').next()?; + (!name.is_empty()).then(|| name.to_owned()) } /// Поддерживает ли драйвер native XDP (по таблице известных драйверов). #[must_use] pub fn driver_supports_native_xdp(driver: &str) -> bool { - NATIVE_XDP_DRIVERS.contains(&driver) + NATIVE_XDP_DRIVERS.contains(&driver) } diff --git a/src/xdp/probe/metrics.rs b/src/xdp/probe/metrics.rs index 59ffa65..99bd70f 100644 --- a/src/xdp/probe/metrics.rs +++ b/src/xdp/probe/metrics.rs @@ -4,50 +4,50 @@ use prometheus::{IntGauge, register}; use super::XdpStats; pub struct XdpMetrics { - total: IntGauge, - tcp: IntGauge, - whitelist: IntGauge, - blacklist: IntGauge, - syn_throttle: IntGauge, - passed: IntGauge, - dropped: IntGauge, - udp: IntGauge, - rate_limit: IntGauge, + total: IntGauge, + tcp: IntGauge, + whitelist: IntGauge, + blacklist: IntGauge, + syn_throttle: IntGauge, + passed: IntGauge, + dropped: IntGauge, + udp: IntGauge, + rate_limit: IntGauge, } impl XdpMetrics { - fn new_gauge(name: &str, help: &str) -> Result { - let gauge = IntGauge::new(name, help)?; - register(Box::new(gauge.clone())).context(format!("failed to register {name}"))?; - Ok(gauge) - } + fn new_gauge(name: &str, help: &str) -> Result { + let gauge = IntGauge::new(name, help)?; + register(Box::new(gauge.clone())).context(format!("failed to register {name}"))?; + Ok(gauge) + } - pub fn register() -> Result { - let m = Self { - total: Self::new_gauge("rampart_xdp_total", "Total XDP packets processed")?, - tcp: Self::new_gauge("rampart_xdp_tcp", "TCP packets processed")?, - whitelist: Self::new_gauge("rampart_xdp_whitelist", "Whitelisted packets")?, - blacklist: Self::new_gauge("rampart_xdp_blacklist", "Blacklisted packets")?, - syn_throttle: Self::new_gauge("rampart_xdp_syn_throttle", "SYN packets rate-limited")?, - passed: Self::new_gauge("rampart_xdp_passed", "Packets passed to upper layers")?, - dropped: Self::new_gauge("rampart_xdp_dropped", "Packets dropped by filter")?, - udp: Self::new_gauge("rampart_xdp_udp", "UDP packets processed")?, - rate_limit: Self::new_gauge("rampart_xdp_rate_limit", "Packets rate-limited by window counter")?, - }; - tracing::info!("XDP Prometheus metrics registered"); - Ok(m) - } + pub fn register() -> Result { + let m = Self { + total: Self::new_gauge("rampart_xdp_total", "Total XDP packets processed")?, + tcp: Self::new_gauge("rampart_xdp_tcp", "TCP packets processed")?, + whitelist: Self::new_gauge("rampart_xdp_whitelist", "Whitelisted packets")?, + blacklist: Self::new_gauge("rampart_xdp_blacklist", "Blacklisted packets")?, + syn_throttle: Self::new_gauge("rampart_xdp_syn_throttle", "SYN packets rate-limited")?, + passed: Self::new_gauge("rampart_xdp_passed", "Packets passed to upper layers")?, + dropped: Self::new_gauge("rampart_xdp_dropped", "Packets dropped by filter")?, + udp: Self::new_gauge("rampart_xdp_udp", "UDP packets processed")?, + rate_limit: Self::new_gauge("rampart_xdp_rate_limit", "Packets rate-limited by window counter")?, + }; + tracing::info!("XDP Prometheus metrics registered"); + Ok(m) + } - pub fn update(&self, stats: &XdpStats) { - self.total.set(stats.total as i64); - self.tcp.set(stats.tcp as i64); - self.whitelist.set(stats.whitelist as i64); - self.blacklist.set(stats.blacklist as i64); - self.syn_throttle.set(stats.syn_throttle as i64); - self.passed.set(stats.passed as i64); - self.dropped.set(stats.dropped as i64); - self.udp.set(stats.udp as i64); - self.rate_limit.set(stats.rate_limit as i64); - tracing::debug!("XDP metrics updated"); - } + pub fn update(&self, stats: &XdpStats) { + self.total.set(stats.total as i64); + self.tcp.set(stats.tcp as i64); + self.whitelist.set(stats.whitelist as i64); + self.blacklist.set(stats.blacklist as i64); + self.syn_throttle.set(stats.syn_throttle as i64); + self.passed.set(stats.passed as i64); + self.dropped.set(stats.dropped as i64); + self.udp.set(stats.udp as i64); + self.rate_limit.set(stats.rate_limit as i64); + tracing::debug!("XDP metrics updated"); + } } diff --git a/src/xdp/probe/mod.rs b/src/xdp/probe/mod.rs index 2513829..7863929 100644 --- a/src/xdp/probe/mod.rs +++ b/src/xdp/probe/mod.rs @@ -4,7 +4,7 @@ mod diagnostics; #[cfg(feature = "xdp")] pub(crate) use diagnostics::preflight; pub use diagnostics::{ - AttachMode, EnvironmentReport, FilesystemProbe, KernelVersion, MIN_KERNEL, SystemProbe, driver_supports_native_xdp, + AttachMode, EnvironmentReport, FilesystemProbe, KernelVersion, MIN_KERNEL, SystemProbe, driver_supports_native_xdp, }; mod stats; diff --git a/src/xdp/probe/stats.rs b/src/xdp/probe/stats.rs index 99d1ef9..3cb29d9 100644 --- a/src/xdp/probe/stats.rs +++ b/src/xdp/probe/stats.rs @@ -1,13 +1,13 @@ /// Счётчики XDP-программы; индексы соответствуют STAT_* из xdp/core/maps.h. #[derive(Debug, Clone, Copy, Default)] pub struct XdpStats { - pub total: u64, - pub tcp: u64, - pub whitelist: u64, - pub blacklist: u64, - pub syn_throttle: u64, - pub passed: u64, - pub dropped: u64, - pub udp: u64, - pub rate_limit: u64, + pub total: u64, + pub tcp: u64, + pub whitelist: u64, + pub blacklist: u64, + pub syn_throttle: u64, + pub passed: u64, + pub dropped: u64, + pub udp: u64, + pub rate_limit: u64, } diff --git a/tests/config_parse.rs b/tests/config_parse.rs index c7bc16f..aede877 100644 --- a/tests/config_parse.rs +++ b/tests/config_parse.rs @@ -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); } diff --git a/tests/filter_logic.rs b/tests/filter_logic.rs index 7142914..fbc795e 100644 --- a/tests/filter_logic.rs +++ b/tests/filter_logic.rs @@ -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))); } diff --git a/tests/http_protocol.rs b/tests/http_protocol.rs index c7f2b2b..6601ffd 100644 --- a/tests/http_protocol.rs +++ b/tests/http_protocol.rs @@ -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()]) } diff --git a/tests/pow_roundtrip.rs b/tests/pow_roundtrip.rs index ad703a2..0450a4b 100644 --- a/tests/pow_roundtrip.rs +++ b/tests/pow_roundtrip.rs @@ -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"); } diff --git a/tests/protocol_registry.rs b/tests/protocol_registry.rs index bd19d8e..8f8e863 100644 --- a/tests/protocol_registry.rs +++ b/tests/protocol_registry.rs @@ -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> + 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> + 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"); } diff --git a/tests/subnet_detection.rs b/tests/subnet_detection.rs index 9062de6..a12622c 100644 --- a/tests/subnet_detection.rs +++ b/tests/subnet_detection.rs @@ -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> { - Ok(self.0.clone()) - } + async fn snapshot(&self) -> anyhow::Result> { + 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::().expect("valid")); - let v6b = IpAddr::V6("2001:db8:1:2::ffff".parse::().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::().expect("valid")); + let v6b = IpAddr::V6("2001:db8:1:2::ffff".parse::().expect("valid")); + tracker.record_connection(v6a); + tracker.record_connection(v6b); + tracker.record_connection(v4([10, 0, 0, 1])); - let snaps: HashMap = tracker.take_snapshot().into_iter().collect(); - assert_eq!(snaps.len(), 2); - assert_eq!( - snaps[&IpAddr::V6("2001:db8:1:2::".parse::().expect("valid"))].unique_sources, - 2 - ); - assert_eq!(snaps[&v4([10, 0, 0, 0])].unique_sources, 1); + let snaps: HashMap = tracker.take_snapshot().into_iter().collect(); + assert_eq!(snaps.len(), 2); + assert_eq!( + snaps[&IpAddr::V6("2001:db8:1:2::".parse::().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::().expect("valid")); - assert_eq!( - prefix_of(ip), - IpAddr::V6("2001:db8:1:2::".parse::().expect("valid")) - ); + let ip = IpAddr::V6("2001:db8:1:2:3:4:5:6".parse::().expect("valid")); + assert_eq!( + prefix_of(ip), + IpAddr::V6("2001:db8:1:2::".parse::().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::(), 24); - assert_eq!(size_of::(), 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::(), 24); + assert_eq!(size_of::(), 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::().expect("valid"))); - assert_eq!(key6.family, rampart::traffic::prefix::PREFIX_FAMILY_V6); - assert_eq!( - key6.to_prefix(), - Some(IpAddr::V6("2001:db8::".parse::().expect("valid"))) - ); + let key6 = PrefixKey::new(IpAddr::V6("2001:db8::1".parse::().expect("valid"))); + assert_eq!(key6.family, rampart::traffic::prefix::PREFIX_FAMILY_V6); + assert_eq!( + key6.to_prefix(), + Some(IpAddr::V6("2001:db8::".parse::().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); } diff --git a/tests/traffic_intel.rs b/tests/traffic_intel.rs index e869ad4..313bdee 100644 --- a/tests/traffic_intel.rs +++ b/tests/traffic_intel.rs @@ -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")); } diff --git a/tests/tui_metrics.rs b/tests/tui_metrics.rs index 239d5fa..4632f26 100644 --- a/tests/tui_metrics.rs +++ b/tests/tui_metrics.rs @@ -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> { - let error = self.error.clone(); - Box::pin(async { Err(error) }) - } + fn fetch(&self) -> BoxFuture<'_, Result> { + 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) + ); } diff --git a/tests/xdp_diagnostics.rs b/tests/xdp_diagnostics.rs index 9f9d485..da28cef 100644 --- a/tests/xdp_diagnostics.rs +++ b/tests/xdp_diagnostics.rs @@ -2,133 +2,133 @@ use rampart::xdp::{AttachMode, EnvironmentReport, KernelVersion, MIN_KERNEL, Sys use std::collections::HashMap; struct MockProbe { - files: HashMap, - symlinks: HashMap, - uid: u32, + files: HashMap, + symlinks: HashMap, + 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 { - self.files - .get(path) - .cloned() - .ok_or_else(|| std::io::Error::other("file not found")) - } + fn read_file(&self, path: &str) -> std::io::Result { + 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 { - self.symlinks.get(path).cloned() - } + fn symlink_target(&self, path: &str) -> Option { + 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}"); } diff --git a/tests/xdp_events.rs b/tests/xdp_events.rs index 88611a3..4e92a58 100644 --- a/tests/xdp_events.rs +++ b/tests/xdp_events.rs @@ -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 + ); } diff --git a/tests/xdp_globals.rs b/tests/xdp_globals.rs index b8be66f..6891d2d 100644 --- a/tests/xdp_globals.rs +++ b/tests/xdp_globals.rs @@ -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()); }