use crate::constants::DaoKeyPrefix;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use crate::limiteron::{GarrisonDaoBanStorage, GarrisonDaoDistributedLimiter};
use crate::strategy::firewall::{FirewallContext, GarrisonFirewallStrategy};
use async_trait::async_trait;
use chrono::Utc;
use limiteron::limiters::DistributedLimiter;
use limiteron::storage::{BanRecord, BanStorage, BanTarget};
use std::sync::Arc;
use std::time::Duration;
#[derive(Debug, Clone)]
pub struct BruteForceConfig {
pub max_attempts: u32,
pub window_seconds: u64,
pub lock_seconds: u64,
}
impl Default for BruteForceConfig {
fn default() -> Self {
Self {
max_attempts: 5,
window_seconds: 60,
lock_seconds: 300,
}
}
}
impl BruteForceConfig {
pub fn validate(&self) -> GarrisonResult<()> {
if self.max_attempts == 0 {
return Err(GarrisonError::InvalidParam(
"firewall-bruteforce-max-attempts-zero::".to_string(),
));
}
if self.window_seconds == 0 {
return Err(GarrisonError::InvalidParam(
"firewall-bruteforce-window-seconds-zero::".to_string(),
));
}
if self.lock_seconds == 0 {
return Err(GarrisonError::InvalidParam(
"firewall-bruteforce-lock-seconds-zero::".to_string(),
));
}
Ok(())
}
}
pub struct BruteForceStrategy {
config: BruteForceConfig,
ban_storage: Arc<dyn BanStorage>,
limiter: Arc<dyn DistributedLimiter>,
}
impl BruteForceStrategy {
pub fn new(config: BruteForceConfig, dao: Arc<dyn GarrisonDao>) -> Self {
debug_assert!(
config.validate().is_ok(),
"invalid BruteForceConfig: {:?} (0 值阈值会导致全拦截/计数失效)",
config
);
let ban_storage = Arc::new(GarrisonDaoBanStorage::new(dao.clone()));
let limiter = Arc::new(GarrisonDaoDistributedLimiter::new(dao));
Self {
config,
ban_storage,
limiter,
}
}
fn ensure_valid_config(&self) -> GarrisonResult<()> {
self.config.validate()
}
pub async fn is_blocked(&self, ctx: &FirewallContext) -> GarrisonResult<bool> {
let target = BanTarget::Ip(ctx.ip.clone());
Ok(self
.ban_storage
.is_banned(&target)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-ban-is-banned::{}", e)))?
.is_some())
}
pub async fn record_failure(&self, ctx: &FirewallContext) -> GarrisonResult<()> {
self.ensure_valid_config()?;
let target = BanTarget::Ip(ctx.ip.clone());
let count_key = format!("{}{}:count", DaoKeyPrefix::BruteForce, ctx.ip);
let new_count = self
.limiter
.incr_with_ttl(
&count_key,
1,
Duration::from_secs(self.config.window_seconds),
)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-incr-ttl::{}", e)))?;
if new_count > self.config.max_attempts as u64 {
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(self.config.lock_seconds),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(self.config.lock_seconds as i64),
is_manual: false,
reason: format!(
"strategy-firewall-bruteforce-reason::{}::{}",
new_count, self.config.max_attempts
),
};
self.ban_storage
.save(&record)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-ban-save::{}", e)))?;
}
Ok(())
}
}
#[async_trait]
impl GarrisonFirewallStrategy for BruteForceStrategy {
async fn check(&self, ctx: &FirewallContext) -> GarrisonResult<()> {
self.ensure_valid_config()?;
let target = BanTarget::Ip(ctx.ip.clone());
let count_key = format!("{}{}:count", DaoKeyPrefix::BruteForce, ctx.ip);
if self
.ban_storage
.is_banned(&target)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-ban-is-banned::{}", e)))?
.is_some()
{
return Err(GarrisonError::FirewallBlocked(format!(
"strategy-firewall-bruteforce-locked::{}",
ctx.ip
)));
}
let new_count = self
.limiter
.incr_with_ttl(
&count_key,
1,
Duration::from_secs(self.config.window_seconds),
)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-incr-ttl::{}", e)))?;
if new_count > self.config.max_attempts as u64 {
let record = BanRecord {
target: target.clone(),
ban_times: 1,
duration: Duration::from_secs(self.config.lock_seconds),
banned_at: Utc::now(),
expires_at: Utc::now() + chrono::Duration::seconds(self.config.lock_seconds as i64),
is_manual: false,
reason: format!(
"strategy-firewall-bruteforce-reason::{}::{}",
new_count, self.config.max_attempts
),
};
self.ban_storage
.save(&record)
.await
.map_err(|e| GarrisonError::Dao(format!("strategy-ban-save::{}", e)))?;
Err(GarrisonError::FirewallBlocked(format!(
"strategy-firewall-bruteforce-blocked::{}::{}::{}",
ctx.ip, new_count, self.config.max_attempts
)))
} else {
Ok(())
}
}
}
inventory::submit! {
crate::strategy::firewall::StrategyRegistration {
name: "bruteforce",
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::error::GarrisonError;
#[tokio::test]
async fn bruteforce_blocks_after_max_attempts() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = BruteForceConfig {
max_attempts: 5,
window_seconds: 60,
lock_seconds: 300,
};
let strategy = BruteForceStrategy::new(config, dao);
let ctx = FirewallContext::new("192.168.1.1");
for i in 1..=5 {
assert!(strategy.check(&ctx).await.is_ok(), "第 {} 次应通过", i);
}
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"第 6 次应返回 FirewallBlocked,实际: {:?}",
result
);
}
#[tokio::test]
async fn bruteforce_lock_persists_after_trigger() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = BruteForceConfig {
max_attempts: 3,
window_seconds: 60,
lock_seconds: 300,
};
let strategy = BruteForceStrategy::new(config, dao);
let ctx = FirewallContext::new("10.0.0.1");
for _ in 0..4 {
let _ = strategy.check(&ctx).await;
}
for i in 1..=5 {
let result = strategy.check(&ctx).await;
assert!(
matches!(result, Err(GarrisonError::FirewallBlocked(_))),
"锁定后第 {} 次请求应被拦截",
i
);
}
}
#[tokio::test]
async fn bruteforce_counts_isolated_per_ip() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = BruteForceConfig {
max_attempts: 3,
window_seconds: 60,
lock_seconds: 300,
};
let strategy = BruteForceStrategy::new(config, dao);
let ctx_a = FirewallContext::new("192.168.1.100");
for _ in 0..4 {
let _ = strategy.check(&ctx_a).await;
}
let ctx_b = FirewallContext::new("192.168.1.200");
assert!(
strategy.check(&ctx_b).await.is_ok(),
"不同 IP 的计数不应互相影响"
);
}
#[tokio::test]
async fn is_blocked_does_not_count() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = BruteForceConfig {
max_attempts: 3,
window_seconds: 60,
lock_seconds: 300,
};
let strategy = BruteForceStrategy::new(config, dao);
let ctx = FirewallContext::new("10.1.1.1");
for _ in 0..10 {
assert!(
!strategy.is_blocked(&ctx).await.unwrap(),
"未失败前不应封禁"
);
}
}
#[tokio::test]
async fn record_failure_bans_after_threshold_then_is_blocked() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let config = BruteForceConfig {
max_attempts: 3,
window_seconds: 60,
lock_seconds: 300,
};
let strategy = BruteForceStrategy::new(config, dao);
let ctx = FirewallContext::new("10.2.2.2");
for _ in 0..3 {
strategy.record_failure(&ctx).await.unwrap();
assert!(!strategy.is_blocked(&ctx).await.unwrap());
}
strategy.record_failure(&ctx).await.unwrap();
assert!(
strategy.is_blocked(&ctx).await.unwrap(),
"超过 max_attempts 次失败后应被封禁"
);
}
}