second_brain_core/keys/
founding.rs1use age::x25519::Recipient;
2use anyhow::{Result, ensure};
3
4use super::{
5 DeviceKeys, DeviceRecord, Epoch, IdentityKey, IdentityTag, recovery_fingerprint, wrap,
6};
7use crate::sqlite_store::SqliteStore;
8
9#[non_exhaustive]
10pub struct Founded {
11 pub tag: IdentityTag,
12 pub epoch: Epoch,
13 pub key: IdentityKey,
14}
15
16pub fn found_identity(
25 store: &SqliteStore,
26 device: &DeviceKeys,
27 name: &str,
28 recovery: &[Recipient],
29 now_micros: i64,
30) -> Result<Founded> {
31 let own = store.machine_id().to_string();
32 ensure!(
33 store.device_record(&own)?.is_none(),
34 "device {own} already has a row; a new identity needs a fresh machine id"
35 );
36 let key = IdentityKey::generate()?;
37 let tag = IdentityTag::founded(&key.key_id(), &device.verifying_key());
38 let epoch = Epoch {
39 number: 1,
40 key_id: key.key_id(),
41 };
42 let retired = store.retired_fingerprints()?;
43 let recovery: Vec<&Recipient> = recovery
44 .iter()
45 .filter(|r| !retired.contains(&recovery_fingerprint(&r.to_string())))
46 .collect();
47 let mut envelopes = vec![wrap(
48 &key,
49 1,
50 &tag,
51 &device.age_recipient(),
52 Some(own.clone()),
53 )?];
54 for recipient in &recovery {
55 envelopes.push(wrap(&key, 1, &tag, recipient, None)?);
56 }
57 let row = DeviceRecord {
58 machine_id: own.clone(),
59 identity_tag: tag.as_str().to_string(),
60 version: 1,
61 name: name.to_string(),
62 age_recipient: device.age_recipient().to_string(),
63 ssh_public_key: device.ssh_public_key(),
64 signing_public_key: device.verifying_key().to_bytes(),
65 recovery_fingerprints: recovery
66 .iter()
67 .map(|r| recovery_fingerprint(&r.to_string()))
68 .collect(),
69 ssh_login: None,
70 ssh_port: None,
71 ssh_host_key: None,
72 }
73 .sign(&own, device.signing_key());
74 store.put_keys_durably(&tag, &[epoch], &envelopes, now_micros)?;
75 store.reset_floor_for_new_identity(&tag)?;
76 store.insert_first_device_record(&row, &own, &device.verifying_key())?;
77 Ok(Founded { tag, epoch, key })
78}
79
80#[cfg(test)]
81mod tests {
82 use super::*;
83
84 const NOW: i64 = 1_793_600_000_000_000;
85
86 #[test]
87 fn founding_needs_a_machine_without_a_row() {
88 let store = SqliteStore::in_memory("local".to_string()).unwrap();
89 let device = DeviceKeys::generate().unwrap();
90 let founded = found_identity(&store, &device, "local", &[], NOW).unwrap();
91 assert_eq!(founded.epoch.number, 1);
92 assert_eq!(
93 founded.tag,
94 IdentityTag::founded(&founded.key.key_id(), &device.verifying_key())
95 );
96 assert!(store.key_epochs(&founded.tag).unwrap()[0].cause.is_none());
97 let row = store.device_record("local").unwrap().unwrap();
98 assert_eq!(row.current.record.identity_tag, founded.tag.as_str());
99 let Err(err) = found_identity(&store, &device, "local", &[], NOW) else {
100 panic!("a second founding on one machine id must fail");
101 };
102 assert!(format!("{err:#}").contains("fresh machine id"), "{err:#}");
103 }
104
105 #[test]
106 fn a_founding_cut_short_before_its_row_can_be_retried() {
107 let store = SqliteStore::in_memory("local".to_string()).unwrap();
108 let device = DeviceKeys::generate().unwrap();
109 let orphan = IdentityKey::generate().unwrap();
110 let orphan_tag = IdentityTag::founded(&orphan.key_id(), &device.verifying_key());
111 let envelope = wrap(
112 &orphan,
113 1,
114 &orphan_tag,
115 &device.age_recipient(),
116 Some("local".into()),
117 )
118 .unwrap();
119 store
120 .put_keys_durably(&orphan_tag, &[envelope.epoch], &[envelope], NOW)
121 .unwrap();
122
123 let founded = found_identity(&store, &device, "local", &[], NOW).unwrap();
124 assert_ne!(founded.tag, orphan_tag);
125 let row = store.device_record("local").unwrap().unwrap();
126 assert_eq!(row.current.record.identity_tag, founded.tag.as_str());
127 }
128}