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, MIN_SECRET_LEN};
use super::SsoTicketData;
const DEFAULT_TICKET_TTL: u64 = 60;
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct SsoMessageEnvelope {
pub payload: String,
pub hmac: String,
pub seq: u64,
}
type HmacSha256 = hmac::Hmac<sha2::Sha256>;
fn sso_message_hmac(secret: &str, payload: &str, seq: u64) -> GarrisonResult<String> {
use base64::Engine as _;
use hmac::{KeyInit, Mac};
let mut mac = HmacSha256::new_from_slice(secret.as_bytes())
.map_err(|e| GarrisonError::Internal(format!("sso-message-hmac-init::{}", e)))?;
mac.update(&seq.to_be_bytes());
mac.update(payload.as_bytes());
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
Ok(BASE64_STANDARD.encode(mac.finalize().into_bytes()))
}
pub fn seal_sso_message(secret: &str, payload: &str, seq: u64) -> GarrisonResult<String> {
let hmac = sso_message_hmac(secret, payload, seq)?;
serde_json::to_string(&SsoMessageEnvelope {
payload: payload.to_string(),
hmac,
seq,
})
.map_err(|e| GarrisonError::Internal(format!("sso-message-envelope-serialize::{}", e)))
}
pub fn verify_sso_message(secret: &str, raw: &str, last_seq: &mut u64) -> GarrisonResult<String> {
use base64::Engine as _;
use hmac::{KeyInit, Mac};
let envelope: SsoMessageEnvelope = serde_json::from_str(raw)
.map_err(|_| GarrisonError::InvalidToken("sso-message-envelope-format::".to_string()))?;
let mut mac = HmacSha256::new_from_slice(secret.as_bytes())
.map_err(|e| GarrisonError::Internal(format!("sso-message-hmac-init::{}", e)))?;
mac.update(&envelope.seq.to_be_bytes());
mac.update(envelope.payload.as_bytes());
let sig_bytes = base64::engine::general_purpose::STANDARD
.decode(&envelope.hmac)
.map_err(|_| GarrisonError::InvalidToken("sso-message-hmac-verify::".to_string()))?;
mac.verify_slice(&sig_bytes)
.map_err(|_| GarrisonError::InvalidToken("sso-message-hmac-verify::".to_string()))?;
if envelope.seq <= *last_seq {
return Err(GarrisonError::InvalidToken(format!(
"sso-message-seq-replay::seq={}::last_seq={}",
envelope.seq, *last_seq
)));
}
*last_seq = envelope.seq;
Ok(envelope.payload)
}
#[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,
message_seq: std::sync::atomic::AtomicU64,
}
impl DefaultSsoServer {
pub fn new(dao: Arc<dyn GarrisonDao>, secret: impl Into<String>) -> GarrisonResult<Self> {
let secret: String = secret.into();
if secret.is_empty() {
return Err(GarrisonError::InvalidParam(
"sso-server-secret-empty::".to_string(),
));
}
if secret.len() < MIN_SECRET_LEN {
return Err(GarrisonError::InvalidParam(format!(
"sso-server-secret-too-short::len={}::min={}",
secret.len(),
MIN_SECRET_LEN
)));
}
Ok(Self {
dao,
ticket_ttl_seconds: DEFAULT_TICKET_TTL,
channel: None,
converter: Arc::new(IdentityCenterIdConverter),
secret,
message_seq: std::sync::atomic::AtomicU64::new(1),
})
}
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(
"sso-ticket-client-id-mismatch::".to_string(),
));
}
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:{}", fingerprint_id(login_id));
let seq = self
.message_seq
.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
let envelope = seal_sso_message(&self.secret, message, seq)?;
channel.push(&topic, &envelope).await?;
}
Ok(())
}
}
fn fingerprint_id(id: &str) -> String {
use sha2::{Digest, Sha256};
let digest = Sha256::digest(id.as_bytes());
digest[..16]
.iter()
.map(|b| format!("{:02x}", b))
.collect::<String>()
}
#[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-for-unit-tests-01")
.expect("secret 非空构造应成功");
}
#[test]
fn builder_chain_sets_fields() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let server = DefaultSsoServer::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功")
.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_eq!(result.unwrap(), (), "NoopSsoChannel::push 应返回 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_eq!(
result.unwrap(),
(),
"NoopSsoChannel::subscribe 应返回 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-for-unit-tests-01")
.expect("secret 非空构造应成功");
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-for-unit-tests-01")
.expect("secret 非空构造应成功");
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-for-unit-tests-01")
.expect("secret 非空构造应成功");
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_eq!(first.unwrap(), "1001", "第一次校验应返回 login_id");
assert!(
matches!(second, Err(GarrisonError::InvalidToken(_))),
"第二次校验应返回 InvalidToken"
);
}
#[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-for-unit-tests-01")
.expect("secret 非空构造应成功");
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-for-unit-tests-01")
.expect("secret 非空构造应成功");
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-for-unit-tests-01")
.expect("secret 非空构造应成功");
let result = server.destroy_ticket("nonexistent-ticket").await;
assert_eq!(result.unwrap(), (), "销毁不存在的票据应返回 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_eq!(result1.unwrap(), (), "销毁存在的票据应返回 Ok(())");
assert_eq!(result2.unwrap(), (), "重复销毁应返回 Ok(())(幂等)");
}
#[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-for-unit-tests-01")
.expect("secret 非空构造应成功")
.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-for-unit-tests-01")
.expect("secret 非空构造应成功");
let result = server.push_message("1001", "hello").await;
assert_eq!(
result.unwrap(),
(),
"未注入 channel 时 push_message 应返回 Ok(())(noop)"
);
}
#[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-for-unit-tests-01")
.expect("secret 非空构造应成功")
.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 push_message_topic_masks_login_id() {
struct TopicCapturingChannel {
topics: std::sync::Mutex<Vec<String>>,
}
#[async_trait]
impl SsoChannel for TopicCapturingChannel {
async fn push(&self, topic: &str, _message: &str) -> GarrisonResult<()> {
self.topics.lock().unwrap().push(topic.to_string());
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(TopicCapturingChannel {
topics: std::sync::Mutex::new(Vec::new()),
});
let server = DefaultSsoServer::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功")
.with_channel(channel.clone());
server.push_message("user@example.com", "m1").await.unwrap();
server.push_message("user@example.com", "m2").await.unwrap();
server.push_message("13800138000", "m3").await.unwrap();
let topics = channel.topics.lock().unwrap();
assert_eq!(topics.len(), 3);
for t in topics.iter() {
assert!(
t.starts_with("sso:user:"),
"topic 应保留 sso:user: 前缀,实际: {}",
t
);
assert!(
!t.contains("user@example.com") && !t.contains("13800138000"),
"topic 不得包含原始 login_id(PII),实际: {}",
t
);
}
assert_eq!(topics[0], topics[1], "同 login_id 应映射到相同 topic");
assert_ne!(topics[0], topics[2], "不同 login_id 应映射到不同 topic");
}
#[test]
fn new_rejects_empty_secret_with_invalid_param() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let result = DefaultSsoServer::new(dao, "");
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("sso-server-secret-empty"),
"错误消息应含 sso-server-secret-empty 前缀,实际: {}",
msg
);
},
Err(other) => panic!("期望 InvalidParam,实际: {:?}", other),
Ok(_) => panic!("空 secret 不应构造成功"),
}
}
#[test]
fn new_rejects_short_secret_with_invalid_param() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let result = DefaultSsoServer::new(dao, "a".repeat(31));
match result {
Err(GarrisonError::InvalidParam(msg)) => {
assert!(
msg.contains("sso-server-secret-too-short"),
"错误消息应含 sso-server-secret-too-short 前缀,实际: {}",
msg
);
},
Err(other) => panic!("期望 InvalidParam,实际: {:?}", other),
Ok(_) => panic!("31 字节 secret 不应构造成功"),
}
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
assert!(
DefaultSsoServer::new(dao, "a".repeat(32)).is_ok(),
"32 字节 secret 应构造成功"
);
}
struct MessageCapturingChannel {
messages: std::sync::Mutex<Vec<String>>,
}
#[async_trait]
impl SsoChannel for MessageCapturingChannel {
async fn push(&self, _topic: &str, message: &str) -> GarrisonResult<()> {
self.messages.lock().unwrap().push(message.to_string());
Ok(())
}
async fn subscribe(
&self,
_topic: &str,
_handler: Box<dyn Fn(String) + Send + Sync>,
) -> GarrisonResult<()> {
Ok(())
}
}
#[tokio::test]
async fn push_message_seals_hmac_envelope_and_verifies() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let channel = Arc::new(MessageCapturingChannel {
messages: std::sync::Mutex::new(Vec::new()),
});
let server = DefaultSsoServer::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功")
.with_channel(channel.clone());
server.push_message("1001", "kickout-notify").await.unwrap();
server.push_message("1001", "perm-changed").await.unwrap();
let messages = channel.messages.lock().unwrap();
assert_eq!(messages.len(), 2);
let mut last_seq = 0u64;
let payload1 = verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&messages[0],
&mut last_seq,
)
.expect("信封验签应通过");
assert_eq!(payload1, "kickout-notify");
let payload2 = verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&messages[1],
&mut last_seq,
)
.expect("第二封信封验签应通过");
assert_eq!(payload2, "perm-changed");
}
#[tokio::test]
async fn verify_sso_message_rejects_tampered_payload() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let channel = Arc::new(MessageCapturingChannel {
messages: std::sync::Mutex::new(Vec::new()),
});
let server = DefaultSsoServer::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功")
.with_channel(channel.clone());
server.push_message("1001", "original").await.unwrap();
let raw = channel.messages.lock().unwrap()[0].clone();
let tampered = raw.replace("original", "forged");
assert_ne!(tampered, raw);
let mut last_seq = 0u64;
let result = verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&tampered,
&mut last_seq,
);
match result {
Err(GarrisonError::InvalidToken(msg)) => assert!(
msg.contains("sso-message-hmac-verify"),
"篡改 payload 应报 sso-message-hmac-verify,实际: {msg}"
),
other => panic!("期望 InvalidToken,实际: {:?}", other),
}
}
#[tokio::test]
async fn verify_sso_message_rejects_replayed_seq() {
let dao: Arc<dyn GarrisonDao> = Arc::new(MockDao::new());
let channel = Arc::new(MessageCapturingChannel {
messages: std::sync::Mutex::new(Vec::new()),
});
let server = DefaultSsoServer::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功")
.with_channel(channel.clone());
server.push_message("1001", "m1").await.unwrap();
server.push_message("1001", "m2").await.unwrap();
let messages = channel.messages.lock().unwrap();
let mut last_seq = 0u64;
verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&messages[0],
&mut last_seq,
)
.unwrap();
verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&messages[1],
&mut last_seq,
)
.unwrap();
let replay = verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&messages[0],
&mut last_seq,
);
match replay {
Err(GarrisonError::InvalidToken(msg)) => assert!(
msg.contains("sso-message-seq-replay"),
"重放旧 seq 应报 sso-message-seq-replay,实际: {msg}"
),
other => panic!("期望 InvalidToken,实际: {:?}", other),
}
let forged = serde_json::json!({
"payload": "forged",
"hmac": "AAAA",
"seq": 9999u64
})
.to_string();
let forged_result = verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
&forged,
&mut last_seq,
);
assert!(
matches!(forged_result, Err(GarrisonError::InvalidToken(_))),
"伪造信封应被拒绝"
);
}
#[tokio::test]
async fn verify_sso_message_rejects_malformed_envelope() {
let mut last_seq = 0u64;
let result = verify_sso_message(
"test-sso-secret-key-for-unit-tests-01",
"plain-message",
&mut last_seq,
);
match result {
Err(GarrisonError::InvalidToken(msg)) => assert!(
msg.contains("sso-message-envelope-format"),
"非信封消息应报 sso-message-envelope-format,实际: {msg}"
),
other => panic!("期望 InvalidToken,实际: {:?}", other),
}
}
#[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-for-unit-tests-01")
.expect("secret 非空构造应成功");
let ticket = server.issue_ticket("1001", 2001).await.unwrap();
let client = SsoClient::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功");
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-for-unit-tests-01")
.expect("secret 非空构造应成功");
let ticket = client.issue_ticket("1001", 2001).await.unwrap();
let server = DefaultSsoServer::new(dao, "test-sso-secret-key-for-unit-tests-01")
.expect("secret 非空构造应成功");
let login_id = server.validate_ticket(&ticket, 2001).await.unwrap();
assert_eq!(login_id, "1001");
}
}