use std::collections::HashMap;
use std::sync::Arc;
use crate::error::{GarrisonError, GarrisonResult};
use super::crypto_value::{AadBinding, CryptoValue, KEY_LEN};
pub trait FieldKeyProvider: Send + Sync {
fn key_for(&self, key_id: &str) -> GarrisonResult<[u8; KEY_LEN]>;
fn primary_key_id(&self) -> GarrisonResult<String>;
}
#[derive(Debug, Clone)]
pub struct StaticFieldKeyProvider {
keys: HashMap<String, [u8; KEY_LEN]>,
primary: String,
}
impl StaticFieldKeyProvider {
pub fn new(keys: Vec<(String, [u8; KEY_LEN])>) -> GarrisonResult<Self> {
let primary = keys
.first()
.map(|(id, _)| id.clone())
.ok_or_else(|| config_err("no-keys-configured"))?;
let mut map = HashMap::with_capacity(keys.len());
for (idx, (id, key)) in keys.into_iter().enumerate() {
if is_degenerate_key(&key) {
if idx == 0 {
return Err(config_err(&format!("weak-key:{id}")));
}
tracing::warn!(
key_id = %id,
"{}", crate::i18n::translate_detail("logs-field-encryption-degenerate-non-primary-key", &[])
);
}
if map.insert(id.clone(), key).is_some() {
return Err(config_err(&format!("duplicate-key-id:{id}")));
}
}
Ok(Self { keys: map, primary })
}
pub fn with_primary(mut self, key_id: &str) -> GarrisonResult<Self> {
let key = self
.keys
.get(key_id)
.ok_or_else(|| config_err(&format!("key-not-found:{key_id}")))?;
if is_degenerate_key(key) {
return Err(config_err(&format!("weak-primary-key:{key_id}")));
}
self.primary = key_id.to_string();
Ok(self)
}
}
impl FieldKeyProvider for StaticFieldKeyProvider {
fn key_for(&self, key_id: &str) -> GarrisonResult<[u8; KEY_LEN]> {
self.keys
.get(key_id)
.copied()
.ok_or_else(|| config_err(&format!("key-not-found:{key_id}")))
}
fn primary_key_id(&self) -> GarrisonResult<String> {
Ok(self.primary.clone())
}
}
fn is_degenerate_key(key: &[u8; KEY_LEN]) -> bool {
key.iter().all(|&b| b == key[0])
}
#[derive(Clone)]
pub struct FieldCipher {
provider: Arc<dyn FieldKeyProvider>,
}
impl FieldCipher {
pub fn new(provider: Arc<dyn FieldKeyProvider>) -> GarrisonResult<Self> {
let primary = provider.primary_key_id()?;
let primary_key = provider.key_for(&primary)?;
if is_degenerate_key(&primary_key) {
return Err(config_err(&format!("weak-primary-key:{primary}")));
}
Ok(Self { provider })
}
pub fn from_key_entries(entries: &[(String, String)]) -> GarrisonResult<Self> {
if entries.is_empty() {
return Err(config_err("no-keys-configured"));
}
let mut keys = Vec::with_capacity(entries.len());
for (key_id, key_hex) in entries {
super::crypto_value::validate_key_id(key_id, "config")?;
let decoded = hex_decode_32(key_hex)
.ok_or_else(|| config_err(&format!("key-hex-invalid:{key_id}")))?;
keys.push((key_id.clone(), decoded));
}
let provider = StaticFieldKeyProvider::new(keys)?;
FieldCipher::new(Arc::new(provider))
}
pub fn primary_key_id(&self) -> GarrisonResult<String> {
self.provider.primary_key_id()
}
pub fn encrypt(&self, aad: &AadBinding, plaintext: &str) -> GarrisonResult<String> {
let key_id = self.provider.primary_key_id()?;
let key = self.provider.key_for(&key_id)?;
Ok(CryptoValue::seal(&key_id, &key, aad, plaintext.as_bytes())?.encode())
}
pub fn decrypt(&self, aad: &AadBinding, stored: &str) -> GarrisonResult<String> {
if !stored.starts_with(CryptoValue::PREFIX) {
return Ok(stored.to_string());
}
let value = CryptoValue::decode(stored)?;
let key = self.provider.key_for(&value.key_id)?;
let plaintext = value.open(&key, aad)?;
String::from_utf8(plaintext)
.map_err(|e| GarrisonError::Internal(format!("secure-field-encryption-utf8::{e}")))
}
}
#[cfg(feature = "config-encryption")]
pub struct ConfersFieldKeyProvider {
registry: Arc<confers::secret::KeyRegistry>,
}
#[cfg(feature = "config-encryption")]
impl ConfersFieldKeyProvider {
pub fn new(registry: Arc<confers::secret::KeyRegistry>) -> Self {
Self { registry }
}
}
#[cfg(feature = "config-encryption")]
impl FieldKeyProvider for ConfersFieldKeyProvider {
fn key_for(&self, key_id: &str) -> GarrisonResult<[u8; KEY_LEN]> {
let bytes = self
.registry
.get_key(key_id)
.map_err(|e| GarrisonError::Internal(format!("secure-field-encryption-config::{e}")))?;
let key: [u8; KEY_LEN] = bytes
.as_slice()
.try_into()
.map_err(|_| config_err(&format!("key-length:got={}", bytes.len())))?;
Ok(key)
}
fn primary_key_id(&self) -> GarrisonResult<String> {
self.registry
.get_primary_key()
.map(|(version, _)| version)
.map_err(|e| GarrisonError::Internal(format!("secure-field-encryption-config::{e}")))
}
}
fn config_err(detail: &str) -> GarrisonError {
GarrisonError::Config(format!("secure-field-encryption-config::{detail}"))
}
fn hex_decode_32(s: &str) -> Option<[u8; KEY_LEN]> {
if s.len() != KEY_LEN * 2 {
return None;
}
let mut out = [0u8; KEY_LEN];
for (i, byte) in out.iter_mut().enumerate() {
*byte = u8::from_str_radix(s.get(i * 2..i * 2 + 2)?, 16).ok()?;
}
Some(out)
}
#[cfg(test)]
mod tests {
use super::*;
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 key_hex(seed: u8) -> String {
crate::secure::encryption::crypto_value::test_key(seed)
.iter()
.map(|b| format!("{b:02x}"))
.collect()
}
fn provider(primary_k1: bool) -> Arc<dyn FieldKeyProvider> {
let p = StaticFieldKeyProvider::new(vec![("k1".to_string(), K1), ("k2".to_string(), K2)])
.unwrap();
let p = if primary_k1 {
p
} else {
p.with_primary("k2").unwrap()
};
Arc::new(p)
}
fn aad() -> AadBinding {
AadBinding::new("tenant-1", "oauth2:atoken", "row-1")
}
#[test]
fn multi_key_id_lookup_and_primary_rotation() {
let shared = provider(true);
let cipher = FieldCipher::new(shared.clone()).unwrap();
let old = cipher.encrypt(&aad(), "secret-v1").unwrap();
assert!(old.starts_with("enc:v1:k1:"), "主钥 k1 加密: {old}");
let rotated = Arc::new(
StaticFieldKeyProvider::new(vec![("k1".to_string(), K1), ("k2".to_string(), K2)])
.unwrap()
.with_primary("k2")
.unwrap(),
);
let rotated_cipher = FieldCipher::new(rotated).unwrap();
let new = rotated_cipher.encrypt(&aad(), "secret-v2").unwrap();
assert!(new.starts_with("enc:v1:k2:"), "切换后主钥 k2 加密: {new}");
assert_eq!(rotated_cipher.decrypt(&aad(), &old).unwrap(), "secret-v1");
assert_eq!(cipher.decrypt(&aad(), &new).unwrap(), "secret-v2");
}
#[test]
fn unknown_key_id_fails_explicitly() {
let cipher = FieldCipher::new(provider(true)).unwrap();
let value = CryptoValue::seal("k9", &[3u8; KEY_LEN], &aad(), b"x")
.unwrap()
.encode();
let err = cipher.decrypt(&aad(), &value).unwrap_err();
assert!(matches!(err, GarrisonError::Config(_)), "got: {err:?}");
}
#[test]
fn missing_key_configuration_fails_closed() {
let empty = StaticFieldKeyProvider::new(vec![]).unwrap_err();
assert!(matches!(empty, GarrisonError::Config(_)));
}
#[test]
fn from_key_entries_config_surface() {
let hex1 = key_hex(1);
let hex2 = key_hex(2);
let entries = vec![("k1".to_string(), hex1.clone()), ("k2".to_string(), hex2)];
let cipher = FieldCipher::from_key_entries(&entries).unwrap();
assert_eq!(cipher.primary_key_id().unwrap(), "k1");
let stored = cipher.encrypt(&aad(), "secret").unwrap();
assert_eq!(cipher.decrypt(&aad(), &stored).unwrap(), "secret");
let direct = FieldCipher::new(Arc::new(
StaticFieldKeyProvider::new(vec![("k1".to_string(), K1), ("k2".to_string(), K2)])
.unwrap(),
))
.unwrap();
assert_eq!(
direct.decrypt(&aad(), &stored).unwrap(),
"secret",
"from_key_entries 与直连装配钥材一致"
);
assert!(FieldCipher::from_key_entries(&[]).is_err());
assert!(FieldCipher::from_key_entries(&[("k".to_string(), "zz".repeat(32))]).is_err());
assert!(FieldCipher::from_key_entries(&[("k".to_string(), "01".repeat(31))]).is_err());
assert!(FieldCipher::from_key_entries(&[("k:1".to_string(), hex1)]).is_err());
}
#[test]
fn decrypt_passthrough_plaintext_legacy_row() {
let cipher = FieldCipher::new(provider(true)).unwrap();
assert_eq!(
cipher.decrypt(&aad(), "plain-legacy").unwrap(),
"plain-legacy"
);
assert_eq!(cipher.decrypt(&aad(), "").unwrap(), "");
}
#[test]
fn cipher_roundtrip_binds_aad() {
let cipher = FieldCipher::new(provider(true)).unwrap();
let stored = cipher.encrypt(&aad(), "secret-value").unwrap();
assert_eq!(cipher.decrypt(&aad(), &stored).unwrap(), "secret-value");
let other_row = AadBinding::new("tenant-1", "oauth2:atoken", "row-2");
assert!(cipher.decrypt(&other_row, &stored).is_err());
}
#[cfg(feature = "config-encryption")]
#[test]
fn confers_registry_adapter_resolves_keys() {
use confers::secret::{KeyRegistry, KeyRotationConfig, SecretBytes};
let registry = Arc::new(KeyRegistry::new(KeyRotationConfig::default()));
registry
.register_key(
"v1".to_string(),
SecretBytes::new(crate::secure::encryption::crypto_value::test_key(3).to_vec()),
true,
)
.unwrap();
registry
.register_key(
"v2".to_string(),
SecretBytes::new(crate::secure::encryption::crypto_value::test_key(4).to_vec()),
false,
)
.unwrap();
let adapter = ConfersFieldKeyProvider::new(registry.clone());
assert_eq!(adapter.primary_key_id().unwrap(), "v1");
assert_eq!(
adapter.key_for("v1").unwrap(),
crate::secure::encryption::crypto_value::test_key(3)
);
assert_eq!(
adapter.key_for("v2").unwrap(),
crate::secure::encryption::crypto_value::test_key(4)
);
assert!(adapter.key_for("v-missing").is_err());
registry
.register_key("short".to_string(), SecretBytes::new(vec![1u8; 16]), false)
.unwrap();
assert!(adapter.key_for("short").is_err());
}
#[test]
fn static_provider_rejects_all_zero_key() {
let err =
StaticFieldKeyProvider::new(vec![("k1".to_string(), [0u8; KEY_LEN])]).unwrap_err();
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("weak-key:k1")),
"全零钥应被拒绝且错误含 key_id,实际: {err:?}"
);
}
#[test]
fn static_provider_rejects_repeated_byte_fill() {
let err =
StaticFieldKeyProvider::new(vec![("kf".to_string(), [0xFFu8; KEY_LEN])]).unwrap_err();
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("weak-key:kf")),
"单字节重复填充钥应被拒绝,实际: {err:?}"
);
}
#[test]
fn weak_non_primary_key_allowed_but_not_promotable() {
let provider = StaticFieldKeyProvider::new(vec![
("k1".to_string(), K1),
("k2".to_string(), [3u8; KEY_LEN]),
])
.expect("非主钥退化钥应放行(warn)");
assert_eq!(provider.key_for("k2").unwrap(), [3u8; KEY_LEN]);
let err = provider.with_primary("k2").unwrap_err();
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("weak-primary-key:k2")),
"退化钥不得提升为主钥,实际: {err:?}"
);
}
#[test]
fn from_key_entries_rejects_repeated_byte_hex() {
let err = match FieldCipher::from_key_entries(&[("kz".to_string(), "00".repeat(32))]) {
Err(e) => e,
Ok(_) => panic!("全零 hex 钥应被拒绝"),
};
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("weak-key:kz")),
"全零 hex 钥应被拒绝,实际: {err:?}"
);
}
#[test]
fn field_cipher_rejects_degenerate_primary_from_custom_provider() {
struct ZeroProvider;
impl FieldKeyProvider for ZeroProvider {
fn key_for(&self, _key_id: &str) -> GarrisonResult<[u8; KEY_LEN]> {
Ok([0u8; KEY_LEN])
}
fn primary_key_id(&self) -> GarrisonResult<String> {
Ok("zp".to_string())
}
}
let err = match FieldCipher::new(Arc::new(ZeroProvider)) {
Err(e) => e,
Ok(_) => panic!("退化主钥应被拒绝"),
};
assert!(
matches!(&err, GarrisonError::Config(m) if m.contains("weak-primary-key:zp")),
"自定义 provider 的退化主钥应被拒绝,实际: {err:?}"
);
}
}