use anyhow::{Context, Result, bail, ensure};
use ed25519_dalek::VerifyingKey;
use rusqlite::{Connection, OptionalExtension, Row, params};
use super::hex;
use super::identity::{Envelope, Epoch, IdentityTag, KeyId};
use super::record::{SignedRecord, check_update};
use crate::sqlite_store::SqliteStore;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StoredEpoch {
pub identity_tag: IdentityTag,
pub epoch: Epoch,
pub cause: Option<String>,
pub created_at: i64,
}
#[derive(Debug, Clone)]
pub struct StoredDeviceRecord {
pub first: SignedRecord,
pub current: SignedRecord,
pub revoked: bool,
}
impl SqliteStore {
pub fn put_key_epoch(
&self,
tag: &IdentityTag,
epoch: &Epoch,
cause: Option<&str>,
created_at: i64,
) -> Result<bool> {
let key_id = epoch.key_id.to_string();
self.with_txn(|tx| {
let inserted = tx.execute(
"INSERT OR IGNORE INTO key_epochs (identity_tag, epoch, key_id, cause, created_at) \
VALUES (?1, ?2, ?3, ?4, ?5)",
params![tag.as_str(), epoch.number, key_id, cause, created_at],
)?;
if inserted == 0 && cause.is_some() {
tx.execute(
"UPDATE key_epochs SET cause = ?4 WHERE identity_tag = ?1 AND epoch = ?2 \
AND key_id = ?3 AND cause IS NULL",
params![tag.as_str(), epoch.number, key_id, cause],
)?;
}
Ok(inserted > 0)
})
}
pub fn key_epochs(&self, tag: &IdentityTag) -> Result<Vec<StoredEpoch>> {
let conn = self.reader();
let mut stmt = conn.prepare(
"SELECT identity_tag, epoch, key_id, cause, created_at FROM key_epochs \
WHERE identity_tag = ?1 ORDER BY epoch, key_id",
)?;
let rows = stmt.query_map(params![tag.as_str()], |r| {
Ok((
r.get::<_, String>(0)?,
r.get::<_, u32>(1)?,
r.get::<_, String>(2)?,
r.get::<_, Option<String>>(3)?,
r.get::<_, i64>(4)?,
))
})?;
rows.map(|row| {
let (tag, number, key_id, cause, created_at) = row?;
Ok(StoredEpoch {
identity_tag: IdentityTag::from(tag),
epoch: Epoch {
number,
key_id: parse_key_id(&key_id)?,
},
cause,
created_at,
})
})
.collect()
}
pub fn put_envelope(&self, envelope: &Envelope) -> Result<bool> {
let inserted = self.conn().execute(
"INSERT OR IGNORE INTO key_envelopes \
(identity_tag, epoch, key_id, recipient, machine_id, envelope) \
VALUES (?1, ?2, ?3, ?4, ?5, ?6)",
params![
envelope.identity_tag.as_str(),
envelope.epoch.number,
envelope.epoch.key_id.to_string(),
envelope.recipient,
envelope.machine_id,
envelope.ciphertext,
],
)?;
Ok(inserted > 0)
}
pub fn envelope(
&self,
tag: &IdentityTag,
epoch: &Epoch,
recipient: &str,
) -> Result<Option<Envelope>> {
let conn = self.reader();
let row = conn
.query_row(
&format!(
"SELECT {ENVELOPE_COLUMNS} FROM key_envelopes \
WHERE identity_tag = ?1 AND epoch = ?2 AND key_id = ?3 AND recipient = ?4"
),
params![
tag.as_str(),
epoch.number,
epoch.key_id.to_string(),
recipient
],
envelope_row,
)
.optional()?;
row.map(EnvelopeRow::into_envelope).transpose()
}
pub fn envelopes_for_epoch(&self, tag: &IdentityTag, epoch: &Epoch) -> Result<Vec<Envelope>> {
let conn = self.reader();
query_envelopes(
&conn,
"identity_tag = ?1 AND epoch = ?2 AND key_id = ?3",
params![tag.as_str(), epoch.number, epoch.key_id.to_string()],
)
}
pub fn envelopes_for_machine(&self, machine_id: &str) -> Result<Vec<Envelope>> {
let conn = self.reader();
query_envelopes(&conn, "machine_id = ?1", params![machine_id])
}
pub fn insert_first_device_record(
&self,
signed: &SignedRecord,
signer: &str,
signer_key: &VerifyingKey,
) -> Result<bool> {
signed.verify_by(signer, signer_key)?;
let verified = signed_only_by(signed, signer)?;
self.with_txn(|tx| {
let machine_id = &signed.record.machine_id;
let Some(stored) = stored_record(tx, machine_id)? else {
write_record(tx, &verified, Some(&verified))?;
return Ok(true);
};
ensure!(
stored.first.record == signed.record,
"device {machine_id} already has a different first record"
);
if stored.first.signatures.iter().any(|s| s.signer == signer) {
return Ok(false);
}
let mut first = stored.first.clone();
first.signatures.extend(verified.signatures);
let current = if stored.current.record == stored.first.record {
&first
} else {
&stored.current
};
write_record(tx, current, Some(&first))?;
Ok(true)
})
}
pub fn update_device_record(&self, signed: &SignedRecord) -> Result<bool> {
self.with_txn(|tx| {
let machine_id = &signed.record.machine_id;
let Some(stored) = stored_record(tx, machine_id)? else {
bail!("device {machine_id} has no first record");
};
if stored.current.record == signed.record {
return Ok(false);
}
check_update(&stored.current, signed)?;
write_record(tx, &signed_only_by(signed, machine_id)?, None)?;
Ok(true)
})
}
pub fn replace_device_record_for_new_identity(
&self,
signed: &SignedRecord,
signer: &str,
signer_key: &VerifyingKey,
) -> Result<bool> {
signed.verify_by(signer, signer_key)?;
let verified = signed_only_by(signed, signer)?;
self.with_txn(|tx| {
let machine_id = &signed.record.machine_id;
let Some(stored) = stored_record(tx, machine_id)? else {
write_record(tx, &verified, Some(&verified))?;
return Ok(true);
};
if stored.first.record == signed.record {
return Ok(false);
}
ensure!(
stored.current.record.identity_tag != signed.record.identity_tag,
"device {machine_id} already belongs to identity {}; within one identity a \
device with new keys needs a fresh machine id",
signed.record.identity_tag
);
tx.execute(
"UPDATE machines SET revoked = 0 WHERE id = ?1",
params![machine_id],
)?;
write_record(tx, &verified, Some(&verified))?;
Ok(true)
})
}
pub fn device_record(&self, machine_id: &str) -> Result<Option<StoredDeviceRecord>> {
stored_record(&self.reader(), machine_id)
}
pub fn device_records(&self) -> Result<Vec<StoredDeviceRecord>> {
let conn = self.reader();
let mut stmt = conn.prepare(
"SELECT first_record, record, revoked FROM machines \
WHERE record IS NOT NULL ORDER BY id",
)?;
let rows = stmt.query_map([], record_columns)?;
rows.map(|row| parse_stored(row?)).collect()
}
}
const ENVELOPE_COLUMNS: &str = "identity_tag, epoch, key_id, recipient, machine_id, envelope";
struct EnvelopeRow {
tag: String,
number: u32,
key_id: String,
recipient: String,
machine_id: Option<String>,
ciphertext: Vec<u8>,
}
impl EnvelopeRow {
fn into_envelope(self) -> Result<Envelope> {
Ok(Envelope {
identity_tag: IdentityTag::from(self.tag),
epoch: Epoch {
number: self.number,
key_id: parse_key_id(&self.key_id)?,
},
recipient: self.recipient,
machine_id: self.machine_id,
ciphertext: self.ciphertext,
})
}
}
fn envelope_row(r: &Row<'_>) -> rusqlite::Result<EnvelopeRow> {
Ok(EnvelopeRow {
tag: r.get(0)?,
number: r.get(1)?,
key_id: r.get(2)?,
recipient: r.get(3)?,
machine_id: r.get(4)?,
ciphertext: r.get(5)?,
})
}
pub(super) fn query_envelopes(
conn: &Connection,
filter: &str,
args: impl rusqlite::Params,
) -> Result<Vec<Envelope>> {
let mut stmt = conn.prepare(&format!(
"SELECT {ENVELOPE_COLUMNS} FROM key_envelopes WHERE {filter} \
ORDER BY identity_tag, epoch, key_id, recipient"
))?;
let rows = stmt.query_map(args, envelope_row)?;
rows.map(|row| row?.into_envelope()).collect()
}
type RecordColumns = (Option<String>, Option<String>, bool);
fn record_columns(r: &Row<'_>) -> rusqlite::Result<RecordColumns> {
Ok((r.get(0)?, r.get(1)?, r.get(2)?))
}
pub(crate) fn identity_tag_of(conn: &Connection, machine_id: &str) -> Result<Option<String>> {
Ok(stored_record(conn, machine_id)?.map(|row| row.current.record.identity_tag))
}
fn stored_record(conn: &Connection, machine_id: &str) -> Result<Option<StoredDeviceRecord>> {
let row = conn
.query_row(
"SELECT first_record, record, revoked FROM machines \
WHERE id = ?1 AND record IS NOT NULL",
params![machine_id],
record_columns,
)
.optional()?;
row.map(parse_stored).transpose()
}
fn parse_stored((first, current, revoked): RecordColumns) -> Result<StoredDeviceRecord> {
let first = first.context("machine row has a record but no first record")?;
let current = current.context("machine row has no record")?;
Ok(StoredDeviceRecord {
first: SignedRecord::from_json(&first)?,
current: SignedRecord::from_json(¤t)?,
revoked,
})
}
fn write_record(
conn: &Connection,
current: &SignedRecord,
first: Option<&SignedRecord>,
) -> Result<()> {
let record = ¤t.record;
let first_json = first.map(SignedRecord::to_json).transpose()?;
let version = i64::try_from(record.version).context("record version out of range")?;
conn.execute(
"INSERT INTO machines (id, name, age_pubkey, ssh_pubkey, signing_pubkey, identity_tag, \
record_version, first_record, record) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9) \
ON CONFLICT(id) DO UPDATE SET name = excluded.name, age_pubkey = excluded.age_pubkey, \
ssh_pubkey = excluded.ssh_pubkey, signing_pubkey = excluded.signing_pubkey, \
identity_tag = excluded.identity_tag, record_version = excluded.record_version, \
first_record = COALESCE(excluded.first_record, machines.first_record), \
record = excluded.record",
params![
record.machine_id,
record.name,
record.age_recipient,
record.ssh_public_key,
hex(&record.signing_public_key),
record.identity_tag,
version,
first_json,
current.to_json()?,
],
)?;
Ok(())
}
fn signed_only_by(signed: &SignedRecord, signer: &str) -> Result<SignedRecord> {
let signature = signed
.signatures
.iter()
.find(|s| s.signer == signer)
.with_context(|| format!("device record has no signature by {signer}"))?;
Ok(SignedRecord {
record: signed.record.clone(),
signatures: vec![signature.clone()],
})
}
fn parse_key_id(text: &str) -> Result<KeyId> {
text.parse()
.with_context(|| format!("stored key id {text:?} is not 16 hex digits"))
}
#[cfg(test)]
mod tests {
use ed25519_dalek::SigningKey;
use super::*;
use crate::keys::device::DeviceKeys;
use crate::keys::identity::{IdentityKey, wrap};
use crate::keys::record::{DeviceRecord, RecordSignature};
fn store() -> SqliteStore {
SqliteStore::in_memory("local".to_string()).unwrap()
}
fn record(machine_id: &str, version: u64, key: &SigningKey) -> DeviceRecord {
DeviceRecord {
machine_id: machine_id.to_string(),
identity_tag: "f-tag".to_string(),
version,
name: format!("{machine_id}-v{version}"),
age_recipient: "age1recipient".to_string(),
ssh_public_key: "ssh-ed25519 AAAA".to_string(),
signing_public_key: key.verifying_key().to_bytes(),
recovery_fingerprints: Vec::new(),
ssh_login: None,
ssh_port: None,
ssh_host_key: None,
}
}
#[test]
fn envelopes_round_trip_and_open_for_their_device() {
let store = store();
let device = DeviceKeys::generate().unwrap();
let key = IdentityKey::generate().unwrap();
let tag = IdentityTag::migrated(&key.key_id());
let envelope = wrap(
&key,
1,
&tag,
&device.age_recipient(),
Some("dev-a".to_string()),
)
.unwrap();
let epoch = envelope.epoch.clone();
assert!(store.put_key_epoch(&tag, &epoch, None, 7).unwrap());
assert!(!store.put_key_epoch(&tag, &epoch, None, 8).unwrap());
assert!(store.put_envelope(&envelope).unwrap());
assert!(!store.put_envelope(&envelope).unwrap());
let epochs = store.key_epochs(&tag).unwrap();
assert_eq!(epochs.len(), 1);
assert_eq!(epochs[0].epoch, epoch);
assert_eq!(epochs[0].created_at, 7);
let loaded = store
.envelope(&tag, &epoch, &envelope.recipient)
.unwrap()
.unwrap();
assert_eq!(loaded.machine_id.as_deref(), Some("dev-a"));
let opened = loaded.open(device.age_identity()).unwrap();
assert_eq!(opened.expose(), key.expose());
assert_eq!(store.envelopes_for_machine("dev-a").unwrap().len(), 1);
assert_eq!(store.envelopes_for_epoch(&tag, &epoch).unwrap().len(), 1);
assert!(store.envelopes_for_machine("dev-b").unwrap().is_empty());
}
#[test]
fn an_epoch_cause_arriving_later_is_kept() {
let store = store();
let key = IdentityKey::generate().unwrap();
let tag = IdentityTag::migrated(&key.key_id());
let epoch = Epoch {
number: 2,
key_id: key.key_id(),
};
assert!(store.put_key_epoch(&tag, &epoch, None, 1).unwrap());
assert!(!store.put_key_epoch(&tag, &epoch, Some("set"), 2).unwrap());
assert!(!store.put_key_epoch(&tag, &epoch, None, 3).unwrap());
let stored = store.key_epochs(&tag).unwrap();
assert_eq!(stored[0].cause.as_deref(), Some("set"));
assert_eq!(stored[0].created_at, 1);
}
fn tagged(machine_id: &str, tag: &str, key: &SigningKey) -> DeviceRecord {
DeviceRecord {
identity_tag: tag.to_string(),
..record(machine_id, 1, key)
}
}
#[test]
fn a_device_moving_to_another_identity_replaces_its_row_and_revocation() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let old_pairer = SigningKey::from_bytes(&[2; 32]);
let new_pairer = SigningKey::from_bytes(&[3; 32]);
let old = tagged("dev-b", "f-old", &device).sign("dev-a", &old_pairer);
store
.insert_first_device_record(&old, "dev-a", &old_pairer.verifying_key())
.unwrap();
store
.conn()
.execute("UPDATE machines SET revoked = 1 WHERE id = 'dev-b'", [])
.unwrap();
let moved = tagged("dev-b", "f-new", &device).sign("dev-c", &new_pairer);
assert!(
store
.insert_first_device_record(&moved, "dev-c", &new_pairer.verifying_key())
.is_err(),
"the plain insert must keep refusing a different first record"
);
assert!(
store
.replace_device_record_for_new_identity(
&moved,
"dev-c",
&old_pairer.verifying_key()
)
.is_err(),
"a signature that does not verify must be refused"
);
assert!(
store
.replace_device_record_for_new_identity(
&moved,
"dev-c",
&new_pairer.verifying_key()
)
.unwrap()
);
let stored = store.device_record("dev-b").unwrap().unwrap();
assert_eq!(stored.first, moved);
assert_eq!(stored.current, moved);
assert!(!stored.revoked);
assert!(
!store
.replace_device_record_for_new_identity(
&moved,
"dev-c",
&new_pairer.verifying_key()
)
.unwrap()
);
}
#[test]
fn a_new_first_record_within_the_same_identity_is_refused() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let rekeyed = SigningKey::from_bytes(&[4; 32]);
let pairer = SigningKey::from_bytes(&[2; 32]);
let first = tagged("dev-b", "f-tag", &device).sign("dev-a", &pairer);
store
.insert_first_device_record(&first, "dev-a", &pairer.verifying_key())
.unwrap();
let other = tagged("dev-b", "f-tag", &rekeyed).sign("dev-a", &pairer);
let err = store
.replace_device_record_for_new_identity(&other, "dev-a", &pairer.verifying_key())
.unwrap_err();
assert!(format!("{err:#}").contains("fresh machine id"), "{err:#}");
assert_eq!(store.device_record("dev-b").unwrap().unwrap().first, first);
}
#[test]
fn a_machine_without_a_row_takes_the_new_identity_record_as_its_first() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let pairer = SigningKey::from_bytes(&[2; 32]);
let first = tagged("dev-b", "f-new", &device).sign("dev-a", &pairer);
assert!(
store
.replace_device_record_for_new_identity(&first, "dev-a", &pairer.verifying_key())
.unwrap()
);
assert_eq!(store.device_record("dev-b").unwrap().unwrap().first, first);
}
#[test]
fn a_verified_countersignature_merges_into_the_first_record() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let introducer = SigningKey::from_bytes(&[2; 32]);
let witness = SigningKey::from_bytes(&[3; 32]);
let first = record("dev-b", 1, &device).sign("dev-a", &introducer);
store
.insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
.unwrap();
let mut countersigned = first.clone();
countersigned.countersign("dev-c", &witness);
assert!(
store
.insert_first_device_record(&countersigned, "dev-c", &introducer.verifying_key())
.is_err()
);
assert!(
store
.insert_first_device_record(&countersigned, "dev-c", &witness.verifying_key())
.unwrap()
);
assert!(
!store
.insert_first_device_record(&countersigned, "dev-c", &witness.verifying_key())
.unwrap()
);
assert!(
!store
.insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
.unwrap()
);
let stored = store.device_record("dev-b").unwrap().unwrap();
stored
.first
.verify_by("dev-a", &introducer.verifying_key())
.unwrap();
stored
.first
.verify_by("dev-c", &witness.verifying_key())
.unwrap();
assert_eq!(stored.current, stored.first);
}
#[test]
fn a_first_record_must_verify_under_its_introducer() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let introducer = SigningKey::from_bytes(&[2; 32]);
let signed = record("dev-b", 1, &device).sign("dev-a", &introducer);
let wrong = SigningKey::from_bytes(&[3; 32]);
assert!(
store
.insert_first_device_record(&signed, "dev-a", &wrong.verifying_key())
.is_err()
);
assert!(store.device_record("dev-b").unwrap().is_none());
assert!(
store
.insert_first_device_record(&signed, "dev-a", &introducer.verifying_key())
.unwrap()
);
assert!(
!store
.insert_first_device_record(&signed, "dev-a", &introducer.verifying_key())
.unwrap()
);
let other = record("dev-b", 2, &device).sign("dev-a", &introducer);
assert!(
store
.insert_first_device_record(&other, "dev-a", &introducer.verifying_key())
.is_err()
);
}
#[test]
fn updates_follow_the_devices_own_signature_and_keep_the_first_record() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let introducer = SigningKey::from_bytes(&[2; 32]);
let first = record("dev-b", 1, &device).sign("dev-a", &introducer);
store
.insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
.unwrap();
let forged = record("dev-b", 2, &device).sign("dev-b", &introducer);
assert!(store.update_device_record(&forged).is_err());
let update = record("dev-b", 2, &device).sign("dev-b", &device);
assert!(store.update_device_record(&update).unwrap());
assert!(!store.update_device_record(&update).unwrap());
assert!(store.update_device_record(&first).is_err());
let stored = store.device_record("dev-b").unwrap().unwrap();
assert_eq!(stored.first.record, first.record);
assert_eq!(stored.current.record, update.record);
assert!(!stored.revoked);
stored.current.verify_self().unwrap();
assert!(
store
.update_device_record(&record("dev-c", 1, &device).sign("dev-c", &device))
.is_err()
);
assert_eq!(store.device_records().unwrap().len(), 1);
}
#[test]
fn only_verified_signatures_are_stored() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let introducer = SigningKey::from_bytes(&[2; 32]);
let mut first = record("dev-b", 1, &device).sign("dev-a", &introducer);
first.signatures.push(RecordSignature {
signer: "dev-c".to_string(),
signature: [9; 64],
});
store
.insert_first_device_record(&first, "dev-a", &introducer.verifying_key())
.unwrap();
let stored = store.device_record("dev-b").unwrap().unwrap();
let signers = |s: &SignedRecord| -> Vec<String> {
s.signatures.iter().map(|s| s.signer.clone()).collect()
};
assert_eq!(signers(&stored.first), ["dev-a"]);
let witness = SigningKey::from_bytes(&[3; 32]);
let mut countersigned = first.clone();
countersigned.signatures.retain(|s| s.signer != "dev-c");
countersigned.countersign("dev-c", &witness);
assert!(
store
.insert_first_device_record(&countersigned, "dev-c", &witness.verifying_key())
.unwrap()
);
let mut update = record("dev-b", 2, &device).sign("dev-b", &device);
update.signatures.push(RecordSignature {
signer: "dev-x".to_string(),
signature: [7; 64],
});
assert!(store.update_device_record(&update).unwrap());
let stored = store.device_record("dev-b").unwrap().unwrap();
assert_eq!(signers(&stored.current), ["dev-b"]);
assert_eq!(signers(&stored.first), ["dev-a", "dev-c"]);
}
#[test]
fn a_tampered_stored_record_fails_verification() {
let store = store();
let device = SigningKey::from_bytes(&[1; 32]);
let first = record("dev-b", 1, &device).sign("dev-b", &device);
store
.insert_first_device_record(&first, "dev-b", &device.verifying_key())
.unwrap();
let json = first.to_json().unwrap().replace("dev-b-v1", "dev-b-v9");
store
.conn()
.execute(
"UPDATE machines SET record = ?1 WHERE id = 'dev-b'",
params![json],
)
.unwrap();
let stored = store.device_record("dev-b").unwrap().unwrap();
assert!(stored.current.verify_self().is_err());
}
}