use super::SsoClient;
use super::SsoTicketData;
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use base64::Engine;
use hmac::{Hmac, KeyInit, Mac};
use sha2::Sha256;
use std::sync::Arc;
use uuid::Uuid;
type HmacSha256 = Hmac<Sha256>;
const DEFAULT_TICKET_TTL: u64 = 60;
pub(crate) const MIN_SECRET_LEN: usize = 32;
pub(crate) fn sign_ticket(secret: &str, random_part: &str) -> GarrisonResult<String> {
let mut mac = HmacSha256::new_from_slice(secret.as_bytes())
.map_err(|e| GarrisonError::Internal(format!("sso-ticket-hmac-init::{}", e)))?;
mac.update(random_part.as_bytes());
Ok(BASE64_STANDARD.encode(mac.finalize().into_bytes()))
}
pub(crate) fn verify_ticket_signature(secret: &str, ticket: &str) -> GarrisonResult<String> {
let (random_part, sig_b64) = ticket
.split_once('.')
.ok_or_else(|| GarrisonError::InvalidToken("sso-ticket-format-no-sig::".to_string()))?;
let mut mac = HmacSha256::new_from_slice(secret.as_bytes())
.map_err(|e| GarrisonError::Internal(format!("sso-ticket-hmac-init::{}", e)))?;
mac.update(random_part.as_bytes());
let sig_bytes = BASE64_STANDARD
.decode(sig_b64)
.map_err(|_| GarrisonError::InvalidToken("sso-ticket-sig-verify::".to_string()))?;
mac.verify_slice(&sig_bytes)
.map_err(|_| GarrisonError::InvalidToken("sso-ticket-sig-verify::".to_string()))?;
Ok(random_part.to_string())
}
impl SsoClient {
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-client-secret-empty::".to_string(),
));
}
if secret.len() < MIN_SECRET_LEN {
return Err(GarrisonError::InvalidParam(format!(
"sso-client-secret-too-short::len={}::min={}",
secret.len(),
MIN_SECRET_LEN
)));
}
Ok(Self {
dao,
ticket_ttl_seconds: DEFAULT_TICKET_TTL,
secret,
})
}
pub fn with_ticket_ttl(mut self, ttl_seconds: u64) -> Self {
self.ticket_ttl_seconds = ttl_seconds;
self
}
fn sign_ticket(&self, random_part: &str) -> GarrisonResult<String> {
sign_ticket(&self.secret, random_part)
}
fn verify_ticket_signature(&self, ticket: &str) -> GarrisonResult<String> {
verify_ticket_signature(&self.secret, ticket)
}
pub async fn issue_ticket(
&self,
login_id: impl Into<String>,
client_id: i64,
) -> GarrisonResult<String> {
let login_id: String = login_id.into();
let random_part = format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple());
let sig = self.sign_ticket(&random_part)?;
let ticket = format!("{}.{}", random_part, sig);
let data = SsoTicketData {
login_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)
}
pub async fn validate_ticket(&self, ticket: &str, client_id: i64) -> GarrisonResult<String> {
let _random_part = self.verify_ticket_signature(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(),
));
}
Ok(data.login_id)
}
pub async fn destroy_ticket(&self, ticket: &str) -> GarrisonResult<()> {
let key = format!("garrison:sso:ticket:{}", ticket);
self.dao.delete(&key).await
}
}
#[cfg(feature = "protocol-zeroize")]
impl Drop for SsoClient {
fn drop(&mut self) {
use zeroize::Zeroize;
self.secret.zeroize();
}
}