use crate::core::permission::PermissionChecker;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
#[cfg(all(
feature = "listener",
any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
)
))]
use crate::listener::GarrisonEvent;
#[cfg(feature = "listener")]
use crate::listener::GarrisonListenerManager;
use crate::plugin::GarrisonPluginManager;
use crate::stp::GarrisonInterface;
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
use crate::strategy::hooks::{GarrisonFirewallCheckHook, LoginContext};
use async_trait::async_trait;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use super::{GarrisonPermissionStrategy, GarrisonPermissionStrategyDefault};
impl GarrisonPermissionStrategyDefault {
pub fn new(interface: Arc<dyn GarrisonInterface>) -> Self {
Self {
interface,
permission_checker: None,
dao: None,
role_hierarchy: HashMap::new(),
plugin_manager: None,
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
firewall_hook: None,
#[cfg(feature = "listener")]
listener_manager: None,
}
}
pub fn with_permission_checker(mut self, pc: Arc<dyn PermissionChecker>) -> Self {
self.permission_checker = Some(pc);
self
}
pub fn with_dao(mut self, dao: Arc<dyn GarrisonDao>) -> Self {
self.dao = Some(dao);
self
}
pub fn with_role_hierarchy(mut self, hierarchy: HashMap<String, Vec<String>>) -> Self {
self.role_hierarchy = hierarchy;
self
}
pub fn with_plugin_manager(mut self, pm: Arc<GarrisonPluginManager>) -> Self {
self.plugin_manager = Some(pm);
self
}
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
pub fn with_firewall_hook(mut self, hook: Arc<dyn GarrisonFirewallCheckHook>) -> Self {
self.firewall_hook = Some(hook);
self
}
#[cfg(feature = "listener")]
pub fn with_listener_manager(mut self, lm: Arc<GarrisonListenerManager>) -> Self {
self.listener_manager = Some(lm);
self
}
fn expand_roles(&self, roles: &[String]) -> HashSet<String> {
let mut result = HashSet::new();
let mut stack: Vec<String> = roles.to_vec();
while let Some(r) = stack.pop() {
if result.insert(r.clone()) {
if let Some(implied) = self.role_hierarchy.get(&r) {
stack.extend(implied.iter().cloned());
}
}
}
result
}
pub async fn cache_permission(
&self,
login_id: &str,
permission: &str,
result: bool,
ttl_seconds: u64,
) -> GarrisonResult<()> {
if let Some(dao) = &self.dao {
let key = format!("garrison:perm:cache:{}:{}", login_id, permission);
dao.set(&key, if result { "true" } else { "false" }, ttl_seconds)
.await?;
}
Ok(())
}
pub async fn get_cached_permission(
&self,
login_id: &str,
permission: &str,
) -> GarrisonResult<Option<bool>> {
if let Some(dao) = &self.dao {
let key = format!("garrison:perm:cache:{}:{}", login_id, permission);
match dao.get(&key).await? {
Some(v) => Ok(Some(v == "true")),
None => Ok(None),
}
} else {
Ok(None)
}
}
}
#[async_trait]
impl GarrisonPermissionStrategy for GarrisonPermissionStrategyDefault {
async fn get_permission_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
self.interface.get_permission_list(login_id).await
}
async fn get_role_list(&self, login_id: &str) -> GarrisonResult<Vec<String>> {
self.interface.get_role_list(login_id).await
}
async fn check_permission(&self, login_id: &str, permission: &str) -> GarrisonResult<bool> {
if permission.is_empty() {
return Err(GarrisonError::InvalidParam(
"strategy-perm-empty".to_string(),
));
}
if let Some(pm) = &self.plugin_manager {
pm.on_permission_check(login_id, permission);
}
if self.dao.is_some() {
if let Ok(Some(cached)) = self.get_cached_permission(login_id, permission).await {
return Ok(cached);
}
}
let result = if let Some(pc) = &self.permission_checker {
pc.has_permission(login_id, permission).await?
} else {
let permissions = self.get_permission_list(login_id).await?;
permissions.iter().any(|p| p == permission)
};
if let Some(_dao) = &self.dao {
if let Err(e) = self
.cache_permission(login_id, permission, result, 300)
.await
{
tracing::warn!(
"权限缓存写入失败 (login_id={}, perm={}): {}",
login_id,
permission,
e
);
}
}
Ok(result)
}
async fn check_role(&self, login_id: &str, role: &str) -> GarrisonResult<bool> {
if role.is_empty() {
return Err(GarrisonError::InvalidParam(
"strategy-role-empty".to_string(),
));
}
let roles = self.get_role_list(login_id).await?;
if !self.role_hierarchy.is_empty() {
let expanded = self.expand_roles(&roles);
Ok(expanded.contains(role))
} else {
Ok(roles.iter().any(|r| r == role))
}
}
async fn check_role_any(&self, login_id: &str, roles: &[&str]) -> GarrisonResult<bool> {
let user_roles = self.get_role_list(login_id).await?;
if !self.role_hierarchy.is_empty() {
let expanded = self.expand_roles(&user_roles);
Ok(roles.iter().any(|r| expanded.contains(*r)))
} else {
Ok(roles.iter().any(|r| user_roles.iter().any(|ur| ur == r)))
}
}
async fn check_role_all(&self, login_id: &str, roles: &[&str]) -> GarrisonResult<bool> {
let user_roles = self.get_role_list(login_id).await?;
if !self.role_hierarchy.is_empty() {
let expanded = self.expand_roles(&user_roles);
Ok(roles.iter().all(|r| expanded.contains(*r)))
} else {
Ok(roles.iter().all(|r| user_roles.iter().any(|ur| ur == r)))
}
}
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
async fn check_login_hooks(&self, login_id: &str, ctx: &LoginContext) -> GarrisonResult<()> {
let Some(hook) = &self.firewall_hook else {
return Ok(());
};
if let Err(e) = hook.check_login_frequency(ctx).await {
self.broadcast_firewall_block(login_id, &e).await;
return Err(e);
}
if let Err(e) = hook.check_brute_force(ctx).await {
self.broadcast_firewall_block(login_id, &e).await;
return Err(e);
}
if let Err(e) = hook.check_geo_anomaly(ctx).await {
self.broadcast_firewall_block(login_id, &e).await;
return Err(e);
}
if let Err(e) = hook.check_token_reuse(ctx).await {
self.broadcast_firewall_block(login_id, &e).await;
return Err(e);
}
if let Err(e) = hook.check_device_anomaly(ctx).await {
self.broadcast_firewall_block(login_id, &e).await;
return Err(e);
}
Ok(())
}
}
impl GarrisonPermissionStrategyDefault {
#[cfg(any(
feature = "sms-rate-limit",
feature = "firewall-ratelimit",
feature = "firewall-bruteforce",
feature = "firewall-ddos",
feature = "firewall",
feature = "oauth2-server"
))]
#[cfg_attr(not(feature = "listener"), allow(unused_variables))]
async fn broadcast_firewall_block(&self, login_id: &str, e: &GarrisonError) {
#[cfg(feature = "listener")]
if let Some(lm) = &self.listener_manager {
lm.broadcast(&GarrisonEvent::FirewallBlock {
login_id: login_id.to_string(),
reason: e.to_string(),
request_context: None,
})
.await;
}
}
}