use super::*;
use crate::dao::repository::validate_imported_hash;
impl DaoCredentialRepository {
pub fn new(dao: Arc<dyn GarrisonDao>) -> Self {
Self { dao }
}
fn make_key(user_id: &str, cred_id: &str) -> String {
format!("{}{}:{}", DaoKeyPrefix::Cred, user_id, cred_id)
}
fn deserialize_credential(json: &str) -> GarrisonResult<CredentialModel> {
serde_json::from_str(json)
.map_err(|e| GarrisonError::Internal(format!("account-cred-deserialize::{}", e)))
}
fn serialize_credential(credential: &CredentialModel) -> GarrisonResult<String> {
serde_json::to_string(credential)
.map_err(|e| GarrisonError::Internal(format!("account-cred-serialize::{}", e)))
}
}
#[async_trait]
impl CredentialRepository for DaoCredentialRepository {
async fn create(&self, credential: CredentialModel) -> GarrisonResult<()> {
if credential.credential_type == "password" {
validate_imported_hash(&credential.secret_data).map_err(|e| {
GarrisonError::InvalidParam(format!("credential-create-hash-gate::{}", e))
})?;
}
let key = Self::make_key(&credential.user_id, &credential.id);
let json = Self::serialize_credential(&credential)?;
let inserted = self.dao.set_if_absent(&key, &json, 0).await?;
if !inserted {
return Err(GarrisonError::InvalidParam(format!(
"credential-already-exists::{}",
credential.id
)));
}
Ok(())
}
async fn find_by_user(
&self,
caller_login_id: &str,
user_id: &str,
) -> GarrisonResult<Vec<CredentialModel>> {
if caller_login_id != user_id {
tracing::warn!(
caller_login_id = caller_login_id,
target_user_id = user_id,
"credential find_by_user denied: caller != target (IDOR)"
);
return Err(GarrisonError::NotPermission(format!(
"credential-query-forbidden::{}::{}",
caller_login_id, user_id
)));
}
let pattern = format!("{}{}:*", DaoKeyPrefix::Cred, user_id);
let keys = self.dao.keys(&pattern).await?;
let mut result = Vec::with_capacity(keys.len());
for key in keys {
if let Some(json) = self.dao.get(&key).await? {
let model: CredentialModel = Self::deserialize_credential(&json)?;
result.push(model);
}
}
result.sort_by_key(|c| c.priority);
Ok(result)
}
async fn find_by_user_and_type(
&self,
user_id: &str,
cred_type: &str,
) -> GarrisonResult<Vec<CredentialModel>> {
let all = self.find_by_user(user_id, user_id).await?;
Ok(all
.into_iter()
.filter(|c| c.credential_type == cred_type)
.collect())
}
async fn update(
&self,
caller_login_id: &str,
credential: CredentialModel,
) -> GarrisonResult<()> {
let pattern = format!("{}*:{}", DaoKeyPrefix::Cred, credential.id);
let keys = self.dao.keys(&pattern).await?;
let existing_key = match keys.into_iter().next() {
Some(k) => k,
None => {
return Err(GarrisonError::InvalidParam(format!(
"credential-not-found::{}",
credential.id
)));
},
};
let existing_json = match self.dao.get(&existing_key).await? {
Some(json) => json,
None => {
return Err(GarrisonError::InvalidParam(format!(
"credential-not-found::{}",
credential.id
)));
},
};
let existing: CredentialModel = Self::deserialize_credential(&existing_json)?;
if existing.user_id != caller_login_id {
tracing::warn!(
caller_login_id = caller_login_id,
owner_user_id = %existing.user_id,
credential_id = %credential.id,
"credential update denied: caller != owner (IDOR)"
);
return Err(GarrisonError::NotPermission(format!(
"credential-update-forbidden::{}::{} (owner {})",
caller_login_id, credential.id, existing.user_id
)));
}
if credential.user_id != existing.user_id {
tracing::warn!(
caller_login_id = caller_login_id,
old_user_id = %existing.user_id,
new_user_id = %credential.user_id,
credential_id = %credential.id,
"credential update denied: user_id transfer forbidden (IDOR)"
);
return Err(GarrisonError::NotPermission(format!(
"credential-transfer-forbidden::{}::{} -> {}",
credential.id, existing.user_id, credential.user_id
)));
}
if credential.credential_type == "password" {
validate_imported_hash(&credential.secret_data).map_err(|e| {
GarrisonError::InvalidParam(format!("credential-update-hash-gate::{}", e))
})?;
}
let json = Self::serialize_credential(&credential)?;
let swapped = self
.dao
.compare_and_swap(&existing_key, Some(&existing_json), &json, 0)
.await?;
if !swapped {
tracing::warn!(
caller_login_id = caller_login_id,
credential_id = %credential.id,
"credential update aborted: concurrent modification detected (CAS mismatch)"
);
return Err(GarrisonError::Internal(format!(
"credential-concurrent-modification::{}",
credential.id
)));
}
Ok(())
}
async fn delete(&self, caller_login_id: &str, credential_id: &str) -> GarrisonResult<()> {
let pattern = format!("{}*:{}", DaoKeyPrefix::Cred, credential_id);
let keys = self.dao.keys(&pattern).await?;
if keys.is_empty() {
return Err(GarrisonError::InvalidParam(format!(
"credential-not-found::{}",
credential_id
)));
}
let mut verified_keys = Vec::with_capacity(keys.len());
for key in keys {
let json = match self.dao.get(&key).await? {
Some(j) => j,
None => continue,
};
let existing: CredentialModel = Self::deserialize_credential(&json)?;
if existing.user_id != caller_login_id {
tracing::warn!(
caller_login_id = caller_login_id,
owner_user_id = %existing.user_id,
credential_id = %credential_id,
"credential delete denied: caller != owner (IDOR)"
);
return Err(GarrisonError::NotPermission(format!(
"credential-delete-forbidden::{}::{} (owner {})",
caller_login_id, credential_id, existing.user_id
)));
}
verified_keys.push(key);
}
for key in verified_keys {
self.dao.delete(&key).await?;
}
Ok(())
}
}