use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
#[cfg(feature = "listener")]
use crate::listener::{GarrisonEvent, GarrisonListenerManager};
use std::sync::Arc;
use std::time::{SystemTime, UNIX_EPOCH};
use uuid::Uuid;
use super::{ApiKeyHandler, ApiKeyInfo};
pub(crate) fn default_namespace() -> String {
"default".to_string()
}
pub(crate) fn idx_key_for(key: &str) -> String {
format!("garrison:apikey:idx:{}", key)
}
fn validate_namespace(namespace: &str) -> GarrisonResult<()> {
if namespace.is_empty() {
return Err(GarrisonError::InvalidParam(
"apikey-namespace-empty".to_string(),
));
}
if namespace.len() > 64 {
return Err(GarrisonError::InvalidParam(format!(
"apikey-namespace-too-long::{}",
namespace.len()
)));
}
if !namespace
.chars()
.all(|c| c.is_ascii_alphanumeric() || c == '_' || c == '-')
{
return Err(GarrisonError::InvalidParam(format!(
"apikey-namespace-invalid-chars::{}",
namespace
)));
}
Ok(())
}
impl ApiKeyHandler {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self {
dao,
#[cfg(feature = "listener")]
listener_manager: None,
}
}
#[cfg(feature = "listener")]
pub fn with_listener_manager(mut self, lm: Arc<GarrisonListenerManager>) -> Self {
self.listener_manager = Some(lm);
self
}
pub async fn generate(
&self,
login_id: impl Into<String>,
scopes: Vec<String>,
timeout: i64,
) -> GarrisonResult<String> {
self.generate_with_namespace(login_id, &default_namespace(), scopes, timeout)
.await
}
pub async fn generate_with_namespace(
&self,
login_id: impl Into<String>,
namespace: &str,
scopes: Vec<String>,
timeout: i64,
) -> GarrisonResult<String> {
let login_id: String = login_id.into();
if timeout <= 0 {
return Err(GarrisonError::InvalidParam(
"apikey-timeout-positive".to_string(),
));
}
validate_namespace(namespace)?;
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.map_err(|e| GarrisonError::Internal(format!("apikey-clock::{}", e)))?;
let info = ApiKeyInfo {
login_id,
scopes,
expire_at: now + timeout,
revoked: false,
namespace: namespace.to_string(),
};
let value = serde_json::to_string(&info)
.map_err(|e| GarrisonError::Internal(format!("apikey-serialize::{}", e)))?;
let key = format!("{}{}", Uuid::new_v4().simple(), Uuid::new_v4().simple());
let dao_key = format!("garrison:apikey:{}:{}", namespace, key);
self.dao.set(&dao_key, &value, timeout as u64).await?;
let idx_key = idx_key_for(&key);
self.dao.set(&idx_key, &dao_key, timeout as u64).await?;
Ok(key)
}
pub async fn verify(&self, key: &str) -> GarrisonResult<ApiKeyInfo> {
let idx_key = idx_key_for(key);
if let Some(dao_key) = self.dao.get(&idx_key).await? {
if let Some(value) = self.dao.get(&dao_key).await? {
return self.decode_and_check(&value).await;
}
}
let old_dao_key = format!("garrison:apikey:{}", key);
if let Some(value) = self.dao.get(&old_dao_key).await? {
return self.decode_and_check(&value).await;
}
Err(GarrisonError::InvalidToken("apikey-not-found".to_string()))
}
pub async fn verify_with_namespace(
&self,
key: &str,
namespace: &str,
) -> GarrisonResult<ApiKeyInfo> {
validate_namespace(namespace)?;
let dao_key = format!("garrison:apikey:{}:{}", namespace, key);
let value = self.dao.get(&dao_key).await?;
let value =
value.ok_or_else(|| GarrisonError::InvalidToken("apikey-not-found".to_string()))?;
let info = self.decode_and_check(&value).await?;
if info.namespace != namespace {
return Err(GarrisonError::InvalidToken(format!(
"apikey-namespace-mismatch::{}::{}",
namespace, info.namespace
)));
}
Ok(info)
}
async fn decode_and_check(&self, value: &str) -> GarrisonResult<ApiKeyInfo> {
let info: ApiKeyInfo = serde_json::from_str(value)
.map_err(|e| GarrisonError::Internal(format!("apikey-deserialize::{}", e)))?;
if info.revoked {
return Err(GarrisonError::InvalidToken("apikey-revoked".to_string()));
}
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.map_err(|e| GarrisonError::Internal(format!("apikey-clock::{}", e)))?;
if info.expire_at <= now {
return Err(GarrisonError::ExpiredToken("apikey-expired".to_string()));
}
Ok(info)
}
pub async fn revoke(&self, key: &str) -> GarrisonResult<()> {
let idx_key = idx_key_for(key);
if let Some(dao_key) = self.dao.get(&idx_key).await? {
return self.revoke_at(&dao_key).await;
}
let old_dao_key = format!("garrison:apikey:{}", key);
if self.dao.get(&old_dao_key).await?.is_some() {
return self.revoke_at(&old_dao_key).await;
}
Err(GarrisonError::InvalidToken("apikey-not-found".to_string()))
}
async fn revoke_at(&self, dao_key: &str) -> GarrisonResult<()> {
let value = self.dao.get(dao_key).await?;
let value =
value.ok_or_else(|| GarrisonError::InvalidToken("apikey-not-found".to_string()))?;
let mut info: ApiKeyInfo = serde_json::from_str(&value)
.map_err(|e| GarrisonError::Internal(format!("apikey-deserialize::{}", e)))?;
info.revoked = true;
let new_value = serde_json::to_string(&info)
.map_err(|e| GarrisonError::Internal(format!("apikey-serialize::{}", e)))?;
self.dao.update(dao_key, &new_value).await
}
pub async fn list_by_namespace(&self, namespace: &str) -> GarrisonResult<Vec<ApiKeyInfo>> {
validate_namespace(namespace)?;
let pattern = format!("garrison:apikey:{}:*", namespace);
let dao_keys = self.dao.keys(&pattern).await?;
let mut result = Vec::with_capacity(dao_keys.len());
for dao_key in dao_keys {
let value = self.dao.get(&dao_key).await?;
if let Some(v) = value {
let info: ApiKeyInfo = serde_json::from_str(&v)
.map_err(|e| GarrisonError::Internal(format!("apikey-deserialize::{}", e)))?;
if !info.revoked {
result.push(info);
}
}
}
Ok(result)
}
pub async fn rotate(&self, old_key: &str) -> GarrisonResult<String> {
let info = self.verify(old_key).await?;
self.revoke(old_key).await?;
let now = SystemTime::now()
.duration_since(UNIX_EPOCH)
.map(|d| d.as_secs() as i64)
.map_err(|e| GarrisonError::Internal(format!("apikey-clock::{}", e)))?;
let remaining_ttl = info.expire_at - now;
if remaining_ttl <= 0 {
return Err(GarrisonError::ExpiredToken(
"apikey-expired-cannot-rotate".to_string(),
));
}
let new_key = self
.generate(info.login_id, info.scopes, remaining_ttl)
.await?;
#[cfg(feature = "listener")]
if let Some(lm) = &self.listener_manager {
lm.broadcast(&GarrisonEvent::TokenRotate {
old_key: old_key.to_string(),
new_key: new_key.clone(),
request_context: None,
})
.await;
}
Ok(new_key)
}
}