use crate::error::{GarrisonError, GarrisonResult};
use super::crypto_value::CryptoValue;
use super::dao::{is_digest_form, FieldEncryptionDao, DIGEST_TABLES};
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct ChangeKeyReport {
pub scanned: usize,
pub reencrypted: usize,
pub legacy_plaintext_reencrypted: usize,
pub legacy_key_migrated: usize,
pub skipped_current_key: usize,
pub failed: Vec<(String, String)>,
}
impl ChangeKeyReport {
pub fn is_clean(&self) -> bool {
self.failed.is_empty()
}
}
#[derive(Debug, Default, Clone, PartialEq, Eq)]
pub struct CheckKeyReport {
pub scanned: usize,
pub encrypted_ok: usize,
pub legacy_plaintext: usize,
pub legacy_raw_key: usize,
pub corrupt: Vec<(String, String)>,
}
impl FieldEncryptionDao {
pub async fn change_key(
&self,
new_cipher: super::cipher::FieldCipher,
batch_size: usize,
) -> GarrisonResult<ChangeKeyReport> {
if batch_size == 0 {
return Err(GarrisonError::InvalidParam(
"secure-field-encryption-change-key::batch-size-zero".to_string(),
));
}
let old_cipher = self.current_cipher();
let new_primary = new_cipher.primary_key_id()?;
let keys = self.filtered_sensitive_keys("*").await?;
let mut report = ChangeKeyReport {
scanned: keys.len(),
..Default::default()
};
for batch in keys.chunks(batch_size) {
for stored_key in batch {
let Some(raw) = self.inner_dao().get(stored_key).await? else {
continue;
};
match self
.reencrypt_row(&old_cipher, &new_cipher, &new_primary, stored_key, &raw)
.await
{
Ok(Some(RowOutcome::Reencrypted)) => report.reencrypted += 1,
Ok(Some(RowOutcome::LegacyPlaintext)) => {
report.legacy_plaintext_reencrypted += 1
},
Ok(Some(RowOutcome::LegacyKeyMigrated)) => report.legacy_key_migrated += 1,
Ok(None) => report.skipped_current_key += 1,
Err(reason) => report.failed.push((stored_key.clone(), reason)),
}
}
}
if report.is_clean() {
self.swap_cipher(new_cipher);
}
Ok(report)
}
pub async fn check_key(&self, pattern: &str) -> GarrisonResult<CheckKeyReport> {
let cipher = self.current_cipher();
let keys = self.filtered_sensitive_keys(pattern).await?;
let mut report = CheckKeyReport {
scanned: keys.len(),
..Default::default()
};
for stored_key in keys {
let Some(raw) = self.inner_dao().get(&stored_key).await? else {
continue;
};
if is_legacy_raw_key(&stored_key) {
report.legacy_raw_key += 1;
}
if !raw.starts_with(CryptoValue::PREFIX) {
report.legacy_plaintext += 1;
continue;
}
match cipher.decrypt(&self.aad_for_key(&stored_key), &raw) {
Ok(_) => report.encrypted_ok += 1,
Err(e) => report.corrupt.push((stored_key, e.to_string())),
}
}
Ok(report)
}
async fn filtered_sensitive_keys(&self, pattern: &str) -> GarrisonResult<Vec<String>> {
let all = self.inner_dao().keys(pattern).await?;
let mut keys: Vec<String> = all.into_iter().filter(|k| Self::is_sensitive(k)).collect();
keys.sort();
Ok(keys)
}
async fn reencrypt_row(
&self,
old_cipher: &super::cipher::FieldCipher,
new_cipher: &super::cipher::FieldCipher,
new_primary: &str,
stored_key: &str,
raw: &str,
) -> Result<Option<RowOutcome>, String> {
let was_encrypted = raw.starts_with(CryptoValue::PREFIX);
let plaintext = if was_encrypted {
match CryptoValue::decode(raw) {
Ok(value) if value.key_id == new_primary && !is_legacy_raw_key(stored_key) => {
return Ok(None);
},
Ok(_) => old_cipher
.decrypt(&self.aad_for_key(stored_key), raw)
.map_err(|e| e.to_string())?,
Err(e) => return Err(e.to_string()),
}
} else {
raw.to_string()
};
let legacy_key = is_legacy_raw_key(stored_key);
let aad_key = if legacy_key {
Self::storage_key(stored_key)
} else {
stored_key.to_string()
};
let stored = new_cipher
.encrypt(&self.aad_for_key(&aad_key), &plaintext)
.map_err(|e| e.to_string())?;
if legacy_key {
let target = aad_key;
let ttl = match self
.inner_dao()
.get_with_ttl(stored_key)
.await
.map_err(|e| e.to_string())?
{
Some((_, Some(d))) => d.as_secs().max(1),
Some((_, None)) => 0,
None => return Err("legacy-key-migration::ttl-query-unsupported".to_string()),
};
self.inner_dao()
.set(&target, &stored, ttl)
.await
.map_err(|e| e.to_string())?;
self.inner_dao()
.delete(stored_key)
.await
.map_err(|e| e.to_string())?;
return Ok(Some(RowOutcome::LegacyKeyMigrated));
}
self.inner_dao()
.update(stored_key, &stored)
.await
.map_err(|e| e.to_string())?;
Ok(Some(if was_encrypted {
RowOutcome::Reencrypted
} else {
RowOutcome::LegacyPlaintext
}))
}
}
enum RowOutcome {
Reencrypted,
LegacyPlaintext,
LegacyKeyMigrated,
}
fn is_legacy_raw_key(stored_key: &str) -> bool {
for table in DIGEST_TABLES {
if let Some(remainder) = stored_key.strip_prefix(table) {
return !is_digest_form(remainder);
}
}
false
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::Arc;
use crate::dao::{GarrisonDao, InMemoryDao};
use crate::secure::encryption::cipher::{FieldCipher, StaticFieldKeyProvider};
use crate::secure::encryption::crypto_value::KEY_LEN;
const K1: [u8; KEY_LEN] = crate::secure::encryption::crypto_value::test_key(1);
const K2: [u8; KEY_LEN] = crate::secure::encryption::crypto_value::test_key(2);
fn cipher(primary: &str) -> FieldCipher {
let provider =
StaticFieldKeyProvider::new(vec![("k1".to_string(), K1), ("k2".to_string(), K2)])
.unwrap()
.with_primary(primary)
.unwrap();
FieldCipher::new(Arc::new(provider)).unwrap()
}
async fn seeded_dao() -> FieldEncryptionDao {
let inner: Arc<dyn GarrisonDao> = Arc::new(InMemoryDao::new());
let dao = FieldEncryptionDao::new(inner, Arc::new(cipher("k1")), "tenant-1").unwrap();
dao.set("oauth2:atoken:tok-1", "token-1", 0).await.unwrap();
dao.set("oauth2:rtoken:rt-1", "refresh-1", 0).await.unwrap();
dao.set("totp:seed:uid", "seed-1", 0).await.unwrap();
dao.set("session:s-1", "not-sensitive", 0).await.unwrap();
dao
}
fn digest_of(remainder: &str) -> String {
use sha2::{Digest, Sha256};
let digest = Sha256::digest(remainder.as_bytes());
digest.iter().map(|b| format!("{b:02x}")).collect()
}
#[tokio::test]
async fn change_key_reencrypts_all_rows_to_new_primary() {
let dao = seeded_dao().await;
let new = cipher("k2");
let report = dao.change_key(new.clone(), 2).await.unwrap();
assert_eq!(report.scanned, 3, "atoken + rtoken + totp:seed");
assert_eq!(report.reencrypted, 3);
assert!(report.is_clean(), "失败行: {:?}", report.failed);
let check = dao.check_key("*").await.unwrap();
assert_eq!(check.encrypted_ok, 3);
assert_eq!(check.legacy_plaintext, 0);
assert!(check.corrupt.is_empty(), "损坏行: {:?}", check.corrupt);
for prefix in ["oauth2:atoken:", "oauth2:rtoken:", "totp:seed:"] {
let keys = dao.inner_dao().keys(&format!("{prefix}*")).await.unwrap();
assert_eq!(keys.len(), 1, "{prefix}");
let raw = dao.inner_dao().get(&keys[0]).await.unwrap().unwrap();
assert!(raw.starts_with("enc:v1:k2:"), "{prefix}: {raw}");
}
assert_eq!(
dao.inner_dao().get("session:s-1").await.unwrap().unwrap(),
"not-sensitive"
);
dao.set("oauth2:atoken:tok-new", "token-new", 0)
.await
.unwrap();
let raw = dao
.inner_dao()
.get(&format!("oauth2:atoken:{}", digest_of("tok-new")))
.await
.unwrap()
.unwrap();
assert!(
raw.starts_with("enc:v1:k2:"),
"切换后新写入必须用新主钥: {raw}"
);
}
#[tokio::test]
async fn change_key_migrates_legacy_raw_keys() {
let inner: Arc<dyn GarrisonDao> = Arc::new(InMemoryDao::new());
let dao =
FieldEncryptionDao::new(inner.clone(), Arc::new(cipher("k1")), "tenant-1").unwrap();
dao.inner_dao()
.set("oauth2:atoken:legacy-raw-token", "plain-row", 3600)
.await
.unwrap();
let report = dao.change_key(cipher("k2"), 10).await.unwrap();
assert_eq!(report.legacy_key_migrated, 1, "报告: {:?}", report);
assert!(report.is_clean());
assert!(
dao.inner_dao()
.get("oauth2:atoken:legacy-raw-token")
.await
.unwrap()
.is_none(),
"遗留 raw key 行必须删除"
);
let check = dao.check_key("oauth2:atoken:*").await.unwrap();
assert_eq!(check.encrypted_ok, 1);
assert_eq!(check.legacy_raw_key, 0);
let (_, ttl) = dao
.get_with_ttl("oauth2:atoken:legacy-raw-token")
.await
.unwrap()
.unwrap();
assert!(ttl.is_some(), "迁移必须保留 TTL");
assert_eq!(
dao.get("oauth2:atoken:legacy-raw-token")
.await
.unwrap()
.unwrap(),
"plain-row"
);
}
#[tokio::test]
async fn change_key_is_idempotent() {
let dao = seeded_dao().await;
dao.change_key(cipher("k2"), 10).await.unwrap();
let rerun = dao.change_key(cipher("k2"), 10).await.unwrap();
assert_eq!(rerun.scanned, 3);
assert_eq!(rerun.reencrypted, 0);
assert_eq!(rerun.skipped_current_key, 3);
assert!(rerun.is_clean());
}
#[tokio::test]
async fn check_key_reports_corrupt_rows() {
let dao = seeded_dao().await;
dao.inner_dao()
.set("totp:seed:corrupt", "enc:v1:k1:AAAA", 0)
.await
.unwrap();
dao.inner_dao()
.set("totp:seed:legacy-plain", "plain-row", 0)
.await
.unwrap();
let report = dao.check_key("*").await.unwrap();
assert_eq!(report.scanned, 5);
assert_eq!(report.encrypted_ok, 3);
assert_eq!(report.legacy_plaintext, 1);
assert_eq!(report.corrupt.len(), 1);
assert_eq!(report.corrupt[0].0, "totp:seed:corrupt");
}
#[tokio::test]
async fn change_key_failure_keeps_old_cipher() {
let dao = seeded_dao().await;
dao.inner_dao()
.set(
"totp:seed:bad",
"enc:v1:k9:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
0,
)
.await
.unwrap();
let report = dao.change_key(cipher("k2"), 10).await.unwrap();
assert!(!report.is_clean());
assert_eq!(report.failed.len(), 1);
assert_eq!(report.failed[0].0, "totp:seed:bad");
dao.set("totp:seed:after-failure", "still-old-key", 0)
.await
.unwrap();
let check = dao.check_key("*").await.unwrap();
assert_eq!(
check.encrypted_ok, 4,
"失败行 + 新写入仍为旧钥: {:?}",
check
);
}
#[tokio::test]
async fn change_key_rejects_zero_batch_size() {
let dao = seeded_dao().await;
let err = dao.change_key(cipher("k2"), 0).await.unwrap_err();
assert!(
matches!(err, GarrisonError::InvalidParam(_)),
"got: {err:?}"
);
}
}