use std::cmp::Reverse;
use std::collections::BTreeSet;
use chrono::Utc;
use second_brain_core::keys::{DEVICE_KEY_FILE, DeviceKeys, DeviceRecord, Epoch, SignedRecord};
use second_brain_core::schema::SyncState;
use second_brain_core::sqlite_store::SqliteStore;
use second_brain_core::store::StoreAdmin;
use second_brain_sync::crypto::{XChaChaEncryptor, seal_line};
use second_brain_sync::keyring::{IdentityMismatch, Keyring, LEGACY_KEY_FILE, migrate_sync_key};
use second_brain_sync::protocol::{HandshakeKeys, Hello};
use tempfile::TempDir;
const NOW: i64 = 1_790_000_000_000_000;
struct Device {
store: SqliteStore,
dir: TempDir,
}
impl Device {
fn id(&self) -> &str {
self.store.machine_id()
}
fn keyring(&self) -> Keyring<'_> {
Keyring::load(&self.store, self.dir.path()).unwrap()
}
fn hello_for(&self, peer: &Device) -> HandshakeKeys {
self.keyring().handshake_for(peer.id(), None).unwrap()
}
fn accept(&self, from: &Device, keys: &HandshakeKeys) -> anyhow::Result<()> {
self.keyring().accept(from.id(), keys, NOW)
}
fn newest(&self) -> Epoch {
self.keyring()
.held_epochs()
.into_iter()
.max_by_key(|e| (e.number, Reverse(e.key_id)))
.unwrap()
}
fn holds(&self, epoch: &Epoch) -> bool {
self.keyring().held_epochs().contains(epoch)
}
fn revoked(&self) -> Vec<String> {
self.store
.device_records()
.unwrap()
.into_iter()
.filter(|row| row.revoked)
.map(|row| row.current.record.machine_id)
.collect()
}
fn remove(&self, target: &str, keeping: &[&str]) -> Option<Epoch> {
self.keyring()
.remove_device(target, &keep(keeping), NOW)
.unwrap()
.epoch
}
}
fn keep(ids: &[&str]) -> BTreeSet<String> {
ids.iter().map(|id| id.to_string()).collect()
}
fn device(id: &str, knows: &[&str]) -> Device {
let store = SqliteStore::in_memory(id.to_string()).unwrap();
let dir = tempfile::tempdir().unwrap();
DeviceKeys::load_or_create(&dir.path().join(DEVICE_KEY_FILE)).unwrap();
std::fs::write(
dir.path().join(LEGACY_KEY_FILE),
format!("{}\n", XChaChaEncryptor::new([5; 32]).key_base64()),
)
.unwrap();
for peer in knows {
store
.set_sync_state(&SyncState {
peer_id: peer.to_string(),
last_seq: 1,
last_sync_at: Utc::now(),
})
.unwrap();
}
migrate_sync_key(&store, dir.path(), id, NOW).unwrap();
Device { store, dir }
}
fn handshake(a: &Device, b: &Device) -> anyhow::Result<()> {
let from_a = a.hello_for(b);
b.accept(a, &from_a)?;
let from_b = b.hello_for(a);
a.accept(b, &from_b)
}
fn mesh(ids: &[&str]) -> Vec<Device> {
let devices: Vec<Device> = ids
.iter()
.map(|id| {
let others: Vec<&str> = ids.iter().copied().filter(|o| o != id).collect();
device(id, &others)
})
.collect();
for _ in 0..2 {
for x in &devices {
for y in &devices {
if x.id() != y.id() {
handshake(x, y).unwrap();
}
}
}
}
devices
}
fn is_mismatch(result: anyhow::Result<()>) -> bool {
result.is_err_and(|e| e.downcast_ref::<IdentityMismatch>().is_some())
}
#[test]
fn removing_a_device_mints_an_epoch_the_rest_receive_and_it_never_does() {
let devices = mesh(&["a", "b", "c"]);
let [a, b, c] = &devices[..] else {
unreachable!()
};
let before = a.newest();
let _n = pair(c, "n");
handshake(c, a).unwrap();
let preview = a.keyring().removal_preview("c", &BTreeSet::new()).unwrap();
assert_eq!(preview.revoked, ["c", "n"], "c paired n");
let kept = a.keyring().removal_preview("c", &keep(&["n"])).unwrap();
assert_eq!(kept.revoked, ["c"]);
assert!(a.revoked().is_empty(), "a preview stores nothing");
let epoch = a.remove("c", &["b"]).expect("an epoch is minted");
assert_eq!(epoch.number, before.number + 1);
assert_eq!(a.revoked(), ["c", "n"]);
assert!(a.holds(&epoch));
assert!(a.hello_for(c).envelopes.is_empty());
assert!(
a.keyring()
.sealer_for("c", None)
.is_err_and(|e| e.downcast_ref::<IdentityMismatch>().is_some())
);
handshake(a, b).unwrap();
handshake(a, b).unwrap();
assert_eq!(b.revoked(), ["c"]);
assert!(
b.store.device_record("n").unwrap().is_none(),
"first seen after c was removed"
);
assert!(b.holds(&epoch));
assert_eq!(b.newest(), epoch);
assert_eq!(
a.keyring().sealer_for("b", None).unwrap().sealing_epoch(),
Some(&epoch)
);
assert_eq!(
b.keyring().sealer_for("a", None).unwrap().sealing_epoch(),
Some(&epoch)
);
assert!(is_mismatch(a.accept(c, &c.hello_for(a))));
assert!(is_mismatch(c.accept(b, &b.hello_for(c))));
assert!(is_mismatch(c.accept(a, &a.hello_for(c))));
assert!(b.hello_for(c).envelopes.is_empty());
assert!(!c.holds(&epoch));
assert!(c.revoked().contains(&"c".to_string()));
}
#[test]
fn a_removal_relays_through_a_hub_to_devices_that_never_meet_the_remover() {
let hub = device("hub", &["a", "b", "d"]);
let spokes: Vec<Device> = ["a", "b", "d"]
.iter()
.map(|id| device(id, &["hub"]))
.collect();
let [a, b, d] = &spokes[..] else {
unreachable!()
};
for _ in 0..2 {
for spoke in &spokes {
handshake(spoke, &hub).unwrap();
}
}
assert!(a.store.device_record("b").unwrap().is_some());
let epoch = a.remove("d", &["hub", "b"]).unwrap();
for _ in 0..2 {
handshake(a, &hub).unwrap();
handshake(b, &hub).unwrap();
}
for here in [a, &hub, b] {
assert_eq!(here.revoked(), ["d"], "on {}", here.id());
assert_eq!(here.newest(), epoch, "on {}", here.id());
}
assert!(is_mismatch(handshake(d, &hub)));
assert!(!d.holds(&epoch));
assert_eq!(
b.keyring().sealer_for("hub", None).unwrap().sealing_epoch(),
Some(&epoch)
);
}
#[test]
fn concurrent_removals_end_on_one_epoch_after_one_round() {
let devices = mesh(&["a", "b", "c", "d", "e"]);
let [a, b, c, d, e] = &devices[..] else {
unreachable!()
};
a.remove("d", &["b", "c", "e"]).unwrap();
b.remove("e", &["a", "c", "d"]).unwrap();
handshake(a, b).unwrap();
handshake(c, a).unwrap();
handshake(c, b).unwrap();
let settled = a.newest();
for _ in 0..2 {
for (x, y) in [(a, b), (b, c), (c, a)] {
handshake(x, y).unwrap();
}
}
for here in [a, b, c] {
assert_eq!(here.revoked(), ["d", "e"], "on {}", here.id());
assert_eq!(here.newest(), settled, "on {}", here.id());
}
assert_eq!(
settled.number, 3,
"one epoch per removal and one to merge them"
);
assert!(!d.holds(&settled) && !e.holds(&settled));
}
#[test]
fn two_devices_minting_equal_sets_at_once_settle_by_key_id_without_another_round() {
let devices = mesh(&["a", "b", "c", "d", "e"]);
let [a, b, c, ..] = &devices[..] else {
unreachable!()
};
a.remove("d", &["b", "c", "e"]).unwrap();
b.remove("e", &["a", "c", "d"]).unwrap();
let from_a = a.hello_for(b);
let from_b = b.hello_for(a);
a.accept(b, &from_b).unwrap();
b.accept(a, &from_a).unwrap();
let minted_by_a = a.newest();
let minted_by_b = b.newest();
assert_eq!(minted_by_a.number, 3);
assert_eq!(minted_by_b.number, 3);
assert_ne!(minted_by_a, minted_by_b);
for _ in 0..2 {
for (x, y) in [(a, b), (b, c), (c, a)] {
handshake(x, y).unwrap();
}
}
let winner = [minted_by_a, minted_by_b]
.into_iter()
.min_by_key(|e| e.key_id)
.unwrap();
for here in [a, b, c] {
assert_eq!(here.newest(), winner, "on {}", here.id());
}
}
#[test]
fn a_thief_that_syncs_first_still_ends_revoked_beside_its_victim_in_either_order() {
for thief_first in [true, false] {
let devices = mesh(&["a", "b", "t"]);
let [a, b, t] = &devices[..] else {
unreachable!()
};
t.remove("a", &["b"]).unwrap();
a.remove("t", &["b"]).unwrap();
let (first, second) = if thief_first { (t, a) } else { (a, t) };
let _ = handshake(first, b);
let _ = handshake(second, b);
assert_eq!(b.revoked(), ["a", "t"], "thief first: {thief_first}");
assert!(is_mismatch(handshake(a, b)));
assert!(is_mismatch(handshake(t, b)));
}
}
#[test]
fn a_revoked_device_never_keeps_the_newest_epoch_when_it_minted_first() {
let devices = mesh(&["a", "b", "c", "d", "t"]);
let [a, b, _, _, t] = &devices[..] else {
unreachable!()
};
t.remove("c", &["a", "b", "d"]).unwrap();
let thief_newest = t.remove("d", &["a", "b"]).unwrap();
assert_eq!(thief_newest.number, 3);
handshake(t, b).unwrap();
assert_eq!(b.newest(), thief_newest);
a.remove("t", &["b"]).unwrap();
handshake(a, b).unwrap();
handshake(a, b).unwrap();
for here in [a, b] {
assert_eq!(here.revoked(), ["c", "d", "t"], "on {}", here.id());
assert!(here.newest().number > thief_newest.number);
assert!(!t.holds(&here.newest()));
}
assert_eq!(a.newest(), b.newest());
}
#[test]
fn a_revoked_device_never_keeps_the_newest_epoch_when_it_mints_after_its_revocation() {
let devices = mesh(&["a", "b", "c", "d", "t", "x"]);
let [a, b, _, _, t, x] = &devices[..] else {
unreachable!()
};
let removal = a.remove("t", &["b", "c", "d", "x"]).unwrap();
handshake(a, b).unwrap();
t.remove("c", &["a", "b", "d", "x"]).unwrap();
let thief_newest = t.remove("d", &["a", "b", "x"]).unwrap();
assert!(thief_newest.number > removal.number);
handshake(t, x).unwrap();
handshake(x, b).unwrap();
handshake(x, b).unwrap();
for here in [b, x] {
assert_eq!(here.revoked(), ["c", "d", "t"], "on {}", here.id());
assert!(
here.newest().number > thief_newest.number,
"on {}",
here.id()
);
assert!(!t.holds(&here.newest()));
}
assert_eq!(b.newest(), x.newest());
}
fn pair(introducer: &Device, id: &str) -> Device {
let new = device(id, &[]);
let keys = DeviceKeys::load(&new.dir.path().join(DEVICE_KEY_FILE))
.unwrap()
.unwrap();
let row = row_for(introducer, id, &keys);
let introducer_keys = DeviceKeys::load(&introducer.dir.path().join(DEVICE_KEY_FILE))
.unwrap()
.unwrap();
introducer
.store
.insert_first_device_record(&row, introducer.id(), &introducer_keys.verifying_key())
.unwrap();
new
}
fn row_for(introducer: &Device, id: &str, keys: &DeviceKeys) -> SignedRecord {
let own = introducer
.store
.device_record(introducer.id())
.unwrap()
.unwrap();
let introducer_keys = DeviceKeys::load(&introducer.dir.path().join(DEVICE_KEY_FILE))
.unwrap()
.unwrap();
DeviceRecord {
machine_id: id.to_string(),
identity_tag: own.current.record.identity_tag.clone(),
version: 1,
name: id.to_string(),
age_recipient: keys.age_recipient().to_string(),
ssh_public_key: keys.ssh_public_key(),
signing_public_key: keys.verifying_key().to_bytes(),
recovery_fingerprints: Vec::new(),
ssh_login: None,
ssh_port: None,
ssh_host_key: None,
}
.sign(introducer.id(), introducer_keys.signing_key())
}
#[test]
fn a_device_the_revoked_one_paired_is_refused_later_unless_the_remover_kept_it() {
for kept in [false, true] {
let devices = mesh(&["a", "b", "c", "d"]);
let [a, b, c, d] = &devices[..] else {
unreachable!()
};
let n = pair(c, "n");
handshake(c, b).unwrap();
if kept {
handshake(c, a).unwrap();
}
assert!(d.store.device_record("n").unwrap().is_none());
let keeping: &[&str] = if kept { &["b", "d", "n"] } else { &["b", "d"] };
let epoch = a.remove("c", keeping).unwrap();
handshake(b, a).unwrap();
let mut forged = a.hello_for(d);
forged.devices.retain(|row| row.record.machine_id != "n");
forged
.devices
.push(row_for(c, "n", &DeviceKeys::generate().unwrap()));
d.accept(a, &forged).unwrap();
assert!(
d.store.device_record("n").unwrap().is_none(),
"a row only the revoked device signed is refused, kept: {kept}"
);
handshake(a, d).unwrap();
handshake(b, d).unwrap();
for here in [a, b, d] {
let active = here
.store
.device_record("n")
.unwrap()
.is_some_and(|row| !row.revoked);
assert_eq!(active, kept, "on {}, kept: {kept}", here.id());
let wrapped = here.keyring().handshake_for("n", None).unwrap().envelopes;
assert_eq!(!wrapped.is_empty(), kept, "on {}, kept: {kept}", here.id());
}
assert!(d.holds(&epoch));
if kept {
let legit = DeviceKeys::load(&n.dir.path().join(DEVICE_KEY_FILE))
.unwrap()
.unwrap();
let row = d.store.device_record("n").unwrap().unwrap();
assert_eq!(
row.current.record.signing_public_key,
legit.verifying_key().to_bytes()
);
}
}
}
fn opens(here: &Device, from: Option<&str>, line: &str) -> bool {
here.keyring().open_lines(from, &[line.to_string()]).is_ok()
}
fn sealed(by: &Device, to: &str, under: Option<&[Epoch]>) -> String {
seal_line(&by.keyring().sealer_for(to, under).unwrap(), b"r").unwrap()
}
#[test]
fn frames_under_an_epoch_older_than_the_removal_are_refused_once_the_peer_used_the_new_one() {
let devices = mesh(&["a", "b", "c"]);
let [a, b, _] = &devices[..] else {
unreachable!()
};
let old = b.newest();
let stale = sealed(b, "a", Some(&[old]));
assert!(opens(a, Some("b"), &stale));
let epoch = a.remove("c", &["b"]).unwrap();
assert!(!opens(a, None, &stale));
for push in 0..2 {
b.accept(a, &a.hello_for(b)).unwrap();
assert!(opens(b, Some("a"), &sealed(a, "b", None)), "push {push}");
}
assert!(
opens(a, Some("b"), &stale),
"b has not sealed under the new epoch"
);
handshake(a, b).unwrap();
handshake(b, a).unwrap();
assert_eq!(
b.keyring().sealer_for("a", None).unwrap().sealing_epoch(),
Some(&epoch)
);
assert!(opens(a, Some("b"), &sealed(b, "a", None)));
let refused = a.keyring().open_lines(Some("b"), &[stale]).unwrap_err();
assert!(refused.downcast_ref::<IdentityMismatch>().is_some());
assert!(
format!("{refused:#}").contains("older than epoch"),
"{refused:#}"
);
}
#[test]
fn a_snapshot_is_opened_under_the_same_epoch_floor_and_revocations_as_frames() {
let devices = mesh(&["a", "b", "c"]);
let [a, b, _] = &devices[..] else {
unreachable!()
};
let old = b.newest();
assert!(a.keyring().snapshot_opening_key("b", &old).is_ok());
let epoch = a.remove("c", &["b"]).unwrap();
let revoked = a.keyring().snapshot_opening_key("c", &old).unwrap_err();
assert!(revoked.downcast_ref::<IdentityMismatch>().is_some());
handshake(a, b).unwrap();
handshake(b, a).unwrap();
assert!(a.keyring().snapshot_opening_key("b", &old).is_ok());
a.keyring().opened_snapshot("b", &epoch).unwrap();
let stale = a.keyring().snapshot_opening_key("b", &old).unwrap_err();
assert!(stale.downcast_ref::<IdentityMismatch>().is_some());
assert!(
format!("{stale:#}").contains("older than epoch"),
"{stale:#}"
);
assert!(a.keyring().snapshot_opening_key("b", &epoch).is_ok());
}
#[test]
fn a_removed_device_can_revoke_only_its_remover_which_reaches_what_the_remover_paired() {
for thief_keeps_n in [true, false] {
let devices = mesh(&["a", "b", "c", "d"]);
let [a, b, c, _] = &devices[..] else {
unreachable!()
};
let _n = pair(a, "n");
handshake(a, b).unwrap();
a.remove("c", &["b", "d"]).unwrap();
handshake(a, b).unwrap();
c.remove("d", &["a", "b"]).unwrap();
let keeping: &[&str] = if thief_keeps_n {
&["b", "d", "n"]
} else {
&["b", "d"]
};
c.remove("a", keeping).unwrap();
assert_eq!(c.hello_for(b).revocations.len(), 2);
assert!(is_mismatch(b.accept(c, &c.hello_for(b))));
let expected: &[&str] = if thief_keeps_n {
&["a", "c"]
} else {
&["a", "c", "n"]
};
assert_eq!(b.revoked(), expected, "thief keeps n: {thief_keeps_n}");
}
}
#[test]
fn a_device_cannot_remove_itself_or_a_stranger_or_a_device_twice() {
let devices = mesh(&["a", "b", "c"]);
let a = &devices[0];
let none = BTreeSet::new();
for (target, expected) in [("a", "can't remove itself"), ("x", "no device x")] {
let err = a.keyring().remove_device(target, &none, NOW).unwrap_err();
assert!(format!("{err:#}").contains(expected), "{err:#}");
}
a.remove("c", &["b"]);
let err = a.keyring().remove_device("c", &none, NOW).unwrap_err();
assert!(format!("{err:#}").contains("already removed"), "{err:#}");
}
#[test]
fn a_hello_carrying_revocations_and_causes_round_trips_as_one_shell_word() {
let devices = mesh(&["a", "b", "c"]);
let [a, b, _] = &devices[..] else {
unreachable!()
};
a.remove("c", &["b"]).unwrap();
let keys = a.hello_for(b);
assert_eq!(keys.revocations.len(), 1);
assert_eq!(keys.causes.len(), 1);
let hello = Hello {
machine_id: "a".to_string(),
wall_micros: NOW,
synced: true,
cursor: None,
held_origin_seq: None,
keys: Some(keys),
peer_in: None,
log_floor: 0,
head: 0,
applied: None,
merging: None,
};
assert_eq!(Hello::from_arg(&hello.to_arg()).unwrap(), hello);
}