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
11pub 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 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 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}