use anyhow::{Context, Result, anyhow, ensure};
use ed25519_dalek::{Signature, Signer, SigningKey, VerifyingKey};
use serde::{Deserialize, Serialize};
const RECORD_DOMAIN: &[u8] = b"second-brain device record v1";
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct DeviceRecord {
pub machine_id: String,
pub identity_tag: String,
pub version: u64,
pub name: String,
pub age_recipient: String,
pub ssh_public_key: String,
#[serde(with = "hex_array")]
pub signing_public_key: [u8; 32],
pub recovery_fingerprints: Vec<String>,
pub ssh_login: Option<String>,
pub ssh_port: Option<u16>,
pub ssh_host_key: Option<String>,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
pub struct RecordSignature {
pub signer: String,
#[serde(with = "hex_array")]
pub signature: [u8; 64],
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
#[serde(try_from = "UncheckedSignedRecord")]
pub struct SignedRecord {
pub record: DeviceRecord,
pub signatures: Vec<RecordSignature>,
}
#[derive(Deserialize)]
struct UncheckedSignedRecord {
record: DeviceRecord,
signatures: Vec<RecordSignature>,
}
impl TryFrom<UncheckedSignedRecord> for SignedRecord {
type Error = anyhow::Error;
fn try_from(unchecked: UncheckedSignedRecord) -> Result<Self> {
let mut signers: Vec<&str> = unchecked
.signatures
.iter()
.map(|s| s.signer.as_str())
.collect();
signers.sort_unstable();
ensure!(
signers.windows(2).all(|pair| pair[0] != pair[1]),
"device record for machine {} carries more than one signature by one signer",
unchecked.record.machine_id
);
Ok(Self {
record: unchecked.record,
signatures: unchecked.signatures,
})
}
}
impl DeviceRecord {
pub fn signing_bytes(&self) -> Vec<u8> {
let mut out = Vec::with_capacity(256);
out.extend_from_slice(RECORD_DOMAIN);
put_str(&mut out, &self.machine_id);
put_str(&mut out, &self.identity_tag);
out.extend_from_slice(&self.version.to_be_bytes());
put_str(&mut out, &self.name);
put_str(&mut out, &self.age_recipient);
put_str(&mut out, &self.ssh_public_key);
out.extend_from_slice(&self.signing_public_key);
put_len(&mut out, self.recovery_fingerprints.len());
for fingerprint in &self.recovery_fingerprints {
put_str(&mut out, fingerprint);
}
match &self.ssh_login {
None => out.push(0),
Some(login) => {
out.push(1);
put_str(&mut out, login);
}
}
match self.ssh_port {
None => out.push(0),
Some(port) => {
out.push(1);
out.extend_from_slice(&port.to_be_bytes());
}
}
match &self.ssh_host_key {
None => out.push(0),
Some(host_key) => {
out.push(1);
put_str(&mut out, host_key);
}
}
out
}
pub fn signing_public_key(&self) -> Result<VerifyingKey> {
VerifyingKey::from_bytes(&self.signing_public_key).map_err(|_| {
anyhow!(
"device record for machine {} has an invalid signing public key",
self.machine_id
)
})
}
pub fn sign(self, signer: &str, key: &SigningKey) -> SignedRecord {
let signature = sign_record(&self, signer, key);
SignedRecord {
record: self,
signatures: vec![signature],
}
}
fn signed_message(&self, signer: &str) -> Vec<u8> {
let mut message = self.signing_bytes();
put_str(&mut message, signer);
message
}
}
impl SignedRecord {
pub fn countersign(&mut self, signer: &str, key: &SigningKey) {
let signature = sign_record(&self.record, signer, key);
match self.signatures.iter_mut().find(|s| s.signer == signer) {
Some(existing) => *existing = signature,
None => self.signatures.push(signature),
}
}
pub fn verify_by(&self, signer: &str, key: &VerifyingKey) -> Result<()> {
let found = self
.signatures
.iter()
.find(|s| s.signer == signer)
.ok_or_else(|| {
anyhow!(
"device record for machine {} has no signature by {signer}",
self.record.machine_id
)
})?;
let message = self.record.signed_message(signer);
key.verify_strict(&message, &Signature::from_bytes(&found.signature))
.map_err(|_| {
anyhow!(
"signature by {signer} on the device record for machine {} does not verify",
self.record.machine_id
)
})
}
pub fn verify_self(&self) -> Result<()> {
let key = self.record.signing_public_key()?;
self.verify_by(&self.record.machine_id, &key)
}
pub fn to_json(&self) -> Result<String> {
serde_json::to_string(self).context("encoding a signed device record")
}
pub fn from_json(text: &str) -> Result<Self> {
serde_json::from_str(text).context("decoding a signed device record")
}
}
pub fn check_update(current: &SignedRecord, incoming: &SignedRecord) -> Result<()> {
let stored = ¤t.record;
let update = &incoming.record;
ensure!(
update.machine_id == stored.machine_id,
"device record update names machine {} but the stored record is for machine {}",
update.machine_id,
stored.machine_id
);
ensure!(
update.identity_tag == stored.identity_tag,
"device record update for machine {} names identity {} but the stored record has identity {}",
update.machine_id,
update.identity_tag,
stored.identity_tag
);
ensure!(
update.version > stored.version,
"device record update for machine {} has version {}, not above the stored version {}",
update.machine_id,
update.version,
stored.version
);
ensure!(
update.signing_public_key == stored.signing_public_key,
"device record update for machine {} changes its signing key; a device rekeys under a new machine id",
update.machine_id
);
let key = stored.signing_public_key()?;
incoming
.verify_by(&stored.machine_id, &key)
.with_context(|| {
format!(
"device record update for machine {} is not signed by its current signing key",
stored.machine_id
)
})
}
fn sign_record(record: &DeviceRecord, signer: &str, key: &SigningKey) -> RecordSignature {
let signature: Signature = key.sign(&record.signed_message(signer));
RecordSignature {
signer: signer.to_string(),
signature: signature.to_bytes(),
}
}
pub(super) fn put_len(out: &mut Vec<u8>, len: usize) {
out.extend_from_slice(&u32::try_from(len).unwrap_or(u32::MAX).to_be_bytes());
}
pub(super) fn put_str(out: &mut Vec<u8>, text: &str) {
put_len(out, text.len());
out.extend_from_slice(text.as_bytes());
}
pub(super) mod hex_array {
use serde::de::Error;
use serde::{Deserialize, Deserializer, Serializer};
pub fn serialize<S: Serializer, const N: usize>(
bytes: &[u8; N],
serializer: S,
) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&crate::keys::hex(bytes))
}
pub fn deserialize<'de, D: Deserializer<'de>, const N: usize>(
deserializer: D,
) -> Result<[u8; N], D::Error> {
let text = String::deserialize(deserializer)?;
crate::keys::unhex(&text)
.ok_or_else(|| D::Error::custom(format!("expected {N} bytes as hex")))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn key(seed: u8) -> SigningKey {
SigningKey::from_bytes(&[seed; 32])
}
fn record(signing: &SigningKey) -> DeviceRecord {
DeviceRecord {
machine_id: "machine-a".to_string(),
identity_tag: "identity-1".to_string(),
version: 3,
name: "laptop".to_string(),
age_recipient: "age1recipient".to_string(),
ssh_public_key: "ssh-ed25519 AAAAexample".to_string(),
signing_public_key: signing.verifying_key().to_bytes(),
recovery_fingerprints: vec!["fp-one".to_string(), "fp-two".to_string()],
ssh_login: Some("user".to_string()),
ssh_port: Some(22),
ssh_host_key: Some("ssh-ed25519 AAAAhost".to_string()),
}
}
fn self_signed(signing: &SigningKey) -> SignedRecord {
record(signing).sign("machine-a", signing)
}
fn message(result: Result<()>) -> String {
format!("{:#}", result.expect_err("expected an error"))
}
#[test]
fn a_self_signed_record_verifies() {
let signing = key(1);
let signed = self_signed(&signing);
signed.verify_self().unwrap();
signed
.verify_by("machine-a", &signing.verifying_key())
.unwrap();
}
#[test]
fn tampering_any_field_breaks_the_signature() {
let cases: [(&str, fn(&mut DeviceRecord)); 16] = [
("machine id", |r: &mut DeviceRecord| {
r.machine_id = "machine-b".into()
}),
("identity tag", |r: &mut DeviceRecord| {
r.identity_tag = "identity-2".into()
}),
("version", |r: &mut DeviceRecord| r.version += 1),
("name", |r: &mut DeviceRecord| r.name = "desktop".into()),
("age recipient", |r: &mut DeviceRecord| {
r.age_recipient = "age1other".into()
}),
("ssh key", |r: &mut DeviceRecord| {
r.ssh_public_key = "ssh-ed25519 BBBB".into()
}),
("signing key", |r: &mut DeviceRecord| {
r.signing_public_key = key(2).verifying_key().to_bytes()
}),
("recovery fingerprint changed", |r: &mut DeviceRecord| {
r.recovery_fingerprints[1] = "fp-three".into()
}),
("recovery fingerprint added", |r: &mut DeviceRecord| {
r.recovery_fingerprints.push("fp-three".into())
}),
("recovery fingerprints reordered", |r: &mut DeviceRecord| {
r.recovery_fingerprints.reverse()
}),
("ssh login changed", |r: &mut DeviceRecord| {
r.ssh_login = Some("root".into())
}),
("ssh login removed", |r: &mut DeviceRecord| {
r.ssh_login = None
}),
("ssh port changed", |r: &mut DeviceRecord| {
r.ssh_port = Some(2222)
}),
("ssh port removed", |r: &mut DeviceRecord| r.ssh_port = None),
("ssh host key changed", |r: &mut DeviceRecord| {
r.ssh_host_key = Some("ssh-ed25519 AAAAother".into())
}),
("ssh host key removed", |r: &mut DeviceRecord| {
r.ssh_host_key = None
}),
];
let signing = key(1);
for (field, tamper) in cases {
let mut signed = self_signed(&signing);
tamper(&mut signed.record);
assert!(
signed
.verify_by("machine-a", &signing.verifying_key())
.is_err(),
"tampered {field} still verifies"
);
}
}
#[test]
fn signing_bytes_keep_field_boundaries() {
let signing = key(1);
let mut split = record(&signing);
split.recovery_fingerprints = vec!["ab".into(), "c".into()];
let mut shifted = record(&signing);
shifted.recovery_fingerprints = vec!["a".into(), "bc".into()];
assert_ne!(split.signing_bytes(), shifted.signing_bytes());
let mut name_long = record(&signing);
name_long.name = "laptopx".into();
name_long.age_recipient = "y".into();
let mut recipient_long = record(&signing);
recipient_long.name = "laptop".into();
recipient_long.age_recipient = "xy".into();
assert_ne!(name_long.signing_bytes(), recipient_long.signing_bytes());
assert!(split.signing_bytes().starts_with(RECORD_DOMAIN));
}
#[test]
fn a_signature_moved_to_another_signer_fails() {
let signing = key(1);
let mut signed = self_signed(&signing);
signed.signatures[0].signer = "machine-b".into();
let err = message(signed.verify_by("machine-b", &signing.verifying_key()));
assert!(err.contains("does not verify"), "{err}");
}
#[test]
fn verify_by_the_wrong_key_fails() {
let signed = self_signed(&key(1));
let err = message(signed.verify_by("machine-a", &key(2).verifying_key()));
assert!(err.contains("does not verify"), "{err}");
}
#[test]
fn verify_by_a_signer_with_no_signature_fails() {
let signed = self_signed(&key(1));
let err = message(signed.verify_by("machine-b", &key(1).verifying_key()));
assert!(err.contains("no signature by machine-b"), "{err}");
}
#[test]
fn countersign_adds_a_second_signature_and_replaces_its_own() {
let own = key(1);
let peer = key(3);
let mut signed = self_signed(&own);
signed.countersign("machine-b", &peer);
assert_eq!(signed.signatures.len(), 2);
signed.verify_self().unwrap();
signed
.verify_by("machine-b", &peer.verifying_key())
.unwrap();
let replacement = key(4);
signed.countersign("machine-b", &replacement);
assert_eq!(signed.signatures.len(), 2);
signed
.verify_by("machine-b", &replacement.verifying_key())
.unwrap();
assert!(
signed
.verify_by("machine-b", &peer.verifying_key())
.is_err()
);
signed.verify_self().unwrap();
}
#[test]
fn json_round_trip_keeps_verification() {
let own = key(1);
let mut signed = self_signed(&own);
signed.countersign("machine-b", &key(3));
let text = signed.to_json().unwrap();
let hex_key: String = own
.verifying_key()
.to_bytes()
.iter()
.map(|b| format!("{b:02x}"))
.collect();
assert!(text.contains(&hex_key), "{text}");
let back = SignedRecord::from_json(&text).unwrap();
assert_eq!(back, signed);
back.verify_self().unwrap();
back.verify_by("machine-b", &key(3).verifying_key())
.unwrap();
}
#[test]
fn json_with_a_malformed_hex_field_is_rejected() {
let text = self_signed(&key(1)).to_json().unwrap();
let value: serde_json::Value = serde_json::from_str(&text).unwrap();
let good = value["record"]["signing_public_key"]
.as_str()
.unwrap()
.to_string();
let bads = vec![
good[2..].to_string(),
"zz".to_string(),
format!("{good}00"),
format!("zz{}", &good[2..]),
];
for bad in bads {
let mut edited = value.clone();
edited["record"]["signing_public_key"] = serde_json::Value::from(bad.clone());
assert!(
SignedRecord::from_json(&edited.to_string()).is_err(),
"accepted {bad}"
);
}
}
fn update(signing_public: &SigningKey, version: u64, signer: &SigningKey) -> SignedRecord {
let mut next = record(signing_public);
next.version = version;
next.name = "renamed laptop".into();
next.sign("machine-a", signer)
}
#[test]
fn check_update_accepts_a_higher_self_signed_version() {
let own = key(1);
let current = self_signed(&own);
check_update(¤t, &update(&own, 4, &own)).unwrap();
}
#[test]
fn check_update_rejects_an_equal_or_lower_version() {
let own = key(1);
let current = self_signed(&own);
for version in [3, 2, 0] {
let err = message(check_update(¤t, &update(&own, version, &own)));
assert!(err.contains("not above the stored version"), "{err}");
}
}
#[test]
fn check_update_rejects_another_machine() {
let own = key(1);
let other = key(5);
let current = self_signed(&own);
let mut foreign = record(&other);
foreign.machine_id = "machine-b".into();
foreign.version = 9;
let incoming = foreign.sign("machine-b", &other);
let err = message(check_update(¤t, &incoming));
assert!(
err.contains("stored record is for machine machine-a"),
"{err}"
);
}
#[test]
fn check_update_rejects_another_identity() {
let own = key(1);
let current = self_signed(&own);
let mut moved = record(&own);
moved.identity_tag = "identity-2".into();
moved.version = 4;
let err = message(check_update(¤t, &moved.sign("machine-a", &own)));
assert!(err.contains("names identity identity-2"), "{err}");
}
#[test]
fn a_signing_key_never_changes_for_a_machine() {
let old = key(1);
let new = key(2);
let current = self_signed(&old);
for signer in [&old, &new] {
let rotated = update(&new, 4, signer);
let err = message(check_update(¤t, &rotated));
assert!(err.contains("changes its signing key"), "{err}");
}
}
#[test]
fn duplicate_signers_are_rejected_on_decode() {
let mut signed = self_signed(&key(1));
signed.signatures.push(signed.signatures[0].clone());
let text = serde_json::to_string(&signed).unwrap();
let err = format!("{:#}", SignedRecord::from_json(&text).unwrap_err());
assert!(err.contains("more than one signature"), "{err}");
let err = serde_json::from_str::<SignedRecord>(&text).unwrap_err();
assert!(err.to_string().contains("more than one signature"), "{err}");
}
#[test]
fn an_invalid_signing_public_key_is_an_error() {
let mut broken = record(&key(1));
let mut off_curve = [0u8; 32];
off_curve[0] = 2;
broken.signing_public_key = off_curve;
let err = format!("{:#}", broken.signing_public_key().unwrap_err());
assert!(err.contains("invalid signing public key"), "{err}");
}
}