use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use async_trait::async_trait;
use std::sync::Arc;
use uuid::Uuid;
use super::client::{sign_ticket, verify_ticket_signature};
use super::SsoTicketData;
const DEFAULT_TICKET_TTL: u64 = 60;
#[async_trait]
pub trait SsoServer: Send + Sync {
async fn issue_ticket(&self, login_id: &str, client_id: i64) -> GarrisonResult<String>;
async fn validate_ticket(&self, ticket: &str, client_id: i64) -> GarrisonResult<String>;
async fn destroy_ticket(&self, ticket: &str) -> GarrisonResult<()>;
async fn push_message(&self, login_id: &str, message: &str) -> GarrisonResult<()>;
}
pub trait CenterIdConverter: Send + Sync {
fn to_center_id(&self, login_id: &str) -> String;
fn to_login_id(&self, center_id: &str) -> String;
}
#[async_trait]
pub trait SsoChannel: Send + Sync {
async fn push(&self, topic: &str, message: &str) -> GarrisonResult<()>;
async fn subscribe(
&self,
topic: &str,
handler: Box<dyn Fn(String) + Send + Sync>,
) -> GarrisonResult<()>;
}
pub struct IdentityCenterIdConverter;
impl CenterIdConverter for IdentityCenterIdConverter {
fn to_center_id(&self, login_id: &str) -> String {
login_id.to_string()
}
fn to_login_id(&self, center_id: &str) -> String {
center_id.to_string()
}
}
pub struct NoopSsoChannel;
#[async_trait]
impl SsoChannel for NoopSsoChannel {
async fn push(&self, _topic: &str, _message: &str) -> GarrisonResult<()> {
Ok(())
}
async fn subscribe(
&self,
_topic: &str,
_handler: Box<dyn Fn(String) + Send + Sync>,
) -> GarrisonResult<()> {
Ok(())
}
}
pub struct DefaultSsoServer {
dao: Arc<dyn GarrisonDao>,
ticket_ttl_seconds: u64,
channel: Option<Arc<dyn SsoChannel>>,
converter: Arc<dyn CenterIdConverter>,
secret: String,
}
impl DefaultSsoServer {
pub fn new(dao: Arc<dyn GarrisonDao>, secret: impl Into<String>) -> Self {
let secret: String = secret.into();
assert!(
!secret.is_empty(),
"SSO secret 不能为空(依据安全审计 M5:ticket 必须签名)"
);
Self {
dao,
ticket_ttl_seconds: DEFAULT_TICKET_TTL,
channel: None,
converter: Arc::new(IdentityCenterIdConverter),
secret,
}
}
pub fn with_ticket_ttl(mut self, ttl_seconds: u64) -> Self {
self.ticket_ttl_seconds = ttl_seconds;
self
}
pub fn with_channel(mut self, channel: Arc<dyn SsoChannel>) -> Self {
self.channel = Some(channel);
self
}
pub fn with_converter(mut self, converter: Arc<dyn CenterIdConverter>) -> Self {
self.converter = converter;
self
}
}
#[async_trait]
impl SsoServer for DefaultSsoServer {
async fn issue_ticket(&self, login_id: &str, client_id: i64) -> GarrisonResult<String> {
let center_id = self.converter.to_center_id(login_id);
let random_part = format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple());
let sig = sign_ticket(&self.secret, &random_part)?;
let ticket = format!("{}.{}", random_part, sig);
let data = SsoTicketData {
login_id: center_id,
client_id,
};
let value = serde_json::to_string(&data)
.map_err(|e| GarrisonError::Internal(format!("sso-ticket-serialize::{}", e)))?;
let key = format!("garrison:sso:ticket:{}", ticket);
self.dao.set(&key, &value, self.ticket_ttl_seconds).await?;
Ok(ticket)
}
async fn validate_ticket(&self, ticket: &str, client_id: i64) -> GarrisonResult<String> {
let _random_part = verify_ticket_signature(&self.secret, ticket)?;
let key = format!("garrison:sso:ticket:{}", ticket);
let value = self
.dao
.get(&key)
.await
.map_err(|e| GarrisonError::Dao(format!("sso-ticket-read::{}", e)))?;
let value = value.ok_or_else(|| {
GarrisonError::InvalidToken("sso-ticket-missing-or-expired".to_string())
})?;
let data: SsoTicketData = serde_json::from_str(&value)
.map_err(|e| GarrisonError::Internal(format!("sso-ticket-deserialize::{}", e)))?;
if data.client_id != client_id {
return Err(GarrisonError::InvalidToken(format!(
"sso-ticket-client-id-mismatch::{}::{}",
data.client_id, client_id
)));
}
let consumed = self
.dao
.get_and_delete(&key)
.await
.map_err(|e| GarrisonError::Dao(format!("sso-ticket-atomic-consume::{}", e)))?;
if consumed.is_none() {
return Err(GarrisonError::InvalidToken(
"sso-ticket-consumed-by-concurrent".to_string(),
));
}
let login_id = self.converter.to_login_id(&data.login_id);
Ok(login_id)
}
async fn destroy_ticket(&self, ticket: &str) -> GarrisonResult<()> {
let key = format!("garrison:sso:ticket:{}", ticket);
self.dao.delete(&key).await
}
async fn push_message(&self, login_id: &str, message: &str) -> GarrisonResult<()> {
if let Some(channel) = &self.channel {
let topic = format!("sso:user:{}", login_id);
channel.push(&topic, message).await?;
}
Ok(())
}
}
#[cfg(feature = "protocol-zeroize")]
impl Drop for DefaultSsoServer {
fn drop(&mut self) {
use zeroize::Zeroize;
self.secret.zeroize();
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::tests::MockDao;
use crate::protocol::sso::SsoClient;
use std::sync::atomic::{AtomicUsize, Ordering};
#[test]
fn new_creates_server_with_dao() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let _server = DefaultSsoServer::new(dao, "test-sso-secret-key");
}
#[test]
fn builder_chain_sets_fields() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key")
.with_ticket_ttl(120)
.with_channel(Arc::new(NoopSsoChannel))
.with_converter(Arc::new(IdentityCenterIdConverter));
assert_eq!(server.ticket_ttl_seconds, 120);
assert!(server.channel.is_some());
}
#[test]
fn identity_converter_roundtrip() {
let converter = IdentityCenterIdConverter;
let center_id = converter.to_center_id("1001");
let login_id = converter.to_login_id(¢er_id);
assert_eq!(login_id, "1001");
assert_eq!(center_id, "1001");
}
#[test]
fn custom_converter_roundtrip() {
struct OffsetConverter;
impl CenterIdConverter for OffsetConverter {
fn to_center_id(&self, login_id: &str) -> String {
format!("c-{}", login_id)
}
fn to_login_id(&self, center_id: &str) -> String {
center_id
.strip_prefix("c-")
.unwrap_or(center_id)
.to_string()
}
}
let converter = OffsetConverter;
let center_id = converter.to_center_id("1001");
assert_eq!(center_id, "c-1001");
let login_id = converter.to_login_id(¢er_id);
assert_eq!(login_id, "1001");
}
#[tokio::test]
async fn noop_channel_push_returns_ok() {
let channel = NoopSsoChannel;
let result = channel.push("topic", "msg").await;
assert!(result.is_ok());
}
#[tokio::test]
async fn noop_channel_subscribe_returns_ok() {
let channel = NoopSsoChannel;
let handler: Box<dyn Fn(String) + Send + Sync> = Box::new(|_msg: String| {});
let result = channel.subscribe("topic", handler).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn issue_and_validate_ticket_roundtrip() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let login_id = server.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
#[tokio::test]
async fn issue_ticket_returns_64_chars() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let parts: Vec<&str> = ticket.splitn(2, '.').collect();
assert_eq!(parts.len(), 2, "ticket 应包含分隔符 '.'");
assert_eq!(parts[0].len(), 64, "random 部分应为 64 字符 hex");
assert!(parts[0].chars().all(|c| c.is_ascii_hexdigit()));
}
#[tokio::test]
async fn validate_ticket_one_time_use_second_fails() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let first = server.validate_ticket(&ticket, 2001).await;
let second = server.validate_ticket(&ticket, 2001).await;
assert!(first.is_ok());
assert!(second.is_err());
}
#[tokio::test]
async fn validate_ticket_client_id_mismatch_returns_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let result = server.validate_ticket(&ticket, 9999).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn validate_ticket_nonexistent_returns_error() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let result = server.validate_ticket("nonexistent-ticket", 2001).await;
assert!(result.is_err());
match result.err() {
Some(GarrisonError::InvalidToken(_)) => {},
other => panic!("期望 InvalidToken 错误,实际: {:?}", other),
}
}
#[tokio::test]
async fn destroy_ticket_idempotent() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let result = server.destroy_ticket("nonexistent-ticket").await;
assert!(result.is_ok());
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let result1 = server.destroy_ticket(&ticket).await;
let result2 = server.destroy_ticket(&ticket).await;
assert!(result1.is_ok());
assert!(result2.is_ok(), "destroy_ticket 应幂等");
}
#[tokio::test]
async fn custom_converter_issue_validate_roundtrip() {
struct OffsetConverter;
impl CenterIdConverter for OffsetConverter {
fn to_center_id(&self, login_id: &str) -> String {
format!("c-{}", login_id)
}
fn to_login_id(&self, center_id: &str) -> String {
center_id
.strip_prefix("c-")
.unwrap_or(center_id)
.to_string()
}
}
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key")
.with_converter(Arc::new(OffsetConverter));
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let login_id = server.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
#[tokio::test]
async fn push_message_noop_when_no_channel() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let result = server.push_message("1001", "hello").await;
assert!(result.is_ok());
}
#[tokio::test]
async fn push_message_delegates_to_channel() {
struct CountingChannel {
count: AtomicUsize,
}
#[async_trait]
impl SsoChannel for CountingChannel {
async fn push(&self, _topic: &str, _message: &str) -> GarrisonResult<()> {
self.count.fetch_add(1, Ordering::SeqCst);
Ok(())
}
async fn subscribe(
&self,
_topic: &str,
_handler: Box<dyn Fn(String) + Send + Sync>,
) -> GarrisonResult<()> {
Ok(())
}
}
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let channel = Arc::new(CountingChannel {
count: AtomicUsize::new(0),
});
let server =
DefaultSsoServer::new(dao, "test-sso-secret-key").with_channel(channel.clone());
server.push_message("1001", "hello").await.unwrap();
server.push_message("1002", "world").await.unwrap();
assert_eq!(channel.count.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn server_and_client_communicate_via_shared_dao() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao.clone(), "test-sso-secret-key");
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let client = SsoClient::new(dao, "test-sso-secret-key");
let login_id = client.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
#[tokio::test]
async fn client_and_server_communicate_via_shared_dao() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let client = SsoClient::new(dao.clone(), "test-sso-secret-key");
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let server = DefaultSsoServer::new(dao, "test-sso-secret-key");
let login_id = server.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
}