Skip to main content

second_brain_core/keys/
founding.rs

1use 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
16/// Starts a new identity with this device as its only member: epoch 1 of a
17/// fresh identity key, wrapped to this device and to each recovery
18/// recipient, and this device's self-signed row listing their fingerprints.
19/// Floor bookkeeping for devices of any other identity is dropped. The new
20/// identity holds no revocation, so epoch 1 has no cause.
21///
22/// The row is written last, so a founding cut short before it leaves only
23/// an unused epoch and can be retried.
24pub 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}