use super::GarrisonLogicDefault;
use crate::core::token::TokenStyleFactory;
use crate::error::{GarrisonError, GarrisonResult};
use crate::loc;
#[cfg(all(feature = "listener", feature = "protocol-jwt"))]
use crate::listener::GarrisonEvent;
use crate::stp::session::SessionLogic;
use async_trait::async_trait;
async fn ensure_valid_token_session(session: &dyn SessionLogic) -> GarrisonResult<()> {
let valid = session.check_login().await?;
if valid {
Ok(())
} else {
Err(GarrisonError::NotLogin(
"stp-token-invalid-or-not-login::".to_string(),
))
}
}
#[async_trait]
pub trait TokenLogic: SessionLogic {
async fn check_access_token(&self) -> GarrisonResult<()>
where
Self: Sized,
{
ensure_valid_token_session(self).await
}
async fn check_client_token(&self) -> GarrisonResult<()>
where
Self: Sized,
{
ensure_valid_token_session(self).await
}
async fn check_temp_token(&self) -> GarrisonResult<()>
where
Self: Sized,
{
ensure_valid_token_session(self).await
}
async fn verify_token(&self, _token: &str) -> GarrisonResult<String> {
Err(GarrisonError::NotImplemented(loc!(
"stp-verify-token-not-implemented",
""
)))
}
async fn refresh_token(&self, _token: &str) -> GarrisonResult<String> {
Err(GarrisonError::NotImplemented(loc!(
"stp-refresh-token-not-implemented",
""
)))
}
}
#[async_trait]
impl TokenLogic for GarrisonLogicDefault {
async fn verify_token(&self, token: &str) -> GarrisonResult<String> {
let token_handler = TokenStyleFactory::new_with_jwt_keys(
&self.config.token_style,
self.config.jwt_secret.as_str(),
Some(&self.config.jwt_algorithm),
self.config.jwt_rsa_private_key_pem.as_deref(),
self.config.jwt_ec_private_key_pem.as_deref(),
self.config.jwt_ed_private_key_pem.as_deref(),
)?;
match token_handler.verify(token) {
Ok(Some(login_id)) => Ok(login_id),
Ok(None) => Err(GarrisonError::InvalidToken(
"stp-token-invalid-or-no-login-id::".to_string(),
)),
Err(_) => Err(GarrisonError::InvalidToken(
"stp-token-invalid::".to_string(),
)),
}
}
#[cfg(feature = "protocol-jwt")]
async fn refresh_token(&self, token: &str) -> GarrisonResult<String> {
if self.config.token_style != "jwt" {
return Err(GarrisonError::NotImplemented(loc!(
"stp-refresh-token-jwt-only",
""
)));
}
let login_id = self.verify_token(token).await?;
let handler = crate::protocol::jwt::JwtHandler::from_algorithm_parts(
&self.config.jwt_algorithm,
self.config.jwt_secret.as_str(),
self.config.jwt_rsa_private_key_pem.as_deref(),
self.config.jwt_ec_private_key_pem.as_deref(),
self.config.jwt_ed_private_key_pem.as_deref(),
)?;
if self.config.enable_jwt_revocation {
if let Ok(claims) = handler.verify(token) {
if let Some(jti) = &claims.jti {
let key = format!("jwt:blacklist:{}", jti);
let revoked = self.session.dao().get(&key).await?;
if revoked.is_some() {
return Err(GarrisonError::InvalidToken(
"stp-refresh-token-revoked::".to_string(),
));
}
}
}
}
let new_token = handler.refresh(token, self.config.timeout)?;
self.blacklist_jwt_jti(token).await;
if let Some(pm) = &self.plugin_manager {
pm.on_login(&login_id, &new_token);
}
#[cfg(feature = "listener")]
if let Some(lm) = &self.listener_manager {
lm.broadcast(&GarrisonEvent::TokenRefresh {
login_id,
old_token: crate::listener::mask_token_for_event(token),
new_token: crate::listener::mask_token_for_event(&new_token),
request_context: None,
})
.await;
}
Ok(new_token)
}
}
#[cfg(test)]
mod tests {
#![allow(clippy::useless_conversion)]
use super::*;
use crate::config::GarrisonConfig;
use crate::error::GarrisonResult;
use crate::stp::core::GarrisonCore;
use crate::stp::session::SessionLogic;
use std::sync::Arc;
struct MockToken {
config: Arc<GarrisonConfig>,
logged_in: bool,
}
impl GarrisonCore for MockToken {
fn config(&self) -> Arc<GarrisonConfig> {
Arc::clone(&self.config)
}
}
#[async_trait]
impl SessionLogic for MockToken {
async fn login(
&self,
_login_id: &str,
_params: &crate::stp::LoginParams,
) -> GarrisonResult<String> {
Ok("mock-token".to_string())
}
async fn login_with_token(&self, _login_id: &str, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn logout(&self) -> GarrisonResult<()> {
Ok(())
}
async fn logout_by_login_id(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn kickout(&self, _login_id: &str) -> GarrisonResult<()> {
Ok(())
}
async fn kickout_by_token(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn revoke_token(&self, _token: &str) -> GarrisonResult<()> {
Ok(())
}
async fn check_login(&self) -> GarrisonResult<bool> {
Ok(self.logged_in)
}
async fn get_login_id(&self) -> GarrisonResult<Option<String>> {
if self.logged_in {
Ok(Some("42".to_string()))
} else {
Ok(None)
}
}
}
#[async_trait]
impl TokenLogic for MockToken {}
#[tokio::test]
async fn check_access_token_ok_when_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
mock.check_access_token().await.unwrap();
}
#[tokio::test]
async fn check_access_token_denies_when_not_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: false,
};
let result = mock.check_access_token().await;
assert!(matches!(result, Err(GarrisonError::NotLogin(_))));
}
#[tokio::test]
async fn check_client_token_ok_when_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
mock.check_client_token().await.unwrap();
}
#[tokio::test]
async fn check_client_token_denies_when_not_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: false,
};
let result = mock.check_client_token().await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(ref msg)) if msg.contains("stp-token-invalid-or-not-login")),
"未登录时应返回 NotLogin 包含 'client_token',实际: {:?}",
result
);
}
#[tokio::test]
async fn check_temp_token_ok_when_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
mock.check_temp_token().await.unwrap();
}
#[tokio::test]
async fn check_temp_token_denies_when_not_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: false,
};
let result = mock.check_temp_token().await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(ref msg)) if msg.contains("stp-token-invalid-or-not-login")),
"未登录时应返回 NotLogin 包含 'temp_token',实际: {:?}",
result
);
}
#[tokio::test]
async fn ensure_valid_token_session_helper_ok_when_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
ensure_valid_token_session(&mock).await.unwrap();
}
#[tokio::test]
async fn ensure_valid_token_session_helper_denies_when_not_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: false,
};
let result = ensure_valid_token_session(&mock).await;
assert!(
matches!(result, Err(GarrisonError::NotLogin(ref msg)) if msg.contains("stp-token-invalid-or-not-login")),
"未登录时应返回 NotLogin 统一错误,实际: {:?}",
result
);
}
#[tokio::test]
async fn all_token_type_checks_share_identical_error_semantics() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: false,
};
let access = mock.check_access_token().await;
let client = mock.check_client_token().await;
let temp = mock.check_temp_token().await;
for result in [access, client, temp] {
let msg = result.expect_err("未登录时应返回 Err");
let inner = match &msg {
GarrisonError::NotLogin(s) => s.clone(),
other => format!("{:?}", other),
};
assert!(
inner.contains("stp-token-invalid-or-not-login"),
"token 类型校验错误消息应统一包含 stp-token-invalid-or-not-login,实际: {}",
inner
);
}
}
#[tokio::test]
async fn verify_token_default_returns_not_implemented() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
let result = mock.verify_token("some-token").await;
assert!(matches!(result, Err(GarrisonError::NotImplemented(_))));
}
#[tokio::test]
async fn refresh_token_default_returns_not_implemented() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
let result = mock.refresh_token("old").await;
assert!(matches!(result, Err(GarrisonError::NotImplemented(_))));
}
#[tokio::test]
async fn mock_token_login_returns_token() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: false,
};
let token = mock
.login("alice", &crate::stp::LoginParams::default())
.await
.unwrap();
assert_eq!(token, "mock-token");
}
#[tokio::test]
async fn mock_token_session_methods_return_ok() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
mock.login_with_token("alice", "tok").await.unwrap();
mock.logout().await.unwrap();
mock.logout_by_login_id("alice").await.unwrap();
mock.kickout("alice").await.unwrap();
mock.kickout_by_token("tok").await.unwrap();
mock.revoke_token("tok").await.unwrap();
}
#[tokio::test]
async fn mock_token_config_returns_arc_clone() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
let c1 = mock.config();
let c2 = mock.config();
assert!(Arc::ptr_eq(&c1, &c2), "两次 config() 应返回同一 Arc");
}
#[tokio::test]
async fn mock_token_get_login_id_when_logged_in() {
let mock = MockToken {
config: Arc::new(GarrisonConfig::default()),
logged_in: true,
};
let id = mock.get_login_id().await.unwrap();
assert_eq!(id.as_deref(), Some("42"));
}
mod default_impl_coverage {
use super::*;
use crate::dao::GarrisonDao;
use crate::session::GarrisonSession;
use crate::stp::mock::{MockDao, MockFirewall};
use crate::strategy::GarrisonPermissionStrategy;
use std::sync::Arc;
const STP_TOKEN_SIMPLE_TEST_SECRET: &str = "stp-token-simple-test-secret-0123456789";
fn test_jwt_secret(secret: &str) -> crate::config::JwtSecret {
#[cfg(feature = "protocol-zeroize")]
{
secret.to_string().into()
}
#[cfg(not(feature = "protocol-zeroize"))]
{
secret.to_string()
}
}
fn make_logic(token_style: &str) -> GarrisonLogicDefault {
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 = token_style.to_string();
if token_style == "simple" {
config.jwt_secret = test_jwt_secret(STP_TOKEN_SIMPLE_TEST_SECRET);
}
let firewall: Arc<dyn GarrisonPermissionStrategy> = Arc::new(MockFirewall {
has_permission: true,
has_role: true,
});
GarrisonLogicDefault::new(
session,
Arc::new(config),
firewall,
Arc::new(crate::account::disable::DefaultDisableRepository::new(
dao.clone(),
)),
)
}
#[cfg(feature = "secure-simple-token")]
#[tokio::test]
async fn verify_token_simple_style_returns_login_id() {
let logic = make_logic("simple");
let style =
crate::core::token::SimpleTokenStyle::new(STP_TOKEN_SIMPLE_TEST_SECRET.to_string());
let token = crate::core::token::Token::generate(&style, "verifyuser", 3600).unwrap();
let result = logic.verify_token(&token).await;
assert!(
result.is_ok(),
"simple token verify_token 应返回 Ok,实际: {:?}",
result
);
assert_eq!(
result.unwrap(),
"verifyuser",
"verify_token 应提取 login_id 'verifyuser'"
);
}
#[tokio::test]
async fn verify_token_uuid_style_returns_invalid_token() {
let logic = make_logic("uuid");
let result = logic.verify_token("some-uuid-token").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.contains("stp-token-invalid-or-no-login-id")),
"uuid token verify_token 应返回 InvalidToken 包含 '不包含 login_id',实际: {:?}",
result
);
}
#[tokio::test]
async fn verify_token_invalid_simple_token_returns_invalid_token() {
let logic = make_logic("simple");
let result = logic.verify_token("nodashtoken").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"无效 simple token 应返回 InvalidToken,实际: {:?}",
result
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn verify_token_jwt_style_returns_login_id() {
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 = "jwt".to_string();
config.jwt_secret = "verify-jwt-secret-0000000000000000".to_string().into();
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 handler =
crate::protocol::jwt::JwtHandler::new("verify-jwt-secret-0000000000000000");
let jwt_token = handler.sign("jwt-verify-user", 3600).unwrap();
let result = logic.verify_token(&jwt_token).await;
assert!(
result.is_ok(),
"JWT token verify_token 应返回 Ok,实际: {:?}",
result
);
assert_eq!(
result.unwrap(),
"jwt-verify-user",
"verify_token 应提取 login_id 'jwt-verify-user'"
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn verify_token_invalid_jwt_returns_invalid_token() {
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 = "jwt".to_string();
config.jwt_secret = "verify-jwt-secret-0000000000000000".to_string().into();
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 result = logic.verify_token("invalid.jwt.token").await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(_))),
"无效 JWT 应返回 InvalidToken,实际: {:?}",
result
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn refresh_token_non_jwt_style_returns_not_implemented() {
let logic = make_logic("uuid");
let result = logic.refresh_token("any-token").await;
assert!(
matches!(result, Err(GarrisonError::NotImplemented(ref msg)) if msg.contains("jwt")),
"非 JWT token_style refresh_token 应返回 NotImplemented 包含 'jwt',实际: {:?}",
result
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn refresh_token_jwt_valid_returns_new_token() {
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 = "jwt".to_string();
config.jwt_secret = "refresh-jwt-secret-0000000000000000".to_string().into();
config.timeout = 3600;
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 handler =
crate::protocol::jwt::JwtHandler::new("refresh-jwt-secret-0000000000000000");
let old_token = handler.sign("refresh-user", 3600).unwrap();
let result = logic.refresh_token(&old_token).await;
assert!(
result.is_ok(),
"JWT refresh_token 应返回 Ok,实际: {:?}",
result
);
let new_token = result.unwrap();
assert_ne!(
new_token, old_token,
"refresh_token 应返回新 token,与旧 token 不同"
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn refresh_token_rejects_blacklisted_token() {
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 = "jwt".to_string();
config.enable_jwt_revocation = true;
config.jwt_secret = test_jwt_secret("jwt-refresh-revoke-secret-32bytes-x");
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 old_token = logic
.login("user-bl", &crate::stp::LoginParams::default())
.await
.expect("login 应成功");
logic.blacklist_jwt_jti(&old_token).await;
let result = logic.refresh_token(&old_token).await;
assert!(
matches!(result, Err(GarrisonError::InvalidToken(ref msg)) if msg.contains("stp-refresh-token-revoked")),
"黑名单 token refresh 应被拒,实际: {:?}",
result
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn refresh_token_invalid_jwt_returns_error() {
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 = "jwt".to_string();
config.jwt_secret = "refresh-jwt-secret-0000000000000000".to_string().into();
config.timeout = 3600;
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 result = logic.refresh_token("invalid.jwt.token").await;
assert!(
result.is_err(),
"无效 JWT refresh_token 应返回 Err,实际: {:?}",
result
);
}
#[cfg(feature = "protocol-jwt")]
#[tokio::test]
async fn refresh_token_revokes_old_token() {
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 = "jwt".to_string();
config.enable_jwt_revocation = true;
config.jwt_secret = test_jwt_secret("jwt-refresh-revoke-secret-32bytes-x");
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 old_token = logic
.login("user-refresh", &crate::stp::LoginParams::default())
.await
.expect("login 应成功");
let new_token = logic
.refresh_token(&old_token)
.await
.expect("refresh 应成功");
assert_ne!(old_token, new_token);
let handler = crate::protocol::jwt::JwtHandler::from_algorithm_parts(
"HS256",
test_jwt_secret("jwt-refresh-revoke-secret-32bytes-x").as_str(),
None,
None,
None,
)
.expect("handler 构造应成功");
let jti = handler
.verify(&old_token)
.expect("旧 token 签名仍可验")
.jti
.expect("JWT 应包含 jti");
let key = format!("jwt:blacklist:{}", jti);
let value = dao.get(&key).await.expect("dao get 应成功");
assert!(value.is_some(), "refresh 后旧 token 的 jti 应被写入黑名单");
}
}
}