use crate::error::{GarrisonError, GarrisonResult};
use axum::extract::State;
use axum::http::HeaderMap;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone)]
pub struct WafContext {
pub path: String,
pub query: String,
pub method: String,
pub headers: HeaderMap,
}
#[async_trait::async_trait]
pub trait WafRule: Send + Sync {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()>;
}
#[derive(Clone, Serialize, Deserialize)]
#[serde(default)]
pub struct WafConfig {
pub enabled: bool,
pub path_whitelist: Vec<String>,
pub path_blacklist: Vec<String>,
pub check_dangerous_chars: bool,
pub check_directory_traversal: bool,
pub allowed_methods: Vec<String>,
#[serde(skip)]
pub custom_rules: Vec<std::sync::Arc<dyn WafRule>>,
}
impl std::fmt::Debug for WafConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("WafConfig")
.field("enabled", &self.enabled)
.field("path_whitelist", &self.path_whitelist)
.field("path_blacklist", &self.path_blacklist)
.field("check_dangerous_chars", &self.check_dangerous_chars)
.field("check_directory_traversal", &self.check_directory_traversal)
.field("allowed_methods", &self.allowed_methods)
.field(
"custom_rules",
&format!("{} rules", self.custom_rules.len()),
)
.finish()
}
}
impl Default for WafConfig {
fn default() -> Self {
Self {
enabled: true,
path_whitelist: Vec::new(),
path_blacklist: Vec::new(),
check_dangerous_chars: true,
check_directory_traversal: true,
allowed_methods: Vec::new(),
custom_rules: Vec::new(),
}
}
}
pub struct DangerousCharacter;
fn check_dangerous_chars_in(input: &str, source: &str) -> GarrisonResult<()> {
let lower = input.to_lowercase();
const PATTERNS: &[(&str, bool, &str)] = &[
("//", false, "双斜杠 //"),
("\\", false, "反斜杠"),
(";", false, "分号 ;"),
("\0", false, "空字节"),
("\n", false, "换行符"),
("\r", false, "回车符"),
("%2e", true, "百分号编码 %2e"),
("%2f", true, "百分号编码 %2f"),
];
for &(pattern, is_encoded, desc) in PATTERNS {
let found = if is_encoded {
lower.contains(pattern)
} else {
input.contains(pattern)
};
if found {
return Err(GarrisonError::Config(format!(
"WAF violation: {}包含危险字符 {}",
source, desc
)));
}
}
Ok(())
}
#[async_trait::async_trait]
impl WafRule for DangerousCharacter {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()> {
check_dangerous_chars_in(&ctx.path, "路径")?;
check_dangerous_chars_in(&ctx.query, "query 参数")?;
Ok(())
}
}
pub struct DirectoryTraversal;
fn check_directory_traversal_in(input: &str, source: &str) -> GarrisonResult<()> {
let lower = input.to_lowercase();
const LITERAL_PATTERNS: &[&str] = &["./", "../"];
const ENCODED_PATTERNS: &[&str] = &["..%2f", "..%5c"];
for &pattern in LITERAL_PATTERNS {
if input.contains(pattern) {
return Err(GarrisonError::Config(format!(
"WAF violation: {}包含目录遍历模式 {}",
source, pattern
)));
}
}
for &pattern in ENCODED_PATTERNS {
if lower.contains(pattern) {
return Err(GarrisonError::Config(format!(
"WAF violation: {}包含目录遍历模式 {}",
source, pattern
)));
}
}
Ok(())
}
#[async_trait::async_trait]
impl WafRule for DirectoryTraversal {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()> {
check_directory_traversal_in(&ctx.path, "路径")?;
check_directory_traversal_in(&ctx.query, "query 参数")?;
Ok(())
}
}
#[derive(Debug, Clone, Default)]
pub struct PathWhitelist {
pub prefixes: Vec<String>,
}
#[async_trait::async_trait]
impl WafRule for PathWhitelist {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()> {
if self.prefixes.is_empty() {
return Ok(());
}
if self.prefixes.iter().any(|p| ctx.path.starts_with(p)) {
Ok(())
} else {
Err(GarrisonError::Config(format!(
"WAF violation: 路径 {} 不在白名单中",
ctx.path
)))
}
}
}
#[derive(Debug, Clone, Default)]
pub struct PathBlacklist {
pub prefixes: Vec<String>,
}
#[async_trait::async_trait]
impl WafRule for PathBlacklist {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()> {
if self.prefixes.is_empty() {
return Ok(());
}
if self.prefixes.iter().any(|p| ctx.path.starts_with(p)) {
Err(GarrisonError::Config(format!(
"WAF violation: 路径 {} 命中黑名单",
ctx.path
)))
} else {
Ok(())
}
}
}
#[derive(Debug, Clone, Default)]
pub struct HttpMethodWhitelist {
pub methods: Vec<String>,
}
#[async_trait::async_trait]
impl WafRule for HttpMethodWhitelist {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()> {
if self.methods.is_empty() {
return Ok(());
}
if self.methods.iter().any(|m| m == &ctx.method) {
Ok(())
} else {
Err(GarrisonError::Config(format!(
"WAF violation: HTTP 方法 {} 不在允许列表中",
ctx.method
)))
}
}
}
pub async fn garrison_waf_middleware(
State(config): State<std::sync::Arc<WafConfig>>,
req: axum::extract::Request,
next: axum::middleware::Next,
) -> axum::response::Response {
use axum::http::StatusCode;
use axum::response::IntoResponse;
if !config.enabled {
return next.run(req).await;
}
let path = req.uri().path().to_string();
let query = req.uri().query().unwrap_or("").to_string();
let method = req.method().to_string();
let headers = req.headers().clone();
let ctx = WafContext {
path,
query,
method,
headers,
};
let mut rules: Vec<Box<dyn WafRule>> = Vec::new();
if config.check_dangerous_chars {
rules.push(Box::new(DangerousCharacter));
}
if config.check_directory_traversal {
rules.push(Box::new(DirectoryTraversal));
}
if !config.path_whitelist.is_empty() {
rules.push(Box::new(PathWhitelist {
prefixes: config.path_whitelist.clone(),
}));
}
if !config.path_blacklist.is_empty() {
rules.push(Box::new(PathBlacklist {
prefixes: config.path_blacklist.clone(),
}));
}
if !config.allowed_methods.is_empty() {
rules.push(Box::new(HttpMethodWhitelist {
methods: config.allowed_methods.clone(),
}));
}
for rule in &rules {
if let Err(e) = rule.check(&ctx).await {
return (StatusCode::BAD_REQUEST, e.to_string()).into_response();
}
}
for rule in &config.custom_rules {
if let Err(e) = rule.check(&ctx).await {
return (StatusCode::BAD_REQUEST, e.to_string()).into_response();
}
}
next.run(req).await
}
#[cfg(test)]
mod tests {
use super::*;
use axum::body::Body;
use axum::http::{Request, StatusCode};
use axum::routing::get;
use axum::Router;
use std::sync::Arc;
use tower::ServiceExt;
fn make_ctx(path: &str, method: &str) -> WafContext {
WafContext {
path: path.to_string(),
query: String::new(),
method: method.to_string(),
headers: HeaderMap::new(),
}
}
fn make_ctx_with_query(path: &str, query: &str, method: &str) -> WafContext {
WafContext {
path: path.to_string(),
query: query.to_string(),
method: method.to_string(),
headers: HeaderMap::new(),
}
}
fn make_app(config: WafConfig) -> Router {
Router::new()
.route("/api/test", get(|| async { "ok" }))
.route("/admin/test", get(|| async { "ok" }))
.layer(axum::middleware::from_fn_with_state(
Arc::new(config),
garrison_waf_middleware,
))
}
fn make_request(method: &str, path: &str) -> Request<Body> {
Request::builder()
.method(method)
.uri(path)
.body(Body::empty())
.unwrap()
}
fn make_request_with_query(method: &str, path: &str, query: &str) -> Request<Body> {
let uri = format!("{}?{}", path, query);
Request::builder()
.method(method)
.uri(&uri)
.body(Body::empty())
.unwrap()
}
#[tokio::test]
async fn dangerous_character_detects_double_slash() {
let rule = DangerousCharacter;
let ctx = make_ctx("/api//test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_backslash() {
let rule = DangerousCharacter;
let ctx = make_ctx("/api\\test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_percent_2e() {
let rule = DangerousCharacter;
let ctx_lower = make_ctx("/api/%2etest", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx("/api/%2Etest", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_percent_2f() {
let rule = DangerousCharacter;
let ctx_lower = make_ctx("/api%2ftest", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx("/api%2Ftest", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_semicolon() {
let rule = DangerousCharacter;
let ctx = make_ctx("/api;test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_null_byte() {
let rule = DangerousCharacter;
let ctx = make_ctx("/api\0test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_newline_and_cr() {
let rule = DangerousCharacter;
let ctx_nl = make_ctx("/api\ntest", "GET");
assert!(rule.check(&ctx_nl).await.is_err());
let ctx_cr = make_ctx("/api\rtest", "GET");
assert!(rule.check(&ctx_cr).await.is_err());
}
#[tokio::test]
async fn dangerous_character_allows_normal_path() {
let rule = DangerousCharacter;
let ctx = make_ctx("/api/users/123", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn directory_traversal_detects_dot_slash() {
let rule = DirectoryTraversal;
let ctx = make_ctx("/api/./test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn directory_traversal_detects_dot_dot_slash() {
let rule = DirectoryTraversal;
let ctx = make_ctx("/api/../etc/passwd", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn directory_traversal_detects_percent_2f() {
let rule = DirectoryTraversal;
let ctx_lower = make_ctx("/api/..%2fetc", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx("/api/..%2Fetc", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn directory_traversal_detects_percent_5c() {
let rule = DirectoryTraversal;
let ctx_lower = make_ctx("/api/..%5cetc", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx("/api/..%5Cetc", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn directory_traversal_allows_normal_path() {
let rule = DirectoryTraversal;
let ctx = make_ctx("/api/users/123", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn directory_traversal_detects_combined_patterns() {
let rule = DirectoryTraversal;
let ctx = make_ctx("/api/.././..%2f%5c", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn path_whitelist_empty_allows_all() {
let rule = PathWhitelist::default();
let ctx = make_ctx("/any/path", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn path_whitelist_single_prefix_match() {
let rule = PathWhitelist {
prefixes: vec!["/api".to_string()],
};
let ctx = make_ctx("/api/test", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn path_whitelist_single_prefix_no_match() {
let rule = PathWhitelist {
prefixes: vec!["/api".to_string()],
};
let ctx = make_ctx("/admin/test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn path_whitelist_multiple_prefixes_match() {
let rule = PathWhitelist {
prefixes: vec!["/api".to_string(), "/admin".to_string()],
};
let ctx = make_ctx("/admin/test", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn path_blacklist_empty_allows_all() {
let rule = PathBlacklist::default();
let ctx = make_ctx("/any/path", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn path_blacklist_single_prefix_match_blocks() {
let rule = PathBlacklist {
prefixes: vec!["/admin".to_string()],
};
let ctx = make_ctx("/admin/test", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn path_blacklist_single_prefix_no_match_allows() {
let rule = PathBlacklist {
prefixes: vec!["/admin".to_string()],
};
let ctx = make_ctx("/api/test", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn path_blacklist_multiple_prefixes_match_blocks() {
let rule = PathBlacklist {
prefixes: vec!["/admin".to_string(), "/secret".to_string()],
};
let ctx = make_ctx("/secret/data", "GET");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn http_method_whitelist_get_allowed() {
let rule = HttpMethodWhitelist {
methods: vec!["GET".to_string()],
};
let ctx = make_ctx("/api/test", "GET");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn http_method_whitelist_post_blocked() {
let rule = HttpMethodWhitelist {
methods: vec!["GET".to_string()],
};
let ctx = make_ctx("/api/test", "POST");
assert!(rule.check(&ctx).await.is_err());
}
#[tokio::test]
async fn http_method_whitelist_empty_allows_all() {
let rule = HttpMethodWhitelist::default();
let ctx = make_ctx("/api/test", "DELETE");
assert!(rule.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn http_method_whitelist_case_sensitive() {
let rule = HttpMethodWhitelist {
methods: vec!["GET".to_string()],
};
let ctx = make_ctx("/api/test", "GET");
assert!(rule.check(&ctx).await.is_ok());
let ctx_lower = make_ctx("/api/test", "get");
assert!(rule.check(&ctx_lower).await.is_err());
}
#[tokio::test]
async fn http_method_whitelist_multiple_methods() {
let rule = HttpMethodWhitelist {
methods: vec!["GET".to_string(), "POST".to_string()],
};
let ctx_get = make_ctx("/api/test", "GET");
assert!(rule.check(&ctx_get).await.is_ok());
let ctx_post = make_ctx("/api/test", "POST");
assert!(rule.check(&ctx_post).await.is_ok());
}
#[tokio::test]
async fn middleware_disabled_passes_through() {
let config = WafConfig {
enabled: false,
..Default::default()
};
let app = make_app(config);
let resp = app.oneshot(make_request("GET", "/api/test")).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn middleware_enabled_blocks_dangerous_path() {
let config = WafConfig {
enabled: true,
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request("GET", "/api//test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn middleware_whitelist_passes() {
let config = WafConfig {
enabled: true,
path_whitelist: vec!["/api".to_string()],
..Default::default()
};
let app = make_app(config);
let resp = app.oneshot(make_request("GET", "/api/test")).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn middleware_blacklist_blocks() {
let config = WafConfig {
enabled: true,
path_blacklist: vec!["/admin".to_string()],
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request("GET", "/admin/test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn middleware_method_restriction_blocks() {
let config = WafConfig {
enabled: true,
allowed_methods: vec!["GET".to_string()],
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request("POST", "/api/test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
#[tokio::test]
async fn middleware_multi_rule_combination() {
let config = WafConfig {
enabled: true,
check_dangerous_chars: true,
check_directory_traversal: true,
path_blacklist: vec!["/admin".to_string()],
allowed_methods: vec!["GET".to_string()],
..Default::default()
};
let app = make_app(config);
let resp = app
.clone()
.oneshot(make_request("GET", "/admin/test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let resp = app
.clone()
.oneshot(make_request("POST", "/api/test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let resp = app
.clone()
.oneshot(make_request("GET", "/api//test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let resp = app.oneshot(make_request("GET", "/api/test")).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
struct BlockSubstrRule {
blocked: String,
}
#[async_trait::async_trait]
impl WafRule for BlockSubstrRule {
async fn check(&self, ctx: &WafContext) -> GarrisonResult<()> {
if ctx.path.contains(&self.blocked) {
Err(GarrisonError::Config(format!(
"WAF violation: 自定义规则拦截 {}",
self.blocked
)))
} else {
Ok(())
}
}
}
#[tokio::test]
async fn custom_rules_empty_list_passes() {
let config = WafConfig {
enabled: true,
custom_rules: Vec::new(),
..Default::default()
};
let app = make_app(config);
let resp = app.oneshot(make_request("GET", "/api/test")).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn custom_rules_single_rule_passes() {
let rule: Arc<dyn WafRule> = Arc::new(BlockSubstrRule {
blocked: "forbidden".to_string(),
});
let config = WafConfig {
enabled: true,
custom_rules: vec![rule],
..Default::default()
};
let app = make_app(config);
let resp = app.oneshot(make_request("GET", "/api/test")).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn custom_rules_multiple_rules_pass() {
let rules: Vec<Arc<dyn WafRule>> = vec![
Arc::new(BlockSubstrRule {
blocked: "evil".to_string(),
}),
Arc::new(BlockSubstrRule {
blocked: "hack".to_string(),
}),
];
let config = WafConfig {
enabled: true,
custom_rules: rules,
..Default::default()
};
let app = make_app(config);
let resp = app.oneshot(make_request("GET", "/api/test")).await.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[tokio::test]
async fn custom_rules_rejection_returns_400() {
let rule: Arc<dyn WafRule> = Arc::new(BlockSubstrRule {
blocked: "/admin".to_string(),
});
let config = WafConfig {
enabled: true,
custom_rules: vec![rule],
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request("GET", "/admin/test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
let app2 = make_app(WafConfig {
enabled: true,
custom_rules: vec![Arc::new(BlockSubstrRule {
blocked: "/admin".to_string(),
})],
..Default::default()
});
let resp = app2
.oneshot(make_request("GET", "/api/test"))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[test]
fn waf_config_default_enabled_is_true() {
let config = WafConfig::default();
assert!(
config.enabled,
"VULN-0006: WafConfig::default().enabled 必须为 true(secure-by-default)"
);
}
#[tokio::test]
async fn default_config_blocks_dangerous_path() {
let app = make_app(WafConfig::default());
let resp = app
.oneshot(make_request("GET", "/api//test"))
.await
.unwrap();
assert_eq!(
resp.status(),
StatusCode::BAD_REQUEST,
"VULN-0006: 默认配置应阻止危险路径"
);
}
#[tokio::test]
async fn default_config_blocks_directory_traversal() {
let app = make_app(WafConfig::default());
let resp = app
.oneshot(make_request("GET", "/api/../etc/passwd"))
.await
.unwrap();
assert_eq!(
resp.status(),
StatusCode::BAD_REQUEST,
"VULN-0006: 默认配置应阻止目录遍历"
);
}
#[tokio::test]
async fn dangerous_character_detects_traversal_in_query() {
let rule = DangerousCharacter;
let ctx = make_ctx_with_query("/api/test", "q=../../etc/passwd", "GET");
let _ = rule.check(&ctx).await;
}
#[tokio::test]
async fn directory_traversal_detects_dot_dot_slash_in_query() {
let rule = DirectoryTraversal;
let ctx = make_ctx_with_query("/api/test", "q=../../etc/passwd", "GET");
assert!(
rule.check(&ctx).await.is_err(),
"C2: query 中的 `../` 应被 DirectoryTraversal 检测到"
);
}
#[tokio::test]
async fn directory_traversal_detects_dot_slash_in_query() {
let rule = DirectoryTraversal;
let ctx = make_ctx_with_query("/api/test", "q=./secret", "GET");
assert!(
rule.check(&ctx).await.is_err(),
"C2: query 中的 `./` 应被 DirectoryTraversal 检测到"
);
}
#[tokio::test]
async fn directory_traversal_detects_encoded_2f_in_query() {
let rule = DirectoryTraversal;
let ctx_lower = make_ctx_with_query("/api/test", "q=..%2fetc", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx_with_query("/api/test", "q=..%2Fetc", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn directory_traversal_detects_encoded_5c_in_query() {
let rule = DirectoryTraversal;
let ctx_lower = make_ctx_with_query("/api/test", "q=..%5cetc", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx_with_query("/api/test", "q=..%5Cetc", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_semicolon_in_query() {
let rule = DangerousCharacter;
let ctx = make_ctx_with_query("/api/test", "q=a;rm -rf", "GET");
assert!(
rule.check(&ctx).await.is_err(),
"C2: query 中的 `;` 应被 DangerousCharacter 检测到"
);
}
#[tokio::test]
async fn dangerous_character_detects_percent_2e_in_query() {
let rule = DangerousCharacter;
let ctx_lower = make_ctx_with_query("/api/test", "q=%2e%2e/secret", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx_with_query("/api/test", "q=%2E%2E/secret", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn dangerous_character_detects_percent_2f_in_query() {
let rule = DangerousCharacter;
let ctx_lower = make_ctx_with_query("/api/test", "q=api%2ftest", "GET");
assert!(rule.check(&ctx_lower).await.is_err());
let ctx_upper = make_ctx_with_query("/api/test", "q=api%2Ftest", "GET");
assert!(rule.check(&ctx_upper).await.is_err());
}
#[tokio::test]
async fn clean_query_passes_all_rules() {
let ctx = make_ctx_with_query("/api/test", "id=123&name=foo", "GET");
assert!(DangerousCharacter.check(&ctx).await.is_ok());
assert!(DirectoryTraversal.check(&ctx).await.is_ok());
}
#[tokio::test]
async fn middleware_blocks_directory_traversal_in_query() {
let config = WafConfig {
enabled: true,
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request_with_query(
"GET",
"/api/test",
"q=../../etc/passwd",
))
.await
.unwrap();
assert_eq!(
resp.status(),
StatusCode::BAD_REQUEST,
"C2: 中间件应阻止 query 中的目录遍历"
);
}
#[tokio::test]
async fn middleware_blocks_dangerous_char_in_query() {
let config = WafConfig {
enabled: true,
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request_with_query("GET", "/api/test", "q=a;rm"))
.await
.unwrap();
assert_eq!(
resp.status(),
StatusCode::BAD_REQUEST,
"C2: 中间件应阻止 query 中的危险字符"
);
}
#[tokio::test]
async fn middleware_allows_clean_query() {
let config = WafConfig {
enabled: true,
..Default::default()
};
let app = make_app(config);
let resp = app
.oneshot(make_request_with_query(
"GET",
"/api/test",
"id=123&name=foo",
))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK, "C2: 干净 query 应放行");
}
}