1use aes_gcm::{
4 aead::{Aead, KeyInit},
5 Aes256Gcm, Nonce,
6};
7use base64::{engine::general_purpose::URL_SAFE_NO_PAD, Engine};
8use std::collections::BTreeMap;
9use std::sync::{Arc, RwLock};
10use uuid::Uuid;
11
12#[derive(Debug, Clone, PartialEq, Eq)]
13pub struct EncryptedEnvelope {
14 pub key_id: String,
15 pub nonce: String,
16 pub ciphertext: String,
17}
18
19#[derive(Debug, Clone, PartialEq, Eq)]
20pub enum EncryptionError {
21 InvalidKey,
22 InvalidEnvelope,
23 AuthenticationFailed,
24 UnknownKey,
25}
26
27#[derive(Clone)]
28pub struct KeyRing {
29 keys: Arc<RwLock<BTreeMap<String, [u8; 32]>>>,
30 current: Arc<RwLock<String>>,
31}
32
33impl KeyRing {
34 pub fn new(key_id: impl Into<String>, key: [u8; 32]) -> Result<Self, EncryptionError> {
35 let key_id = key_id.into();
36 if key_id.trim().is_empty() {
37 return Err(EncryptionError::InvalidKey);
38 }
39 let mut keys = BTreeMap::new();
40 keys.insert(key_id.clone(), key);
41 Ok(Self {
42 keys: Arc::new(RwLock::new(keys)),
43 current: Arc::new(RwLock::new(key_id)),
44 })
45 }
46 pub fn rotate(&self, key_id: impl Into<String>, key: [u8; 32]) -> Result<(), EncryptionError> {
47 let key_id = key_id.into();
48 if key_id.trim().is_empty() {
49 return Err(EncryptionError::InvalidKey);
50 }
51 self.keys
52 .write()
53 .expect("key ring poisoned")
54 .insert(key_id.clone(), key);
55 *self.current.write().expect("key ring poisoned") = key_id;
56 Ok(())
57 }
58 pub fn encrypt(
59 &self,
60 plaintext: &[u8],
61 associated_data: &[u8],
62 ) -> Result<EncryptedEnvelope, EncryptionError> {
63 let key_id = self.current.read().expect("key ring poisoned").clone();
64 let key = *self
65 .keys
66 .read()
67 .expect("key ring poisoned")
68 .get(&key_id)
69 .ok_or(EncryptionError::UnknownKey)?;
70 let cipher = Aes256Gcm::new_from_slice(&key).map_err(|_| EncryptionError::InvalidKey)?;
71 let nonce_bytes = *Uuid::new_v4().as_bytes();
72 let nonce = Nonce::from_slice(&nonce_bytes[..12]);
73 let ciphertext = cipher
74 .encrypt(
75 nonce,
76 aes_gcm::aead::Payload {
77 msg: plaintext,
78 aad: associated_data,
79 },
80 )
81 .map_err(|_| EncryptionError::AuthenticationFailed)?;
82 Ok(EncryptedEnvelope {
83 key_id,
84 nonce: URL_SAFE_NO_PAD.encode(&nonce_bytes[..12]),
85 ciphertext: URL_SAFE_NO_PAD.encode(ciphertext),
86 })
87 }
88 pub fn decrypt(
89 &self,
90 envelope: &EncryptedEnvelope,
91 associated_data: &[u8],
92 ) -> Result<Vec<u8>, EncryptionError> {
93 let key = *self
94 .keys
95 .read()
96 .expect("key ring poisoned")
97 .get(&envelope.key_id)
98 .ok_or(EncryptionError::UnknownKey)?;
99 let nonce_bytes = URL_SAFE_NO_PAD
100 .decode(&envelope.nonce)
101 .map_err(|_| EncryptionError::InvalidEnvelope)?;
102 if nonce_bytes.len() != 12 {
103 return Err(EncryptionError::InvalidEnvelope);
104 }
105 let ciphertext = URL_SAFE_NO_PAD
106 .decode(&envelope.ciphertext)
107 .map_err(|_| EncryptionError::InvalidEnvelope)?;
108 let cipher = Aes256Gcm::new_from_slice(&key).map_err(|_| EncryptionError::InvalidKey)?;
109 cipher
110 .decrypt(
111 Nonce::from_slice(&nonce_bytes),
112 aes_gcm::aead::Payload {
113 msg: &ciphertext,
114 aad: associated_data,
115 },
116 )
117 .map_err(|_| EncryptionError::AuthenticationFailed)
118 }
119}
120
121#[cfg(test)]
122mod tests {
123 use super::*;
124
125 #[test]
126 fn encrypts_and_decrypts_with_authenticated_metadata() {
127 let ring = KeyRing::new("v1", [7; 32]).unwrap();
128 let envelope = ring.encrypt(b"secret", b"tenant-a").unwrap();
129 assert_eq!(ring.decrypt(&envelope, b"tenant-a").unwrap(), b"secret");
130 assert_eq!(
131 ring.decrypt(&envelope, b"tenant-b"),
132 Err(EncryptionError::AuthenticationFailed)
133 );
134 }
135
136 #[test]
137 fn rotates_keys_while_retaining_old_key_decryption() {
138 let ring = KeyRing::new("v1", [1; 32]).unwrap();
139 let old = ring.encrypt(b"old", b"").unwrap();
140 ring.rotate("v2", [2; 32]).unwrap();
141 let fresh = ring.encrypt(b"new", b"").unwrap();
142 assert_eq!(old.key_id, "v1");
143 assert_eq!(fresh.key_id, "v2");
144 assert_eq!(ring.decrypt(&old, b"").unwrap(), b"old");
145 }
146
147 #[test]
148 fn rejects_tampering_and_unknown_keys() {
149 let ring = KeyRing::new("v1", [3; 32]).unwrap();
150 let mut envelope = ring.encrypt(b"secret", b"").unwrap();
151 let replacement = if envelope.ciphertext.starts_with('A') {
152 "B"
153 } else {
154 "A"
155 };
156 envelope.ciphertext.replace_range(0..1, replacement);
157 assert_eq!(
158 ring.decrypt(&envelope, b""),
159 Err(EncryptionError::AuthenticationFailed)
160 );
161 envelope.key_id = "missing".into();
162 assert_eq!(
163 ring.decrypt(&envelope, b""),
164 Err(EncryptionError::UnknownKey)
165 );
166 }
167}