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 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 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 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 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 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
309pub(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(¤t)?,
333 revoked,
334 })
335}
336
337fn write_record(
338 conn: &Connection,
339 current: &SignedRecord,
340 first: Option<&SignedRecord>,
341) -> Result<()> {
342 let record = ¤t.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}