use std::sync::Arc;
use arc_swap::ArcSwap;
use async_trait::async_trait;
use sha2::{Digest, Sha256};
use crate::dao::GarrisonDao;
use crate::error::{GarrisonError, GarrisonResult};
use super::cipher::FieldCipher;
use super::crypto_value::AadBinding;
pub const SENSITIVE_TABLES: &[&str] = &[
"oauth2:atoken:",
"oauth2:rtoken:",
"oauth2:codeused:",
"totp:seed:",
];
pub const DIGEST_TABLES: &[&str] = &["oauth2:atoken:", "oauth2:rtoken:", "oauth2:codeused:"];
pub fn is_digest_form(remainder: &str) -> bool {
remainder.len() == 64
&& remainder
.bytes()
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
}
pub struct FieldEncryptionDao {
inner: Arc<dyn GarrisonDao>,
cipher: ArcSwap<FieldCipher>,
tenant: String,
}
impl std::fmt::Debug for FieldEncryptionDao {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("FieldEncryptionDao")
.field("tenant", &self.tenant)
.finish_non_exhaustive()
}
}
impl FieldEncryptionDao {
pub fn new(
inner: Arc<dyn GarrisonDao>,
cipher: Arc<FieldCipher>,
tenant: &str,
) -> GarrisonResult<Self> {
if tenant.is_empty() {
return Err(GarrisonError::Config(
"secure-field-encryption-dao::empty-tenant".to_string(),
));
}
Ok(Self {
inner,
cipher: ArcSwap::from(cipher),
tenant: tenant.to_string(),
})
}
pub(crate) fn inner_dao(&self) -> &dyn GarrisonDao {
self.inner.as_ref()
}
pub(crate) fn current_cipher(&self) -> Arc<FieldCipher> {
self.cipher.load().clone()
}
pub(crate) fn swap_cipher(&self, new_cipher: FieldCipher) {
self.cipher.store(Arc::new(new_cipher));
}
pub(crate) fn is_sensitive(key: &str) -> bool {
SENSITIVE_TABLES.iter().any(|t| key.starts_with(t))
}
pub(crate) fn storage_key(key: &str) -> String {
for table in DIGEST_TABLES {
if let Some(remainder) = key.strip_prefix(table) {
let digest = Sha256::digest(remainder.as_bytes());
let mut hex = String::with_capacity(64);
for byte in digest {
hex.push_str(&format!("{byte:02x}"));
}
return format!("{table}{hex}");
}
}
key.to_string()
}
pub(crate) fn aad_for_key(&self, stored_key: &str) -> AadBinding {
for table in SENSITIVE_TABLES {
if let Some(row) = stored_key.strip_prefix(table) {
return AadBinding::new(&self.tenant, &table[..table.len() - 1], row);
}
}
AadBinding::new(&self.tenant, "unknown", stored_key)
}
async fn encrypt_for_write(&self, stored_key: &str, value: &str) -> GarrisonResult<String> {
if !Self::is_sensitive(stored_key) {
return Ok(value.to_string());
}
self.current_cipher()
.encrypt(&self.aad_for_key(stored_key), value)
}
async fn decrypt_for_read(
&self,
stored_key: &str,
value: Option<String>,
) -> GarrisonResult<Option<String>> {
let Some(value) = value else {
return Ok(None);
};
if !Self::is_sensitive(stored_key) {
return Ok(Some(value));
}
self.current_cipher()
.decrypt(&self.aad_for_key(stored_key), &value)
.map(Some)
}
async fn sensitive_get(&self, presented: &str) -> GarrisonResult<Option<String>> {
let stored = Self::storage_key(presented);
if stored != presented {
if let Some(raw) = self.inner.get(&stored).await? {
return self.decrypt_for_read(&stored, Some(raw)).await;
}
}
let raw = self.inner.get(presented).await?;
self.decrypt_for_read(presented, raw).await
}
fn unsupported_op(key: &str, op: &str) -> GarrisonError {
GarrisonError::Internal(format!(
"secure-field-encryption-dao::{op}-unsupported-on-sensitive-namespace::key-prefix={}",
key.split(':').take(2).collect::<Vec<_>>().join(":")
))
}
}
#[async_trait]
impl GarrisonDao for FieldEncryptionDao {
async fn get(&self, key: &str) -> GarrisonResult<Option<String>> {
if !Self::is_sensitive(key) {
return self.inner.get(key).await;
}
self.sensitive_get(key).await
}
async fn set(&self, key: &str, value: &str, ttl_seconds: u64) -> GarrisonResult<()> {
let stored = Self::storage_key(key);
let encrypted = self.encrypt_for_write(&stored, value).await?;
self.inner.set(&stored, &encrypted, ttl_seconds).await
}
async fn update(&self, key: &str, value: &str) -> GarrisonResult<()> {
let stored = Self::storage_key(key);
let encrypted = self.encrypt_for_write(&stored, value).await?;
self.inner.update(&stored, &encrypted).await
}
async fn expire(&self, key: &str, seconds: u64) -> GarrisonResult<()> {
self.inner.expire(&Self::storage_key(key), seconds).await
}
async fn delete(&self, key: &str) -> GarrisonResult<()> {
let stored = Self::storage_key(key);
self.inner.delete(&stored).await?;
if stored != key && Self::is_sensitive(key) {
let _ = self.inner.delete(key).await;
}
Ok(())
}
async fn set_permanent(&self, key: &str, value: &str) -> GarrisonResult<()> {
let stored = Self::storage_key(key);
let encrypted = self.encrypt_for_write(&stored, value).await?;
self.inner.set_permanent(&stored, &encrypted).await
}
async fn set_if_absent(
&self,
key: &str,
value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
let stored = Self::storage_key(key);
let encrypted = self.encrypt_for_write(&stored, value).await?;
self.inner
.set_if_absent(&stored, &encrypted, ttl_seconds)
.await
}
async fn get_timeout(&self, key: &str) -> GarrisonResult<Option<std::time::Duration>> {
self.inner.get_timeout(&Self::storage_key(key)).await
}
async fn get_with_ttl(
&self,
key: &str,
) -> GarrisonResult<Option<(String, Option<std::time::Duration>)>> {
let stored = Self::storage_key(key);
let (found_key, value_ttl) = if stored != key && Self::is_sensitive(key) {
match self.inner.get_with_ttl(&stored).await? {
Some(pair) => (stored, Some(pair)),
None => match self.inner.get_with_ttl(key).await? {
Some(pair) => (key.to_string(), Some(pair)),
None => (key.to_string(), None),
},
}
} else {
match self.inner.get_with_ttl(&stored).await? {
Some(pair) => (stored, Some(pair)),
None => (stored, None),
}
};
match value_ttl {
None => Ok(None),
Some((value, ttl)) => self
.decrypt_for_read(&found_key, Some(value))
.await
.map(|v| v.map(|v| (v, ttl))),
}
}
async fn keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
self.inner.keys(pattern).await
}
async fn rename(&self, old_key: &str, new_key: &str) -> GarrisonResult<()> {
if !Self::is_sensitive(old_key) && !Self::is_sensitive(new_key) {
return self.inner.rename(old_key, new_key).await;
}
let old_stored = Self::storage_key(old_key);
let new_stored = Self::storage_key(new_key);
let plaintext = self.get(old_key).await?.ok_or_else(|| {
GarrisonError::InvalidParam(format!(
"secure-field-encryption-dao::rename-missing-key::{old_key}"
))
})?;
self.inner.rename(&old_stored, &new_stored).await?;
match self.encrypt_for_write(&new_stored, &plaintext).await {
Ok(encrypted) => self.inner.update(&new_stored, &encrypted).await,
Err(e) => {
self.inner.rename(&new_stored, &old_stored).await?;
Err(e)
},
}
}
async fn get_and_delete(&self, key: &str) -> GarrisonResult<Option<String>> {
if !Self::is_sensitive(key) {
let raw = self.inner.get_and_delete(key).await?;
return self.decrypt_for_read(key, raw).await;
}
let stored = Self::storage_key(key);
let hit_digest = if stored != key {
self.inner
.get_and_delete(&stored)
.await?
.map(|raw| (stored.clone(), Some(raw)))
} else {
None
};
let (found_key, raw) = match hit_digest {
Some(pair) => pair,
None => (key.to_string(), self.inner.get_and_delete(key).await?),
};
if found_key == stored && stored != key {
let _ = self.inner.delete(key).await;
}
self.decrypt_for_read(&found_key, raw).await
}
async fn incr(&self, key: &str, ttl_seconds: u64) -> GarrisonResult<u64> {
if Self::is_sensitive(key) {
return Err(Self::unsupported_op(key, "incr"));
}
self.inner.incr(key, ttl_seconds).await
}
async fn decr(&self, key: &str) -> GarrisonResult<u64> {
if Self::is_sensitive(key) {
return Err(Self::unsupported_op(key, "decr"));
}
self.inner.decr(key).await
}
async fn compare_and_update_if_greater(
&self,
key: &str,
new_value: u64,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
if Self::is_sensitive(key) {
return Err(Self::unsupported_op(key, "compare_and_update_if_greater"));
}
self.inner
.compare_and_update_if_greater(key, new_value, ttl_seconds)
.await
}
async fn compare_and_swap(
&self,
key: &str,
expected: Option<&str>,
new_value: &str,
ttl_seconds: u64,
) -> GarrisonResult<bool> {
if Self::is_sensitive(key) {
return Err(Self::unsupported_op(key, "compare_and_swap"));
}
self.inner
.compare_and_swap(key, expected, new_value, ttl_seconds)
.await
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::dao::InMemoryDao;
use crate::secure::encryption::cipher::StaticFieldKeyProvider;
use crate::secure::encryption::crypto_value::KEY_LEN;
const K1: [u8; KEY_LEN] = crate::secure::encryption::crypto_value::test_key(1);
fn fixture() -> (FieldEncryptionDao, Arc<dyn GarrisonDao>) {
let inner: Arc<dyn GarrisonDao> = Arc::new(InMemoryDao::new());
let provider = Arc::new(StaticFieldKeyProvider::new(vec![("k1".to_string(), K1)]).unwrap());
let cipher = Arc::new(FieldCipher::new(provider).unwrap());
let dao = FieldEncryptionDao::new(inner.clone(), cipher, "tenant-1").unwrap();
(dao, inner)
}
#[tokio::test]
async fn write_path_encrypts_value_and_digests_key() {
let (dao, inner) = fixture();
dao.set("oauth2:atoken:bearer-secret-token", "secret-token", 60)
.await
.unwrap();
dao.set("session:s-1", "raw-session", 60).await.unwrap();
let stored_keys = inner.keys("oauth2:atoken:*").await.unwrap();
assert_eq!(stored_keys.len(), 1);
let stored_key = &stored_keys[0];
assert_ne!(
stored_key.as_str(),
"oauth2:atoken:bearer-secret-token",
"落库 key 不得为裸 token"
);
assert!(!stored_key.contains("bearer-secret-token"));
assert_eq!(stored_key.len(), "oauth2:atoken:".len() + 64);
assert!(is_digest_form(&stored_key["oauth2:atoken:".len()..]));
let raw_value = inner.get(stored_key).await.unwrap().unwrap();
assert!(
raw_value.starts_with("enc:v1:"),
"敏感列必须密文落库: {raw_value}"
);
assert_ne!(raw_value, "secret-token");
let raw_session = inner.get("session:s-1").await.unwrap().unwrap();
assert_eq!(raw_session, "raw-session", "非敏感命名空间透传");
}
#[tokio::test]
async fn digest_key_lookup_transparent() {
let (dao, inner) = fixture();
dao.set("oauth2:rtoken:refresh-abc", "refresh-record", 60)
.await
.unwrap();
assert_eq!(
dao.get("oauth2:rtoken:refresh-abc").await.unwrap().unwrap(),
"refresh-record"
);
let keys = inner.keys("oauth2:rtoken:*").await.unwrap();
assert_eq!(keys.len(), 1, "同一 token 只落一行");
dao.set("oauth2:rtoken:refresh-abc", "updated", 60)
.await
.unwrap();
let keys_after = inner.keys("oauth2:rtoken:*").await.unwrap();
assert_eq!(keys_after, keys, "重复写同 token 落同 key(摘要确定性)");
assert_eq!(
dao.get("oauth2:rtoken:refresh-abc").await.unwrap().unwrap(),
"updated"
);
}
#[tokio::test]
async fn read_roundtrip_across_write_paths() {
let (dao, inner) = fixture();
dao.set("oauth2:atoken:a", "v-set", 60).await.unwrap();
assert_eq!(dao.get("oauth2:atoken:a").await.unwrap().unwrap(), "v-set");
dao.update("oauth2:atoken:a", "v-update").await.unwrap();
assert_eq!(
dao.get("oauth2:atoken:a").await.unwrap().unwrap(),
"v-update"
);
dao.set_permanent("totp:seed:uid", "v-permanent")
.await
.unwrap();
assert_eq!(
dao.get("totp:seed:uid").await.unwrap().unwrap(),
"v-permanent"
);
let inserted = dao
.set_if_absent("oauth2:rtoken:r", "v-setnx", 60)
.await
.unwrap();
assert!(inserted);
assert_eq!(
dao.get("oauth2:rtoken:r").await.unwrap().unwrap(),
"v-setnx"
);
let second = dao
.set_if_absent("oauth2:rtoken:r", "v-other", 60)
.await
.unwrap();
assert!(!second);
for prefix in ["oauth2:atoken:", "totp:seed:", "oauth2:rtoken:"] {
let stored = inner.keys(&format!("{prefix}*")).await.unwrap();
assert_eq!(stored.len(), 1, "{prefix}");
let raw = inner.get(&stored[0]).await.unwrap().unwrap();
assert!(raw.starts_with("enc:v1:"), "{prefix} 必须密文落库: {raw}");
}
}
#[tokio::test]
async fn legacy_plaintext_row_readable() {
let (dao, inner) = fixture();
inner
.set("totp:seed:legacy", "plain-legacy", 0)
.await
.unwrap();
assert_eq!(
dao.get("totp:seed:legacy").await.unwrap().unwrap(),
"plain-legacy"
);
}
#[tokio::test]
async fn legacy_raw_key_row_readable_and_consumable() {
let (dao, inner) = fixture();
inner
.set("oauth2:atoken:legacy-raw-token", "plain-legacy-row", 60)
.await
.unwrap();
assert_eq!(
dao.get("oauth2:atoken:legacy-raw-token")
.await
.unwrap()
.unwrap(),
"plain-legacy-row"
);
let consumed = dao
.get_and_delete("oauth2:atoken:legacy-raw-token")
.await
.unwrap()
.unwrap();
assert_eq!(consumed, "plain-legacy-row");
assert!(dao
.get("oauth2:atoken:legacy-raw-token")
.await
.unwrap()
.is_none());
}
#[tokio::test]
async fn ciphertext_moved_to_other_row_fails() {
let (dao, inner) = fixture();
dao.set("totp:seed:row-a", "secret", 60).await.unwrap();
let stored_keys = inner.keys("totp:seed:*").await.unwrap();
let raw = inner.get(&stored_keys[0]).await.unwrap().unwrap();
inner.set("totp:seed:row-b", &raw, 60).await.unwrap();
let err = dao.get("totp:seed:row-b").await.unwrap_err();
assert!(
matches!(err, GarrisonError::Internal(_)),
"挪用行必须显性报错: {err:?}"
);
}
#[tokio::test]
async fn atomic_read_paths_dual_read() {
let (dao, _inner) = fixture();
dao.set("totp:seed:user-1", "seed-secret", 60)
.await
.unwrap();
let (value, ttl) = dao.get_with_ttl("totp:seed:user-1").await.unwrap().unwrap();
assert_eq!(value, "seed-secret");
assert!(ttl.is_some());
let deleted = dao
.get_and_delete("totp:seed:user-1")
.await
.unwrap()
.unwrap();
assert_eq!(deleted, "seed-secret");
assert!(dao.get("totp:seed:user-1").await.unwrap().is_none());
}
#[tokio::test]
async fn rename_reencrypts_under_new_key() {
let (dao, inner) = fixture();
dao.set("totp:seed:old-id", "seed-config", 0).await.unwrap();
dao.rename("totp:seed:old-id", "totp:seed:new-id")
.await
.unwrap();
assert!(inner.get("totp:seed:old-id").await.unwrap().is_none());
let stored = inner.keys("totp:seed:new-id*").await.unwrap();
assert_eq!(stored.len(), 1);
let raw = inner.get(&stored[0]).await.unwrap().unwrap();
assert!(raw.starts_with("enc:v1:"));
assert_eq!(
dao.get("totp:seed:new-id").await.unwrap().unwrap(),
"seed-config"
);
}
#[tokio::test]
async fn counter_ops_rejected_on_sensitive_namespace() {
let (dao, _inner) = fixture();
let err = dao.incr("totp:seed:counter", 60).await.unwrap_err();
assert!(matches!(err, GarrisonError::Internal(_)), "got: {err:?}");
let err = dao.decr("oauth2:atoken:c").await.unwrap_err();
assert!(matches!(err, GarrisonError::Internal(_)));
let err = dao
.compare_and_swap("oauth2:rtoken:c", None, "x", 60)
.await
.unwrap_err();
assert!(matches!(err, GarrisonError::Internal(_)));
assert_eq!(dao.incr("session:counter", 60).await.unwrap(), 1);
let swapped = dao
.compare_and_swap("oauth2:client:cid", None, r#"{"v":1}"#, 60)
.await
.unwrap();
assert!(swapped);
}
#[test]
fn empty_tenant_rejected() {
let inner: Arc<dyn GarrisonDao> = Arc::new(InMemoryDao::new());
let provider = Arc::new(StaticFieldKeyProvider::new(vec![("k1".to_string(), K1)]).unwrap());
let cipher = Arc::new(FieldCipher::new(provider).unwrap());
let err = FieldEncryptionDao::new(inner, cipher, "").unwrap_err();
assert!(matches!(err, GarrisonError::Config(_)), "got: {err:?}");
}
}