use crate::config::GarrisonConfig;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use std::collections::HashSet;
#[derive(Debug, Clone, Copy)]
pub struct WafContext<'a> {
pub path: &'a str,
pub method: &'a str,
pub host: Option<&'a str>,
pub headers: &'a [(String, String)],
pub params: &'a [(String, String)],
}
#[derive(Debug, Clone)]
pub enum WafVerdict {
Allow,
AllowAndSkip,
Deny {
reason: String,
hook: &'static str,
},
}
#[async_trait]
pub trait WafHook: Send + Sync {
fn name(&self) -> &'static str;
async fn check(&self, ctx: &WafContext<'_>) -> WafVerdict;
}
pub struct WafHookChain {
hooks: Vec<Box<dyn WafHook>>,
}
impl WafHookChain {
pub fn new() -> Self {
Self { hooks: Vec::new() }
}
pub fn register(&mut self, hook: Box<dyn WafHook>) {
self.hooks.push(hook);
}
pub async fn check(&self, ctx: &WafContext<'_>) -> GarrisonResult<()> {
for hook in &self.hooks {
match hook.check(ctx).await {
WafVerdict::Allow => continue,
WafVerdict::AllowAndSkip => {
tracing::debug!(hook = hook.name(), "WAF whitelist allowed");
return Ok(());
},
WafVerdict::Deny { reason, hook: name } => {
tracing::warn!(hook = name, reason = %reason, "WAF blocked request");
return Err(GarrisonError::FirewallBlocked(reason));
},
}
}
Ok(())
}
pub fn from_config(config: &GarrisonConfig) -> Self {
let mut chain = Self::new();
let enabled: HashSet<&str> = config
.waf_enabled_hooks
.iter()
.map(|s| s.as_str())
.collect();
let all_enabled = enabled.is_empty();
let is_enabled = |name: &str| all_enabled || enabled.contains(name);
Self::register_unconditional_hooks(&mut chain, &is_enabled);
Self::register_config_gated_hooks(&mut chain, config, &is_enabled);
chain
}
fn register_config_gated_hooks(
chain: &mut Self,
config: &GarrisonConfig,
is_enabled: &dyn Fn(&str) -> bool,
) {
type GatedHook = (&'static str, fn(Vec<String>) -> Box<dyn WafHook>);
let gated: &[GatedHook] = &[
("white_path", |v| {
Box::new(super::waf_hooks::WhitePathHook::new(v))
}),
("black_path", |v| {
Box::new(super::waf_hooks::BlackPathHook::new(v))
}),
("host", |v| Box::new(super::waf_hooks::HostHook::new(v))),
("http_method", |v| {
Box::new(super::waf_hooks::HttpMethodHook::new(v))
}),
("header", |v| Box::new(super::waf_hooks::HeaderHook::new(v))),
("parameter", |v| {
Box::new(super::waf_hooks::ParameterHook::new(v))
}),
];
let config_slices: &[(&str, &[String])] = &[
("white_path", &config.waf_white_paths),
("black_path", &config.waf_black_paths),
("host", &config.waf_allowed_hosts),
("http_method", &config.waf_allowed_methods),
("header", &config.waf_banned_headers),
("parameter", &config.waf_banned_params),
];
for (name, items) in config_slices {
if is_enabled(name) && !items.is_empty() {
let ctor = gated.iter().find(|(n, _)| n == name).unwrap().1;
chain.register(ctor(items.to_vec()));
}
}
}
fn register_unconditional_hooks(chain: &mut Self, is_enabled: &dyn Fn(&str) -> bool) {
type UncondHook = (&'static str, fn() -> Box<dyn WafHook>);
let unconditional: &[UncondHook] = &[
("danger_char", || {
Box::new(super::waf_hooks::DangerCharacterHook::new())
}),
("banned_char", || {
Box::new(super::waf_hooks::BannedCharacterHook::new())
}),
("dir_traversal", || {
Box::new(super::waf_hooks::DirectoryTraversalHook::new())
}),
];
for &(name, ctor) in unconditional {
if is_enabled(name) {
chain.register(ctor());
}
}
}
}
impl Default for WafHookChain {
fn default() -> Self {
Self::new()
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{Arc, Mutex};
struct AllowHook {
hook_name: &'static str,
}
#[async_trait]
impl WafHook for AllowHook {
fn name(&self) -> &'static str {
self.hook_name
}
async fn check(&self, _ctx: &WafContext<'_>) -> WafVerdict {
WafVerdict::Allow
}
}
struct DenyHook {
hook_name: &'static str,
deny_reason: String,
}
#[async_trait]
impl WafHook for DenyHook {
fn name(&self) -> &'static str {
self.hook_name
}
async fn check(&self, _ctx: &WafContext<'_>) -> WafVerdict {
WafVerdict::Deny {
reason: self.deny_reason.clone(),
hook: self.hook_name,
}
}
}
struct RecordingHook {
hook_name: &'static str,
log: Arc<Mutex<Vec<&'static str>>>,
}
#[async_trait]
impl WafHook for RecordingHook {
fn name(&self) -> &'static str {
self.hook_name
}
async fn check(&self, _ctx: &WafContext<'_>) -> WafVerdict {
self.log.lock().unwrap().push(self.hook_name);
WafVerdict::Allow
}
}
fn make_ctx<'a>() -> WafContext<'a> {
WafContext {
path: "/api/test",
method: "GET",
host: Some("example.com"),
headers: &[],
params: &[],
}
}
#[tokio::test]
async fn empty_chain_returns_ok() {
let chain = WafHookChain::new();
let ctx = make_ctx();
let result = chain.check(&ctx).await;
assert!(result.is_ok(), "空 chain 应返回 Ok(())");
}
#[tokio::test]
async fn all_allow_returns_ok() {
let mut chain = WafHookChain::new();
chain.register(Box::new(AllowHook { hook_name: "a" }));
chain.register(Box::new(AllowHook { hook_name: "b" }));
let ctx = make_ctx();
let result = chain.check(&ctx).await;
assert!(result.is_ok(), "全部 Allow 时应返回 Ok(())");
}
#[tokio::test]
async fn deny_short_circuits() {
let log = Arc::new(Mutex::new(Vec::new()));
let mut chain = WafHookChain::new();
chain.register(Box::new(RecordingHook {
hook_name: "first",
log: log.clone(),
}));
chain.register(Box::new(DenyHook {
hook_name: "deny",
deny_reason: "blocked".to_string(),
}));
chain.register(Box::new(RecordingHook {
hook_name: "third",
log: log.clone(),
}));
let ctx = make_ctx();
let result = chain.check(&ctx).await;
assert!(result.is_err(), "Deny 时应返回 Err");
let executed = log.lock().unwrap();
assert!(
executed.contains(&"first") && !executed.contains(&"third"),
"短路后第三个 Hook 不应执行,实际执行: {:?}",
executed
);
}
#[tokio::test]
async fn multiple_hooks_execute_in_order() {
let log = Arc::new(Mutex::new(Vec::new()));
let mut chain = WafHookChain::new();
chain.register(Box::new(RecordingHook {
hook_name: "first",
log: log.clone(),
}));
chain.register(Box::new(RecordingHook {
hook_name: "second",
log: log.clone(),
}));
chain.register(Box::new(RecordingHook {
hook_name: "third",
log: log.clone(),
}));
let ctx = make_ctx();
chain.check(&ctx).await.unwrap();
let executed = log.lock().unwrap();
assert_eq!(
*executed,
vec!["first", "second", "third"],
"Hook 应按注册顺序执行"
);
}
#[test]
fn waf_context_fields_accessible() {
let headers = vec![("Content-Type".to_string(), "application/json".to_string())];
let params = vec![("id".to_string(), "123".to_string())];
let ctx = WafContext {
path: "/api/test",
method: "GET",
host: Some("example.com"),
headers: &headers,
params: ¶ms,
};
assert_eq!(ctx.path, "/api/test");
assert_eq!(ctx.method, "GET");
assert_eq!(ctx.host, Some("example.com"));
assert_eq!(ctx.headers.len(), 1);
assert_eq!(ctx.params.len(), 1);
assert_eq!(ctx.headers[0].0, "Content-Type");
assert_eq!(ctx.params[0].1, "123");
}
#[test]
fn waf_verdict_allow_constructable() {
let verdict = WafVerdict::Allow;
assert!(matches!(verdict, WafVerdict::Allow));
}
#[test]
fn waf_verdict_deny_constructable() {
let verdict = WafVerdict::Deny {
reason: "test reason".to_string(),
hook: "test_hook",
};
match verdict {
WafVerdict::Deny { reason, hook } => {
assert_eq!(reason, "test reason");
assert_eq!(hook, "test_hook");
},
WafVerdict::Allow => panic!("应为 Deny"),
WafVerdict::AllowAndSkip => panic!("应为 Deny"),
}
}
#[test]
fn hook_name_returns_static_str() {
let hook = AllowHook { hook_name: "test" };
let name: &'static str = hook.name();
assert_eq!(name, "test");
}
#[tokio::test]
async fn deny_error_contains_reason() {
let mut chain = WafHookChain::new();
chain.register(Box::new(DenyHook {
hook_name: "test_hook",
deny_reason: "suspicious_path".to_string(),
}));
let ctx = make_ctx();
let result = chain.check(&ctx).await;
assert!(result.is_err());
let err = result.unwrap_err();
let err_msg = err.to_string();
assert!(
err_msg.contains("suspicious_path"),
"错误消息应含 reason,实际: {}",
err_msg
);
}
#[tokio::test]
async fn register_appends_hook() {
let log = Arc::new(Mutex::new(Vec::new()));
let mut chain = WafHookChain::new();
chain.register(Box::new(RecordingHook {
hook_name: "first",
log: log.clone(),
}));
chain.register(Box::new(RecordingHook {
hook_name: "second",
log: log.clone(),
}));
let ctx = make_ctx();
chain.check(&ctx).await.unwrap();
let executed = log.lock().unwrap();
assert_eq!(executed.len(), 2, "应执行 2 个 Hook");
assert_eq!(executed[0], "first", "第一个 Hook 应先执行");
assert_eq!(executed[1], "second", "第二个 Hook 应后执行");
}
#[tokio::test]
async fn from_config_empty_registers_none() {
let mut config = GarrisonConfig::default_config();
config.waf_enabled_hooks = Vec::new();
config.waf_white_paths = Vec::new();
config.waf_black_paths = Vec::new();
config.waf_allowed_hosts = Vec::new();
config.waf_allowed_methods = Vec::new();
config.waf_banned_headers = Vec::new();
config.waf_banned_params = Vec::new();
let chain = WafHookChain::from_config(&config);
let ctx = make_ctx();
assert!(chain.check(&ctx).await.is_ok(), "空配置应不注册任何 Hook");
}
#[tokio::test]
async fn from_config_all_enabled_registers_all_hooks() {
let mut config = GarrisonConfig::default_config();
config.waf_enabled_hooks = Vec::new();
config.waf_white_paths = vec!["/api".to_string()];
config.waf_black_paths = vec!["/admin".to_string()];
config.waf_allowed_hosts = vec!["example.com".to_string()];
config.waf_allowed_methods = vec!["GET".to_string()];
config.waf_banned_headers = vec!["X-Blocked".to_string()];
config.waf_banned_params = vec!["secret".to_string()];
let chain = WafHookChain::from_config(&config);
let ctx = make_ctx();
assert!(chain.check(&ctx).await.is_ok(), "白名单路径应放行");
let ctx = WafContext {
path: "/admin/secret",
method: "GET",
host: Some("example.com"),
headers: &[],
params: &[],
};
assert!(chain.check(&ctx).await.is_err(), "黑名单路径应拦截");
}
#[tokio::test]
async fn from_config_selective_hooks() {
let mut config = GarrisonConfig::default_config();
config.waf_enabled_hooks = vec!["danger_char".to_string(), "host".to_string()];
config.waf_allowed_hosts = vec!["example.com".to_string()];
let chain = WafHookChain::from_config(&config);
let ctx = WafContext {
path: "/api//test",
method: "GET",
host: Some("example.com"),
headers: &[],
params: &[],
};
assert!(chain.check(&ctx).await.is_err(), "danger_char 应拦截 //");
let ctx = WafContext {
path: "/api/test",
method: "GET",
host: Some("evil.com"),
headers: &[],
params: &[],
};
assert!(chain.check(&ctx).await.is_err(), "host 应拦截非白名单域名");
let ctx = make_ctx();
assert!(chain.check(&ctx).await.is_ok(), "正常请求应放行");
}
#[tokio::test]
async fn from_config_banned_char_and_dir_traversal() {
let mut config = GarrisonConfig::default_config();
config.waf_enabled_hooks = vec!["banned_char".to_string(), "dir_traversal".to_string()];
let chain = WafHookChain::from_config(&config);
let ctx = WafContext {
path: "/api/../etc",
method: "GET",
host: Some("example.com"),
headers: &[],
params: &[],
};
assert!(chain.check(&ctx).await.is_err(), "dir_traversal 应拦截 ../");
let ctx = make_ctx();
assert!(chain.check(&ctx).await.is_ok(), "正常路径应放行");
}
}