summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-19 11:23:40 +0000
committertv <tv@krebsco.de>2026-11-19 13:10:02 +0100
commite8f0760a9b08e6b1a7372e79c48744035d1e4e1a (patch)
treece159860da9a97cfba4758e8e03d73a97cd97c59
parentd62c36d10e916bff09dff56c384e38bb93e82d86 (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.
-rw-r--r--src/federation/attacks.rs179
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());
}