use crate::config::GarrisonConfig;
use crate::core::auth::AuthLogic;
use crate::core::permission::PermissionChecker;
#[allow(unused_imports)]
use crate::error::{GarrisonError, GarrisonResult};
#[cfg(feature = "listener")]
use crate::listener::GarrisonListenerManager;
use crate::plugin::GarrisonPluginManager;
use crate::session::GarrisonSession;
use crate::strategy::GarrisonPermissionStrategy;
use chrono::{DateTime, Utc};
use dashmap::DashMap;
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::Mutex as TokioMutex;
#[cfg(feature = "parameter-query")]
pub mod parameter;
pub mod clock;
pub mod context;
pub mod core;
pub mod interface;
pub mod mfa;
pub mod password;
pub mod permission;
#[cfg(feature = "security-extra")]
pub mod safe;
pub mod session;
pub mod token;
pub mod util;
pub use self::context::{
current_ip, current_token, with_current_ip, with_current_token, with_login_id_scope,
};
pub use self::core::GarrisonCore;
pub use self::interface::GarrisonInterface;
pub use self::mfa::MfaLogic;
pub use self::mfa::{
AmrEntry, MfaChainDecision, RequiredActionChallenge, RequiredActionContext,
RequiredActionProvider,
};
#[cfg(feature = "mfa-recovery")]
pub use self::mfa::{RecoveryCodeManager, RecoveryVerify};
pub use self::password::PasswordLogic;
pub use self::permission::PermissionLogic;
pub use self::session::SessionLogic;
pub use self::token::TokenLogic;
#[cfg(any(feature = "backend-embedded", feature = "backend-remote"))]
pub use self::util::init_backend;
pub use self::util::{GarrisonUtil, JwtMode};
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct LoginParams {
pub device: Option<String>,
pub ip: Option<String>,
pub user_agent: Option<String>,
pub remember_me: bool,
pub require_mfa: bool,
}
tokio::task_local! {
static CURRENT_TOKEN: String;
}
pub struct GarrisonContext {
token: Option<String>,
}
pub trait Clock: Send + Sync {
fn now(&self) -> DateTime<Utc>;
}
pub struct SystemClock;
#[derive(Clone)]
pub struct MockClock {
time: Arc<RwLock<DateTime<Utc>>>,
}
pub struct GarrisonLogicDefault {
pub(crate) session: Arc<GarrisonSession>,
config: Arc<GarrisonConfig>,
pub(crate) firewall: Arc<dyn GarrisonPermissionStrategy>,
pub(crate) plugin_manager: Option<Arc<GarrisonPluginManager>>,
#[cfg(feature = "listener")]
pub(crate) listener_manager: Option<Arc<GarrisonListenerManager>>,
pub(crate) auth_logic: Option<Arc<dyn AuthLogic>>,
pub(crate) permission_checker: Option<Arc<dyn PermissionChecker>>,
#[cfg(feature = "metrics-prometheus")]
metrics: Option<Arc<crate::observability::GarrisonMetrics>>,
#[cfg(all(feature = "account-credential", feature = "db-sqlite"))]
password_hasher: Option<Arc<dyn crate::account::credential::password::PasswordHasher>>,
#[cfg(all(feature = "account-credential", feature = "db-sqlite"))]
user_repository: Option<Arc<dyn crate::dao::repository::UserRepository>>,
pub(crate) login_type: String,
pub(crate) jwt_mode: JwtMode,
#[cfg(all(feature = "protocol-jwt", feature = "db-sqlite"))]
refresh_token_rotation: Option<crate::protocol::jwt::refresh::RefreshTokenRotation>,
renewal_locks: DashMap<String, Arc<TokioMutex<()>>>,
clock: Arc<dyn Clock>,
#[cfg(feature = "security-extra")]
pub(crate) anomaly_detectors: Option<Vec<Arc<dyn crate::strategy::alert::AnomalyDetector>>>,
#[cfg(feature = "security-extra")]
pub(crate) alert_listener_manager: Option<Arc<crate::strategy::alert::AlertListenerManager>>,
#[cfg(feature = "device-binding")]
pub(crate) device_binding_policy:
Option<Arc<dyn crate::strategy::device_binding::DeviceBindingPolicy>>,
pub(crate) disable_repository: Arc<dyn crate::account::disable::DisableRepository>,
#[cfg(feature = "three-tier-cache")]
pub(crate) user_cache_service: Option<Arc<crate::cache::UserCacheService>>,
pub(crate) marker: Option<&'static str>,
#[cfg(all(feature = "protocol-apikey", feature = "firewall-bruteforce"))]
brute_force_strategy:
std::sync::OnceLock<Arc<crate::strategy::firewall::brute_force::BruteForceStrategy>>,
}
mod default_impl;
#[cfg(test)]
pub(crate) mod mock;
#[cfg(test)]
mod tests;
#[cfg(test)]
#[cfg(not(feature = "security-extra"))]
mod safe_feature_gate_tests {
use super::*;
use crate::dao::GarrisonDao;
use crate::stp::mock::{MockDao, MockFirewall};
use crate::strategy::GarrisonPermissionStrategy;
use std::sync::Arc;
#[tokio::test]
async fn t026_safe_auth_not_in_scope_when_disabled() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let session = Arc::new(GarrisonSession::new(dao.clone(), 3600, 86400, 0));
let mut config = GarrisonConfig::default_config();
config.throw_on_not_login = false;
config.token_style = "uuid".to_string();
let firewall: Arc<dyn GarrisonPermissionStrategy> = Arc::new(MockFirewall {
has_permission: true,
has_role: true,
});
let logic = GarrisonLogicDefault::new(
session,
Arc::new(config),
firewall,
Arc::new(crate::account::disable::DefaultDisableRepository::new(
dao.clone(),
)),
);
let token = logic
.login("user-t026-002", &LoginParams::default())
.await
.unwrap();
with_current_token(token, async {
assert!(
logic.open_safe("default", 3600).await.is_ok(),
"security-extra 禁用时 open_safe 应走 trait default 返回 Ok(())"
);
assert!(
logic.is_safe("default").await.unwrap_or(false),
"security-extra 禁用时 is_safe 应走 trait default 返回 Ok(true)"
);
assert!(
logic.close_safe("default").await.is_ok(),
"security-extra 禁用时 close_safe 应走 trait default 返回 Ok(())"
);
})
.await;
}
}