aboutsummaryrefslogtreecommitdiffstats
path: root/docs/federation.md
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-19 01:48:57 +0000
committertv <tv@krebsco.de>2026-11-19 03:18:49 +0100
commit03744437a5ffc36fbb5e973a0ddfd6b91945b212 (patch)
tree227eb42b4e7cac546b857cfacb79ab890e8bb137 /docs/federation.md
parentf24063e90d02ef76d87401d6e74cf8c9f489ff7d (diff)
federation: votes on the events proposing a checkpoint above its heads
Anyone could propose a checkpoint's version again, by an event beside its heads. A node voting by itself, and a party's client, built a vote on every event proposing what it voted on, so every vote was beside the heads, and no version event written on them was taken: the checkpoint could never move the store. And the voters' rule refused it once that event was held for a while, as the heads left it out. They vote on the events proposing it that are above the heads it names (`State::proposing`), which `GET /events/counts` lists as `proposals`; where there are none, `none` says so, the node casts nothing and the client says why. The voters' rule leaves proposals and votes aside, as they lapse with the move. Row 70 is tested (`federation_attack_70`).
Diffstat (limited to 'docs/federation.md')
-rw-r--r--docs/federation.md51
1 files changed, 27 insertions, 24 deletions
diff --git a/docs/federation.md b/docs/federation.md
index 669527d..6438c42 100644
--- a/docs/federation.md
+++ b/docs/federation.md
@@ -446,30 +446,32 @@ starting from a checkpoint holds what judging them reads. A proposer names heads
held for a while, by its own clock, which judges nothing, so that every node holds them.
A party's client, and a node voting by itself, back a checkpoint only where everything
they held for a while before it was proposed is among its heads, in their history, or
-above them: a move refuses what isn't above its heads, and heads a proposer made up,
-built on little, would take back what was written since, a key set dropping a stolen key
-among it. A node shows, for a proposed checkpoint, what it holds that its heads lack, as
-for a fork ([Forks](#forks)). This is the voter's rule, by its own clock: nothing more is
-judged. It is a version only where its proposal is above those heads, and a version event
-writing it is taken only where it is above them too, and so is every vote it is written on
-([`store.md`](store.md), [Events](store.md#events)): so moving to the checkpoint refuses
-nothing that decided it. A party's client, and a node voting by itself, vote on the events
-proposing what they vote on, and a node proposes a checkpoint on its heads: so their votes
-are above those heads wherever the proposal is. A vote beside them binds its party as any
-yes does, until the move refuses it. A node that takes the version moves to the
-checkpoint: it builds it, forgets everything before those heads that it doesn't keep, and
-every event not above them, and refuses such events from then on. Judging an event after
-them needs nothing it forgot: the version, every party's keys and node list, and the
-proposals on the current version with their votes all count, and are kept. A node starting
-from a checkpoint reads what it keeps as written under its version, as it holds none of
-their histories: each was written under that one or an earlier, counting there, a kept
-proposal is on it, and a later `since` that leaves one out is past it. A node that can't
-build a checkpoint, as it was away across a move and a remake after it, or as it joins,
-takes it only where its operator pins it ([`store.md`](store.md),
-[Pinned checkpoints](store.md#pinned-checkpoints)). What it can't check of its heads it
-takes on its operator's word: that they are after the checkpoint current at the version
-naming them, at which that one is current too; so it judges that version as every node
-does.
+above them, proposals and votes aside, which lapse with the move: a move refuses what
+isn't above its heads, and heads a proposer made up, built on little, would take back what
+was written since, a key set dropping a stolen key among it. A node shows, for a proposed
+checkpoint, what it holds that its heads lack, as for a fork ([Forks](#forks)). This is
+the voter's rule, by its own clock: nothing more is judged. It is a version only where its
+proposal is above those heads, and a version event writing it is taken only where it is
+above them too, and so is every vote it is written on ([`store.md`](store.md),
+[Events](store.md#events)): so moving to the checkpoint refuses nothing that decided it. A
+party's client, and a node voting by itself, vote on the events proposing what they vote
+on that are above those heads, as a node shows them, and a node proposes a checkpoint on
+its heads: so their votes are above those heads wherever the proposal is. One proposing it
+again beside them they don't build on, as a vote on it would be beside them too. A vote
+beside them binds its party as any yes does, until the move refuses it. A node that takes
+the version moves to the checkpoint: it builds it, forgets everything before those heads
+that it doesn't keep, and every event not above them, and refuses such events from then
+on. Judging an event after them needs nothing it forgot: the version, every party's keys
+and node list, and the proposals on the current version with their votes all count, and
+are kept. A node starting from a checkpoint reads what it keeps as written under its
+version, as it holds none of their histories: each was written under that one or an
+earlier, counting there, a kept proposal is on it, and a later `since` that leaves one out
+is past it. A node that can't build a checkpoint, as it was away across a move and a
+remake after it, or as it joins, takes it only where its operator pins it
+([`store.md`](store.md), [Pinned checkpoints](store.md#pinned-checkpoints)). What it can't
+check of its heads it takes on its operator's word: that they are after the checkpoint
+current at the version naming them, at which that one is current too; so it judges that
+version as every node does.
What a checkpoint loses: what counted no more before it, so that a key added back, or a
place given back, brings back nothing signed before it, and a party that voted twice on
@@ -730,6 +732,7 @@ fold, with crafted events. *Sim*: a simulation. *Bench*: measured, not judged.
| 67 | A party keeps a proposal alive that nobody else backs, to hold back automatic checkpoints | Holds back none: a node proposes a checkpoint beside a proposal it wouldn't back that nobody backs but its proposer | sim |
| 68 | A checkpoint proposed at heads that leave out what was written since: a key set dropping a stolen key, say | Not backed: clients and nodes back a checkpoint only where what they held for a while is among its heads, in their history, or above them; a node shows what they lack | unit |
| 69 | A key a version names, stolen, writes its party's node list at a history from before the version naming the party's keys anew, beside the list the party writes under that version, several, for the lowest ID | The party's counts: of a party's lists, those written under the latest version come first | unit |
+| 70 | A checkpoint's version proposed again, by an event beside its heads | Voters back it all the same, as a proposal lapses with the move, and vote on the events proposing it above its heads, as a node shows them; a version event on votes beside them is refused | unit |
## Roads not taken