diff --git a/TODO.md b/TODO.md index a8d7ea9..7fe63b7 100644 --- a/TODO.md +++ b/TODO.md @@ -287,9 +287,10 @@ module-size, secrets, `cargo deny`, rustdoc без warning'ов, clang+verifier, ### Осталось -- [ ] Monitor (`add_cidr`) и `traffic/hook` autoban не сверяются с `trusted_cidrs`: если - доверенный прокси физически живёт в банимой подсети, его адрес может попасть под - префиксный бан. Нужна общая проверка перед любым баном. +- [x] Monitor (`add_cidr`) и `traffic/hook` autoban сверяются с `trusted_cidrs`: бан + подавляется, если префикс пересекается с доверенной сетью (`TrustedProxyCidr::overlaps_prefix`), + о чём пишется warn. Тесты: `tests/subnet_detection.rs`, `tests/traffic_intel.rs`, + `tests/proxy_identity.rs`. ### Сделано в этом раунде diff --git a/src/app/runtime.rs b/src/app/runtime.rs index 91142d2..675be95 100644 --- a/src/app/runtime.rs +++ b/src/app/runtime.rs @@ -64,12 +64,15 @@ pub async fn run() -> anyhow::Result { 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 hook = Arc::new( + TrafficHook::new( + reputation.clone(), + blacklist.clone(), + config.detect.autoban.clone(), + config.ban.ban_duration_secs, + ) + .with_trusted(config.proxy_protocol.trusted_cidrs.clone()), + ); let alert_dispatcher = AlertDispatcher::new(); let webhook_url = config.detect.alert.webhook_url.clone(); let allowed_1s = Arc::new(AtomicU64::new(0)); @@ -132,11 +135,14 @@ pub async fn run() -> anyhow::Result { let subnet_tracker = start_subnet_tracker(&config); monitor::spawn( &config.detect.prefix, - Duration::from_secs(config.ban.ban_duration_secs), - blacklist.clone(), - !config.proxy_protocol.ingress_enabled, - subnet_tracker.clone(), - xdp_filter.clone(), + monitor::MonitorSetup { + ban_ttl: Duration::from_secs(config.ban.ban_duration_secs), + blacklist: blacklist.clone(), + trusted_peer: !config.proxy_protocol.ingress_enabled, + trusted_networks: config.proxy_protocol.trusted_cidrs.clone(), + tracker: subnet_tracker.clone(), + xdp: xdp_filter.clone(), + }, shutdown_rx.clone(), ); diff --git a/src/config/mod.rs b/src/config/mod.rs index 6f9996e..727d0e4 100644 --- a/src/config/mod.rs +++ b/src/config/mod.rs @@ -3,6 +3,7 @@ //! Owns the [`Config`] root type, its serde defaults and the semantic validation //! that runs before the daemon binds a socket. mod sections; +mod trusted; #[cfg(feature = "protocol-http")] pub use sections::HttpProtocolConfig; @@ -12,9 +13,9 @@ pub use sections::MinecraftProtocolConfig; pub use sections::ProtocolConfig; pub use sections::{ BackendConfig, BanConfig, BindConfig, DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig, - LimitsConfig, LoggingConfig, MetricsConfig, PowConfig, ProxyProtocolConfig, StoreConfig, TrustedProxyCidr, - WorkerConfig, XdpConfig, + LimitsConfig, LoggingConfig, MetricsConfig, PowConfig, ProxyProtocolConfig, StoreConfig, WorkerConfig, XdpConfig, }; +pub use trusted::TrustedProxyCidr; use serde::Deserialize; use std::fs; diff --git a/src/config/sections/edge.rs b/src/config/sections/edge.rs index 79541b5..c4c7163 100644 --- a/src/config/sections/edge.rs +++ b/src/config/sections/edge.rs @@ -1,8 +1,7 @@ //! Edge sections: bind, backend, workers, limits, ban, PoW and PROXY protocol. +use crate::config::trusted::TrustedProxyCidr; use serde::{Deserialize, Deserializer}; -use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; -use std::str::FromStr; /// `[bind]` section: listen address and port of the edge node. #[derive(Debug, Clone, Deserialize)] @@ -159,66 +158,6 @@ fn default_pow_difficulty() -> u8 { 4 } -/// CIDR network allowed to send inbound PROXY protocol headers. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct TrustedProxyCidr { - network: IpAddr, - prefix_len: u8, -} - -impl TrustedProxyCidr { - /// Returns whether `ip` belongs to this network. - #[must_use] - pub fn contains(&self, ip: IpAddr) -> bool { - // Masks are family-specific: a prefix above 32 would underflow the v4 shift. - let prefix = self.prefix_len; - match (self.network, ip) { - (IpAddr::V4(net), IpAddr::V4(ip)) => u32::from(net) & mask_v4(prefix) == u32::from(ip) & mask_v4(prefix), - (IpAddr::V6(net), IpAddr::V6(ip)) => u128::from(net) & mask_v6(prefix) == u128::from(ip) & mask_v6(prefix), - _ => false, - } - } -} - -impl FromStr for TrustedProxyCidr { - type Err = String; - - fn from_str(value: &str) -> Result { - let (address, prefix) = value.split_once('/').map_or((value, None), |(a, p)| (a, Some(p))); - 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 = prefix - .map_or(Ok(max_prefix), |prefix| prefix.parse::()) - .map_err(|_| format!("invalid trusted proxy CIDR prefix: {value}"))?; - 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 mask_v4(prefix: u8) -> u32 { - if prefix == 0 { 0 } else { u32::MAX << (32 - prefix) } -} - -fn mask_v6(prefix: u8) -> u128 { - if prefix == 0 { 0 } else { u128::MAX << (128 - prefix) } -} - /// `[proxy_protocol]` section: inbound PROXY protocol ingestion. #[derive(Debug, Clone, Deserialize)] pub struct ProxyProtocolConfig { diff --git a/src/config/sections/mod.rs b/src/config/sections/mod.rs index ffb8121..142cf8e 100644 --- a/src/config/sections/mod.rs +++ b/src/config/sections/mod.rs @@ -11,7 +11,5 @@ pub use detect::MinecraftProtocolConfig; #[cfg(any(feature = "protocol-http", feature = "protocol-minecraft"))] pub use detect::ProtocolConfig; pub use detect::{DetectAlertConfig, DetectAutobanConfig, DetectConfig, DetectPrefixConfig}; -pub use edge::{ - BackendConfig, BanConfig, BindConfig, LimitsConfig, PowConfig, ProxyProtocolConfig, TrustedProxyCidr, WorkerConfig, -}; +pub use edge::{BackendConfig, BanConfig, BindConfig, LimitsConfig, PowConfig, ProxyProtocolConfig, WorkerConfig}; pub use platform::{LoggingConfig, MetricsConfig, StoreConfig, XdpConfig}; diff --git a/src/config/trusted.rs b/src/config/trusted.rs new file mode 100644 index 0000000..06dc4c7 --- /dev/null +++ b/src/config/trusted.rs @@ -0,0 +1,108 @@ +//! Trusted PROXY-protocol networks and CIDR helpers shared by the edge paths. + +use serde::{Deserialize, Deserializer}; +use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; +use std::str::FromStr; + +/// CIDR network allowed to send inbound PROXY protocol headers. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct TrustedProxyCidr { + network: IpAddr, + prefix_len: u8, +} + +impl TrustedProxyCidr { + /// Returns whether `ip` belongs to this network. + #[must_use] + pub fn contains(&self, ip: IpAddr) -> bool { + // Masks are family-specific: a prefix above 32 would underflow the v4 shift. + let prefix = self.prefix_len; + match (self.network, normalize(ip)) { + (IpAddr::V4(net), IpAddr::V4(ip)) => u32::from(net) & mask_v4(prefix) == u32::from(ip) & mask_v4(prefix), + (IpAddr::V6(net), IpAddr::V6(ip)) => u128::from(net) & mask_v6(prefix) == u128::from(ip) & mask_v6(prefix), + _ => false, + } + } + + /// Returns whether `ip/prefix_len` intersects this network. + /// + /// Used before banning a prefix: a ban covering a trusted proxy address + /// would punish the proxy and every client behind it. + #[must_use] + pub fn overlaps_prefix(&self, ip: IpAddr, prefix_len: u8) -> bool { + match (self.network, normalize(ip)) { + (IpAddr::V4(net), IpAddr::V4(other)) => { + if prefix_len == 0 || prefix_len > 32 { + return false; + } + let net_mask = mask_v4(self.prefix_len); + let other_mask = mask_v4(prefix_len); + let net_start = u32::from(net) & net_mask; + let net_end = net_start | !net_mask; + let other_start = u32::from(other) & other_mask; + let other_end = other_start | !other_mask; + net_start <= other_end && other_start <= net_end + }, + (IpAddr::V6(net), IpAddr::V6(other)) => { + if prefix_len == 0 || prefix_len > 128 { + return false; + } + let net_mask = mask_v6(self.prefix_len); + let other_mask = mask_v6(prefix_len); + let net_start = u128::from(net) & net_mask; + let net_end = net_start | !net_mask; + let other_start = u128::from(other) & other_mask; + let other_end = other_start | !other_mask; + net_start <= other_end && other_start <= net_end + }, + _ => false, + } + } +} + +impl FromStr for TrustedProxyCidr { + type Err = String; + + fn from_str(value: &str) -> Result { + let (address, prefix) = value.split_once('/').map_or((value, None), |(a, p)| (a, Some(p))); + 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 = prefix + .map_or(Ok(max_prefix), |prefix| prefix.parse::()) + .map_err(|_| format!("invalid trusted proxy CIDR prefix: {value}"))?; + 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) + } +} + +/// Collapses IPv4-mapped IPv6 addresses to IPv4. +fn normalize(ip: IpAddr) -> IpAddr { + match ip { + IpAddr::V6(v6) => v6.to_ipv4_mapped().map_or(ip, IpAddr::V4), + IpAddr::V4(_) => ip, + } +} + +fn mask_v4(prefix: u8) -> u32 { + if prefix == 0 { 0 } else { u32::MAX << (32 - prefix) } +} + +fn mask_v6(prefix: u8) -> u128 { + if prefix == 0 { 0 } else { u128::MAX << (128 - prefix) } +} diff --git a/src/engine/subnet/monitor.rs b/src/engine/subnet/monitor.rs index e8a822a..3a55e58 100644 --- a/src/engine/subnet/monitor.rs +++ b/src/engine/subnet/monitor.rs @@ -38,6 +38,9 @@ struct BanPolicy { blacklist: Arc, ttl: Duration, trusted: bool, + /// Trusted PROXY-protocol networks; a prefix ban overlapping one of them is + /// suppressed, because it would punish the proxy and every client behind it. + trusted_networks: Vec, } /// Spawns the background subnet monitor when `[detect.prefix] enabled`. @@ -46,22 +49,37 @@ struct BanPolicy { /// aggregator. Without either source the monitor stays disabled and logs a /// warning. /// -/// `ban_ttl` comes from `[ban].ban_duration_secs`. `trusted_peer` is false when -/// the observed address comes from an unverified ingress path (inbound PROXY -/// protocol), where banning it could punish the transport proxy instead of the -/// real client. -pub fn spawn( - detect: &DetectPrefixConfig, - ban_ttl: Duration, - blacklist: Arc, - trusted_peer: bool, - tracker: Option>, - xdp: Option>>, - mut shutdown: watch::Receiver, -) { +/// Everything the monitor task needs besides the detection config. +pub struct MonitorSetup { + /// Ban lifetime, from `[ban].ban_duration_secs`. + pub ban_ttl: Duration, + /// Shared ban table. + pub blacklist: Arc, + /// False when the observed address comes from an unverified ingress path + /// (inbound PROXY protocol), where banning it could punish the transport + /// proxy instead of the real client. + pub trusted_peer: bool, + /// Trusted proxy networks; a prefix ban overlapping one is suppressed. + pub trusted_networks: Vec, + /// Userspace aggregator, used when XDP is not available. + pub tracker: Option>, + /// Loaded XDP filter, preferred over the userspace tracker when present. + pub xdp: Option>>, +} + +/// Spawns the background subnet monitor when `[detect.prefix] enabled`. +pub fn spawn(detect: &DetectPrefixConfig, setup: MonitorSetup, mut shutdown: watch::Receiver) { if !detect.enabled { return; } + let MonitorSetup { + ban_ttl, + blacklist, + trusted_peer, + trusted_networks, + tracker, + xdp, + } = setup; let Some(source) = build_source(tracker, xdp) else { tracing::warn!("detect.prefix enabled but no stats source available; monitor disabled"); return; @@ -72,6 +90,7 @@ pub fn spawn( blacklist, ttl: ban_ttl, trusted: trusted_peer, + trusted_networks, }; tokio::spawn(async move { @@ -124,7 +143,7 @@ fn apply_verdicts(verdicts: &[PrefixVerdict], source: &Source, policy: &BanPolic } match source { #[cfg(feature = "xdp")] - Source::Xdp(xdp) if policy.trusted => ban_xdp_verdicts(xdp, verdicts, policy.ttl), + Source::Xdp(xdp) if policy.trusted => ban_xdp_verdicts(xdp, verdicts, policy.ttl, &policy.trusted_networks), #[cfg(feature = "xdp")] Source::Xdp(_) => { if verdicts.iter().any(|pv| pv.verdict == SubnetVerdict::Block) { @@ -132,7 +151,13 @@ fn apply_verdicts(verdicts: &[PrefixVerdict], source: &Source, policy: &BanPolic } }, Source::Tracker(_) => { - enforce_tracker_verdicts(verdicts, &policy.blacklist, policy.ttl, policy.trusted); + enforce_tracker_verdicts( + verdicts, + &policy.blacklist, + policy.ttl, + policy.trusted, + &policy.trusted_networks, + ); }, } } @@ -150,6 +175,7 @@ pub fn enforce_tracker_verdicts( blacklist: &Blacklist, ttl: Duration, trusted: bool, + trusted_networks: &[crate::config::TrustedProxyCidr], ) -> usize { let mut banned = 0; for pv in verdicts.iter().filter(|pv| pv.verdict == SubnetVerdict::Block) { @@ -160,6 +186,16 @@ pub fn enforce_tracker_verdicts( ); continue; } + if trusted_networks + .iter() + .any(|net| net.overlaps_prefix(pv.prefix, prefix_len(pv.prefix))) + { + tracing::warn!( + prefix = %pv.prefix, + "subnet ban suppressed: the prefix contains a trusted proxy network" + ); + continue; + } blacklist.add_cidr(pv.prefix, prefix_len(pv.prefix), ttl, "subnet_attack"); banned += 1; tracing::warn!( @@ -172,8 +208,21 @@ pub fn enforce_tracker_verdicts( } #[cfg(feature = "xdp")] -fn ban_xdp_verdicts(xdp: &XdpPrefixStats, verdicts: &[PrefixVerdict], ttl: Duration) { +fn ban_xdp_verdicts( + xdp: &XdpPrefixStats, + verdicts: &[PrefixVerdict], + ttl: Duration, + trusted_networks: &[crate::config::TrustedProxyCidr], +) { for pv in verdicts.iter().filter(|pv| pv.verdict == SubnetVerdict::Block) { + let len = prefix_len(pv.prefix); + if trusted_networks.iter().any(|net| net.overlaps_prefix(pv.prefix, len)) { + tracing::warn!( + prefix = %pv.prefix, + "subnet kernel ban suppressed: the prefix contains a trusted proxy network" + ); + continue; + } let result = { let guard = xdp.filter_lock(); guard.ban_cidr(pv.prefix, prefix_len(pv.prefix), ttl.as_secs()) diff --git a/src/traffic/hook.rs b/src/traffic/hook.rs index 356f250..850e909 100644 --- a/src/traffic/hook.rs +++ b/src/traffic/hook.rs @@ -25,6 +25,8 @@ pub struct TrafficHook { autoban: DetectAutobanConfig, ban_ttl_secs: u64, conn_window: AtomicU64, + /// Trusted PROXY-protocol networks; addresses inside them are never banned. + trusted: Vec, } impl TrafficHook { @@ -40,9 +42,17 @@ impl TrafficHook { autoban, ban_ttl_secs, conn_window: AtomicU64::new(0), + trusted: Vec::new(), } } + /// Marks the networks whose addresses must never be banned (trusted proxies). + #[must_use] + pub fn with_trusted(mut self, trusted: Vec) -> Self { + self.trusted = trusted; + self + } + /// A new connection was accepted by the accept loop. /// /// Only bumps the cps window counter; the counter is drained by @@ -76,8 +86,9 @@ impl TrafficHook { if self.blacklist.is_blocked(ip) { continue; } - self.ban(ip, BAN_REASON_ATTACK); - banned += 1; + if self.ban(ip, BAN_REASON_ATTACK) { + banned += 1; + } } banned } @@ -91,12 +102,21 @@ impl TrafficHook { if self.reputation.score(ip) > self.autoban.reputation_threshold { return; } - self.ban(ip, reason); + let _ = self.ban(ip, reason); } - fn ban(&self, ip: IpAddr, reason: &str) { + /// Bans `ip` unless it belongs to a trusted proxy network. + /// + /// Returns whether the ban was actually installed. + fn ban(&self, ip: IpAddr, reason: &str) -> bool { + let host_prefix = if ip.is_ipv4() { 32 } else { 128 }; + if self.trusted.iter().any(|net| net.overlaps_prefix(ip, host_prefix)) { + tracing::warn!(%ip, reason, "auto-ban suppressed: address belongs to a trusted proxy network"); + return false; + } 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"); + true } } diff --git a/tests/proxy_identity.rs b/tests/proxy_identity.rs index bb441fb..731cdd8 100644 --- a/tests/proxy_identity.rs +++ b/tests/proxy_identity.rs @@ -237,3 +237,25 @@ async fn plain_connection_uses_the_transport_peer() { let outcome = handle_plain(&gateway, peer).await; assert_eq!(outcome.client_ip, Some(peer.ip())); } + +#[test] +fn trusted_network_overlap_checks_prefix_intersection() { + let net: TrustedProxyCidr = "10.0.0.0/8".parse().expect("cidr"); + assert!(net.overlaps_prefix("10.1.2.0".parse().expect("ip"), 24), "same range"); + assert!( + net.overlaps_prefix("10.0.0.0".parse().expect("ip"), 7), + "wider prefix overlaps" + ); + assert!( + !net.overlaps_prefix("11.0.0.0".parse().expect("ip"), 8), + "sibling range" + ); + assert!( + !net.overlaps_prefix("10.0.0.0".parse().expect("ip"), 0), + "/0 is rejected" + ); + + let v6: TrustedProxyCidr = "fd00::/8".parse().expect("cidr"); + assert!(v6.overlaps_prefix("fd12::".parse().expect("ip"), 16)); + assert!(!v6.overlaps_prefix("2001:db8::".parse().expect("ip"), 32)); +} diff --git a/tests/subnet_detection.rs b/tests/subnet_detection.rs index 8301c27..cf33eaa 100644 --- a/tests/subnet_detection.rs +++ b/tests/subnet_detection.rs @@ -1,6 +1,6 @@ //! Integration tests for subnet-level detection: tracker, detector and verdicts. -use rampart::config::Config; +use rampart::config::{Config, TrustedProxyCidr}; use rampart::engine::subnet::monitor::enforce_tracker_verdicts; use rampart::engine::subnet_tracker::SubnetTracker; use rampart::filter::blacklist::Blacklist; @@ -299,7 +299,7 @@ fn block_verdict(prefix: IpAddr) -> PrefixVerdict { fn trusted_tracker_block_reaches_the_blacklist_with_the_configured_ttl() { let blacklist = Blacklist::new(); let verdicts = [block_verdict(v4([203, 0, 113, 0]))]; - let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true); + let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true, &[]); assert_eq!(banned, 1); assert!(blacklist.is_blocked(v4([203, 0, 113, 0]))); } @@ -308,7 +308,7 @@ fn trusted_tracker_block_reaches_the_blacklist_with_the_configured_ttl() { fn untrusted_tracker_block_only_warns() { let blacklist = Blacklist::new(); let verdicts = [block_verdict(v4([198, 51, 100, 0]))]; - let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), false); + let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), false, &[]); assert_eq!(banned, 0); assert!(blacklist.is_empty()); } @@ -317,7 +317,7 @@ fn untrusted_tracker_block_only_warns() { fn tracker_ban_uses_the_given_duration() { let blacklist = Blacklist::new(); let verdicts = [block_verdict(v4([192, 0, 2, 0]))]; - enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_millis(1), true); + enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_millis(1), true, &[]); std::thread::sleep(Duration::from_millis(2)); assert!( !blacklist.is_blocked(v4([192, 0, 2, 0])), @@ -331,7 +331,7 @@ fn non_block_verdicts_do_not_ban() { let mut verdict = block_verdict(v4([203, 0, 113, 0])); verdict.verdict = SubnetVerdict::Challenge; assert_eq!( - enforce_tracker_verdicts(&[verdict], &blacklist, Duration::from_secs(60), true), + enforce_tracker_verdicts(&[verdict], &blacklist, Duration::from_secs(60), true, &[]), 0 ); assert!(blacklist.is_empty()); @@ -375,3 +375,23 @@ fn prefix_key_normalises_ipv4_mapped_addresses() { assert_eq!(PrefixKey::new(mapped).to_prefix(), Some(prefix_of(mapped))); assert_eq!(PrefixKey::new(mapped).to_prefix(), Some(v4([1, 2, 3, 0]))); } + +#[test] +fn tracker_block_is_suppressed_when_a_trusted_proxy_lives_in_the_prefix() { + let blacklist = Blacklist::new(); + let verdicts = [block_verdict(v4([10, 9, 0, 0]))]; + let trusted: Vec = vec!["10.9.0.5/32".parse().expect("trusted cidr")]; + let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true, &trusted); + assert_eq!(banned, 0, "a ban covering a trusted proxy must be suppressed"); + assert!(blacklist.is_empty()); +} + +#[test] +fn tracker_block_still_applies_when_trusted_networks_do_not_overlap() { + let blacklist = Blacklist::new(); + let verdicts = [block_verdict(v4([10, 9, 0, 0]))]; + let trusted: Vec = vec!["192.0.2.0/24".parse().expect("trusted cidr")]; + let banned = enforce_tracker_verdicts(&verdicts, &blacklist, Duration::from_secs(120), true, &trusted); + assert_eq!(banned, 1); + assert!(blacklist.is_blocked(v4([10, 9, 0, 7]))); +} diff --git a/tests/traffic_intel.rs b/tests/traffic_intel.rs index 7f73248..22d30d9 100644 --- a/tests/traffic_intel.rs +++ b/tests/traffic_intel.rs @@ -446,3 +446,33 @@ fn alerts_fire_only_on_state_transitions() { assert!(alerts[0].message.contains("attack started")); assert!(alerts[1].message.contains("attack ended")); } + +#[test] +fn auto_ban_never_targets_a_trusted_proxy_network() { + let reputation = Arc::new(IpReputation::new()); + let blacklist = Arc::new(Blacklist::new()); + let trusted: Vec = vec!["10.0.0.0/8".parse().expect("trusted cidr")]; + let hook = + TrafficHook::new(Arc::clone(&reputation), Arc::clone(&blacklist), autoban_cfg(true), 60).with_trusted(trusted); + let inside = ip([10, 1, 2, 3]); + + for _ in 0..6 { + reputation.record_bad(inside); + hook.on_connection_end(inside); + } + assert!( + reputation.score(inside) <= -50, + "reputation must fall below the threshold" + ); + assert_eq!(hook.ban_offenders(), 0, "trusted addresses are never banned"); + + let public = ip([198, 51, 100, 9]); + for _ in 0..6 { + reputation.record_bad(public); + hook.on_connection_end(public); + } + assert!( + blacklist.is_blocked(public), + "non-trusted offenders are still banned by the reputation path" + ); +}