diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/federation/attacks.rs | 27 | ||||
| -rw-r--r-- | src/federation/fold.rs | 27 | ||||
| -rw-r--r-- | src/federation/model.rs | 15 |
3 files changed, 55 insertions, 14 deletions
diff --git a/src/federation/attacks.rs b/src/federation/attacks.rs index 3f44ad0..2043c19 100644 --- a/src/federation/attacks.rs +++ b/src/federation/attacks.rs @@ -1300,6 +1300,33 @@ fn federation_attack_63() { assert_eq!(pinned.state().current().hash, two.hash()); } +/// A key a version names, stolen, writes its party's node list at histories from before +/// the version that names the party's keys anew, beside the list the party writes under +/// that version, several, so that one has a lower ID: the party's counts. +#[test] +fn federation_attack_69() { + let (tv, lass, makefu) = (tv(), lass(), makefu()); + let tv_now = Party::new("tv", 4); + let mut fed = three(); + let root = fed.root(); + let on = fed.first.hash(); + let mut renamed = fed.first.after(on); + renamed.parties[0].keys_since = 1; + renamed.parties[0].keys = vec![tv_now.key_line()]; + let before = fed.take(lass.write(&[root], "home/lass/a", s("1"))); + let (_, written) = fed.pass(&[root], &lass, &renamed, on, &[&lass, &makefu]); + fed.take(tv_now.nodes(&[written], &[harness::node_id(1)])); + for n in 2..6 { + // Taken: tv's old key is named at its history. + fed.take(tv.nodes(&[before], &[harness::node_id(n)])); + } + let state = fed.store.state(); + assert_eq!( + state.nodes_of("tv", state.current()), + vec![harness::node_id(1)] + ); +} + #[test] fn federation_attack_64() { let (mut fed, head, gone, _, written) = moved(); diff --git a/src/federation/fold.rs b/src/federation/fold.rs index 3ebeebf..2e3fc56 100644 --- a/src/federation/fold.rs +++ b/src/federation/fold.rs @@ -186,28 +186,35 @@ impl State { .copied() } - /// The key set, or node list, of `party` that counts by `current`: one written under a - /// version numbered at least the `since` it gives the party's. + /// The key set, or node list, of `party` that counts by `current`: of those written + /// under a version numbered at least the `since` it gives the party's, those written + /// under the latest version, and of those the latest (`latest`). So one a stolen key + /// writes at a history from before the version that named its party's keys anew + /// replaces nothing the party wrote under that version. fn list(&self, party: &str, current: &Version, list: List) -> Option<Id> { let given = current.parties.get(party)?; let since = match list { List::Keys => given.keys_since, List::Nodes => given.nodes_since, }; - let candidates: Vec<Id> = self + let candidates: Vec<(Id, u64)> = self .signed() - .filter(|(_, signed, under)| { - signed.party == party + .filter_map(|(id, signed, under)| { + let number = self.versions.get(under)?.number; + (signed.party == party && matches!( (&signed.does, list), (Does::Keys(_), List::Keys) | (Does::Nodes(_), List::Nodes) ) - && self - .versions - .get(under) - .is_some_and(|version| version.number >= since) + && number >= since) + .then_some((*id, number)) }) - .map(|(id, _, _)| *id) + .collect(); + let latest = candidates.iter().map(|(_, number)| *number).max()?; + let candidates: Vec<Id> = candidates + .into_iter() + .filter(|(_, number)| *number == latest) + .map(|(id, _)| id) .collect(); self.latest(&candidates) } diff --git a/src/federation/model.rs b/src/federation/model.rs index 2107d9f..8cd189b 100644 --- a/src/federation/model.rs +++ b/src/federation/model.rs @@ -205,7 +205,8 @@ impl Model { }) } - /// The key set, or node list, of `party` that counts in a history by `version`. + /// The key set, or node list, of `party` that counts in a history by `version`: of + /// those written under the latest version, the latest. fn list( &self, history: &BTreeSet<Id>, @@ -219,17 +220,23 @@ impl Model { } else { given.nodes_since }; - let ids: Vec<Id> = self + let ids: Vec<(Id, u64)> = self .signed(history) - .filter(|(id, signed)| { + .filter(|(_, signed)| { signed.party == party && match signed.does { Does::Keys(_) => keys, Does::Nodes(_) => !keys, _ => false, } - && self.under(id).is_some_and(|under| under.number >= since) }) + .filter_map(|(id, _)| Some((id, self.under(&id)?.number))) + .filter(|(_, number)| *number >= since) + .collect(); + let latest = ids.iter().map(|(_, number)| *number).max()?; + let ids: Vec<Id> = ids + .into_iter() + .filter(|(_, number)| *number == latest) .map(|(id, _)| id) .collect(); self.latest(&ids) |
