1use crate::errors::{AuthError, Result};
2use crate::storage::{AuthStorage, SessionData};
3use crate::tokens::AuthToken;
4use aes_gcm::{
5 Aes256Gcm, Key, KeyInit, Nonce,
6 aead::{Aead, Payload},
7};
8use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
9use serde::{Deserialize, Serialize};
10use std::collections::HashMap;
11use std::env;
12use std::fs;
13use std::time::Duration;
14use zeroize::Zeroize;
15
16#[cfg(test)]
35pub(crate) static TEST_ENCRYPTION_ENV_LOCK: tokio::sync::Mutex<()> =
36 tokio::sync::Mutex::const_new(());
37
38#[cfg(test)]
46pub(crate) struct EncryptionEnvGuard;
47
48#[cfg(test)]
49impl EncryptionEnvGuard {
50 pub(crate) fn set(key: &str) -> Self {
51 unsafe {
55 std::env::set_var("AUTH_STORAGE_ENCRYPTION_KEY", key);
56 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE");
57 }
58 Self
59 }
60}
61
62#[cfg(test)]
63impl Drop for EncryptionEnvGuard {
64 fn drop(&mut self) {
65 unsafe {
68 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEY");
69 }
70 }
71}
72
73const CURRENT_FORMAT_VERSION: u8 = 2;
87
88const FORMAT_V1: u8 = 1;
90
91const ALGORITHM: &str = "AES-256-GCM";
93
94const DECRYPT_FAILED: &str = "Decryption failed";
99
100fn bound_aad(v: u8, algorithm: &str, key_id: &str, record_aad: &[u8]) -> Vec<u8> {
107 let mut out = Vec::with_capacity(48 + algorithm.len() + key_id.len() + record_aad.len());
108 out.extend_from_slice(b"auth-framework/storage-envelope");
109 out.push(v);
110 for part in [algorithm.as_bytes(), key_id.as_bytes(), record_aad] {
111 out.extend_from_slice(&(part.len() as u32).to_be_bytes());
112 out.extend_from_slice(part);
113 }
114 out
115}
116
117fn default_format_version() -> u8 {
118 0
129}
130
131#[derive(Debug, Clone, Serialize, Deserialize)]
146pub struct EncryptedData {
147 pub data: String,
149 pub nonce: String,
151 pub algorithm: String,
153 #[serde(default)]
156 pub key_id: String,
157 #[serde(default = "default_format_version")]
162 pub v: u8,
163 #[serde(default)]
166 pub key_derivation: String,
167}
168
169pub trait KeyProvider: Send + Sync {
177 fn load_keys(&self) -> Result<LoadedKeys>;
185}
186
187pub struct LoadedKeys {
190 pub current_key_id: String,
191 pub keys: HashMap<String, [u8; 32]>,
196}
197
198pub struct EnvKeyProvider;
230
231impl KeyProvider for EnvKeyProvider {
232 fn load_keys(&self) -> Result<LoadedKeys> {
233 if let Ok(path) = env::var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE") {
234 return Self::load_from_file(&path);
235 }
236
237 let mut key_data = env::var("AUTH_STORAGE_ENCRYPTION_KEY").map_err(|_| {
238 AuthError::config(
239 "No storage encryption key configured: set AUTH_STORAGE_ENCRYPTION_KEY \
240 (or AUTH_STORAGE_ENCRYPTION_KEYS_FILE for multi-key rotation). \
241 Refusing to start rather than silently storing data unencrypted.",
242 )
243 })?;
244 let key_id = env::var("AUTH_STORAGE_ENCRYPTION_KEY_ID").unwrap_or_else(|_| "1".to_string());
245 let key = decode_key(&key_data);
246 key_data.zeroize();
247 let key = key?;
248
249 let mut keys = HashMap::new();
250 keys.insert(key_id.clone(), key);
251 Ok(LoadedKeys {
252 current_key_id: key_id,
253 keys,
254 })
255 }
256}
257
258impl EnvKeyProvider {
259 fn load_from_file(path: &str) -> Result<LoadedKeys> {
260 #[derive(Deserialize)]
261 struct KeysFile {
262 current: String,
263 keys: HashMap<String, String>,
264 }
265
266 check_keys_file_permissions(path, strict_permissions_requested())?;
267
268 let mut contents = fs::read_to_string(path).map_err(|e| {
269 AuthError::config(format!(
270 "Failed to read AUTH_STORAGE_ENCRYPTION_KEYS_FILE '{path}': {e}"
271 ))
272 })?;
273 let parsed: Result<KeysFile> = serde_json::from_str(&contents).map_err(|e| {
274 AuthError::config(format!(
275 "Failed to parse AUTH_STORAGE_ENCRYPTION_KEYS_FILE '{path}': {e}"
276 ))
277 });
278 contents.zeroize();
279 let mut parsed = parsed?;
280
281 if !parsed.keys.contains_key(&parsed.current) {
282 for encoded in parsed.keys.values_mut() {
285 encoded.zeroize();
286 }
287 return Err(AuthError::config(format!(
288 "AUTH_STORAGE_ENCRYPTION_KEYS_FILE '{path}': current key id '{}' \
289 is not present in 'keys'",
290 parsed.current
291 )));
292 }
293
294 let mut keys = HashMap::with_capacity(parsed.keys.len());
303 let mut first_error = None;
304 for (id, mut encoded) in parsed.keys {
305 match decode_key(&encoded) {
306 Ok(key) => {
307 keys.insert(id, key);
308 }
309 Err(e) if first_error.is_none() => {
310 first_error = Some(e);
311 }
312 Err(_) => {}
313 }
314 encoded.zeroize();
315 }
316
317 if let Some(error) = first_error {
318 for key_bytes in keys.values_mut() {
319 key_bytes.zeroize();
320 }
321 return Err(error);
322 }
323
324 Ok(LoadedKeys {
325 current_key_id: parsed.current,
326 keys,
327 })
328 }
329}
330
331const STRICT_KEY_FILE_PERMISSIONS_ENV: &str = "AUTH_STORAGE_ENCRYPTION_STRICT_KEY_FILE_PERMISSIONS";
334
335#[cfg_attr(not(unix), allow(dead_code))]
338fn keys_file_mode_too_open(mode: u32) -> bool {
339 mode & 0o077 != 0
340}
341
342fn strict_permissions_requested() -> bool {
343 env::var(STRICT_KEY_FILE_PERMISSIONS_ENV)
344 .map(|value| {
345 matches!(
346 value.trim().to_ascii_lowercase().as_str(),
347 "1" | "true" | "yes"
348 )
349 })
350 .unwrap_or(false)
351}
352
353fn check_keys_file_permissions(path: &str, strict: bool) -> Result<()> {
362 #[cfg(unix)]
363 {
364 use std::os::unix::fs::PermissionsExt;
365 if let Ok(metadata) = fs::metadata(path) {
366 let mode = metadata.permissions().mode();
367 if keys_file_mode_too_open(mode) {
368 if strict {
369 return Err(AuthError::config(format!(
370 "AUTH_STORAGE_ENCRYPTION_KEYS_FILE '{path}' has mode {:o}: it is \
371 accessible to group or other. Restrict it to the owner (chmod 600) \
372 or unset {STRICT_KEY_FILE_PERMISSIONS_ENV}.",
373 mode & 0o777
374 )));
375 }
376 tracing::warn!(
377 path = path,
378 mode = format!("{mode:o}"),
379 "AUTH_STORAGE_ENCRYPTION_KEYS_FILE is readable by group or other -- \
380 restrict it to the owner only (chmod 600), or set \
381 {STRICT_KEY_FILE_PERMISSIONS_ENV}=1 to make this fatal."
382 );
383 }
384 }
385 }
386 #[cfg(not(unix))]
387 {
388 let _ = path;
389 if strict {
390 tracing::warn!(
391 "{STRICT_KEY_FILE_PERMISSIONS_ENV} is set but key-file permissions cannot be \
392 inspected on this platform; it is not enforced."
393 );
394 }
395 }
396 Ok(())
397}
398
399pub(crate) fn env_key_source_in_use() -> bool {
405 env::var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE").is_err()
406 && env::var("AUTH_STORAGE_ENCRYPTION_KEY").is_ok()
407}
408
409pub(crate) async fn stored_envelopes_exist<S: AuthStorage + ?Sized>(
413 storage: &S,
414 limit: usize,
415) -> Result<bool> {
416 for key in storage.list_kv_keys("").await?.into_iter().take(limit) {
417 if let Some(raw) = storage.get_kv(&key).await?
418 && StorageEncryption::looks_like_envelope(&raw)
419 {
420 return Ok(true);
421 }
422 }
423 Ok(false)
424}
425
426fn safe_log_id(key: &str) -> String {
444 use sha2::{Digest, Sha256};
445 let hash_hex = hex::encode(&Sha256::digest(key.as_bytes())[..8]);
446 match key.split_once(':') {
447 Some((namespace, _)) => format!("{namespace}:{hash_hex}"),
448 None => format!("key:{hash_hex}"),
449 }
450}
451
452fn decode_key(encoded: &str) -> Result<[u8; 32]> {
453 let mut key_bytes = BASE64
454 .decode(encoded)
455 .map_err(|_| AuthError::config("Invalid base64 in storage encryption key"))?;
456 if key_bytes.len() != 32 {
457 key_bytes.zeroize();
458 return Err(AuthError::config(
459 "Storage encryption key must be 32 bytes (256 bits) once base64-decoded",
460 ));
461 }
462 let mut key = [0u8; 32];
463 key.copy_from_slice(&key_bytes);
464 key_bytes.zeroize();
465 Ok(key)
466}
467
468pub struct StorageEncryption {
513 current_key_id: String,
514 ciphers: HashMap<String, Aes256Gcm>,
515}
516
517impl StorageEncryption {
518 pub fn new(provider: &dyn KeyProvider) -> Result<Self> {
522 let mut loaded = provider.load_keys()?;
523
524 let validation_error = if loaded.current_key_id.is_empty() {
529 Some(AuthError::config(
530 "Key provider's current_key_id must not be empty",
531 ))
532 } else if loaded.keys.keys().any(|id| id.is_empty()) {
533 Some(AuthError::config(
534 "Key provider returned a key with an empty id -- an empty id is reserved \
535 to mean \"format-version-0 envelope, no key id at all\"",
536 ))
537 } else if !loaded.keys.contains_key(&loaded.current_key_id) {
538 Some(AuthError::config(format!(
539 "Key provider's current_key_id '{}' is not among the keys it loaded",
540 loaded.current_key_id
541 )))
542 } else {
543 None
544 };
545
546 if let Some(error) = validation_error {
547 for key_bytes in loaded.keys.values_mut() {
548 key_bytes.zeroize();
549 }
550 return Err(error);
551 }
552
553 let ciphers = loaded
554 .keys
555 .iter()
556 .map(|(id, key_bytes)| {
557 let key = Key::<Aes256Gcm>::from_slice(key_bytes);
558 (id.clone(), Aes256Gcm::new(key))
559 })
560 .collect();
561 for key_bytes in loaded.keys.values_mut() {
565 key_bytes.zeroize();
566 }
567 Ok(Self {
568 current_key_id: loaded.current_key_id,
569 ciphers,
570 })
571 }
572
573 pub fn from_env() -> Result<Self> {
576 Self::new(&EnvKeyProvider)
577 }
578
579 #[cfg(test)]
581 pub fn new_random() -> Self {
582 use rand::Rng;
583 let mut key_bytes = [0u8; 32];
584 rand::rng().fill_bytes(&mut key_bytes);
585 let key = Key::<Aes256Gcm>::from_slice(&key_bytes);
586 let mut ciphers = HashMap::new();
587 ciphers.insert("test".to_string(), Aes256Gcm::new(key));
588 key_bytes.zeroize();
589 Self {
590 current_key_id: "test".to_string(),
591 ciphers,
592 }
593 }
594
595 pub fn generate_key() -> String {
598 use rand::Rng;
599 let mut key_bytes = [0u8; 32];
600 rand::rng().fill_bytes(&mut key_bytes);
601 let encoded = BASE64.encode(key_bytes);
602 key_bytes.zeroize();
603 encoded
604 }
605
606 pub fn encrypt(&self, plaintext: &[u8], aad: &[u8]) -> Result<EncryptedData> {
611 use rand::Rng;
612 let cipher = self.ciphers.get(&self.current_key_id).ok_or_else(|| {
613 AuthError::internal("Current encryption key missing from loaded cipher set")
614 })?;
615
616 let mut nonce_bytes = [0u8; 12];
624 rand::rng().fill_bytes(&mut nonce_bytes);
625 let nonce = Nonce::from_slice(&nonce_bytes);
626
627 let bound = bound_aad(CURRENT_FORMAT_VERSION, ALGORITHM, &self.current_key_id, aad);
628 let ciphertext = cipher
629 .encrypt(
630 nonce,
631 Payload {
632 msg: plaintext,
633 aad: &bound,
634 },
635 )
636 .map_err(|e| AuthError::internal(format!("Encryption failed: {}", e)))?;
637
638 Ok(EncryptedData {
639 data: BASE64.encode(&ciphertext),
640 nonce: BASE64.encode(nonce_bytes),
641 algorithm: ALGORITHM.to_string(),
642 key_id: self.current_key_id.clone(),
643 v: CURRENT_FORMAT_VERSION,
644 key_derivation: String::new(),
645 })
646 }
647
648 pub fn decrypt(&self, encrypted: &EncryptedData, aad: &[u8]) -> Result<Vec<u8>> {
659 let fail = |why: &str| -> AuthError {
662 tracing::warn!(
665 key_id = ?encrypted.key_id.chars().take(64).collect::<String>(),
666 v = encrypted.v,
667 "storage envelope decryption failed: {why}"
668 );
669 AuthError::internal(DECRYPT_FAILED)
670 };
671
672 if encrypted.algorithm != ALGORITHM {
673 return Err(fail("unsupported algorithm"));
674 }
675
676 let ciphertext = BASE64
677 .decode(&encrypted.data)
678 .map_err(|_| fail("invalid base64 in data"))?;
679 let nonce_bytes = BASE64
680 .decode(&encrypted.nonce)
681 .map_err(|_| fail("invalid base64 in nonce"))?;
682 if nonce_bytes.len() != 12 {
683 return Err(fail("invalid nonce length"));
684 }
685 let nonce = Nonce::from_slice(&nonce_bytes);
686
687 if encrypted.v == 0 {
688 for id in self.sorted_key_ids() {
692 if let Some(cipher) = self.ciphers.get(&id)
693 && let Ok(plaintext) = cipher.decrypt(
694 nonce,
695 Payload {
696 msg: &ciphertext,
697 aad: b"",
698 },
699 )
700 {
701 return Ok(plaintext);
702 }
703 }
704 return Err(fail("no loaded key opens this format-version-0 envelope"));
705 }
706
707 let cipher = self
708 .ciphers
709 .get(&encrypted.key_id)
710 .ok_or_else(|| fail("no loaded key for this key_id (rotated out?)"))?;
711
712 let bound;
715 let effective_aad: &[u8] = match encrypted.v {
716 FORMAT_V1 => aad,
717 CURRENT_FORMAT_VERSION => {
718 bound = bound_aad(encrypted.v, &encrypted.algorithm, &encrypted.key_id, aad);
719 &bound
720 }
721 _ => return Err(fail("unsupported envelope version")),
722 };
723
724 cipher
725 .decrypt(
726 nonce,
727 Payload {
728 msg: &ciphertext,
729 aad: effective_aad,
730 },
731 )
732 .map_err(|_| fail("authentication failed (wrong key, wrong record, or tampered)"))
733 }
734
735 pub fn encrypt_for_storage(&self, data: &[u8], aad: &[u8]) -> Result<Vec<u8>> {
739 let encrypted = self.encrypt(data, aad)?;
740 let serialized = serde_json::to_string(&encrypted).map_err(|e| {
741 AuthError::internal(format!("Failed to serialize encrypted data: {}", e))
742 })?;
743 Ok(serialized.into_bytes())
744 }
745
746 pub fn decrypt_from_storage(&self, data: &[u8], aad: &[u8]) -> Result<Vec<u8>> {
749 let parsed = std::str::from_utf8(data)
752 .map_err(|e| e.to_string())
753 .and_then(|s| serde_json::from_str::<EncryptedData>(s).map_err(|e| e.to_string()));
754 let encrypted = parsed.map_err(|why| {
755 tracing::warn!("stored value is not a readable envelope: {why}");
756 AuthError::internal(DECRYPT_FAILED)
757 })?;
758 self.decrypt(&encrypted, aad)
759 }
760
761 pub fn parse_envelope(data: &[u8]) -> Option<EncryptedData> {
772 let encrypted = std::str::from_utf8(data)
773 .ok()
774 .and_then(|s| serde_json::from_str::<EncryptedData>(s).ok())?;
775 if encrypted.algorithm != ALGORITHM {
776 return None;
777 }
778 let well_formed = if encrypted.v == 0 {
782 encrypted.key_id.is_empty()
783 } else {
784 !encrypted.key_id.is_empty()
785 };
786 well_formed.then_some(encrypted)
787 }
788
789 fn sorted_key_ids(&self) -> Vec<String> {
792 let mut ids: Vec<String> = self.ciphers.keys().cloned().collect();
793 ids.sort();
794 ids
795 }
796
797 pub fn looks_like_envelope(data: &[u8]) -> bool {
802 Self::parse_envelope(data).is_some()
803 }
804}
805
806pub struct EncryptedStorage<T> {
819 inner: T,
820 encryption: StorageEncryption,
821 allow_plaintext_reads: bool,
823 allow_legacy_v0: bool,
825}
826
827impl<T> EncryptedStorage<T> {
828 pub fn new(
851 storage: T,
852 encryption: StorageEncryption,
853 allow_plaintext_reads: bool,
854 allow_legacy_v0: bool,
855 ) -> Self {
856 Self {
857 inner: storage,
858 encryption,
859 allow_plaintext_reads,
860 allow_legacy_v0,
861 }
862 }
863
864 pub fn into_inner(self) -> T {
865 self.inner
866 }
867}
868
869#[async_trait::async_trait]
870impl<T> AuthStorage for EncryptedStorage<T>
871where
872 T: AuthStorage + Send + Sync,
873{
874 async fn store_token(&self, token: &AuthToken) -> Result<()> {
877 self.inner.store_token(token).await
878 }
879
880 async fn get_token(&self, token_id: &str) -> Result<Option<AuthToken>> {
881 self.inner.get_token(token_id).await
882 }
883
884 async fn get_token_by_access_token(&self, access_token: &str) -> Result<Option<AuthToken>> {
885 self.inner.get_token_by_access_token(access_token).await
886 }
887
888 async fn update_token(&self, token: &AuthToken) -> Result<()> {
889 self.inner.update_token(token).await
890 }
891
892 async fn delete_token(&self, token_id: &str) -> Result<()> {
893 self.inner.delete_token(token_id).await
894 }
895
896 async fn list_user_tokens(&self, user_id: &str) -> Result<Vec<AuthToken>> {
897 self.inner.list_user_tokens(user_id).await
898 }
899
900 async fn store_session(&self, session_id: &str, data: &SessionData) -> Result<()> {
901 self.inner.store_session(session_id, data).await
902 }
903
904 async fn get_session(&self, session_id: &str) -> Result<Option<SessionData>> {
905 self.inner.get_session(session_id).await
906 }
907
908 async fn delete_session(&self, session_id: &str) -> Result<()> {
909 self.inner.delete_session(session_id).await
910 }
911
912 async fn list_user_sessions(&self, user_id: &str) -> Result<Vec<SessionData>> {
913 self.inner.list_user_sessions(user_id).await
914 }
915
916 async fn count_active_sessions(&self) -> Result<u64> {
917 self.inner.count_active_sessions().await
918 }
919
920 async fn store_tokens_bulk(&self, tokens: &[AuthToken]) -> Result<()> {
926 self.inner.store_tokens_bulk(tokens).await
927 }
928
929 async fn delete_tokens_bulk(&self, token_ids: &[String]) -> Result<()> {
930 self.inner.delete_tokens_bulk(token_ids).await
931 }
932
933 async fn store_sessions_bulk(&self, sessions: &[(String, SessionData)]) -> Result<()> {
934 self.inner.store_sessions_bulk(sessions).await
935 }
936
937 async fn delete_sessions_bulk(&self, session_ids: &[String]) -> Result<()> {
938 self.inner.delete_sessions_bulk(session_ids).await
939 }
940
941 async fn get_kv_ttl(&self, key: &str) -> Result<Option<Duration>> {
944 self.inner.get_kv_ttl(key).await
946 }
947
948 async fn store_kv(&self, key: &str, value: &[u8], ttl: Option<Duration>) -> Result<()> {
949 let encrypted_value = self.encryption.encrypt_for_storage(value, key.as_bytes())?;
950 self.inner.store_kv(key, &encrypted_value, ttl).await
951 }
952
953 async fn store_kv_if_absent(
954 &self,
955 key: &str,
956 value: &[u8],
957 ttl: Option<Duration>,
958 ) -> Result<bool> {
959 let encrypted_value = self.encryption.encrypt_for_storage(value, key.as_bytes())?;
960 self.inner
961 .store_kv_if_absent(key, &encrypted_value, ttl)
962 .await
963 }
964
965 async fn get_kv(&self, key: &str) -> Result<Option<Vec<u8>>> {
981 let Some(raw) = self.inner.get_kv(key).await? else {
982 return Ok(None);
983 };
984
985 if let Some(envelope) = StorageEncryption::parse_envelope(&raw) {
986 if envelope.v < CURRENT_FORMAT_VERSION && !self.allow_legacy_v0 {
987 return Err(AuthError::internal(format!(
988 "Value for record '{}' uses legacy envelope format version {} (its \
989 metadata is not bound into the authenticated data), and \
990 storage_encryption.allow_legacy_v0 is false. Run the migration tool \
991 (`auth-framework-admin security encrypt-kv --accept-legacy-v0`) to \
992 upgrade it to the current format, or temporarily set \
993 storage_encryption.allow_legacy_v0 = true if something else needs to \
994 read it first.",
995 safe_log_id(key),
996 envelope.v
997 )));
998 }
999 let decrypted = self.encryption.decrypt(&envelope, key.as_bytes())?;
1000 return Ok(Some(decrypted));
1001 }
1002
1003 if self.allow_plaintext_reads {
1004 return Ok(Some(raw));
1005 }
1006
1007 Err(AuthError::internal(format!(
1008 "Value for record '{}' is not a valid encrypted envelope, and \
1009 storage_encryption.allow_plaintext_reads is false. If this key genuinely \
1010 predates encryption being enabled, run the migration tool \
1011 (`auth-framework-admin security encrypt-kv`) or temporarily set \
1012 storage_encryption.allow_plaintext_reads = true while migrating.",
1013 safe_log_id(key)
1014 )))
1015 }
1016
1017 fn tracks_kv_ttl(&self) -> bool {
1018 self.inner.tracks_kv_ttl()
1020 }
1021
1022 fn encrypts_kv_at_rest(&self) -> bool {
1023 true
1024 }
1025
1026 async fn delete_kv(&self, key: &str) -> Result<()> {
1027 self.inner.delete_kv(key).await
1028 }
1029
1030 async fn list_kv_keys(&self, prefix: &str) -> Result<Vec<String>> {
1036 self.inner.list_kv_keys(prefix).await
1037 }
1038
1039 async fn cleanup_expired(&self) -> Result<()> {
1040 self.inner.cleanup_expired().await
1041 }
1042}
1043
1044#[derive(Debug, Clone, Default, PartialEq, Eq)]
1052#[non_exhaustive]
1053pub struct KvEncryptionMigrationReport {
1054 pub dry_run: bool,
1056 pub scanned: u64,
1060 pub already_encrypted: u64,
1063 pub legacy_v0_found: u64,
1073 pub upgraded_from_legacy: u64,
1079 pub encrypted: u64,
1082 pub vanished: u64,
1085 pub failed: Vec<String>,
1096}
1097
1098#[derive(Debug, Clone, Copy, Default)]
1103#[non_exhaustive]
1104pub struct MigrationOptions {
1105 pub dry_run: bool,
1110 pub accept_legacy_v0: bool,
1115 pub accept_ttl_loss: bool,
1119}
1120
1121impl MigrationOptions {
1122 pub fn with_accept_ttl_loss(mut self, accept_ttl_loss: bool) -> Self {
1124 self.accept_ttl_loss = accept_ttl_loss;
1125 self
1126 }
1127
1128 pub fn with_dry_run(mut self, dry_run: bool) -> Self {
1134 self.dry_run = dry_run;
1135 self
1136 }
1137
1138 pub fn with_accept_legacy_v0(mut self, accept_legacy_v0: bool) -> Self {
1141 self.accept_legacy_v0 = accept_legacy_v0;
1142 self
1143 }
1144}
1145
1146pub async fn migrate_kv_to_encrypted<S: AuthStorage + ?Sized>(
1219 storage: &S,
1220 encryption: &StorageEncryption,
1221 prefix: &str,
1222 options: MigrationOptions,
1223) -> Result<KvEncryptionMigrationReport> {
1224 let MigrationOptions {
1225 dry_run,
1226 accept_legacy_v0,
1227 accept_ttl_loss,
1228 } = options;
1229
1230 if !dry_run && !accept_ttl_loss && !storage.tracks_kv_ttl() {
1234 return Err(AuthError::validation(
1235 "This storage backend does not report KV TTLs, so migrating would make every \
1236 expiring entry (OAuth codes, MFA/SMS codes, rate-limit windows, expiring API \
1237 keys, ...) permanent. Scope the prefix to durable secrets and pass \
1238 accept_ttl_loss (CLI: --accept-ttl-loss) to proceed anyway.",
1239 ));
1240 }
1241 let mut report = KvEncryptionMigrationReport {
1242 dry_run,
1243 ..Default::default()
1244 };
1245
1246 let keys = storage.list_kv_keys(prefix).await?;
1247 report.scanned = keys.len() as u64;
1248
1249 for key in keys {
1250 let ttl = storage.get_kv_ttl(&key).await?;
1254 let Some(mut raw) = storage.get_kv(&key).await? else {
1255 report.vanished += 1;
1257 continue;
1258 };
1259
1260 if let Some(envelope) = StorageEncryption::parse_envelope(&raw) {
1261 if envelope.v >= CURRENT_FORMAT_VERSION {
1262 report.already_encrypted += 1;
1263 continue;
1264 }
1265
1266 match encryption.decrypt(&envelope, key.as_bytes()) {
1270 Err(_) => {
1271 tracing::warn!(
1272 record = %safe_log_id(&key),
1273 "migrate_kv_to_encrypted: could not decrypt format-version-0 \
1274 envelope with any loaded key -- skipping, not aborting the rest \
1275 of the run"
1276 );
1277 report.failed.push(safe_log_id(&key));
1278 }
1279 Ok(mut plaintext) => {
1280 report.legacy_v0_found += 1;
1281 if !dry_run && accept_legacy_v0 {
1282 if envelope.v == 0 {
1283 tracing::warn!(
1284 record = %safe_log_id(&key),
1285 "migrate_kv_to_encrypted: upgrading format-version-0 \
1286 envelope to the current format -- v0 has no AAD, so this \
1287 plaintext's association with this specific key was not \
1288 cryptographically verified by this upgrade"
1289 );
1290 } else {
1291 tracing::info!(
1292 record = %safe_log_id(&key),
1293 v = envelope.v,
1294 "migrate_kv_to_encrypted: upgrading legacy envelope to the \
1295 current format (its AAD bound the record key)"
1296 );
1297 }
1298 let encrypt_result =
1299 encryption.encrypt_for_storage(&plaintext, key.as_bytes());
1300 plaintext.zeroize();
1301 let new_envelope = encrypt_result?;
1302 storage.store_kv(&key, &new_envelope, ttl).await?;
1303 report.upgraded_from_legacy += 1;
1304 } else {
1305 plaintext.zeroize();
1306 }
1307 }
1308 }
1309 continue;
1310 }
1311
1312 report.encrypted += 1;
1313 if !dry_run {
1314 let encrypt_result = encryption.encrypt_for_storage(&raw, key.as_bytes());
1315 raw.zeroize();
1316 let envelope = encrypt_result?;
1317 storage.store_kv(&key, &envelope, ttl).await?;
1318 } else {
1319 raw.zeroize();
1320 }
1321 }
1322
1323 Ok(report)
1324}
1325
1326#[cfg(test)]
1327mod tests {
1328 use super::*;
1329 use crate::storage::MemoryStorage;
1330
1331 #[test]
1332 fn test_key_generation() {
1333 let key = StorageEncryption::generate_key();
1334 assert!(!key.is_empty());
1335 let decoded = BASE64.decode(&key).unwrap();
1336 assert_eq!(decoded.len(), 32);
1337 }
1338
1339 #[test]
1340 fn test_encrypt_decrypt_roundtrip() {
1341 let enc = StorageEncryption::new_random();
1342 let plaintext = b"super secret totp seed, not utf8 safe either: \xff\xfe";
1343 let encrypted = enc.encrypt(plaintext, b"user:alice:totp_secret").unwrap();
1344 let decrypted = enc.decrypt(&encrypted, b"user:alice:totp_secret").unwrap();
1345 assert_eq!(decrypted, plaintext);
1346 }
1347
1348 #[test]
1354 fn test_decrypt_rejects_wrong_aad() {
1355 let enc = StorageEncryption::new_random();
1356 let encrypted = enc
1357 .encrypt(b"alice's secret", b"user:alice:totp_secret")
1358 .unwrap();
1359 let result = enc.decrypt(&encrypted, b"user:bob:totp_secret");
1360 assert!(
1361 result.is_err(),
1362 "decrypting with the wrong AAD (a different record's key) must fail"
1363 );
1364 }
1365
1366 #[test]
1370 fn test_nonces_are_unique_across_many_encryptions() {
1371 let enc = StorageEncryption::new_random();
1372 let mut seen = std::collections::HashSet::new();
1373 for _ in 0..1000 {
1374 let encrypted = enc
1375 .encrypt(b"same plaintext every time", b"same:aad")
1376 .unwrap();
1377 assert_eq!(
1378 BASE64.decode(&encrypted.nonce).unwrap().len(),
1379 12,
1380 "nonce must be 96 bits"
1381 );
1382 assert!(
1383 seen.insert(encrypted.nonce.clone()),
1384 "nonce reused across encryptions -- this breaks AES-GCM's security guarantee"
1385 );
1386 }
1387 }
1388
1389 #[test]
1390 fn test_storage_roundtrip_non_utf8_bytes() {
1391 let enc = StorageEncryption::new_random();
1392 let raw_salt: &[u8] = &[0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0xFF, 0x80, 0x81];
1393 let stored = enc.encrypt_for_storage(raw_salt, b"salt:key").unwrap();
1394 let restored = enc.decrypt_from_storage(&stored, b"salt:key").unwrap();
1395 assert_eq!(restored, raw_salt);
1396 }
1397
1398 struct EmptyKeyProvider;
1402 impl KeyProvider for EmptyKeyProvider {
1403 fn load_keys(&self) -> Result<LoadedKeys> {
1404 Err(AuthError::config("no key configured (test)"))
1405 }
1406 }
1407
1408 #[test]
1409 fn test_construction_fails_closed_with_no_key() {
1410 let result = StorageEncryption::new(&EmptyKeyProvider);
1411 assert!(
1412 result.is_err(),
1413 "StorageEncryption::new must fail, not silently construct an unusable/no-op encryptor"
1414 );
1415 }
1416
1417 struct FixedKeyProvider(LoadedKeys);
1418 impl KeyProvider for FixedKeyProvider {
1419 fn load_keys(&self) -> Result<LoadedKeys> {
1420 Ok(LoadedKeys {
1421 current_key_id: self.0.current_key_id.clone(),
1422 keys: self.0.keys.clone(),
1423 })
1424 }
1425 }
1426
1427 #[test]
1428 fn test_construction_rejects_empty_key_id() {
1429 let mut keys = HashMap::new();
1435 keys.insert("1".to_string(), [1u8; 32]);
1436 keys.insert(String::new(), [2u8; 32]);
1437 let result = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1438 current_key_id: "1".to_string(),
1439 keys,
1440 }));
1441 assert!(
1442 result.is_err(),
1443 "an empty key id anywhere in the loaded key set must be rejected (it's reserved \
1444 for format-version-0 envelopes), even when current_key_id itself is valid"
1445 );
1446 }
1447
1448 struct TwoKeyProvider {
1452 current_id: String,
1453 old_key: [u8; 32],
1454 new_key: [u8; 32],
1455 old_id: String,
1456 }
1457 impl KeyProvider for TwoKeyProvider {
1458 fn load_keys(&self) -> Result<LoadedKeys> {
1459 let mut keys = HashMap::new();
1460 keys.insert(self.old_id.clone(), self.old_key);
1461 keys.insert(self.current_id.clone(), self.new_key);
1462 Ok(LoadedKeys {
1463 current_key_id: self.current_id.clone(),
1464 keys,
1465 })
1466 }
1467 }
1468
1469 #[test]
1470 fn test_old_key_still_decrypts_after_rotation() {
1471 let mut keys = HashMap::new();
1472 keys.insert("1".to_string(), [7u8; 32]);
1473 let enc_before_rotation = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1474 current_key_id: "1".to_string(),
1475 keys,
1476 }))
1477 .unwrap();
1478 let old_envelope = enc_before_rotation
1479 .encrypt(b"written before rotation", b"some:key")
1480 .unwrap();
1481 assert_eq!(old_envelope.key_id, "1");
1482
1483 let provider = TwoKeyProvider {
1485 current_id: "2".to_string(),
1486 old_id: "1".to_string(),
1487 old_key: [7u8; 32],
1488 new_key: [9u8; 32],
1489 };
1490 let enc_after_rotation = StorageEncryption::new(&provider).unwrap();
1491
1492 let new_envelope = enc_after_rotation
1494 .encrypt(b"written after rotation", b"some:key")
1495 .unwrap();
1496 assert_eq!(new_envelope.key_id, "2");
1497
1498 let decrypted_old = enc_after_rotation
1500 .decrypt(&old_envelope, b"some:key")
1501 .unwrap();
1502 assert_eq!(decrypted_old, b"written before rotation");
1503 }
1504
1505 #[test]
1511 fn test_decrypts_format_version_0_envelope() {
1512 let mut keys = HashMap::new();
1513 keys.insert("1".to_string(), [3u8; 32]);
1514 let enc = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1515 current_key_id: "1".to_string(),
1516 keys,
1517 }))
1518 .unwrap();
1519
1520 let cipher = {
1523 let key = Key::<Aes256Gcm>::from_slice(&[3u8; 32]);
1524 Aes256Gcm::new(key)
1525 };
1526 let nonce_bytes = [5u8; 12];
1527 let nonce = Nonce::from_slice(&nonce_bytes);
1528 let ciphertext = cipher
1529 .encrypt(nonce, b"legacy-format plaintext".as_ref())
1530 .unwrap();
1531 let legacy_json = format!(
1532 r#"{{"data":"{}","nonce":"{}","algorithm":"AES-256-GCM","key_derivation":"direct"}}"#,
1533 BASE64.encode(&ciphertext),
1534 BASE64.encode(nonce_bytes)
1535 );
1536
1537 assert!(StorageEncryption::looks_like_envelope(
1538 legacy_json.as_bytes()
1539 ));
1540 let decrypted = enc
1541 .decrypt_from_storage(legacy_json.as_bytes(), b"irrelevant-for-v0")
1542 .unwrap();
1543 assert_eq!(decrypted, b"legacy-format plaintext".to_vec());
1544 }
1545
1546 #[tokio::test]
1556 async fn test_wrapper_rejects_v1_envelope_downgraded_to_look_like_v0() {
1557 let mut keys = HashMap::new();
1558 keys.insert("1".to_string(), [4u8; 32]);
1559 let encryption = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1560 current_key_id: "1".to_string(),
1561 keys,
1562 }))
1563 .unwrap();
1564
1565 let inner = MemoryStorage::new();
1566 let wrapped = EncryptedStorage::new(inner, encryption, false, false);
1567
1568 wrapped
1569 .store_kv("user:alice:totp_secret", b"real secret", None)
1570 .await
1571 .unwrap();
1572
1573 let inner = wrapped.into_inner();
1574 let real_envelope: EncryptedData = serde_json::from_slice(
1575 &inner
1576 .get_kv("user:alice:totp_secret")
1577 .await
1578 .unwrap()
1579 .unwrap(),
1580 )
1581 .unwrap();
1582
1583 let downgraded_json = serde_json::json!({
1586 "data": real_envelope.data,
1587 "nonce": real_envelope.nonce,
1588 "algorithm": real_envelope.algorithm,
1589 })
1590 .to_string();
1591 inner
1592 .store_kv("user:alice:totp_secret", downgraded_json.as_bytes(), None)
1593 .await
1594 .unwrap();
1595
1596 let mut keys2 = HashMap::new();
1597 keys2.insert("1".to_string(), [4u8; 32]);
1598 let encryption2 = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1599 current_key_id: "1".to_string(),
1600 keys: keys2,
1601 }))
1602 .unwrap();
1603 let wrapped = EncryptedStorage::new(inner, encryption2, false, false);
1604
1605 let result = wrapped.get_kv("user:alice:totp_secret").await;
1606 assert!(
1607 result.is_err(),
1608 "a v1 envelope downgraded to look like v0 must not be accepted as the record's \
1609 value, with allow_legacy_v0 at its default (false)"
1610 );
1611 }
1612
1613 #[tokio::test]
1614 async fn test_list_kv_keys_passes_through_unencrypted() {
1615 let inner = MemoryStorage::new();
1616 inner
1617 .store_kv("prefix:a", b"ignored by this test", None)
1618 .await
1619 .unwrap();
1620 inner
1621 .store_kv("prefix:b", b"ignored by this test", None)
1622 .await
1623 .unwrap();
1624 let wrapped = EncryptedStorage::new(inner, StorageEncryption::new_random(), false, false);
1625
1626 let mut keys = wrapped.list_kv_keys("prefix:").await.unwrap();
1627 keys.sort();
1628 assert_eq!(
1629 keys,
1630 vec!["prefix:a".to_string(), "prefix:b".to_string()],
1631 "list_kv_keys must pass through to the inner backend, not use the trait's \
1632 empty-Vec default"
1633 );
1634 }
1635
1636 #[tokio::test]
1637 async fn test_encrypted_storage_roundtrip() {
1638 let inner = MemoryStorage::new();
1639 let wrapped = EncryptedStorage::new(inner, StorageEncryption::new_random(), false, false);
1640
1641 wrapped
1642 .store_kv("user:alice:totp_secret", b"JBSWY3DPEHPK3PXP", None)
1643 .await
1644 .unwrap();
1645 let value = wrapped.get_kv("user:alice:totp_secret").await.unwrap();
1646 assert_eq!(value, Some(b"JBSWY3DPEHPK3PXP".to_vec()));
1647 }
1648
1649 #[tokio::test]
1653 async fn test_encrypted_storage_actually_encrypts_the_underlying_value() {
1654 let wrapped = EncryptedStorage::new(
1655 MemoryStorage::new(),
1656 StorageEncryption::new_random(),
1657 false,
1658 false,
1659 );
1660
1661 wrapped
1662 .store_kv("user:alice:totp_secret", b"JBSWY3DPEHPK3PXP", None)
1663 .await
1664 .unwrap();
1665
1666 let inner = wrapped.into_inner();
1667 let raw = inner
1668 .get_kv("user:alice:totp_secret")
1669 .await
1670 .unwrap()
1671 .unwrap();
1672 assert_ne!(
1673 raw,
1674 b"JBSWY3DPEHPK3PXP".to_vec(),
1675 "the underlying storage must not hold the plaintext value"
1676 );
1677 assert!(
1678 StorageEncryption::looks_like_envelope(&raw),
1679 "the underlying storage must hold a proper encrypted envelope"
1680 );
1681 }
1682
1683 #[tokio::test]
1691 async fn test_wrapper_rejects_ciphertext_swapped_between_records() {
1692 let mut keys = HashMap::new();
1693 keys.insert("1".to_string(), [11u8; 32]);
1694 let loaded = LoadedKeys {
1695 current_key_id: "1".to_string(),
1696 keys,
1697 };
1698 let encryption_for_wrapper = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1699 current_key_id: loaded.current_key_id.clone(),
1700 keys: loaded.keys.clone(),
1701 }))
1702 .unwrap();
1703 let encryption_for_verification =
1707 StorageEncryption::new(&FixedKeyProvider(loaded)).unwrap();
1708
1709 let inner = MemoryStorage::new();
1710 let wrapped = EncryptedStorage::new(inner, encryption_for_wrapper, false, false);
1711
1712 wrapped
1713 .store_kv("user:alice:totp_secret", b"alice-secret", None)
1714 .await
1715 .unwrap();
1716
1717 let inner = wrapped.into_inner();
1718 let raw = inner
1719 .get_kv("user:alice:totp_secret")
1720 .await
1721 .unwrap()
1722 .unwrap();
1723
1724 let decrypted = encryption_for_verification
1727 .decrypt(
1728 &serde_json::from_slice(&raw).unwrap(),
1729 b"user:alice:totp_secret",
1730 )
1731 .unwrap();
1732 assert_eq!(decrypted, b"alice-secret".to_vec());
1733
1734 let wrong_aad_result = encryption_for_verification.decrypt(
1739 &serde_json::from_slice(&raw).unwrap(),
1740 b"user:bob:totp_secret",
1741 );
1742 assert!(
1743 wrong_aad_result.is_err(),
1744 "the wrapper's envelope must not decrypt under a different record's key name -- \
1745 if it does, the wrapper is using a constant AAD instead of the real storage key"
1746 );
1747 }
1748
1749 #[tokio::test]
1754 async fn test_reads_legacy_plaintext_when_allowed() {
1755 let inner = MemoryStorage::new();
1756 inner
1757 .store_kv("legacy:key", b"pre-existing plaintext value", None)
1758 .await
1759 .unwrap();
1760 let wrapped = EncryptedStorage::new(inner, StorageEncryption::new_random(), true, false);
1761
1762 let value = wrapped.get_kv("legacy:key").await.unwrap();
1763 assert_eq!(value, Some(b"pre-existing plaintext value".to_vec()));
1764 }
1765
1766 #[tokio::test]
1774 async fn test_rejects_non_envelope_value_when_plaintext_reads_disallowed() {
1775 let inner = MemoryStorage::new();
1776 inner
1777 .store_kv("user:alice:totp_secret", b"attacker-chosen-plaintext", None)
1778 .await
1779 .unwrap();
1780 let wrapped = EncryptedStorage::new(inner, StorageEncryption::new_random(), false, false);
1781
1782 let result = wrapped.get_kv("user:alice:totp_secret").await;
1783 assert!(
1784 result.is_err(),
1785 "a non-envelope value must be rejected, not silently treated as plaintext, \
1786 when allow_plaintext_reads is false"
1787 );
1788 }
1789
1790 #[tokio::test]
1795 async fn test_migration_upgrades_v0_envelope_to_current_format() {
1796 let mut keys = HashMap::new();
1797 keys.insert("1".to_string(), [6u8; 32]);
1798 let encryption = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1799 current_key_id: "1".to_string(),
1800 keys,
1801 }))
1802 .unwrap();
1803
1804 let cipher = {
1807 let key = Key::<Aes256Gcm>::from_slice(&[6u8; 32]);
1808 Aes256Gcm::new(key)
1809 };
1810 let nonce_bytes = [8u8; 12];
1811 let nonce = Nonce::from_slice(&nonce_bytes);
1812 let ciphertext = cipher.encrypt(nonce, b"v0 secret".as_ref()).unwrap();
1813 let v0_json = format!(
1814 r#"{{"data":"{}","nonce":"{}","algorithm":"AES-256-GCM","key_derivation":"direct"}}"#,
1815 BASE64.encode(&ciphertext),
1816 BASE64.encode(nonce_bytes)
1817 );
1818
1819 let storage = MemoryStorage::new();
1820 storage
1821 .store_kv("secret:legacy", v0_json.as_bytes(), None)
1822 .await
1823 .unwrap();
1824
1825 let report = migrate_kv_to_encrypted(
1826 &storage,
1827 &encryption,
1828 "secret:",
1829 MigrationOptions {
1830 dry_run: false,
1831 accept_legacy_v0: true,
1832 ..Default::default()
1833 },
1834 )
1835 .await
1836 .unwrap();
1837 assert_eq!(
1838 report.legacy_v0_found, 1,
1839 "a decryptable v0 envelope must be counted as found"
1840 );
1841 assert_eq!(
1842 report.upgraded_from_legacy, 1,
1843 "with accept_legacy_v0 true on a real run, it must actually be upgraded"
1844 );
1845 assert_eq!(report.already_encrypted, 0);
1846 assert!(report.failed.is_empty());
1847
1848 let raw_after = storage.get_kv("secret:legacy").await.unwrap().unwrap();
1849 let envelope_after: EncryptedData = serde_json::from_slice(&raw_after).unwrap();
1850 assert_eq!(
1851 envelope_after.v, CURRENT_FORMAT_VERSION,
1852 "the stored envelope must now be the current format, not still v0"
1853 );
1854 assert!(
1855 !envelope_after.key_id.is_empty(),
1856 "the upgraded envelope must have a real key_id"
1857 );
1858
1859 let decrypted = encryption
1862 .decrypt(&envelope_after, b"secret:legacy")
1863 .unwrap();
1864 assert_eq!(decrypted, b"v0 secret".to_vec());
1865
1866 let report2 = migrate_kv_to_encrypted(
1868 &storage,
1869 &encryption,
1870 "secret:",
1871 MigrationOptions {
1872 dry_run: false,
1873 accept_legacy_v0: false,
1874 ..Default::default()
1875 },
1876 )
1877 .await
1878 .unwrap();
1879 assert_eq!(report2.upgraded_from_legacy, 0);
1880 assert_eq!(report2.already_encrypted, 1);
1881 }
1882
1883 #[tokio::test]
1888 async fn test_migration_does_not_upgrade_legacy_v0_without_accept_flag() {
1889 let mut keys = HashMap::new();
1890 keys.insert("1".to_string(), [7u8; 32]);
1891 let encryption = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1892 current_key_id: "1".to_string(),
1893 keys,
1894 }))
1895 .unwrap();
1896
1897 let cipher = {
1898 let key = Key::<Aes256Gcm>::from_slice(&[7u8; 32]);
1899 Aes256Gcm::new(key)
1900 };
1901 let nonce_bytes = [3u8; 12];
1902 let nonce = Nonce::from_slice(&nonce_bytes);
1903 let ciphertext = cipher.encrypt(nonce, b"v0 secret".as_ref()).unwrap();
1904 let v0_json = format!(
1905 r#"{{"data":"{}","nonce":"{}","algorithm":"AES-256-GCM","key_derivation":"direct"}}"#,
1906 BASE64.encode(&ciphertext),
1907 BASE64.encode(nonce_bytes)
1908 );
1909
1910 let storage = MemoryStorage::new();
1911 storage
1912 .store_kv("secret:legacy", v0_json.as_bytes(), None)
1913 .await
1914 .unwrap();
1915
1916 let report = migrate_kv_to_encrypted(
1918 &storage,
1919 &encryption,
1920 "secret:",
1921 MigrationOptions {
1922 dry_run: false,
1923 accept_legacy_v0: false,
1924 ..Default::default()
1925 },
1926 )
1927 .await
1928 .unwrap();
1929 assert_eq!(
1930 report.legacy_v0_found, 1,
1931 "the v0 envelope must still be detected/decrypted"
1932 );
1933 assert_eq!(
1934 report.upgraded_from_legacy, 0,
1935 "without accept_legacy_v0, nothing must actually be rewritten"
1936 );
1937
1938 let raw_after = storage.get_kv("secret:legacy").await.unwrap().unwrap();
1939 assert_eq!(
1940 raw_after,
1941 v0_json.as_bytes(),
1942 "the stored envelope must be byte-for-byte unchanged without accept_legacy_v0"
1943 );
1944 }
1945
1946 #[tokio::test]
1951 async fn test_migration_skips_undecryptable_v0_envelope_without_aborting() {
1952 let mut keys = HashMap::new();
1953 keys.insert("1".to_string(), [9u8; 32]);
1954 let encryption = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
1955 current_key_id: "1".to_string(),
1956 keys,
1957 }))
1958 .unwrap();
1959
1960 let bad_cipher = {
1963 let key = Key::<Aes256Gcm>::from_slice(&[0u8; 32]);
1964 Aes256Gcm::new(key)
1965 };
1966 let nonce_bytes = [1u8; 12];
1967 let nonce = Nonce::from_slice(&nonce_bytes);
1968 let bad_ciphertext = bad_cipher
1969 .encrypt(nonce, b"undecryptable".as_ref())
1970 .unwrap();
1971 let bad_v0_json = format!(
1972 r#"{{"data":"{}","nonce":"{}","algorithm":"AES-256-GCM","key_derivation":"direct"}}"#,
1973 BASE64.encode(&bad_ciphertext),
1974 BASE64.encode(nonce_bytes)
1975 );
1976
1977 let storage = MemoryStorage::new();
1978 storage
1979 .store_kv("secret:bad", bad_v0_json.as_bytes(), None)
1980 .await
1981 .unwrap();
1982 storage
1983 .store_kv("secret:good_a", b"plaintext-a", None)
1984 .await
1985 .unwrap();
1986 storage
1987 .store_kv("secret:good_b", b"plaintext-b", None)
1988 .await
1989 .unwrap();
1990
1991 let report = migrate_kv_to_encrypted(
1992 &storage,
1993 &encryption,
1994 "secret:",
1995 MigrationOptions {
1996 dry_run: false,
1997 accept_legacy_v0: true,
1998 ..Default::default()
1999 },
2000 )
2001 .await
2002 .expect("one undecryptable record must not abort the whole migration");
2003
2004 assert_eq!(report.scanned, 3);
2005 assert_eq!(
2006 report.failed,
2007 vec![safe_log_id("secret:bad")],
2008 "the undecryptable record must be named (as a safe identifier, not the raw \
2009 key) in `failed`, not silently dropped"
2010 );
2011 assert_eq!(
2012 report.encrypted, 2,
2013 "the other two plaintext keys must still be processed despite the bad one"
2014 );
2015
2016 let good_a_after = storage.get_kv("secret:good_a").await.unwrap().unwrap();
2017 assert!(StorageEncryption::looks_like_envelope(&good_a_after));
2018 let good_b_after = storage.get_kv("secret:good_b").await.unwrap().unwrap();
2019 assert!(StorageEncryption::looks_like_envelope(&good_b_after));
2020
2021 let bad_after = storage.get_kv("secret:bad").await.unwrap().unwrap();
2023 assert_eq!(bad_after, bad_v0_json.as_bytes());
2024 }
2025
2026 #[tokio::test]
2031 async fn test_migration_dry_run_detects_undecryptable_v0_envelope() {
2032 let mut keys = HashMap::new();
2033 keys.insert("1".to_string(), [5u8; 32]);
2034 let encryption = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
2035 current_key_id: "1".to_string(),
2036 keys,
2037 }))
2038 .unwrap();
2039
2040 let bad_cipher = {
2041 let key = Key::<Aes256Gcm>::from_slice(&[0u8; 32]);
2042 Aes256Gcm::new(key)
2043 };
2044 let nonce_bytes = [2u8; 12];
2045 let nonce = Nonce::from_slice(&nonce_bytes);
2046 let bad_ciphertext = bad_cipher
2047 .encrypt(nonce, b"undecryptable".as_ref())
2048 .unwrap();
2049 let bad_v0_json = format!(
2050 r#"{{"data":"{}","nonce":"{}","algorithm":"AES-256-GCM","key_derivation":"direct"}}"#,
2051 BASE64.encode(&bad_ciphertext),
2052 BASE64.encode(nonce_bytes)
2053 );
2054
2055 let storage = MemoryStorage::new();
2056 storage
2057 .store_kv("secret:bad", bad_v0_json.as_bytes(), None)
2058 .await
2059 .unwrap();
2060
2061 let dry_report = migrate_kv_to_encrypted(
2062 &storage,
2063 &encryption,
2064 "secret:",
2065 MigrationOptions {
2066 dry_run: true,
2067 accept_legacy_v0: true,
2068 ..Default::default()
2069 },
2070 )
2071 .await
2072 .unwrap();
2073 assert_eq!(
2074 dry_report.failed,
2075 vec![safe_log_id("secret:bad")],
2076 "a dry run must actually attempt the decrypt and report the same failure a \
2077 real run would, not optimistically assume every v0 envelope would succeed"
2078 );
2079 assert_eq!(dry_report.upgraded_from_legacy, 0);
2080 assert_eq!(dry_report.legacy_v0_found, 0);
2081 }
2082
2083 #[test]
2088 fn test_safe_log_id_never_contains_the_raw_secret() {
2089 let raw_secret = "ak_live_super_secret_bearer_token_12345";
2090 let key = format!("api_key:{raw_secret}");
2091 let id = safe_log_id(&key);
2092
2093 assert!(
2094 !id.contains(raw_secret),
2095 "safe_log_id must never contain the raw secret portion of the key, got: {id}"
2096 );
2097 assert!(
2098 id.starts_with("api_key:"),
2099 "safe_log_id should keep the (non-secret) namespace prefix, got: {id}"
2100 );
2101 assert_eq!(id, safe_log_id(&key));
2105 }
2106
2107 #[test]
2112 fn test_safe_log_id_handles_colonless_key_without_leaking_it() {
2113 let raw_secret = "a_bearer_token_with_no_colon_in_it_at_all";
2114 let id = safe_log_id(raw_secret);
2115
2116 assert!(
2117 !id.contains(raw_secret),
2118 "a colonless key must not appear verbatim in its safe_log_id, got: {id}"
2119 );
2120 assert!(
2121 id.starts_with("key:"),
2122 "a colonless key should fall back to the literal 'key:' prefix, got: {id}"
2123 );
2124 }
2125
2126 #[tokio::test]
2133 async fn test_dry_run_with_accept_legacy_v0_does_not_write_a_decryptable_v0_record() {
2134 let mut keys = HashMap::new();
2135 keys.insert("1".to_string(), [4u8; 32]);
2136 let encryption = StorageEncryption::new(&FixedKeyProvider(LoadedKeys {
2137 current_key_id: "1".to_string(),
2138 keys,
2139 }))
2140 .unwrap();
2141
2142 let cipher = {
2143 let key = Key::<Aes256Gcm>::from_slice(&[4u8; 32]);
2144 Aes256Gcm::new(key)
2145 };
2146 let nonce_bytes = [6u8; 12];
2147 let nonce = Nonce::from_slice(&nonce_bytes);
2148 let ciphertext = cipher.encrypt(nonce, b"v0 secret".as_ref()).unwrap();
2149 let v0_json = format!(
2150 r#"{{"data":"{}","nonce":"{}","algorithm":"AES-256-GCM","key_derivation":"direct"}}"#,
2151 BASE64.encode(&ciphertext),
2152 BASE64.encode(nonce_bytes)
2153 );
2154
2155 let storage = MemoryStorage::new();
2156 storage
2157 .store_kv("secret:legacy", v0_json.as_bytes(), None)
2158 .await
2159 .unwrap();
2160
2161 let report = migrate_kv_to_encrypted(
2163 &storage,
2164 &encryption,
2165 "secret:",
2166 MigrationOptions {
2167 dry_run: true,
2168 accept_legacy_v0: true,
2169 ..Default::default()
2170 },
2171 )
2172 .await
2173 .unwrap();
2174
2175 assert_eq!(
2176 report.legacy_v0_found, 1,
2177 "a dry run must still report a decryptable v0 record as found"
2178 );
2179 assert_eq!(
2180 report.upgraded_from_legacy, 0,
2181 "a dry run must never actually upgrade anything, even with accept_legacy_v0 true"
2182 );
2183
2184 let raw_after = storage.get_kv("secret:legacy").await.unwrap().unwrap();
2185 assert_eq!(
2186 raw_after,
2187 v0_json.as_bytes(),
2188 "a dry run with accept_legacy_v0 true must leave the record byte-for-byte \
2189 unchanged"
2190 );
2191 }
2192
2193 #[tokio::test]
2194 async fn test_migration_dry_run_reports_without_writing() {
2195 let storage = MemoryStorage::new();
2196 storage
2197 .store_kv("secret:a", b"plaintext-a", None)
2198 .await
2199 .unwrap();
2200 storage
2201 .store_kv("secret:b", b"plaintext-b", None)
2202 .await
2203 .unwrap();
2204 let encryption = StorageEncryption::new_random();
2205
2206 let report = migrate_kv_to_encrypted(
2207 &storage,
2208 &encryption,
2209 "secret:",
2210 MigrationOptions {
2211 dry_run: true,
2212 accept_legacy_v0: false,
2213 ..Default::default()
2214 },
2215 )
2216 .await
2217 .unwrap();
2218
2219 assert!(report.dry_run);
2220 assert_eq!(report.scanned, 2);
2221 assert_eq!(report.encrypted, 2);
2222 assert_eq!(report.already_encrypted, 0);
2223
2224 let still_plaintext = storage.get_kv("secret:a").await.unwrap().unwrap();
2226 assert_eq!(still_plaintext, b"plaintext-a".to_vec());
2227 }
2228
2229 #[tokio::test]
2230 async fn test_migration_encrypts_plaintext_values() {
2231 let storage = MemoryStorage::new();
2232 storage
2233 .store_kv("secret:a", b"plaintext-a", None)
2234 .await
2235 .unwrap();
2236 let encryption = StorageEncryption::new_random();
2237
2238 let report = migrate_kv_to_encrypted(
2239 &storage,
2240 &encryption,
2241 "secret:",
2242 MigrationOptions {
2243 dry_run: false,
2244 accept_legacy_v0: false,
2245 ..Default::default()
2246 },
2247 )
2248 .await
2249 .unwrap();
2250 assert_eq!(report.encrypted, 1);
2251
2252 let raw = storage.get_kv("secret:a").await.unwrap().unwrap();
2253 assert!(StorageEncryption::looks_like_envelope(&raw));
2254 let decrypted = encryption.decrypt_from_storage(&raw, b"secret:a").unwrap();
2255 assert_eq!(decrypted, b"plaintext-a".to_vec());
2256 }
2257
2258 #[tokio::test]
2263 async fn test_migration_is_idempotent_and_resumable() {
2264 let storage = MemoryStorage::new();
2265 storage
2266 .store_kv("secret:a", b"plaintext-a", None)
2267 .await
2268 .unwrap();
2269 storage
2270 .store_kv("secret:b", b"plaintext-b", None)
2271 .await
2272 .unwrap();
2273 let encryption = StorageEncryption::new_random();
2274
2275 let envelope_a = encryption
2278 .encrypt_for_storage(b"plaintext-a", b"secret:a")
2279 .unwrap();
2280 storage
2281 .store_kv("secret:a", &envelope_a, None)
2282 .await
2283 .unwrap();
2284
2285 let report = migrate_kv_to_encrypted(
2288 &storage,
2289 &encryption,
2290 "secret:",
2291 MigrationOptions {
2292 dry_run: false,
2293 accept_legacy_v0: false,
2294 ..Default::default()
2295 },
2296 )
2297 .await
2298 .unwrap();
2299 assert_eq!(report.scanned, 2);
2300 assert_eq!(report.already_encrypted, 1);
2301 assert_eq!(report.encrypted, 1);
2302
2303 let raw_a_after = storage.get_kv("secret:a").await.unwrap().unwrap();
2304 assert_eq!(
2305 raw_a_after, envelope_a,
2306 "an already-encrypted value must be left byte-for-byte unchanged, not double-encrypted"
2307 );
2308 let raw_b_after = storage.get_kv("secret:b").await.unwrap().unwrap();
2309 assert!(StorageEncryption::looks_like_envelope(&raw_b_after));
2310
2311 let report2 = migrate_kv_to_encrypted(
2313 &storage,
2314 &encryption,
2315 "secret:",
2316 MigrationOptions {
2317 dry_run: false,
2318 accept_legacy_v0: false,
2319 ..Default::default()
2320 },
2321 )
2322 .await
2323 .unwrap();
2324 assert_eq!(report2.already_encrypted, 2);
2325 assert_eq!(report2.encrypted, 0);
2326 }
2327
2328 #[tokio::test]
2329 async fn test_migration_only_touches_matching_prefix() {
2330 let storage = MemoryStorage::new();
2331 storage
2332 .store_kv("secret:a", b"plaintext-a", None)
2333 .await
2334 .unwrap();
2335 storage
2336 .store_kv("other:b", b"plaintext-b", None)
2337 .await
2338 .unwrap();
2339 let encryption = StorageEncryption::new_random();
2340
2341 let report = migrate_kv_to_encrypted(
2342 &storage,
2343 &encryption,
2344 "secret:",
2345 MigrationOptions {
2346 dry_run: false,
2347 accept_legacy_v0: false,
2348 ..Default::default()
2349 },
2350 )
2351 .await
2352 .unwrap();
2353 assert_eq!(report.scanned, 1);
2354
2355 let other_untouched = storage.get_kv("other:b").await.unwrap().unwrap();
2356 assert_eq!(
2357 other_untouched,
2358 b"plaintext-b".to_vec(),
2359 "a key outside the given prefix must not be touched"
2360 );
2361 }
2362
2363 #[tokio::test]
2366 async fn wrapper_passes_kv_ttl_through() {
2367 let wrapped = EncryptedStorage::new(
2368 MemoryStorage::new(),
2369 StorageEncryption::new_random(),
2370 false,
2371 false,
2372 );
2373 wrapped
2374 .store_kv("k", b"v", Some(Duration::from_secs(600)))
2375 .await
2376 .unwrap();
2377 let ttl = wrapped.get_kv_ttl("k").await.unwrap().unwrap();
2378 assert!(ttl > Duration::from_secs(590) && ttl <= Duration::from_secs(600));
2379 }
2380
2381 struct FixedKeys {
2384 current: &'static str,
2385 keys: Vec<(&'static str, [u8; 32])>,
2386 }
2387
2388 impl KeyProvider for FixedKeys {
2389 fn load_keys(&self) -> Result<LoadedKeys> {
2390 Ok(LoadedKeys {
2391 current_key_id: self.current.to_string(),
2392 keys: self
2393 .keys
2394 .iter()
2395 .map(|(id, key)| (id.to_string(), *key))
2396 .collect(),
2397 })
2398 }
2399 }
2400
2401 const KEY_A: [u8; 32] = [0x11; 32];
2402 const KEY_B: [u8; 32] = [0x22; 32];
2403
2404 fn manual_envelope(
2407 key: &[u8; 32],
2408 key_id: &str,
2409 v: u8,
2410 plaintext: &[u8],
2411 aad: &[u8],
2412 ) -> Vec<u8> {
2413 let cipher = Aes256Gcm::new(Key::<Aes256Gcm>::from_slice(key));
2414 let nonce_bytes = [7u8; 12];
2415 let ciphertext = cipher
2416 .encrypt(
2417 Nonce::from_slice(&nonce_bytes),
2418 Payload {
2419 msg: plaintext,
2420 aad,
2421 },
2422 )
2423 .unwrap();
2424 serde_json::to_vec(&EncryptedData {
2425 data: BASE64.encode(ciphertext),
2426 nonce: BASE64.encode(nonce_bytes),
2427 algorithm: "AES-256-GCM".to_string(),
2428 key_id: key_id.to_string(),
2429 v,
2430 key_derivation: String::new(),
2431 })
2432 .unwrap()
2433 }
2434
2435 #[test]
2436 fn new_envelopes_use_format_v2() {
2437 let enc = StorageEncryption::new_random();
2438 assert_eq!(enc.encrypt(b"x", b"k").unwrap().v, 2);
2439 }
2440
2441 #[test]
2446 fn v2_aad_binds_key_id_and_version() {
2447 let enc = StorageEncryption::new(&FixedKeys {
2448 current: "a",
2449 keys: vec![("a", KEY_A), ("b", KEY_A)],
2450 })
2451 .unwrap();
2452 let envelope = enc.encrypt(b"secret", b"rec:1").unwrap();
2453 assert_eq!(enc.decrypt(&envelope, b"rec:1").unwrap(), b"secret");
2454
2455 let mut relabelled = envelope.clone();
2456 relabelled.key_id = "b".to_string();
2457 assert!(
2458 enc.decrypt(&relabelled, b"rec:1").is_err(),
2459 "relabelling key_id must fail authentication"
2460 );
2461
2462 let mut downgraded = envelope.clone();
2463 downgraded.v = 1;
2464 assert!(
2465 enc.decrypt(&downgraded, b"rec:1").is_err(),
2466 "rewriting v to 1 must not make a v2 ciphertext verify"
2467 );
2468 }
2469
2470 #[tokio::test]
2474 async fn v1_envelopes_are_legacy_and_migrate_to_v2() {
2475 let storage = MemoryStorage::new();
2476 storage
2477 .store_kv(
2478 "rec:1",
2479 &manual_envelope(&KEY_A, "1", 1, b"secret", b"rec:1"),
2480 None,
2481 )
2482 .await
2483 .unwrap();
2484 let provider = || FixedKeys {
2485 current: "1",
2486 keys: vec![("1", KEY_A)],
2487 };
2488
2489 let strict = EncryptedStorage::new(
2490 storage.clone(),
2491 StorageEncryption::new(&provider()).unwrap(),
2492 false,
2493 false,
2494 );
2495 assert!(
2496 strict.get_kv("rec:1").await.is_err(),
2497 "v1 must need the legacy policy"
2498 );
2499
2500 let lenient = EncryptedStorage::new(
2501 storage.clone(),
2502 StorageEncryption::new(&provider()).unwrap(),
2503 false,
2504 true,
2505 );
2506 assert_eq!(lenient.get_kv("rec:1").await.unwrap().unwrap(), b"secret");
2507
2508 let report = migrate_kv_to_encrypted(
2509 &storage,
2510 &StorageEncryption::new(&provider()).unwrap(),
2511 "",
2512 MigrationOptions::default().with_accept_legacy_v0(true),
2513 )
2514 .await
2515 .unwrap();
2516 assert_eq!(report.upgraded_from_legacy, 1, "{report:?}");
2517
2518 let raw = storage.get_kv("rec:1").await.unwrap().unwrap();
2519 assert_eq!(StorageEncryption::parse_envelope(&raw).unwrap().v, 2);
2520 let strict_after = EncryptedStorage::new(
2522 storage,
2523 StorageEncryption::new(&provider()).unwrap(),
2524 false,
2525 false,
2526 );
2527 assert_eq!(
2528 strict_after.get_kv("rec:1").await.unwrap().unwrap(),
2529 b"secret"
2530 );
2531 }
2532
2533 #[tokio::test]
2536 async fn upgraded_records_cannot_be_swapped_between_keys() {
2537 let storage = MemoryStorage::new();
2538 for (key, secret) in [("rec:1", &b"one"[..]), ("rec:2", b"two")] {
2539 storage
2540 .store_kv(key, &manual_envelope(&KEY_A, "1", 0, secret, b""), None)
2541 .await
2542 .unwrap();
2543 }
2544 let provider = || FixedKeys {
2545 current: "1",
2546 keys: vec![("1", KEY_A)],
2547 };
2548 migrate_kv_to_encrypted(
2549 &storage,
2550 &StorageEncryption::new(&provider()).unwrap(),
2551 "",
2552 MigrationOptions::default().with_accept_legacy_v0(true),
2553 )
2554 .await
2555 .unwrap();
2556
2557 let swapped = storage.get_kv("rec:1").await.unwrap().unwrap();
2558 storage.store_kv("rec:2", &swapped, None).await.unwrap();
2559 let strict = EncryptedStorage::new(
2560 storage,
2561 StorageEncryption::new(&provider()).unwrap(),
2562 false,
2563 false,
2564 );
2565 assert!(strict.get_kv("rec:2").await.is_err());
2566 }
2567
2568 #[test]
2571 fn envelope_classification_requires_version_and_key_id() {
2572 let shape = |extra: &str| {
2573 format!(
2574 r#"{{"data":"AAAA","nonce":"AAAAAAAAAAAAAAAA","algorithm":"AES-256-GCM"{extra}}}"#
2575 )
2576 };
2577 assert!(StorageEncryption::parse_envelope(shape(r#","v":2"#).as_bytes()).is_none());
2579 assert!(
2581 StorageEncryption::parse_envelope(shape(r#","v":1,"key_id":"""#).as_bytes()).is_none()
2582 );
2583 assert!(
2585 StorageEncryption::parse_envelope(shape(r#","v":2,"key_id":"1""#).as_bytes()).is_some()
2586 );
2587 assert!(StorageEncryption::parse_envelope(shape("").as_bytes()).is_some());
2589 }
2590
2591 #[test]
2594 fn decrypt_failures_share_one_error_text() {
2595 let enc = StorageEncryption::new(&FixedKeys {
2596 current: "a",
2597 keys: vec![("a", KEY_A), ("b", KEY_B)],
2598 })
2599 .unwrap();
2600 let good = enc.encrypt(b"secret", b"rec:1").unwrap();
2601
2602 let mut bad_base64 = good.clone();
2603 bad_base64.data = "!!not base64!!".to_string();
2604 let mut short_nonce = good.clone();
2605 short_nonce.nonce = BASE64.encode([1u8; 4]);
2606 let mut unknown_key = good.clone();
2607 unknown_key.key_id = "zzz".to_string();
2608 let mut wrong_algorithm = good.clone();
2609 wrong_algorithm.algorithm = "ROT13".to_string();
2610 let mut tampered = good.clone();
2611 let mut raw = BASE64.decode(&tampered.data).unwrap();
2612 raw[0] ^= 0x01;
2613 tampered.data = BASE64.encode(raw);
2614
2615 let messages: Vec<String> = [
2616 (&bad_base64, &b"rec:1"[..]),
2617 (&short_nonce, b"rec:1"),
2618 (&unknown_key, b"rec:1"),
2619 (&wrong_algorithm, b"rec:1"),
2620 (&tampered, b"rec:1"),
2621 (&good, b"rec:OTHER"),
2622 ]
2623 .iter()
2624 .map(|(envelope, aad)| enc.decrypt(envelope, aad).unwrap_err().to_string())
2625 .collect();
2626 assert!(
2627 messages.windows(2).all(|w| w[0] == w[1]),
2628 "decrypt failures must be indistinguishable, got: {messages:#?}"
2629 );
2630 }
2631
2632 #[test]
2633 fn legacy_trial_decryption_order_is_stable() {
2634 let enc = StorageEncryption::new(&FixedKeys {
2635 current: "k0",
2636 keys: (0..8)
2637 .map(|i| {
2638 let id: &'static str = Box::leak(format!("k{i}").into_boxed_str());
2639 (id, [i as u8 + 1; 32])
2640 })
2641 .rev()
2642 .collect(),
2643 })
2644 .unwrap();
2645 let ids = enc.sorted_key_ids();
2646 let mut expected = ids.clone();
2647 expected.sort();
2648 assert_eq!(ids, expected);
2649 assert_eq!(ids.len(), 8);
2650 }
2651
2652 #[test]
2653 fn safe_log_id_keeps_eight_hash_bytes() {
2654 let id = safe_log_id("api_key:abc123");
2655 let hash = id.strip_prefix("api_key:").unwrap();
2656 assert_eq!(hash.len(), 16, "8 bytes = 16 hex chars, got {id}");
2657 let colonless = safe_log_id("rawsecret");
2658 assert_eq!(colonless.strip_prefix("key:").unwrap().len(), 16);
2659 }
2660
2661 fn load_with_env(key: Option<&str>) -> Result<LoadedKeys> {
2664 let _lock = TEST_ENCRYPTION_ENV_LOCK.blocking_lock();
2665 unsafe {
2667 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE");
2668 match key {
2669 Some(key) => std::env::set_var("AUTH_STORAGE_ENCRYPTION_KEY", key),
2670 None => std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEY"),
2671 }
2672 }
2673 let result = EnvKeyProvider.load_keys();
2674 unsafe { std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEY") };
2676 result
2677 }
2678
2679 #[test]
2680 fn malformed_env_keys_fail_closed() {
2681 assert!(load_with_env(None).is_err(), "no key at all");
2682 assert!(load_with_env(Some("")).is_err(), "empty key");
2683 assert!(
2684 load_with_env(Some("!!!not base64!!!")).is_err(),
2685 "bad base64"
2686 );
2687 assert!(
2688 load_with_env(Some(&BASE64.encode([1u8; 16]))).is_err(),
2689 "16-byte key"
2690 );
2691 assert!(
2692 load_with_env(Some(&BASE64.encode([1u8; 33]))).is_err(),
2693 "33-byte key"
2694 );
2695 assert!(load_with_env(Some(&BASE64.encode([1u8; 32]))).is_ok());
2696 }
2697
2698 #[test]
2699 fn malformed_keys_file_fails_closed() {
2700 let dir = tempfile::tempdir().unwrap();
2701 let good = BASE64.encode([3u8; 32]);
2702 let cases: [(&str, String); 4] = [
2703 ("not json", "{{{".to_string()),
2704 (
2705 "current missing from keys",
2706 format!(r#"{{"current":"x","keys":{{"1":"{good}"}}}}"#),
2707 ),
2708 (
2709 "one malformed entry",
2710 format!(r#"{{"current":"1","keys":{{"1":"{good}","2":"short"}}}}"#),
2711 ),
2712 ("empty keys", r#"{"current":"1","keys":{}}"#.to_string()),
2713 ];
2714 let _lock = TEST_ENCRYPTION_ENV_LOCK.blocking_lock();
2715 for (name, body) in cases {
2716 let path = dir.path().join("keys.json");
2717 std::fs::write(&path, body).unwrap();
2718 unsafe {
2720 std::env::set_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE", &path);
2721 }
2722 let result = EnvKeyProvider.load_keys();
2723 unsafe { std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE") };
2725 assert!(result.is_err(), "{name} must fail closed");
2726 }
2727 }
2728
2729 fn ttl_provider() -> FixedKeys {
2732 FixedKeys {
2733 current: "1",
2734 keys: vec![("1", KEY_A)],
2735 }
2736 }
2737
2738 #[tokio::test]
2739 async fn migration_preserves_ttl_when_encrypting_plaintext() {
2740 let storage = MemoryStorage::new();
2741 storage
2742 .store_kv("otp:1", b"123456", Some(Duration::from_secs(600)))
2743 .await
2744 .unwrap();
2745 storage.store_kv("durable:1", b"keep", None).await.unwrap();
2746
2747 migrate_kv_to_encrypted(
2748 &storage,
2749 &StorageEncryption::new(&ttl_provider()).unwrap(),
2750 "",
2751 MigrationOptions::default(),
2752 )
2753 .await
2754 .unwrap();
2755
2756 let ttl = storage.get_kv_ttl("otp:1").await.unwrap().unwrap();
2757 assert!(
2758 ttl > Duration::from_secs(590) && ttl <= Duration::from_secs(600),
2759 "TTL must survive migration, got {ttl:?}"
2760 );
2761 assert_eq!(storage.get_kv_ttl("durable:1").await.unwrap(), None);
2762 let raw = storage.get_kv("otp:1").await.unwrap().unwrap();
2763 assert!(
2764 StorageEncryption::looks_like_envelope(&raw),
2765 "must be encrypted"
2766 );
2767 }
2768
2769 #[tokio::test]
2770 async fn legacy_upgrade_preserves_ttl() {
2771 let storage = MemoryStorage::new();
2772 storage
2773 .store_kv(
2774 "rec:1",
2775 &manual_envelope(&KEY_A, "", 0, b"secret", b""),
2776 Some(Duration::from_secs(600)),
2777 )
2778 .await
2779 .unwrap();
2780
2781 migrate_kv_to_encrypted(
2782 &storage,
2783 &StorageEncryption::new(&ttl_provider()).unwrap(),
2784 "",
2785 MigrationOptions::default().with_accept_legacy_v0(true),
2786 )
2787 .await
2788 .unwrap();
2789
2790 let ttl = storage.get_kv_ttl("rec:1").await.unwrap().unwrap();
2791 assert!(ttl > Duration::from_secs(590) && ttl <= Duration::from_secs(600));
2792 let raw = storage.get_kv("rec:1").await.unwrap().unwrap();
2793 assert_eq!(
2794 StorageEncryption::parse_envelope(&raw).unwrap().v,
2795 CURRENT_FORMAT_VERSION
2796 );
2797 }
2798
2799 #[tokio::test]
2803 async fn migration_refuses_backend_that_cannot_report_ttl_without_opt_in() {
2804 let storage = crate::testing::utilities::MockStorage::new();
2805 let encryption = StorageEncryption::new(&ttl_provider()).unwrap();
2806
2807 assert!(
2808 migrate_kv_to_encrypted(&storage, &encryption, "", MigrationOptions::default())
2809 .await
2810 .is_err(),
2811 "a real run on a TTL-blind backend must be refused"
2812 );
2813 assert!(
2814 migrate_kv_to_encrypted(
2815 &storage,
2816 &encryption,
2817 "",
2818 MigrationOptions::default().with_dry_run(true)
2819 )
2820 .await
2821 .is_ok(),
2822 "a dry run writes nothing, so it is allowed"
2823 );
2824 assert!(
2825 migrate_kv_to_encrypted(
2826 &storage,
2827 &encryption,
2828 "",
2829 MigrationOptions::default().with_accept_ttl_loss(true)
2830 )
2831 .await
2832 .is_ok(),
2833 "explicit opt-in proceeds"
2834 );
2835 }
2836
2837 #[tokio::test]
2838 async fn backends_that_honour_ttl_say_so() {
2839 let memory = MemoryStorage::new();
2840 assert!(memory.tracks_kv_ttl());
2841 let wrapped = EncryptedStorage::new(
2842 MemoryStorage::new(),
2843 StorageEncryption::new_random(),
2844 false,
2845 false,
2846 );
2847 assert!(
2848 wrapped.tracks_kv_ttl(),
2849 "the wrapper forwards the inner answer"
2850 );
2851 let shared: std::sync::Arc<dyn AuthStorage> = std::sync::Arc::new(MemoryStorage::new());
2852 assert!(shared.tracks_kv_ttl(), "the Arc impl forwards too");
2853 assert!(
2854 !crate::testing::utilities::MockStorage::new().tracks_kv_ttl(),
2855 "a backend that ignores TTLs must say so"
2856 );
2857 }
2858
2859 #[test]
2862 fn keys_file_mode_check_flags_group_and_other_access() {
2863 for open in [0o644, 0o640, 0o604, 0o660, 0o666, 0o777, 0o601, 0o610] {
2864 assert!(keys_file_mode_too_open(open), "{open:o} must be flagged");
2865 }
2866 for closed in [0o600, 0o400, 0o700, 0o500, 0o200] {
2867 assert!(!keys_file_mode_too_open(closed), "{closed:o} must pass");
2868 }
2869 }
2870
2871 #[test]
2872 fn strict_permissions_env_parsing() {
2873 let _lock = TEST_ENCRYPTION_ENV_LOCK.blocking_lock();
2874 let read = |value: Option<&str>| {
2875 unsafe {
2877 match value {
2878 Some(v) => std::env::set_var(STRICT_KEY_FILE_PERMISSIONS_ENV, v),
2879 None => std::env::remove_var(STRICT_KEY_FILE_PERMISSIONS_ENV),
2880 }
2881 }
2882 strict_permissions_requested()
2883 };
2884 assert!(!read(None));
2885 assert!(!read(Some("")));
2886 assert!(!read(Some("0")));
2887 assert!(!read(Some("no")));
2888 assert!(read(Some("1")));
2889 assert!(read(Some("true")));
2890 assert!(read(Some("TRUE")));
2891 assert!(read(Some("Yes")));
2892 unsafe { std::env::remove_var(STRICT_KEY_FILE_PERMISSIONS_ENV) };
2894 }
2895
2896 #[cfg(unix)]
2898 #[test]
2899 fn keys_file_permissions_strict_mode_fails_startup() {
2900 use std::os::unix::fs::PermissionsExt;
2901 let dir = tempfile::tempdir().unwrap();
2902 let path = dir.path().join("keys.json");
2903 std::fs::write(&path, "{}").unwrap();
2904 let path_str = path.to_str().unwrap();
2905
2906 std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o644)).unwrap();
2907 assert!(
2908 check_keys_file_permissions(path_str, true).is_err(),
2909 "strict + 0644"
2910 );
2911 assert!(
2912 check_keys_file_permissions(path_str, false).is_ok(),
2913 "warn-only + 0644"
2914 );
2915
2916 std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
2917 assert!(
2918 check_keys_file_permissions(path_str, true).is_ok(),
2919 "strict + 0600"
2920 );
2921 }
2922
2923 #[test]
2924 fn env_key_source_detection() {
2925 let _lock = TEST_ENCRYPTION_ENV_LOCK.blocking_lock();
2926 unsafe {
2928 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE");
2929 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEY");
2930 }
2931 assert!(!env_key_source_in_use(), "no key configured at all");
2932 unsafe { std::env::set_var("AUTH_STORAGE_ENCRYPTION_KEY", "irrelevant") };
2934 assert!(
2935 env_key_source_in_use(),
2936 "no keys file => the env var is the source"
2937 );
2938 unsafe { std::env::set_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE", "/some/keys.json") };
2940 assert!(!env_key_source_in_use(), "a keys file supports rotation");
2941 unsafe {
2943 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEYS_FILE");
2944 std::env::remove_var("AUTH_STORAGE_ENCRYPTION_KEY");
2945 }
2946 }
2947
2948 #[tokio::test]
2949 async fn envelope_probe_finds_stored_envelopes_within_its_limit() {
2950 let enc = StorageEncryption::new_random();
2951 let storage = MemoryStorage::new();
2952 storage
2953 .store_kv("plain:1", b"just text", None)
2954 .await
2955 .unwrap();
2956 assert!(
2957 !stored_envelopes_exist(&storage, 10).await.unwrap(),
2958 "plaintext only"
2959 );
2960
2961 let sealed = enc.encrypt_for_storage(b"secret", b"sealed:1").unwrap();
2962 storage.store_kv("sealed:1", &sealed, None).await.unwrap();
2963 assert!(
2964 stored_envelopes_exist(&storage, 10).await.unwrap(),
2965 "envelope present"
2966 );
2967
2968 assert!(!stored_envelopes_exist(&storage, 0).await.unwrap());
2970 }
2971
2972 #[tokio::test]
2973 async fn encrypted_storage_says_it_encrypts() {
2974 let wrapped = EncryptedStorage::new(
2975 MemoryStorage::new(),
2976 StorageEncryption::new_random(),
2977 false,
2978 false,
2979 );
2980 assert!(wrapped.encrypts_kv_at_rest());
2981 assert!(!MemoryStorage::new().encrypts_kv_at_rest());
2982 let shared: std::sync::Arc<dyn AuthStorage> = std::sync::Arc::new(wrapped);
2983 assert!(shared.encrypts_kv_at_rest(), "the Arc impl forwards");
2984 }
2985}