diff options
| author | tv <tv@krebsco.de> | 2026-11-18 17:26:53 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-18 18:31:11 +0100 |
| commit | 598366b03679eac9d04f32d9194f3ba4ba9c3da8 (patch) | |
| tree | 91620955243fa081fdd0365fb76c8aca0ba4288c /src/federation/held.rs | |
| parent | f261a80b88c1fb640f4c892934809e15a7e05a95 (diff) | |
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.
Diffstat (limited to 'src/federation/held.rs')
| -rw-r--r-- | src/federation/held.rs | 83 |
1 files changed, 75 insertions, 8 deletions
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<String>, #[serde(default)] dropped: BTreeSet<String>, + #[serde(default)] + writes: BTreeMap<String, String>, } +/// What the store refused of its own, what it dropped, and of the dropped what each writes. +type KeptIds = (Vec<Id>, Vec<Id>, 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<Id>, Vec<Id>)> { + /// The IDs it holds: what was refused, what dropped, and what of that writes what. + fn ids(&self) -> Option<KeptIds> { let ids = |set: &BTreeSet<String>| { set.iter() .map(|id| Id::from_hex(id)) .collect::<Option<Vec<Id>>>() }; - 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::<Option<Vec<(Id, Id)>>>()?; + 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<Vec<Vec<u8>>> { 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::<Vec<u8>>::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::<Vec<u8>>::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. |
