Skip to main content

second_brain_core/keys/
tables.rs

1use anyhow::{Context, Result, bail, ensure};
2use ed25519_dalek::VerifyingKey;
3use rusqlite::{Connection, OptionalExtension, Row, params};
4
5use super::hex;
6use super::identity::{Envelope, Epoch, IdentityTag, KeyId};
7use super::record::{SignedRecord, check_update};
8use crate::sqlite_store::SqliteStore;
9
10#[derive(Debug, Clone, PartialEq, Eq)]
11pub struct StoredEpoch {
12    pub identity_tag: IdentityTag,
13    pub epoch: Epoch,
14    pub cause: Option<String>,
15    pub created_at: i64,
16}
17
18#[derive(Debug, Clone)]
19pub struct StoredDeviceRecord {
20    pub first: SignedRecord,
21    pub current: SignedRecord,
22    pub revoked: bool,
23}
24
25impl SqliteStore {
26    /// Records an epoch once, filling in its cause if a later call brings
27    /// one; returns false when the epoch was already known.
28    pub fn put_key_epoch(
29        &self,
30        tag: &IdentityTag,
31        epoch: &Epoch,
32        cause: Option<&str>,
33        created_at: i64,
34    ) -> Result<bool> {
35        let key_id = epoch.key_id.to_string();
36        self.with_txn(|tx| {
37            let inserted = tx.execute(
38                "INSERT OR IGNORE INTO key_epochs (identity_tag, epoch, key_id, cause, created_at) \
39                 VALUES (?1, ?2, ?3, ?4, ?5)",
40                params![tag.as_str(), epoch.number, key_id, cause, created_at],
41            )?;
42            if inserted == 0 && cause.is_some() {
43                tx.execute(
44                    "UPDATE key_epochs SET cause = ?4 WHERE identity_tag = ?1 AND epoch = ?2 \
45                     AND key_id = ?3 AND cause IS NULL",
46                    params![tag.as_str(), epoch.number, key_id, cause],
47                )?;
48            }
49            Ok(inserted > 0)
50        })
51    }
52
53    pub fn key_epochs(&self, tag: &IdentityTag) -> Result<Vec<StoredEpoch>> {
54        let conn = self.reader();
55        let mut stmt = conn.prepare(
56            "SELECT identity_tag, epoch, key_id, cause, created_at FROM key_epochs \
57             WHERE identity_tag = ?1 ORDER BY epoch, key_id",
58        )?;
59        let rows = stmt.query_map(params![tag.as_str()], |r| {
60            Ok((
61                r.get::<_, String>(0)?,
62                r.get::<_, u32>(1)?,
63                r.get::<_, String>(2)?,
64                r.get::<_, Option<String>>(3)?,
65                r.get::<_, i64>(4)?,
66            ))
67        })?;
68        rows.map(|row| {
69            let (tag, number, key_id, cause, created_at) = row?;
70            Ok(StoredEpoch {
71                identity_tag: IdentityTag::from(tag),
72                epoch: Epoch {
73                    number,
74                    key_id: parse_key_id(&key_id)?,
75                },
76                cause,
77                created_at,
78            })
79        })
80        .collect()
81    }
82
83    /// Keeps the first envelope stored for an epoch and recipient; age output
84    /// is randomized, so a second wrap of the same key is a different blob
85    /// carrying nothing new. Returns false when one was already stored.
86    pub fn put_envelope(&self, envelope: &Envelope) -> Result<bool> {
87        let inserted = self.conn().execute(
88            "INSERT OR IGNORE INTO key_envelopes \
89             (identity_tag, epoch, key_id, recipient, machine_id, envelope) \
90             VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
91            params![
92                envelope.identity_tag.as_str(),
93                envelope.epoch.number,
94                envelope.epoch.key_id.to_string(),
95                envelope.recipient,
96                envelope.machine_id,
97                envelope.ciphertext,
98            ],
99        )?;
100        Ok(inserted > 0)
101    }
102
103    pub fn envelope(
104        &self,
105        tag: &IdentityTag,
106        epoch: &Epoch,
107        recipient: &str,
108    ) -> Result<Option<Envelope>> {
109        let conn = self.reader();
110        let row = conn
111            .query_row(
112                &format!(
113                    "SELECT {ENVELOPE_COLUMNS} FROM key_envelopes \
114                     WHERE identity_tag = ?1 AND epoch = ?2 AND key_id = ?3 AND recipient = ?4"
115                ),
116                params![
117                    tag.as_str(),
118                    epoch.number,
119                    epoch.key_id.to_string(),
120                    recipient
121                ],
122                envelope_row,
123            )
124            .optional()?;
125        row.map(EnvelopeRow::into_envelope).transpose()
126    }
127
128    pub fn envelopes_for_epoch(&self, tag: &IdentityTag, epoch: &Epoch) -> Result<Vec<Envelope>> {
129        let conn = self.reader();
130        query_envelopes(
131            &conn,
132            "identity_tag = ?1 AND epoch = ?2 AND key_id = ?3",
133            params![tag.as_str(), epoch.number, epoch.key_id.to_string()],
134        )
135    }
136
137    pub fn envelopes_for_machine(&self, machine_id: &str) -> Result<Vec<Envelope>> {
138        let conn = self.reader();
139        query_envelopes(&conn, "machine_id = ?1", params![machine_id])
140    }
141
142    /// Stores a device's first record after checking it is signed by
143    /// `signer` under `signer_key`. Which signer may introduce a device
144    /// (the founder, a pairing device, a migration self-signature) is the
145    /// caller's rule. Only that verified signature is stored, and the same
146    /// first record arriving under another signer gains its signature.
147    /// Returns false when nothing new was stored.
148    pub fn insert_first_device_record(
149        &self,
150        signed: &SignedRecord,
151        signer: &str,
152        signer_key: &VerifyingKey,
153    ) -> Result<bool> {
154        signed.verify_by(signer, signer_key)?;
155        let verified = signed_only_by(signed, signer)?;
156        self.with_txn(|tx| {
157            let machine_id = &signed.record.machine_id;
158            let Some(stored) = stored_record(tx, machine_id)? else {
159                write_record(tx, &verified, Some(&verified))?;
160                return Ok(true);
161            };
162            ensure!(
163                stored.first.record == signed.record,
164                "device {machine_id} already has a different first record"
165            );
166            if stored.first.signatures.iter().any(|s| s.signer == signer) {
167                return Ok(false);
168            }
169            let mut first = stored.first.clone();
170            first.signatures.extend(verified.signatures);
171            let current = if stored.current.record == stored.first.record {
172                &first
173            } else {
174                &stored.current
175            };
176            write_record(tx, current, Some(&first))?;
177            Ok(true)
178        })
179    }
180
181    /// Replaces a device's current record with a later version it signed
182    /// itself under its current key, keeping only that signature. Returns
183    /// false when that version is already stored unchanged.
184    pub fn update_device_record(&self, signed: &SignedRecord) -> Result<bool> {
185        self.with_txn(|tx| {
186            let machine_id = &signed.record.machine_id;
187            let Some(stored) = stored_record(tx, machine_id)? else {
188                bail!("device {machine_id} has no first record");
189            };
190            if stored.current.record == signed.record {
191                return Ok(false);
192            }
193            check_update(&stored.current, signed)?;
194            write_record(tx, &signed_only_by(signed, machine_id)?, None)?;
195            Ok(true)
196        })
197    }
198
199    /// Stores a first record that moves a device into another identity,
200    /// after checking it is signed by `signer` under `signer_key`. The row
201    /// held for that machine id under its earlier identity is replaced, and
202    /// its revoked flag cleared, since revocations apply per identity; the
203    /// caller reapplies the new identity's revocations. A machine with no
204    /// row gets this one as its first. Returns false when the record is
205    /// already the stored first record.
206    pub fn replace_device_record_for_new_identity(
207        &self,
208        signed: &SignedRecord,
209        signer: &str,
210        signer_key: &VerifyingKey,
211    ) -> Result<bool> {
212        signed.verify_by(signer, signer_key)?;
213        let verified = signed_only_by(signed, signer)?;
214        self.with_txn(|tx| {
215            let machine_id = &signed.record.machine_id;
216            let Some(stored) = stored_record(tx, machine_id)? else {
217                write_record(tx, &verified, Some(&verified))?;
218                return Ok(true);
219            };
220            if stored.first.record == signed.record {
221                return Ok(false);
222            }
223            ensure!(
224                stored.current.record.identity_tag != signed.record.identity_tag,
225                "device {machine_id} already belongs to identity {}; within one identity a \
226                 device with new keys needs a fresh machine id",
227                signed.record.identity_tag
228            );
229            tx.execute(
230                "UPDATE machines SET revoked = 0 WHERE id = ?1",
231                params![machine_id],
232            )?;
233            write_record(tx, &verified, Some(&verified))?;
234            Ok(true)
235        })
236    }
237
238    pub fn device_record(&self, machine_id: &str) -> Result<Option<StoredDeviceRecord>> {
239        stored_record(&self.reader(), machine_id)
240    }
241
242    pub fn device_records(&self) -> Result<Vec<StoredDeviceRecord>> {
243        let conn = self.reader();
244        let mut stmt = conn.prepare(
245            "SELECT first_record, record, revoked FROM machines \
246             WHERE record IS NOT NULL ORDER BY id",
247        )?;
248        let rows = stmt.query_map([], record_columns)?;
249        rows.map(|row| parse_stored(row?)).collect()
250    }
251}
252
253const ENVELOPE_COLUMNS: &str = "identity_tag, epoch, key_id, recipient, machine_id, envelope";
254
255struct EnvelopeRow {
256    tag: String,
257    number: u32,
258    key_id: String,
259    recipient: String,
260    machine_id: Option<String>,
261    ciphertext: Vec<u8>,
262}
263
264impl EnvelopeRow {
265    fn into_envelope(self) -> Result<Envelope> {
266        Ok(Envelope {
267            identity_tag: IdentityTag::from(self.tag),
268            epoch: Epoch {
269                number: self.number,
270                key_id: parse_key_id(&self.key_id)?,
271            },
272            recipient: self.recipient,
273            machine_id: self.machine_id,
274            ciphertext: self.ciphertext,
275        })
276    }
277}
278
279fn envelope_row(r: &Row<'_>) -> rusqlite::Result<EnvelopeRow> {
280    Ok(EnvelopeRow {
281        tag: r.get(0)?,
282        number: r.get(1)?,
283        key_id: r.get(2)?,
284        recipient: r.get(3)?,
285        machine_id: r.get(4)?,
286        ciphertext: r.get(5)?,
287    })
288}
289
290pub(super) fn query_envelopes(
291    conn: &Connection,
292    filter: &str,
293    args: impl rusqlite::Params,
294) -> Result<Vec<Envelope>> {
295    let mut stmt = conn.prepare(&format!(
296        "SELECT {ENVELOPE_COLUMNS} FROM key_envelopes WHERE {filter} \
297         ORDER BY identity_tag, epoch, key_id, recipient"
298    ))?;
299    let rows = stmt.query_map(args, envelope_row)?;
300    rows.map(|row| row?.into_envelope()).collect()
301}
302
303type RecordColumns = (Option<String>, Option<String>, bool);
304
305fn record_columns(r: &Row<'_>) -> rusqlite::Result<RecordColumns> {
306    Ok((r.get(0)?, r.get(1)?, r.get(2)?))
307}
308
309/// The identity `machine_id`'s current record names, read on `conn` so a
310/// writer transaction sees its own changes.
311pub(crate) fn identity_tag_of(conn: &Connection, machine_id: &str) -> Result<Option<String>> {
312    Ok(stored_record(conn, machine_id)?.map(|row| row.current.record.identity_tag))
313}
314
315fn stored_record(conn: &Connection, machine_id: &str) -> Result<Option<StoredDeviceRecord>> {
316    let row = conn
317        .query_row(
318            "SELECT first_record, record, revoked FROM machines \
319             WHERE id = ?1 AND record IS NOT NULL",
320            params![machine_id],
321            record_columns,
322        )
323        .optional()?;
324    row.map(parse_stored).transpose()
325}
326
327fn parse_stored((first, current, revoked): RecordColumns) -> Result<StoredDeviceRecord> {
328    let first = first.context("machine row has a record but no first record")?;
329    let current = current.context("machine row has no record")?;
330    Ok(StoredDeviceRecord {
331        first: SignedRecord::from_json(&first)?,
332        current: SignedRecord::from_json(&current)?,
333        revoked,
334    })
335}
336
337fn write_record(
338    conn: &Connection,
339    current: &SignedRecord,
340    first: Option<&SignedRecord>,
341) -> Result<()> {
342    let record = &current.record;
343    let first_json = first.map(SignedRecord::to_json).transpose()?;
344    let version = i64::try_from(record.version).context("record version out of range")?;
345    conn.execute(
346        "INSERT INTO machines (id, name, age_pubkey, ssh_pubkey, signing_pubkey, identity_tag, \
347         record_version, first_record, record) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9) \
348         ON CONFLICT(id) DO UPDATE SET name = excluded.name, age_pubkey = excluded.age_pubkey, \
349         ssh_pubkey = excluded.ssh_pubkey, signing_pubkey = excluded.signing_pubkey, \
350         identity_tag = excluded.identity_tag, record_version = excluded.record_version, \
351         first_record = COALESCE(excluded.first_record, machines.first_record), \
352         record = excluded.record",
353        params![
354            record.machine_id,
355            record.name,
356            record.age_recipient,
357            record.ssh_public_key,
358            hex(&record.signing_public_key),
359            record.identity_tag,
360            version,
361            first_json,
362            current.to_json()?,
363        ],
364    )?;
365    Ok(())
366}
367
368fn signed_only_by(signed: &SignedRecord, signer: &str) -> Result<SignedRecord> {
369    let signature = signed
370        .signatures
371        .iter()
372        .find(|s| s.signer == signer)
373        .with_context(|| format!("device record has no signature by {signer}"))?;
374    Ok(SignedRecord {
375        record: signed.record.clone(),
376        signatures: vec![signature.clone()],
377    })
378}
379
380fn parse_key_id(text: &str) -> Result<KeyId> {
381    text.parse()
382        .with_context(|| format!("stored key id {text:?} is not 16 hex digits"))
383}
384
385#[cfg(test)]
386mod tests {
387    use ed25519_dalek::SigningKey;
388
389    use super::*;
390    use crate::keys::device::DeviceKeys;
391    use crate::keys::identity::{IdentityKey, wrap};
392    use crate::keys::record::{DeviceRecord, RecordSignature};
393
394    fn store() -> SqliteStore {
395        SqliteStore::in_memory("local".to_string()).unwrap()
396    }
397
398    fn record(machine_id: &str, version: u64, key: &SigningKey) -> DeviceRecord {
399        DeviceRecord {
400            machine_id: machine_id.to_string(),
401            identity_tag: "f-tag".to_string(),
402            version,
403            name: format!("{machine_id}-v{version}"),
404            age_recipient: "age1recipient".to_string(),
405            ssh_public_key: "ssh-ed25519 AAAA".to_string(),
406            signing_public_key: key.verifying_key().to_bytes(),
407            recovery_fingerprints: Vec::new(),
408            ssh_login: None,
409            ssh_port: None,
410            ssh_host_key: None,
411        }
412    }
413
414    #[test]
415    fn envelopes_round_trip_and_open_for_their_device() {
416        let store = store();
417        let device = DeviceKeys::generate().unwrap();
418        let key = IdentityKey::generate().unwrap();
419        let tag = IdentityTag::migrated(&key.key_id());
420        let envelope = wrap(
421            &key,
422            1,
423            &tag,
424            &device.age_recipient(),
425            Some("dev-a".to_string()),
426        )
427        .unwrap();
428        let epoch = envelope.epoch.clone();
429
430        assert!(store.put_key_epoch(&tag, &epoch, None, 7).unwrap());
431        assert!(!store.put_key_epoch(&tag, &epoch, None, 8).unwrap());
432        assert!(store.put_envelope(&envelope).unwrap());
433        assert!(!store.put_envelope(&envelope).unwrap());
434
435        let epochs = store.key_epochs(&tag).unwrap();
436        assert_eq!(epochs.len(), 1);
437        assert_eq!(epochs[0].epoch, epoch);
438        assert_eq!(epochs[0].created_at, 7);
439
440        let loaded = store
441            .envelope(&tag, &epoch, &envelope.recipient)
442            .unwrap()
443            .unwrap();
444        assert_eq!(loaded.machine_id.as_deref(), Some("dev-a"));
445        let opened = loaded.open(device.age_identity()).unwrap();
446        assert_eq!(opened.expose(), key.expose());
447
448        assert_eq!(store.envelopes_for_machine("dev-a").unwrap().len(), 1);
449        assert_eq!(store.envelopes_for_epoch(&tag, &epoch).unwrap().len(), 1);
450        assert!(store.envelopes_for_machine("dev-b").unwrap().is_empty());
451    }
452
453    #[test]
454    fn an_epoch_cause_arriving_later_is_kept() {
455        let store = store();
456        let key = IdentityKey::generate().unwrap();
457        let tag = IdentityTag::migrated(&key.key_id());
458        let epoch = Epoch {
459            number: 2,
460            key_id: key.key_id(),
461        };
462        assert!(store.put_key_epoch(&tag, &epoch, None, 1).unwrap());
463        assert!(!store.put_key_epoch(&tag, &epoch, Some("set"), 2).unwrap());
464        assert!(!store.put_key_epoch(&tag, &epoch, None, 3).unwrap());
465        let stored = store.key_epochs(&tag).unwrap();
466        assert_eq!(stored[0].cause.as_deref(), Some("set"));
467        assert_eq!(stored[0].created_at, 1);
468    }
469
470    fn tagged(machine_id: &str, tag: &str, key: &SigningKey) -> DeviceRecord {
471        DeviceRecord {
472            identity_tag: tag.to_string(),
473            ..record(machine_id, 1, key)
474        }
475    }
476
477    #[test]
478    fn a_device_moving_to_another_identity_replaces_its_row_and_revocation() {
479        let store = store();
480        let device = SigningKey::from_bytes(&[1; 32]);
481        let old_pairer = SigningKey::from_bytes(&[2; 32]);
482        let new_pairer = SigningKey::from_bytes(&[3; 32]);
483        let old = tagged("dev-b", "f-old", &device).sign("dev-a", &old_pairer);
484        store
485            .insert_first_device_record(&old, "dev-a", &old_pairer.verifying_key())
486            .unwrap();
487        store
488            .conn()
489            .execute("UPDATE machines SET revoked = 1 WHERE id = 'dev-b'", [])
490            .unwrap();
491
492        let moved = tagged("dev-b", "f-new", &device).sign("dev-c", &new_pairer);
493        assert!(
494            store
495                .insert_first_device_record(&moved, "dev-c", &new_pairer.verifying_key())
496                .is_err(),
497            "the plain insert must keep refusing a different first record"
498        );
499        assert!(
500            store
501                .replace_device_record_for_new_identity(
502                    &moved,
503                    "dev-c",
504                    &old_pairer.verifying_key()
505                )
506                .is_err(),
507            "a signature that does not verify must be refused"
508        );
509        assert!(
510            store
511                .replace_device_record_for_new_identity(
512                    &moved,
513                    "dev-c",
514                    &new_pairer.verifying_key()
515                )
516                .unwrap()
517        );
518        let stored = store.device_record("dev-b").unwrap().unwrap();
519        assert_eq!(stored.first, moved);
520        assert_eq!(stored.current, moved);
521        assert!(!stored.revoked);
522        assert!(
523            !store
524                .replace_device_record_for_new_identity(
525                    &moved,
526                    "dev-c",
527                    &new_pairer.verifying_key()
528                )
529                .unwrap()
530        );
531    }
532
533    #[test]
534    fn a_new_first_record_within_the_same_identity_is_refused() {
535        let store = store();
536        let device = SigningKey::from_bytes(&[1; 32]);
537        let rekeyed = SigningKey::from_bytes(&[4; 32]);
538        let pairer = SigningKey::from_bytes(&[2; 32]);
539        let first = tagged("dev-b", "f-tag", &device).sign("dev-a", &pairer);
540        store
541            .insert_first_device_record(&first, "dev-a", &pairer.verifying_key())
542            .unwrap();
543        let other = tagged("dev-b", "f-tag", &rekeyed).sign("dev-a", &pairer);
544        let err = store
545            .replace_device_record_for_new_identity(&other, "dev-a", &pairer.verifying_key())
546            .unwrap_err();
547        assert!(format!("{err:#}").contains("fresh machine id"), "{err:#}");
548        assert_eq!(store.device_record("dev-b").unwrap().unwrap().first, first);
549    }
550
551    #[test]
552    fn a_machine_without_a_row_takes_the_new_identity_record_as_its_first() {
553        let store = store();
554        let device = SigningKey::from_bytes(&[1; 32]);
555        let pairer = SigningKey::from_bytes(&[2; 32]);
556        let first = tagged("dev-b", "f-new", &device).sign("dev-a", &pairer);
557        assert!(
558            store
559                .replace_device_record_for_new_identity(&first, "dev-a", &pairer.verifying_key())
560                .unwrap()
561        );
562        assert_eq!(store.device_record("dev-b").unwrap().unwrap().first, first);
563    }
564
565    #[test]
566    fn a_verified_countersignature_merges_into_the_first_record() {
567        let store = store();
568        let device = SigningKey::from_bytes(&[1; 32]);
569        let introducer = SigningKey::from_bytes(&[2; 32]);
570        let witness = SigningKey::from_bytes(&[3; 32]);
571        let first = record("dev-b", 1, &device).sign("dev-a", &introducer);
572        store
573            .insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
574            .unwrap();
575
576        let mut countersigned = first.clone();
577        countersigned.countersign("dev-c", &witness);
578        assert!(
579            store
580                .insert_first_device_record(&countersigned, "dev-c", &introducer.verifying_key())
581                .is_err()
582        );
583        assert!(
584            store
585                .insert_first_device_record(&countersigned, "dev-c", &witness.verifying_key())
586                .unwrap()
587        );
588        assert!(
589            !store
590                .insert_first_device_record(&countersigned, "dev-c", &witness.verifying_key())
591                .unwrap()
592        );
593        assert!(
594            !store
595                .insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
596                .unwrap()
597        );
598
599        let stored = store.device_record("dev-b").unwrap().unwrap();
600        stored
601            .first
602            .verify_by("dev-a", &introducer.verifying_key())
603            .unwrap();
604        stored
605            .first
606            .verify_by("dev-c", &witness.verifying_key())
607            .unwrap();
608        assert_eq!(stored.current, stored.first);
609    }
610
611    #[test]
612    fn a_first_record_must_verify_under_its_introducer() {
613        let store = store();
614        let device = SigningKey::from_bytes(&[1; 32]);
615        let introducer = SigningKey::from_bytes(&[2; 32]);
616        let signed = record("dev-b", 1, &device).sign("dev-a", &introducer);
617
618        let wrong = SigningKey::from_bytes(&[3; 32]);
619        assert!(
620            store
621                .insert_first_device_record(&signed, "dev-a", &wrong.verifying_key())
622                .is_err()
623        );
624        assert!(store.device_record("dev-b").unwrap().is_none());
625
626        assert!(
627            store
628                .insert_first_device_record(&signed, "dev-a", &introducer.verifying_key())
629                .unwrap()
630        );
631        assert!(
632            !store
633                .insert_first_device_record(&signed, "dev-a", &introducer.verifying_key())
634                .unwrap()
635        );
636        let other = record("dev-b", 2, &device).sign("dev-a", &introducer);
637        assert!(
638            store
639                .insert_first_device_record(&other, "dev-a", &introducer.verifying_key())
640                .is_err()
641        );
642    }
643
644    #[test]
645    fn updates_follow_the_devices_own_signature_and_keep_the_first_record() {
646        let store = store();
647        let device = SigningKey::from_bytes(&[1; 32]);
648        let introducer = SigningKey::from_bytes(&[2; 32]);
649        let first = record("dev-b", 1, &device).sign("dev-a", &introducer);
650        store
651            .insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
652            .unwrap();
653
654        let forged = record("dev-b", 2, &device).sign("dev-b", &introducer);
655        assert!(store.update_device_record(&forged).is_err());
656
657        let update = record("dev-b", 2, &device).sign("dev-b", &device);
658        assert!(store.update_device_record(&update).unwrap());
659        assert!(!store.update_device_record(&update).unwrap());
660        assert!(store.update_device_record(&first).is_err());
661
662        let stored = store.device_record("dev-b").unwrap().unwrap();
663        assert_eq!(stored.first.record, first.record);
664        assert_eq!(stored.current.record, update.record);
665        assert!(!stored.revoked);
666        stored.current.verify_self().unwrap();
667
668        assert!(
669            store
670                .update_device_record(&record("dev-c", 1, &device).sign("dev-c", &device))
671                .is_err()
672        );
673        assert_eq!(store.device_records().unwrap().len(), 1);
674    }
675
676    #[test]
677    fn only_verified_signatures_are_stored() {
678        let store = store();
679        let device = SigningKey::from_bytes(&[1; 32]);
680        let introducer = SigningKey::from_bytes(&[2; 32]);
681        let mut first = record("dev-b", 1, &device).sign("dev-a", &introducer);
682        first.signatures.push(RecordSignature {
683            signer: "dev-c".to_string(),
684            signature: [9; 64],
685        });
686        store
687            .insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
688            .unwrap();
689        let stored = store.device_record("dev-b").unwrap().unwrap();
690        let signers = |s: &SignedRecord| -> Vec<String> {
691            s.signatures.iter().map(|s| s.signer.clone()).collect()
692        };
693        assert_eq!(signers(&stored.first), ["dev-a"]);
694
695        let witness = SigningKey::from_bytes(&[3; 32]);
696        let mut countersigned = first.clone();
697        countersigned.signatures.retain(|s| s.signer != "dev-c");
698        countersigned.countersign("dev-c", &witness);
699        assert!(
700            store
701                .insert_first_device_record(&countersigned, "dev-c", &witness.verifying_key())
702                .unwrap()
703        );
704
705        let mut update = record("dev-b", 2, &device).sign("dev-b", &device);
706        update.signatures.push(RecordSignature {
707            signer: "dev-x".to_string(),
708            signature: [7; 64],
709        });
710        assert!(store.update_device_record(&update).unwrap());
711        let stored = store.device_record("dev-b").unwrap().unwrap();
712        assert_eq!(signers(&stored.current), ["dev-b"]);
713        assert_eq!(signers(&stored.first), ["dev-a", "dev-c"]);
714    }
715
716    #[test]
717    fn a_tampered_stored_record_fails_verification() {
718        let store = store();
719        let device = SigningKey::from_bytes(&[1; 32]);
720        let first = record("dev-b", 1, &device).sign("dev-b", &device);
721        store
722            .insert_first_device_record(&first, "dev-b", &device.verifying_key())
723            .unwrap();
724        let json = first.to_json().unwrap().replace("dev-b-v1", "dev-b-v9");
725        store
726            .conn()
727            .execute(
728                "UPDATE machines SET record = ?1 WHERE id = 'dev-b'",
729                params![json],
730            )
731            .unwrap();
732        let stored = store.device_record("dev-b").unwrap().unwrap();
733        assert!(stored.current.verify_self().is_err());
734    }
735}