Skip to main content

second_brain_core/cold/
envelope_keys.rs

1use std::collections::HashMap;
2use std::sync::{Arc, Mutex, PoisonError, Weak};
3
4use anyhow::Result;
5use zeroize::Zeroizing;
6
7use super::{ArchiveKeys, Kek, KekLabel};
8use crate::keys::{DeviceKeys, Envelope, Subkey, derive_subkey, newest_epoch};
9use crate::sqlite_store::SqliteStore;
10
11/// The `archive-kek` subkey of each identity key epoch this device holds an
12/// envelope for, opened with the device's own age identity. New segments are
13/// sealed under the epoch sync seals under (the newest of the identity this
14/// device's own record names); older epochs and earlier identities stay open
15/// for segments sealed under them. Holds the store weakly, since the store
16/// holds the cold tier.
17pub struct EnvelopeArchiveKeys {
18    store: Weak<SqliteStore>,
19    device: Option<DeviceKeys>,
20    derived: Mutex<HashMap<KekLabel, Zeroizing<[u8; 32]>>>,
21}
22
23fn label_of(envelope: &Envelope) -> KekLabel {
24    KekLabel {
25        epoch: envelope.epoch.number,
26        key_id: envelope.epoch.key_id,
27    }
28}
29
30impl EnvelopeArchiveKeys {
31    pub fn new(store: &Arc<SqliteStore>, device: Option<DeviceKeys>) -> Self {
32        Self {
33            store: Arc::downgrade(store),
34            device,
35            derived: Mutex::new(HashMap::new()),
36        }
37    }
38
39    /// This device's envelopes of any identity: wrapped to its own
40    /// recipient, since an envelope for the same machine id under another
41    /// device key won't open.
42    fn envelopes(&self) -> Result<Option<(Arc<SqliteStore>, Vec<Envelope>)>> {
43        let (Some(store), Some(device)) = (self.store.upgrade(), &self.device) else {
44            return Ok(None);
45        };
46        let recipient = device.age_recipient().to_string();
47        let mut envelopes = store.envelopes_for_machine(store.machine_id())?;
48        envelopes.retain(|e| e.recipient == recipient);
49        Ok(Some((store, envelopes)))
50    }
51
52    fn cached(&self, label: &KekLabel) -> Option<Zeroizing<[u8; 32]>> {
53        self.derived
54            .lock()
55            .unwrap_or_else(PoisonError::into_inner)
56            .get(label)
57            .cloned()
58    }
59
60    fn derive(&self, envelope: &Envelope) -> Result<Option<Zeroizing<[u8; 32]>>> {
61        let Some(device) = &self.device else {
62            return Ok(None);
63        };
64        let label = label_of(envelope);
65        let mut derived = self.derived.lock().unwrap_or_else(PoisonError::into_inner);
66        if let Some(key) = derived.get(&label) {
67            return Ok(Some(key.clone()));
68        }
69        let identity = envelope.open(device.age_identity())?;
70        let subkey = derive_subkey(&identity, &envelope.epoch, Subkey::ArchiveKek)?;
71        let key = Zeroizing::new(*subkey.expose());
72        derived.insert(label, key.clone());
73        Ok(Some(key))
74    }
75}
76
77impl ArchiveKeys for EnvelopeArchiveKeys {
78    fn current(&self) -> Result<Option<Kek>> {
79        let (Some(store), Some(device)) = (self.store.upgrade(), &self.device) else {
80            return Ok(None);
81        };
82        let recipient = device.age_recipient().to_string();
83        let Some((_, envelopes)) = store.own_identity_envelopes(&recipient)? else {
84            return Ok(None);
85        };
86        let mut sealable: Vec<Envelope> = envelopes
87            .into_iter()
88            .filter(|e| e.epoch.number > 0)
89            .collect();
90        while let Some(epoch) = newest_epoch(sealable.iter().map(|e| &e.epoch)) {
91            let at = sealable
92                .iter()
93                .position(|e| e.epoch == epoch)
94                .expect("newest_epoch picks from the list");
95            let envelope = sealable.swap_remove(at);
96            match self.derive(&envelope) {
97                Ok(key) => {
98                    return Ok(key.map(|key| Kek {
99                        label: label_of(&envelope),
100                        key,
101                    }));
102                }
103                Err(e) => {
104                    tracing::warn!("skipping an envelope this device cannot open: {e:#}")
105                }
106            }
107        }
108        Ok(None)
109    }
110
111    /// Answers from the cache when it can. A miss reads the store, which on
112    /// an in-memory store waits on the writer, so a miss there inside a
113    /// write transaction would wait on itself; daemon stores are file-backed.
114    fn by_label(&self, label: &KekLabel) -> Result<Option<Zeroizing<[u8; 32]>>> {
115        if let Some(key) = self.cached(label) {
116            return Ok(Some(key));
117        }
118        let Some((_, envelopes)) = self.envelopes()? else {
119            return Ok(None);
120        };
121        match envelopes.iter().find(|e| label_of(e) == *label) {
122            Some(envelope) => self.derive(envelope),
123            None => Ok(None),
124        }
125    }
126}
127
128#[cfg(test)]
129mod tests {
130    use super::*;
131    use crate::keys::{DeviceRecord, IdentityKey, IdentityTag, KeyGuard, wrap};
132
133    fn store() -> Arc<SqliteStore> {
134        Arc::new(SqliteStore::in_memory("local".to_string()).unwrap())
135    }
136
137    fn identity(byte: u8) -> IdentityKey {
138        IdentityKey::from_bytes(KeyGuard::new([byte; 32]))
139    }
140
141    fn tag() -> IdentityTag {
142        IdentityTag::migrated(&identity(9).key_id())
143    }
144
145    fn own_record(store: &SqliteStore, device: &DeviceKeys, tag: &IdentityTag) {
146        let record = DeviceRecord {
147            machine_id: "local".into(),
148            identity_tag: tag.as_str().to_string(),
149            version: 1,
150            name: "local".into(),
151            age_recipient: device.age_recipient().to_string(),
152            ssh_public_key: device.ssh_public_key(),
153            signing_public_key: device.verifying_key().to_bytes(),
154            recovery_fingerprints: Vec::new(),
155            ssh_login: None,
156            ssh_port: None,
157            ssh_host_key: None,
158        };
159        store
160            .insert_first_device_record(
161                &record.sign("local", device.signing_key()),
162                "local",
163                &device.verifying_key(),
164            )
165            .unwrap();
166    }
167
168    fn give(store: &SqliteStore, device: &DeviceKeys, key: &IdentityKey, epoch: u32) {
169        give_as(store, device, key, epoch, &tag());
170    }
171
172    fn give_as(
173        store: &SqliteStore,
174        device: &DeviceKeys,
175        key: &IdentityKey,
176        epoch: u32,
177        tag: &IdentityTag,
178    ) {
179        let envelope = wrap(
180            key,
181            epoch,
182            tag,
183            &device.age_recipient(),
184            Some("local".into()),
185        )
186        .unwrap();
187        store.put_envelope(&envelope).unwrap();
188    }
189
190    fn expected(key: &IdentityKey, epoch: u32) -> [u8; 32] {
191        let epoch = crate::keys::Epoch {
192            number: epoch,
193            key_id: key.key_id(),
194        };
195        *derive_subkey(key, &epoch, Subkey::ArchiveKek)
196            .unwrap()
197            .expose()
198    }
199
200    #[test]
201    fn segments_seal_under_the_newest_epoch_and_older_ones_still_open() {
202        let s = store();
203        let device = DeviceKeys::generate().unwrap();
204        let (one, two) = (identity(1), identity(2));
205        give(&s, &device, &one, 1);
206        give(&s, &device, &two, 2);
207        own_record(&s, &device, &tag());
208        let keys = EnvelopeArchiveKeys::new(&s, Some(device));
209
210        let current = keys.current().unwrap().unwrap();
211        assert_eq!(current.label.epoch, 2);
212        assert_eq!(current.label.key_id, two.key_id());
213        assert_eq!(*current.key, expected(&two, 2));
214        let older = KekLabel {
215            epoch: 1,
216            key_id: one.key_id(),
217        };
218        assert_eq!(*keys.by_label(&older).unwrap().unwrap(), expected(&one, 1));
219    }
220
221    #[test]
222    fn an_envelope_wrapped_to_another_device_key_is_not_used() {
223        let s = store();
224        let device = DeviceKeys::generate().unwrap();
225        let other = DeviceKeys::generate().unwrap();
226        let (mine, theirs) = (identity(1), identity(3));
227        give(&s, &device, &mine, 1);
228        give(&s, &other, &theirs, 3);
229        own_record(&s, &device, &tag());
230        let keys = EnvelopeArchiveKeys::new(&s, Some(device));
231
232        let current = keys.current().unwrap().unwrap();
233        assert_eq!(current.label.epoch, 1);
234        let label = KekLabel {
235            epoch: 3,
236            key_id: theirs.key_id(),
237        };
238        assert!(keys.by_label(&label).unwrap().is_none());
239    }
240
241    #[test]
242    fn epoch_zero_never_seals() {
243        let s = store();
244        let device = DeviceKeys::generate().unwrap();
245        give(&s, &device, &identity(1), 0);
246        own_record(&s, &device, &tag());
247        let keys = EnvelopeArchiveKeys::new(&s, Some(device));
248        assert!(keys.current().unwrap().is_none());
249    }
250
251    #[test]
252    fn without_an_envelope_or_device_keys_nothing_seals() {
253        let s = store();
254        assert!(
255            EnvelopeArchiveKeys::new(&s, Some(DeviceKeys::generate().unwrap()))
256                .current()
257                .unwrap()
258                .is_none()
259        );
260        let device = DeviceKeys::generate().unwrap();
261        give(&s, &device, &identity(1), 1);
262        let keys = EnvelopeArchiveKeys::new(&s, None);
263        assert!(keys.current().unwrap().is_none());
264        let label = KekLabel {
265            epoch: 1,
266            key_id: identity(1).key_id(),
267        };
268        assert!(keys.by_label(&label).unwrap().is_none());
269    }
270
271    #[test]
272    fn an_epoch_this_device_holds_no_envelope_for_is_absent() {
273        let s = store();
274        let device = DeviceKeys::generate().unwrap();
275        give(&s, &device, &identity(1), 1);
276        own_record(&s, &device, &tag());
277        let keys = EnvelopeArchiveKeys::new(&s, Some(device));
278        let label = KekLabel {
279            epoch: 5,
280            key_id: identity(5).key_id(),
281        };
282        assert!(keys.by_label(&label).unwrap().is_none());
283    }
284
285    #[test]
286    fn equal_epoch_numbers_seal_under_the_lower_key_id_like_sync() {
287        let s = store();
288        let device = DeviceKeys::generate().unwrap();
289        let (a, b) = (identity(4), identity(5));
290        give(&s, &device, &a, 2);
291        give(&s, &device, &b, 2);
292        own_record(&s, &device, &tag());
293        let lower = a.key_id().min(b.key_id());
294        let keys = EnvelopeArchiveKeys::new(&s, Some(device));
295        assert_eq!(keys.current().unwrap().unwrap().label.key_id, lower);
296    }
297
298    #[test]
299    fn only_the_identity_of_this_devices_record_seals_but_others_still_open() {
300        let s = store();
301        let dir = tempfile::tempdir().unwrap();
302        let key_file = dir.path().join(crate::keys::DEVICE_KEY_FILE);
303        let (device, _) = DeviceKeys::load_or_create(&key_file).unwrap();
304        let (mine, earlier) = (identity(1), identity(6));
305        let other = IdentityTag::migrated(&identity(7).key_id());
306        give(&s, &device, &mine, 1);
307        give_as(&s, &device, &earlier, 3, &other);
308        let keys = EnvelopeArchiveKeys::new(&s, DeviceKeys::load(&key_file).unwrap());
309        assert!(keys.current().unwrap().is_none());
310
311        own_record(&s, &device, &tag());
312        let current = keys.current().unwrap().unwrap();
313        assert_eq!(current.label.epoch, 1);
314        let label = KekLabel {
315            epoch: 3,
316            key_id: earlier.key_id(),
317        };
318        assert_eq!(
319            *keys.by_label(&label).unwrap().unwrap(),
320            expected(&earlier, 3)
321        );
322    }
323
324    #[test]
325    fn an_envelope_that_will_not_open_is_skipped_like_sync() {
326        let s = store();
327        let device = DeviceKeys::generate().unwrap();
328        give(&s, &device, &identity(1), 1);
329        let mut broken = wrap(
330            &identity(2),
331            2,
332            &tag(),
333            &device.age_recipient(),
334            Some("local".into()),
335        )
336        .unwrap();
337        broken.ciphertext = vec![0; 64];
338        s.put_envelope(&broken).unwrap();
339        own_record(&s, &device, &tag());
340        let keys = EnvelopeArchiveKeys::new(&s, Some(device));
341        assert_eq!(keys.current().unwrap().unwrap().label.epoch, 1);
342    }
343}