use super::geo::{GeoCoord, GeoLookup};
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::strategy::firewall::{FirewallContext, GarrisonFirewallStrategy};
use async_trait::async_trait;
use std::sync::Arc;
#[derive(Debug, Clone)]
pub struct AnomalousConfig {
pub known_geo_threshold: u32,
}
impl Default for AnomalousConfig {
fn default() -> Self {
Self {
known_geo_threshold: 500,
}
}
}
pub struct AnomalousLoginStrategy {
config: AnomalousConfig,
dao: Arc<dyn GarrisonDao>,
geo_lookup: Arc<dyn GeoLookup>,
}
impl AnomalousLoginStrategy {
pub fn new(
config: AnomalousConfig,
dao: Arc<dyn GarrisonDao>,
geo_lookup: Arc<dyn GeoLookup>,
) -> Self {
Self {
config,
dao,
geo_lookup,
}
}
async fn update_historic_coord(
&self,
key: &str,
current_coord: GeoCoord,
) -> GarrisonResult<()> {
self.dao.set_permanent(key, ¤t_coord.to_csv()).await
}
}
fn haversine_km(lat1: f64, lon1: f64, lat2: f64, lon2: f64) -> f64 {
const R_KM: f64 = 6371.0;
let lat1_rad = lat1.to_radians();
let lat2_rad = lat2.to_radians();
let dlat = (lat2 - lat1).to_radians();
let dlon = (lon2 - lon1).to_radians();
let a =
(dlat / 2.0).sin().powi(2) + lat1_rad.cos() * lat2_rad.cos() * (dlon / 2.0).sin().powi(2);
let c = 2.0 * a.sqrt().asin();
R_KM * c
}
#[async_trait]
impl GarrisonFirewallStrategy for AnomalousLoginStrategy {
async fn check(&self, ctx: &FirewallContext) -> GarrisonResult<()> {
let login_id = ctx.login_id.as_ref().ok_or_else(|| {
GarrisonError::InvalidParam("firewall-anomalous-need-login-id::".to_string())
})?;
let current_coord = match self.geo_lookup.lookup(&ctx.ip).await? {
Some(c) => c,
None => return Ok(()),
};
let key = format!("anom:user:{}", login_id);
match self.dao.get(&key).await? {
None => {
self.update_historic_coord(&key, current_coord).await?;
Ok(())
},
Some(csv) => {
let historic_coord = GeoCoord::from_csv(&csv).ok_or_else(|| {
GarrisonError::Dao(format!(
"firewall-anomalous-geo-parse-failed::{}::{}",
key, csv
))
})?;
let distance = haversine_km(
historic_coord.lat,
historic_coord.lon,
current_coord.lat,
current_coord.lon,
);
if distance > self.config.known_geo_threshold as f64 {
let loc = format!("{}f {}", login_id, ctx.ip);
let detail = format!(
"distance {:.0}km exceeds threshold {}km",
distance, self.config.known_geo_threshold
);
Err(GarrisonError::FirewallBlocked(format!(
"firewall-anomalous-distance-exceeded::{}::{}",
loc, detail
)))
} else {
self.update_historic_coord(&key, current_coord).await?;
Ok(())
}
},
}
}
}
inventory::submit! {
crate::strategy::firewall::StrategyRegistration {
name: "anomalous",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
use crate::strategy::firewall::GeoCoord;
use std::collections::HashMap;
struct MockGeoLookup {
map: HashMap<String, GeoCoord>,
}
impl MockGeoLookup {
fn new() -> Self {
Self {
map: HashMap::new(),
}
}
fn with(mut self, ip: &str, coord: GeoCoord) -> Self {
self.map.insert(ip.to_string(), coord);
self
}
}
#[async_trait]
impl GeoLookup for MockGeoLookup {
async fn lookup(&self, ip: &str) -> GarrisonResult<Option<GeoCoord>> {
Ok(self.map.get(ip).copied())
}
}
#[test]
fn haversine_beijing_to_new_york_exceeds_500km() {
let dist = haversine_km(39.9042, 116.4074, 40.7128, -74.0060);
assert!(dist > 500.0, "北京→纽约距离应 > 500km,实际: {}", dist);
assert!(dist > 10000.0, "北京→纽约距离应 > 10000km,实际: {}", dist);
}
#[test]
fn haversine_same_city_under_10km() {
let dist = haversine_km(39.9042, 116.4074, 39.9100, 116.4000);
assert!(dist < 10.0, "同城距离应 < 10km,实际: {}", dist);
}
#[tokio::test]
async fn anomalous_blocks_cross_continent_login() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let geo: Arc<dyn GeoLookup> = Arc::new(
MockGeoLookup::new()
.with("1.1.1.1", GeoCoord::new(39.9042, 116.4074).unwrap()) .with("2.2.2.2", GeoCoord::new(40.7128, -74.0060).unwrap()), );
let config = AnomalousConfig {
known_geo_threshold: 500,
};
let strategy = AnomalousLoginStrategy::new(config, dao, geo);
let ctx_first = FirewallContext::new("1.1.1.1").with_login_id("1001");
let ctx_second = FirewallContext::new("2.2.2.2").with_login_id("1001");
assert!(
strategy.check(&ctx_first).await.is_ok(),
"首次登录应放行(无历史记录)"
);
let result = strategy.check(&ctx_second).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"异地登录应返回 FirewallBlocked,实际: {:?}",
result
);
}
#[tokio::test]
async fn anomalous_first_login_passes_and_writes_geo() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let geo: Arc<dyn GeoLookup> = Arc::new(
MockGeoLookup::new().with("1.1.1.1", GeoCoord::new(39.9042, 116.4074).unwrap()),
);
let config = AnomalousConfig {
known_geo_threshold: 500,
};
let strategy = AnomalousLoginStrategy::new(config, dao.clone(), geo);
let ctx = FirewallContext::new("1.1.1.1").with_login_id("1001");
assert!(strategy.check(&ctx).await.is_ok());
let stored = dao.get("anom:user:1001").await.unwrap();
assert!(stored.is_some(), "首次登录后应写入历史 geo");
let coord = GeoCoord::from_csv(&stored.unwrap()).unwrap();
assert!((coord.lat - 39.9042).abs() < 1e-6);
assert!((coord.lon - 116.4074).abs() < 1e-6);
}
#[tokio::test]
async fn anomalous_same_city_login_passes() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let geo: Arc<dyn GeoLookup> = Arc::new(
MockGeoLookup::new()
.with("1.1.1.1", GeoCoord::new(39.9042, 116.4074).unwrap())
.with("1.1.1.2", GeoCoord::new(39.9100, 116.4000).unwrap()), );
let config = AnomalousConfig {
known_geo_threshold: 500,
};
let strategy = AnomalousLoginStrategy::new(config, dao, geo);
let ctx_first = FirewallContext::new("1.1.1.1").with_login_id("1001");
let ctx_second = FirewallContext::new("1.1.1.2").with_login_id("1001");
assert!(strategy.check(&ctx_first).await.is_ok());
assert!(
strategy.check(&ctx_second).await.is_ok(),
"同城登录(距离 < 阈值)应放行"
);
}
#[tokio::test]
async fn anomalous_requires_login_id() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let geo: Arc<dyn GeoLookup> = Arc::new(MockGeoLookup::new());
let config = AnomalousConfig {
known_geo_threshold: 500,
};
let strategy = AnomalousLoginStrategy::new(config, dao, geo);
let ctx = FirewallContext::new("1.1.1.1");
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::InvalidParam(_))),
"login_id=None 应返回 InvalidParam,实际: {:?}",
result
);
}
#[tokio::test]
async fn check_updates_historic_coord_on_first_login() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let current_coord = GeoCoord::new(39.9042, 116.4074).unwrap(); let expected_csv = current_coord.to_csv();
let geo: Arc<dyn GeoLookup> = Arc::new(MockGeoLookup::new().with("1.1.1.1", current_coord));
let config = AnomalousConfig {
known_geo_threshold: 500,
};
let strategy = AnomalousLoginStrategy::new(config, dao.clone(), geo);
let ctx = FirewallContext::new("1.1.1.1").with_login_id("1001");
assert!(
strategy.check(&ctx).await.is_ok(),
"首次登录应放行(无历史记录)"
);
let stored = dao.get("anom:user:1001").await.unwrap();
assert_eq!(
stored.as_deref(),
Some(expected_csv.as_str()),
"首次登录后应调用 set_permanent 写入当前坐标(精确匹配 csv)"
);
}
}