use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::limiteron::GarrisonDaoDistributedLimiter;
use crate::strategy::firewall::{FirewallContext, GarrisonFirewallStrategy};
use async_trait::async_trait;
use std::sync::Arc;
use std::time::Duration;
#[derive(Debug, Clone)]
pub struct DDoSConfig {
pub per_ip_rps: u32,
pub burst: u32,
}
impl Default for DDoSConfig {
fn default() -> Self {
Self {
per_ip_rps: 10,
burst: 20,
}
}
}
pub struct DDoSStrategy {
config: DDoSConfig,
limiter: GarrisonDaoDistributedLimiter,
}
impl DDoSStrategy {
pub fn new(config: DDoSConfig, dao: Arc<dyn GarrisonDao>) -> Self {
Self {
config,
limiter: GarrisonDaoDistributedLimiter::new(dao),
}
}
}
#[async_trait]
impl GarrisonFirewallStrategy for DDoSStrategy {
async fn check(&self, ctx: &FirewallContext) -> GarrisonResult<()> {
const WINDOW_TTL: Duration = Duration::from_secs(1);
let ip_key = format!("ddos:ip:{}", ctx.ip);
let ip_ok = self
.limiter
.atomic_check_and_incr(&ip_key, self.config.per_ip_rps as u64, WINDOW_TTL)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-ddos-ip::{}::{}", ctx.ip, e)))?;
if !ip_ok {
return Err(GarrisonError::FirewallBlocked(format!(
"strategy-ddos-ip-blocked::{}::{}",
ctx.ip, self.config.per_ip_rps
)));
}
let global_ok = self
.limiter
.atomic_check_and_incr("ddos:global", self.config.burst as u64, WINDOW_TTL)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-ddos-global::{}", e)))?;
if !global_ok {
return Err(GarrisonError::FirewallBlocked(format!(
"strategy-ddos-global-blocked::{}",
self.config.burst
)));
}
Ok(())
}
}
inventory::submit! {
crate::strategy::firewall::StrategyRegistration {
name: "ddos",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
#[tokio::test]
async fn ddos_global_burst_limit() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = DDoSConfig {
per_ip_rps: 1000, burst: 3,
};
let strategy = DDoSStrategy::new(config, dao);
let ctx = FirewallContext::new("192.168.1.1");
for i in 1..=3 {
assert!(strategy.check(&ctx).await.is_ok(), "第 {} 次应通过", i);
}
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"第 4 次应返回 FirewallBlocked,实际: {:?}",
result
);
}
#[tokio::test]
async fn ddos_per_ip_isolation() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = DDoSConfig {
per_ip_rps: 2,
burst: 1000, };
let strategy = DDoSStrategy::new(config, dao);
let ctx_a = FirewallContext::new("192.168.1.1");
let ctx_b = FirewallContext::new("192.168.1.2");
for i in 1..=2 {
assert!(
strategy.check(&ctx_a).await.is_ok(),
"IP A 第 {} 次应通过",
i
);
}
let result = strategy.check(&ctx_a).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"IP A 第 3 次应被 per_ip 拦截,实际: {:?}",
result
);
assert!(strategy.check(&ctx_b).await.is_ok(), "不同 IP 应互不影响");
}
#[tokio::test]
async fn ddos_window_reset_after_ttl() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = DDoSConfig {
per_ip_rps: 1000, burst: 2,
};
let strategy = DDoSStrategy::new(config, dao);
let ctx = FirewallContext::new("192.168.1.1");
assert!(strategy.check(&ctx).await.is_ok());
assert!(strategy.check(&ctx).await.is_ok());
assert!(matches!(
strategy.check(&ctx).await,
Err(GarrisonError::FirewallBlocked(_))
));
tokio::time::sleep(Duration::from_millis(1100)).await;
assert!(
strategy.check(&ctx).await.is_ok(),
"窗口 TTL 过期后应能通过(计数已重置)"
);
}
#[tokio::test]
async fn ddos_dual_limit_per_ip_triggered_first() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = DDoSConfig {
per_ip_rps: 1,
burst: 10,
};
let strategy = DDoSStrategy::new(config, dao);
let ctx = FirewallContext::new("10.0.0.1");
assert!(strategy.check(&ctx).await.is_ok(), "第 1 次应通过");
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"第 2 次应被 per_ip 拦截(per_ip_rps=1),实际: {:?}",
result
);
if let Err(GarrisonError::FirewallBlocked(msg)) = result {
assert!(msg.contains("10.0.0.1"), "错误消息应包含 IP,实际: {}", msg);
}
}
#[tokio::test]
async fn ddos_limiter_error_maps_to_garrison_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
dao.set("ddos:global", "not-a-number", 60).await.unwrap();
let config = DDoSConfig::default();
let strategy = DDoSStrategy::new(config, dao);
let ctx = FirewallContext::new("1.2.3.4");
let result = strategy.check(&ctx).await;
assert!(
matches!(&result, Err(GarrisonError::Dao(msg)) if msg.contains("strategy-ddos-global")),
"全局桶脏数据应映射为含 strategy-ddos-global 前缀的 GarrisonError::Dao,实际: {:?}",
result
);
}
#[tokio::test]
async fn per_ip_block_does_not_consume_global_quota() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = DDoSConfig {
per_ip_rps: 2,
burst: 3,
};
let strategy = DDoSStrategy::new(config, dao);
let attacker = FirewallContext::new("9.9.9.9");
assert!(
strategy.check(&attacker).await.is_ok(),
"攻击 IP 第 1 次应通过"
);
assert!(
strategy.check(&attacker).await.is_ok(),
"攻击 IP 第 2 次应通过"
);
assert!(matches!(
strategy.check(&attacker).await,
Err(GarrisonError::FirewallBlocked(msg)) if msg.contains("ddos-ip-blocked")
));
let victim = FirewallContext::new("7.7.7.7");
assert!(
strategy.check(&victim).await.is_ok(),
"单 IP 拦截不应消耗全局额度,正常 IP 第 1 次应通过"
);
assert!(matches!(
strategy.check(&victim).await,
Err(GarrisonError::FirewallBlocked(msg)) if msg.contains("ddos-global-blocked")
));
}
}