Skip to main content

yaiko_core/
encryption.rs

1//! Authenticated envelope encryption and key rotation primitives.
2
3use 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}