From 598366b03679eac9d04f32d9194f3ba4ba9c3da8 Mon Sep 17 00:00:00 2001 From: tv Date: Wed, 18 Nov 2026 17:26:53 +0000 Subject: store: a drop refuses whatever writes what a dropped event writes A fold may say what an event writes that others may write alike (`Fold::writes`): of the federation, a version event's version. A node whose operator has it drop such an event drops the taken events writing the same with it, and refuses any writing it from then on, whoever wrote it anew: of a version, it takes no other version event naming it and writes none itself, though it holds the votes that passed it. The node keeps what each dropped event writes in its store file, across restarts; allowing one of them takes them all back. Row 51 of the federation's attacks has its test, and waits no more. --- src/federation/held.rs | 83 +++++++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 75 insertions(+), 8 deletions(-) (limited to 'src/federation/held.rs') diff --git a/src/federation/held.rs b/src/federation/held.rs index c29dd0a..200323e 100644 --- a/src/federation/held.rs +++ b/src/federation/held.rs @@ -50,7 +50,8 @@ const LOOK: Duration = Duration::from_secs(5); const PUT_BYTES: usize = 1024 * 1024; /// What a node keeps of its own of its store across restarts, as its file holds it: the -/// events it refused by what it took before, and those its operator had it drop, by ID. +/// events it refused by what it took before, and those its operator had it drop, by ID; +/// and of the dropped version events, the version each writes. #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)] #[serde(rename_all = "camelCase", deny_unknown_fields)] struct Kept { @@ -58,24 +59,38 @@ struct Kept { refused: BTreeSet, #[serde(default)] dropped: BTreeSet, + #[serde(default)] + writes: BTreeMap, } +/// What the store refused of its own, what it dropped, and of the dropped what each writes. +type KeptIds = (Vec, Vec, Vec<(Id, Id)>); + impl Kept { - fn of(own: &[Id], dropped: &[Id]) -> Self { + fn of(own: &[Id], dropped: &[Id], writes: &[(Id, Id)]) -> Self { Kept { refused: own.iter().map(Id::to_string).collect(), dropped: dropped.iter().map(Id::to_string).collect(), + writes: writes + .iter() + .map(|(id, writes)| (id.to_string(), writes.to_string())) + .collect(), } } - /// The IDs it holds: what was refused, and what dropped. - fn ids(&self) -> Option<(Vec, Vec)> { + /// The IDs it holds: what was refused, what dropped, and what of that writes what. + fn ids(&self) -> Option { let ids = |set: &BTreeSet| { set.iter() .map(|id| Id::from_hex(id)) .collect::>>() }; - Some((ids(&self.refused)?, ids(&self.dropped)?)) + let writes = self + .writes + .iter() + .map(|(id, writes)| Some((Id::from_hex(id)?, Id::from_hex(writes)?))) + .collect::>>()?; + Some((ids(&self.refused)?, ids(&self.dropped)?, writes)) } } @@ -248,7 +263,7 @@ impl Holding { return; }; let id = Id::of(&root); - let (own, dropped) = inner.kept.ids().unwrap_or_default(); + let (own, dropped, writes) = inner.kept.ids().unwrap_or_default(); // What a checkpoint keeps follows it in the document: a fork's root's too. let kept = |checkpoint: &[u8]| -> Option>> { Federation::parts(checkpoint) @@ -296,7 +311,7 @@ impl Holding { match started { Ok(store) => { info!(store = %id, refused = own.len(), dropped = dropped.len(), "Reading the store from the document"); - inner.store = Some(store.refusing(&own, &dropped)); + inner.store = Some(store.refusing(&own, &dropped, &writes)); } Err(why) => { if inner.none.replace(id) != Some(id) { @@ -342,7 +357,7 @@ impl Holding { inner.taken_at.entry(*id).or_insert(now); } let (own, dropped) = store.own(); - let kept = Kept::of(&own, &dropped); + let kept = Kept::of(&own, &dropped, &store.dropped_writes()); if kept != inner.kept { for id in kept.refused.difference(&inner.kept.refused) { warn!(event = %id, "Refused an event its history takes, by what this node took before: kept so"); @@ -1609,6 +1624,58 @@ mod tests { ); } + /// Row 51 (`docs/federation.md`): a node whose operator had it drop a version is sent + /// it again, written anew by another node, and holds the votes that passed it: it takes + /// no event writing that version and writes it no more, before or after a restart, + /// until its operator allows it again. + #[test] + fn federation_attack_51() { + let (tv, lass, makefu) = ( + Party::new("tv", 1), + Party::new("lass", 2), + Party::new("makefu", 3), + ); + let first = Spec::first(&[&tv, &lass, &makefu], &[]); + let root = first.root(); + let on = first.hash(); + let one = first.after(on); + let proposal = tv.propose(&[Id::of(&root)], &one.json()); + let votes = [&tv, &lass, &makefu] + .map(|party| party.vote(&[Id::of(&proposal)], on, one.hash(), true)); + let written = harness::version_event(&[Id::of(&votes[0]), Id::of(&votes[1])], one.hash()); + let anew = harness::version_event(&[Id::of(&votes[1]), Id::of(&votes[2])], one.hash()); + let current = |holding: &Holding| holding.with(|store| store.state().current().hash); + let started = || { + let mut doc = events::started(Federation::NAME, &root, &[]).unwrap(); + for event in [&proposal].into_iter().chain(&votes).chain([&written]) { + put(&mut doc, event); + } + doc + }; + let dir = crate::files::scratch_dir("held-attack-51"); + let path = dir.join("store.json"); + let files = Arc::new(Files::default()); + let holding = Holding::open(Some(path.clone()), Arc::clone(&files), None, None).unwrap(); + read(&holding, &started(), 0); + assert_eq!(current(&holding), Some(one.hash())); + holding.drop_taken(&[Id::of(&written)]).unwrap().unwrap(); + assert_eq!(current(&holding), Some(on)); + // Sent again, in another document, beside the same version written anew. + let mut again = started(); + assert_eq!(put_by(&mut again, "node-b", &anew), Ok(())); + read(&holding, &again, 1); + assert_eq!(current(&holding), Some(on)); + assert_eq!(holding.passed(), Vec::>::new()); + let restarted = Holding::open(Some(path), files, None, None).unwrap(); + read(&restarted, &again, 0); + assert_eq!(current(&restarted), Some(on)); + assert_eq!(restarted.passed(), Vec::>::new()); + // Allowed again: taken. + assert!(restarted.allow(&[Id::of(&written)])); + read(&restarted, &again, 0); + assert_eq!(current(&restarted), Some(one.hash())); + } + // The store's attack rows (`docs/store.md`, Attacks) read from a document. /// tv's federation, its root, and a document started from it. -- cgit v1.3.1