#[cfg(feature = "abac")]
use super::AbacEngine;
#[cfg(feature = "abac")]
use crate::error::{GarrisonError, GarrisonResult};
#[cfg(feature = "abac")]
use crate::loc;
#[cfg(feature = "abac")]
use std::sync::{Arc, Mutex};
#[cfg(feature = "abac")]
static CURRENT_ENGINE: Mutex<Option<Arc<AbacEngine>>> = Mutex::new(None);
#[cfg(feature = "abac")]
pub fn init_abac_engine(engine: AbacEngine) -> GarrisonResult<()> {
let mut guard = CURRENT_ENGINE
.lock()
.map_err(|_| GarrisonError::Config("CURRENT_ENGINE lock poisoned".into()))?;
if guard.is_some() {
return Err(GarrisonError::Config(
"AbacEngine already initialized".into(),
));
}
*guard = Some(Arc::new(engine));
Ok(())
}
#[cfg(feature = "abac")]
pub(crate) fn get_abac_engine() -> GarrisonResult<Option<Arc<AbacEngine>>> {
let guard = CURRENT_ENGINE
.lock()
.map_err(|_| GarrisonError::Config("CURRENT_ENGINE lock poisoned".into()))?;
Ok(guard.clone())
}
#[cfg(feature = "abac")]
#[cfg(any(test, feature = "testing"))]
pub fn reset_abac_for_test() {
if let Ok(mut guard) = CURRENT_ENGINE.lock() {
*guard = None;
}
}
#[cfg(feature = "abac")]
const ABAC_EXPR_MAX_LEN: usize = 512;
#[cfg(feature = "abac")]
pub fn validate_abac_expr(expr: &str) -> GarrisonResult<()> {
let trimmed = expr.trim();
if trimmed.is_empty() {
return Err(GarrisonError::InvalidParam(loc!(
"abac-expr-empty",
"abac_expr must not be empty"
)));
}
if trimmed.len() > ABAC_EXPR_MAX_LEN {
return Err(GarrisonError::InvalidParam(loc!(
"abac-expr-too-long",
format!(
"abac_expr exceeds {} characters (DoS protection)",
ABAC_EXPR_MAX_LEN
),
("max", ABAC_EXPR_MAX_LEN.to_string().as_str())
)));
}
if expr.contains("};") {
return Err(GarrisonError::InvalidParam(loc!(
"abac-expr-illegal-chars",
"abac_expr contains illegal characters `};` (possible policy injection)"
)));
}
if expr.contains("permit(") || expr.contains("forbid(") {
return Err(GarrisonError::InvalidParam(loc!(
"abac-expr-policy-forbidden",
"abac_expr must not declare permit/forbid policies"
)));
}
let lower = expr.to_lowercase();
if !lower.contains("principal") && !lower.contains("resource") && !lower.contains("action") {
return Err(GarrisonError::InvalidParam(loc!(
"abac-expr-must-reference-entity",
"abac_expr must reference principal/resource/action (plain literals rejected)"
)));
}
Ok(())
}
#[cfg(feature = "abac")]
pub async fn check_abac_with_policy(
action: &str,
resource: &str,
abac_expr: &str,
) -> GarrisonResult<()> {
let engine = match get_abac_engine()? {
Some(e) => e,
None => {
return Err(GarrisonError::Config(loc!(
"abac-engine-not-initialized",
"AbacEngine not initialized; ABAC check failed (fail-closed)"
)))
}, };
validate_abac_expr(abac_expr)?;
let login_id = crate::stp::GarrisonUtil::get_login_id().await?;
let login_id = match login_id {
Some(id) => id,
None => {
return Err(GarrisonError::NotLogin(loc!(
"abac-login-id-missing",
"login_id not available during ABAC validation"
)))
},
};
let principal = format!(r#"User::"{login_id}""#);
let action_uid = format!(r#"Action::"{action}""#);
let policy_src = format!(
r#"permit(principal, action == Action::"{action}", resource) when {{ {abac_expr} }};"#
);
let decision = engine
.evaluate_with_temp_policy(&principal, &action_uid, resource, None, &policy_src)
.await?;
if decision.allowed {
Ok(())
} else {
tracing::debug!(expr = %abac_expr, "ABAC policy denied");
Err(GarrisonError::NotPermission(format!(
"abac-policy-denied::{}::{}",
action, resource
)))
}
}
#[cfg(not(feature = "abac"))]
pub async fn check_abac_with_policy(
_action: &str,
_resource: &str,
_abac_expr: &str,
) -> crate::error::GarrisonResult<()> {
Ok(())
}