use crate::middleware::auth::{
is_api_path, join_route_path, match_path_pattern, normalize_path, PathPattern,
};
use crate::router::RouteEntry;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RouteAuthRequirement {
Public,
Required,
}
impl RouteAuthRequirement {
fn as_str(&self) -> &'static str {
match self {
RouteAuthRequirement::Public => "public",
RouteAuthRequirement::Required => "required",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RoutePolicy {
pub path: String,
pub method: String,
pub auth: RouteAuthRequirement,
pub permission: Option<String>,
}
impl RoutePolicy {
fn is_permission_required(&self) -> bool {
self.permission.is_some()
}
}
struct CompiledPolicy {
norm: String,
pattern: PathPattern,
seg_count: Option<usize>,
methods: Option<Vec<String>>,
}
impl CompiledPolicy {
fn compile(p: &RoutePolicy) -> Self {
let norm = normalize_path(&p.path);
let pattern = PathPattern::compile_normalized(&norm);
let seg_count = match &pattern {
PathPattern::Segments(segs) => Some(segs.len()),
PathPattern::TailWildcard(_) => None,
};
let methods = if p.method.is_empty() {
None
} else {
Some(p.method.split(',').map(|m| m.to_ascii_lowercase()).collect())
};
Self {
norm: norm.to_string(),
pattern,
seg_count,
methods,
}
}
fn overlaps(a: &Self, b: &Self) -> bool {
Self::matches_into(a, b) || Self::matches_into(b, a)
}
fn matches_into(a: &Self, b: &Self) -> bool {
if a.norm == b.norm {
return true;
}
if a.seg_count.is_some() && b.seg_count.is_some() && a.seg_count != b.seg_count {
return false;
}
a.pattern.matches_normalized(&b.norm)
}
fn methods_overlap(a: &Self, b: &Self) -> bool {
match (&a.methods, &b.methods) {
(None, _) | (_, None) => true,
(Some(x), Some(y)) => x.iter().any(|m| y.contains(m)),
}
}
}
#[derive(Debug, Default)]
pub struct RoutePolicyTable {
pub policies: Vec<RoutePolicy>,
}
impl RoutePolicyTable {
pub fn build(
prefix: &str,
routes: &[RouteEntry],
auth_enabled: bool,
config_ignore_paths: &[String],
permission_enabled: bool,
config_rules: &[wordval_config::PermissionRule],
) -> Self {
let mut policies: Vec<RoutePolicy> = Vec::new();
for r in routes {
if !r.guard.public && r.guard.permission.is_none() {
continue;
}
policies.push(RoutePolicy {
path: join_route_path(prefix, &r.path),
method: r.method.clone(),
auth: if r.guard.public {
RouteAuthRequirement::Public
} else {
RouteAuthRequirement::Required
},
permission: r.guard.permission.clone(),
});
}
if auth_enabled {
for path in config_ignore_paths {
policies.push(RoutePolicy {
path: join_route_path(prefix, path),
method: String::new(),
auth: RouteAuthRequirement::Public,
permission: None,
});
}
}
if permission_enabled {
for rule in config_rules {
policies.push(RoutePolicy {
path: join_route_path(prefix, &rule.path),
method: rule.methods.join(","),
auth: RouteAuthRequirement::Required,
permission: Some(rule.permission.clone()),
});
}
}
Self { policies }
}
pub fn conflicts(&self) -> Vec<String> {
let mut conflicts = Vec::new();
for p in &self.policies {
if p.auth == RouteAuthRequirement::Public && p.is_permission_required() {
conflicts.push(format!(
"公开路由不可携带权限要求: {} {} (permission={})",
method_display(&p.method),
p.path,
p.permission.as_deref().unwrap_or("")
));
}
}
let compiled: Vec<CompiledPolicy> = self
.policies
.iter()
.map(CompiledPolicy::compile)
.collect();
for (i, p) in self.policies.iter().enumerate() {
if p.auth != RouteAuthRequirement::Public {
continue;
}
for (j, q) in self.policies.iter().enumerate() {
if !q.is_permission_required() {
continue;
}
if CompiledPolicy::overlaps(&compiled[i], &compiled[j])
&& CompiledPolicy::methods_overlap(&compiled[i], &compiled[j])
{
conflicts.push(format!(
"公开路由与权限路由重叠: {} {} 与 {} {} (permission={})",
method_display(&p.method),
p.path,
method_display(&q.method),
q.path,
q.permission.as_deref().unwrap_or("")
));
}
}
}
for (i, a) in self.policies.iter().enumerate() {
if !a.is_permission_required() {
continue;
}
for (j, b) in self.policies.iter().enumerate().skip(i + 1) {
if !b.is_permission_required() {
continue;
}
if !CompiledPolicy::overlaps(&compiled[i], &compiled[j]) {
continue;
}
if !CompiledPolicy::methods_overlap(&compiled[i], &compiled[j]) {
continue;
}
if a.permission != b.permission {
conflicts.push(format!(
"同一路由重复注册不同权限: {} {} -> {} vs {}",
method_display(&a.method),
a.path,
a.permission.as_deref().unwrap_or(""),
b.permission.as_deref().unwrap_or("")
));
}
}
}
conflicts
}
pub fn validate(&self) -> std::result::Result<(), String> {
let conflicts = self.conflicts();
if conflicts.is_empty() {
Ok(())
} else {
Err(format!(
"路由策略存在冲突(共 {} 处):
- {}",
conflicts.len(),
conflicts.join(
"
- "
)
))
}
}
pub fn log(
&self,
prefix: &str,
routes: &[RouteEntry],
config_ignore_paths: &[String],
api_prefixes: &[String],
auth_enabled: bool,
) {
let (public, required) = classify_route_auth(
prefix,
routes,
config_ignore_paths,
api_prefixes,
auth_enabled,
);
tracing::info!(
"路由策略表: 已注册 {} 条(公开 {} / 需登录 {})",
routes.len(),
public,
required
);
let exempt = prefix_exempt_routes(
prefix,
routes,
config_ignore_paths,
api_prefixes,
auth_enabled,
);
if !exempt.is_empty() {
tracing::warn!(
"以下 {} 条路由不在 api_prefixes {:?} 内且未标 public 守卫,启用 auth 后仍默认免鉴权(fail-open);\
如需强制鉴权请将其纳入前缀或显式配置 api_prefixes=[]:",
exempt.len(),
api_prefixes
);
for (method, path) in &exempt {
tracing::warn!(" [免鉴权] {} {}", method_display(method), path);
}
}
for p in &self.policies {
tracing::debug!(
" route-policy: {} {} auth={} permission={}",
method_display(&p.method),
p.path,
p.auth.as_str(),
p.permission.as_deref().unwrap_or("-")
);
}
}
}
pub fn classify_route_auth(
prefix: &str,
routes: &[RouteEntry],
config_ignore_paths: &[String],
api_prefixes: &[String],
auth_enabled: bool,
) -> (usize, usize) {
if !auth_enabled {
return (routes.len(), 0);
}
let ignore_rules: Vec<String> = config_ignore_paths
.iter()
.map(|p| join_route_path(prefix, p))
.collect();
let public = routes
.iter()
.filter(|r| {
let joined = join_route_path(prefix, &r.path);
let path = normalize_path(&joined);
r.guard.public
|| ignore_rules.iter().any(|p| match_path_pattern(p, &path))
|| !is_api_path(&path, api_prefixes)
})
.count();
(public, routes.len() - public)
}
pub fn prefix_exempt_routes(
prefix: &str,
routes: &[crate::router::RouteEntry],
config_ignore_paths: &[String],
api_prefixes: &[String],
auth_enabled: bool,
) -> Vec<(String, String)> {
if !auth_enabled || api_prefixes.is_empty() {
return Vec::new();
}
let ignore_rules: Vec<String> = config_ignore_paths
.iter()
.map(|p| join_route_path(prefix, p))
.collect();
routes
.iter()
.filter_map(|r| {
let joined = join_route_path(prefix, &r.path);
let path = normalize_path(&joined);
let explicit_public = r.guard.public
|| ignore_rules.iter().any(|p| match_path_pattern(p, &path));
if !explicit_public && !is_api_path(&path, api_prefixes) {
Some((r.method.clone(), path.into_owned()))
} else {
None
}
})
.collect()
}
fn method_display(method: &str) -> &str {
if method.is_empty() {
"*"
} else {
method
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::router::RouteGuard;
use wordval_config::PermissionRule;
fn route(method: &str, path: &str, guard: RouteGuard) -> RouteEntry {
RouteEntry {
method: method.to_string(),
path: path.to_string(),
guard,
}
}
fn public_route(method: &str, path: &str) -> RouteEntry {
route(method, path, RouteGuard::public())
}
fn perm_route(method: &str, path: &str, permission: &str) -> RouteEntry {
route(method, path, RouteGuard::permission(permission))
}
fn cfg_rule(path: &str, methods: &[&str], permission: &str) -> PermissionRule {
PermissionRule {
path: path.to_string(),
methods: methods.iter().map(|s| s.to_string()).collect(),
permission: permission.to_string(),
}
}
fn table(routes: &[RouteEntry]) -> RoutePolicyTable {
RoutePolicyTable::build("", routes, true, &[], true, &[])
}
#[test]
fn guard_public_and_permission_conflicts() {
let t = table(&[route(
"POST",
"/api/orders",
RouteGuard {
permission: Some("order:create".to_string()),
public: true,
audit: None,
},
)]);
assert!(!t.conflicts().is_empty());
assert!(t.validate().is_err());
}
#[test]
fn config_ignore_overlaps_guard_permission() {
let t = RoutePolicyTable::build(
"",
&[perm_route("GET", "/api/public/admin", "admin:access")],
true,
&["/api/public/{*rest}".to_string()],
true,
&[],
);
assert!(!t.conflicts().is_empty());
}
#[test]
fn method_specific_public_does_not_weaken_other_method() {
let t = table(&[
public_route("GET", "/api/orders"),
perm_route("POST", "/api/orders", "order:create"),
]);
assert!(t.conflicts().is_empty());
}
#[test]
fn duplicate_permission_with_different_perm_conflicts() {
let t = RoutePolicyTable::build(
"",
&[],
true,
&[],
true,
&[
cfg_rule("/api/users", &["GET"], "user:list"),
cfg_rule("/api/users", &["GET"], "user:admin"),
],
);
assert!(!t.conflicts().is_empty());
}
#[test]
fn same_route_same_permission_is_fine() {
let t = RoutePolicyTable::build(
"",
&[perm_route("GET", "/api/users", "user:list")],
true,
&[],
true,
&[cfg_rule("/api/users", &["GET"], "user:list")],
);
assert!(t.conflicts().is_empty());
}
#[test]
fn distinct_routes_do_not_conflict() {
let t = table(&[
public_route("POST", "/api/auth/login"),
perm_route("GET", "/api/admin/users", "user:list"),
]);
assert!(t.conflicts().is_empty());
}
#[test]
fn global_prefix_joined_into_policy_path() {
let t = RoutePolicyTable::build(
"/api",
&[
public_route("POST", "/auth/login"),
perm_route("GET", "/admin/users", "user:list"),
],
true,
&[],
true,
&[],
);
assert!(t.policies.iter().any(|p| p.path == "/api/auth/login"));
assert!(t.policies.iter().any(|p| p.path == "/api/admin/users"));
}
#[test]
fn guard_without_policy_is_not_listed() {
let t = table(&[route("GET", "/api/orders", RouteGuard::default())]);
assert!(t.policies.is_empty());
}
#[test]
fn config_rules_and_ignore_paths_included() {
let t = RoutePolicyTable::build(
"",
&[],
true,
&["/health".to_string()],
true,
&[cfg_rule("/orders", &["POST"], "order:create")],
);
assert_eq!(t.policies.len(), 2);
let health = t.policies.iter().find(|p| p.path == "/health").unwrap();
assert_eq!(health.auth, RouteAuthRequirement::Public);
let order = t.policies.iter().find(|p| p.path == "/orders").unwrap();
assert_eq!(order.permission.as_deref(), Some("order:create"));
}
#[test]
fn dormant_config_ignored_when_disabled() {
let t = RoutePolicyTable::build(
"",
&[],
false,
&["/health".to_string()],
false,
&[cfg_rule("/orders", &["POST"], "order:create")],
);
assert!(t.policies.is_empty());
}
#[test]
fn classify_counts_guard_and_ignore_as_public() {
let routes = vec![
public_route("POST", "/api/auth/login"),
route("GET", "/api/auth/login", RouteGuard::default()),
route("POST", "/api/orders", RouteGuard::default()),
route("GET", "/api/orders", RouteGuard::default()),
];
let (public, required) = classify_route_auth(
"",
&routes,
&["/api/orders".to_string()],
&[],
true,
);
assert_eq!(public, 3);
assert_eq!(required, 1);
}
#[test]
fn classify_page_paths_outside_api_prefixes_are_public() {
let routes = vec![
route("GET", "/api/data", RouteGuard::default()),
route("GET", "/v1/models", RouteGuard::default()),
route("GET", "/user_center/page", RouteGuard::default()),
];
let (public, required) =
classify_route_auth("", &routes, &[], &["/api".to_string()], true);
assert_eq!(public, 2);
assert_eq!(required, 1);
}
#[test]
fn classify_auth_disabled_all_public() {
let routes = vec![
route("GET", "/api/data", RouteGuard::default()),
route("POST", "/api/save", RouteGuard::default()),
];
let (public, required) = classify_route_auth("", &routes, &[], &[], false);
assert_eq!(public, 2);
assert_eq!(required, 0);
}
#[test]
fn classify_pattern_rules_match_param_paths() {
let routes = vec![
route("GET", "/api/public/token/{id}", RouteGuard::default()),
route("GET", "/api/public/token/{id}/delete", RouteGuard::default()),
];
let (public, required) = classify_route_auth(
"",
&routes,
&["/api/public/token/{id}".to_string()],
&[],
true,
);
assert_eq!(public, 1);
assert_eq!(required, 1);
}
#[test]
fn prefix_exempt_names_only_outside_prefix_not_explicit_public() {
let routes = vec![
route("GET", "/api/data", RouteGuard::default()), route("GET", "/v1/models", RouteGuard::default()), public_route("POST", "/internal/sync"), route("GET", "/health", RouteGuard::default()), ];
let exempt = prefix_exempt_routes(
"",
&routes,
&["/health".to_string()],
&["/api".to_string()],
true,
);
assert_eq!(exempt, vec![("GET".to_string(), "/v1/models".to_string())]);
}
#[test]
fn prefix_exempt_empty_when_fail_closed_or_auth_disabled() {
let routes = vec![route("GET", "/v1/models", RouteGuard::default())];
assert!(prefix_exempt_routes("", &routes, &[], &[], true).is_empty());
assert!(prefix_exempt_routes("", &routes, &[], &["/api".to_string()], false).is_empty());
}
#[test]
fn classify_counts_global_prefix_prefixed_routes() {
let routes = vec![
public_route("POST", "/auth/login"),
route("POST", "/orders", RouteGuard::default()),
];
let (public, required) =
classify_route_auth("/api", &routes, &["/orders".to_string()], &[], true);
assert_eq!(public, 2);
assert_eq!(required, 0);
}
}