diff options
| author | tv <tv@krebsco.de> | 2026-11-19 11:23:40 +0000 |
|---|---|---|
| committer | tv <tv@krebsco.de> | 2026-11-19 13:10:02 +0100 |
| commit | e8f0760a9b08e6b1a7372e79c48744035d1e4e1a (patch) | |
| tree | ce159860da9a97cfba4758e8e03d73a97cd97c59 /src/federation | |
| parent | d62c36d10e916bff09dff56c384e38bb93e82d86 (diff) | |
attacks: the histories they offer, recorded while asked to
The attack rows' tests craft histories and assert what the design says becomes of each
event: worth judging by later releases too, as they were judged when the tests passed.
Their stores are made and offered through the harness (`Fed::new`, `Fed::offer`), and
while `recording` runs a test, each of them is recorded: its root, the events offered in
order, and whether nothing but offers made it what it became (an operator's drop doesn't).
A test that fails records nothing. `TESTS` names every attack test, which a test checks
against the file.
Diffstat (limited to 'src/federation')
| -rw-r--r-- | src/federation/attacks.rs | 179 |
1 files changed, 159 insertions, 20 deletions
diff --git a/src/federation/attacks.rs b/src/federation/attacks.rs index 215a860..0f280c5 100644 --- a/src/federation/attacks.rs +++ b/src/federation/attacks.rs @@ -32,35 +32,157 @@ fn makefu() -> Party { struct Fed { store: Store<Federation>, first: Spec, + /// Where what it offers is recorded, while a test is (`recording`). + record: Option<usize>, } -fn fed(parties: &[&Party], rules: &[(&str, Json)]) -> Fed { - let first = Spec::first(parties, rules); - Fed { - store: Store::new(first.root(), Vec::new()).expect("a root"), - first, +/// A history an attack test's store was offered: its root and its events in the order +/// offered, and whether nothing but offers made it what it became. +pub(super) struct Recorded { + pub(super) root: Vec<u8>, + pub(super) events: Vec<Vec<u8>>, + pub(super) offers_only: bool, +} + +thread_local! { + static RECORDING: std::cell::RefCell<Option<Vec<Recorded>>> = + const { std::cell::RefCell::new(None) }; +} + +/// The histories `test` offers its stores, recorded as it runs: none where it fails, so +/// that each recorded is what the test asserts of it (`federation::judge`). +pub(super) fn recording(test: fn()) -> Vec<Recorded> { + RECORDING.with(|recording| *recording.borrow_mut() = Some(Vec::new())); + let passed = std::panic::catch_unwind(test).is_ok(); + let recorded = RECORDING.with(|recording| recording.borrow_mut().take()); + if passed { + recorded.unwrap_or_default() + } else { + Vec::new() } } +/// Every attack test by name, to record what each offers (`recording`); checked to list +/// them all (`every_attack_test_is_listed`). +pub(super) const TESTS: &[(&str, fn())] = &[ + ("federation_attack_1", federation_attack_1), + ("federation_attack_2", federation_attack_2), + ("federation_attack_3", federation_attack_3), + ("federation_attack_4", federation_attack_4), + ("federation_attack_5", federation_attack_5), + ("federation_attack_6", federation_attack_6), + ("federation_attack_7", federation_attack_7), + ("federation_attack_8", federation_attack_8), + ("federation_attack_9", federation_attack_9), + ("federation_attack_10", federation_attack_10), + ("federation_attack_11", federation_attack_11), + ("federation_attack_12", federation_attack_12), + ("federation_attack_13", federation_attack_13), + ("federation_attack_14", federation_attack_14), + ("federation_attack_15", federation_attack_15), + ("federation_attack_16", federation_attack_16), + ("federation_attack_17", federation_attack_17), + ("federation_attack_18", federation_attack_18), + ("federation_attack_19", federation_attack_19), + ("federation_attack_20", federation_attack_20), + ("federation_attack_21", federation_attack_21), + ("federation_attack_22", federation_attack_22), + ("federation_attack_23", federation_attack_23), + ("federation_attack_24", federation_attack_24), + ("federation_attack_25", federation_attack_25), + ("federation_attack_26", federation_attack_26), + ("federation_attack_27", federation_attack_27), + ("federation_attack_31", federation_attack_31), + ("federation_attack_32", federation_attack_32), + ("federation_attack_34", federation_attack_34), + ("federation_attack_35", federation_attack_35), + ("federation_attack_36", federation_attack_36), + ("federation_attack_37", federation_attack_37), + ("federation_attack_38", federation_attack_38), + ("federation_attack_40", federation_attack_40), + ("federation_attack_41", federation_attack_41), + ("federation_attack_42", federation_attack_42), + ("federation_attack_43", federation_attack_43), + ("federation_attack_44", federation_attack_44), + ("federation_attack_46", federation_attack_46), + ("federation_attack_47", federation_attack_47), + ("federation_attack_48", federation_attack_48), + ("federation_attack_50", federation_attack_50), + ("federation_attack_52", federation_attack_52), + ("federation_attack_53", federation_attack_53), + ("federation_attack_54", federation_attack_54), + ("federation_attack_55", federation_attack_55), + ("federation_attack_56", federation_attack_56), + ("federation_attack_57", federation_attack_57), + ("federation_attack_61", federation_attack_61), + ("federation_attack_62", federation_attack_62), + ("federation_attack_63", federation_attack_63), + ("federation_attack_64", federation_attack_64), + ("federation_attack_69", federation_attack_69), + ("federation_attack_71", federation_attack_71), +]; + +fn fed(parties: &[&Party], rules: &[(&str, Json)]) -> Fed { + Fed::new(Spec::first(parties, rules)) +} + /// tv, lass and makefu, each with a namespace. fn three() -> Fed { fed(&[&tv(), &lass(), &makefu()], &[]) } impl Fed { + /// A store from the root of `first`, recorded while a test is (`recording`). + fn new(first: Spec) -> Fed { + let root = first.root(); + let record = RECORDING.with(|recording| { + recording.borrow_mut().as_mut().map(|histories| { + histories.push(Recorded { + root: root.clone(), + events: Vec::new(), + offers_only: true, + }); + histories.len() - 1 + }) + }); + Fed { + store: Store::new(root, Vec::new()).expect("a root"), + first, + record, + } + } + + /// Changes its recorded history, where it is recorded. + fn recorded(&self, change: impl FnOnce(&mut Recorded)) { + let Some(at) = self.record else { + return; + }; + RECORDING.with(|recording| { + if let Some(histories) = recording.borrow_mut().as_mut() { + change(&mut histories[at]); + } + }); + } + + /// Offers `bytes` to its store, recorded. + fn offer(&mut self, bytes: Vec<u8>) -> Offered { + self.recorded(|history| history.events.push(bytes.clone())); + self.store.offer(bytes) + } + fn root(&self) -> Id { self.store.id() } fn take(&mut self, bytes: Vec<u8>) -> Id { - match self.store.offer(bytes) { + match self.offer(bytes) { Offered::Taken(ids) => ids[0], other => panic!("not taken: {other:?}"), } } fn refused(&mut self, bytes: Vec<u8>) -> Refusal { - match self.store.offer(bytes) { + match self.offer(bytes) { Offered::Refused(why) => why, other => panic!("not refused: {other:?}"), } @@ -74,9 +196,10 @@ impl Fed { /// An event the store stops at (`Fold::stops`), and its operator has it drop. fn stops(&mut self, bytes: Vec<u8>) { let id = Id::of(&bytes); - assert_eq!(self.store.offer(bytes), Offered::Stopped); + assert_eq!(self.offer(bytes), Offered::Stopped); assert_eq!(self.store.stopped().map(|(at, ..)| *at), Some(id)); assert_eq!(self.store.drop_taken(&[id]), Ok(vec![id])); + self.recorded(|history| history.offers_only = false); } fn value(&self, path: &str) -> Option<Json> { @@ -124,6 +247,28 @@ fn every_row_has_its_test() { } #[test] +fn every_attack_test_is_listed() { + let defined: std::collections::BTreeSet<&str> = include_str!("attacks.rs") + .lines() + .filter_map(|line| line.strip_prefix("fn federation_attack_")) + .filter_map(|rest| rest.strip_suffix("() {")) + .collect(); + let listed: std::collections::BTreeSet<&str> = TESTS + .iter() + .map(|(name, _)| { + name.strip_prefix("federation_attack_") + .expect("an attack test") + }) + .collect(); + assert_eq!(listed, defined, "TESTS lists every attack test, once"); + assert_eq!( + listed.len(), + TESTS.len(), + "TESTS lists every attack test, once" + ); +} + +#[test] fn federation_attack_1() { let mut fed = three(); let root = fed.root(); @@ -171,7 +316,7 @@ fn federation_attack_3() { let other = fed_with_rule("names/x"); let tv = tv(); let elsewhere = tv.write(&[other.root()], "home/tv/a", s("1")); - assert_eq!(fed.store.offer(elsewhere), Offered::Waiting); + assert_eq!(fed.offer(elsewhere), Offered::Waiting); let root = fed.root(); let here = fed.take(tv.write(&[root], "home/tv/a", s("1"))); let mut fork = fed.first.after(fed.first.hash()); @@ -182,7 +327,7 @@ fn federation_attack_3() { .expect("a fork"); let forked: Store<Federation> = Store::new(fork_root, kept).expect("its root"); let after = tv.write(&[forked.id()], "home/tv/b", s("2")); - assert_eq!(fed.store.offer(after), Offered::Waiting); + assert_eq!(fed.offer(after), Offered::Waiting); } fn fed_with_rule(path: &str) -> Fed { @@ -197,7 +342,7 @@ fn federation_attack_4() { let old = tv.write(&[root], "home/tv/a", s("1")); let first = fed.take(old.clone()); fed.take(tv.write(&[first], "home/tv/a", s("2"))); - assert_eq!(fed.store.offer(old), Offered::Held); + assert_eq!(fed.offer(old), Offered::Held); assert_eq!(fed.value("home/tv/a"), Some(s("2"))); } @@ -553,7 +698,7 @@ fn federation_attack_20() { fn federation_attack_21() { let (mut fed, before, versions) = twice(); for bytes in before { - fed.store.offer(bytes); + fed.offer(bytes); } fed.take(versions[0].clone()); assert_eq!(fed.refused(versions[1].clone()), Refusal::Own); @@ -1174,10 +1319,7 @@ fn federation_attack_62() { // or `r` longer. The write as it was signed is taken. let mut first = Spec::first(&[&tv, &lass()], &[]); first.parties[0].keys = vec![ECDSA_KEY.to_owned()]; - let mut fed = Fed { - store: Store::new(first.root(), Vec::new()).expect("a root"), - first, - }; + let mut fed = Fed::new(first); let event = super::jcs::read(ECDSA_WRITE.as_bytes()).expect("JCS"); let sig = event.get("sig").and_then(Json::as_str).expect("a sig"); let key = super::keys::key(ECDSA_KEY).expect("a key"); @@ -1267,10 +1409,7 @@ fn federation_attack_63() { // The others pass a checkpoint after their version 1: a node pinning it never takes // the chain old keys grew. - let mut theirs = Fed { - store: Store::new(first.root(), Vec::new()).expect("a root"), - first: first.clone(), - }; + let mut theirs = Fed::new(first.clone()); for event in &others { theirs.take(event.clone()); } |
