From 56fbbcf61ae77aed17b1fc04e914ccd3939df26f Mon Sep 17 00:00:00 2001 From: tv Date: Sun, 15 Nov 2026 21:43:18 +0000 Subject: rules: a swarm turns strict only at its start or through a strict remake A strict policy written into a running swarm left a time before it: changes written there, beside the turn, were refused by the nodes that took the turn first and taken by the others where they came first (a signed policy that isn't strict, among them, unseated the turn there); and a remake whose base preceded the turn had every switching node replay the turn as one of its own, each refusing the others'. A change writing a strict policy where the policy at its history isn't strict (`"signed"` at its `values`, or an envelope there asking for signed values) is now refused, in every swarm. A swarm turns strict at its start (`--bootstrap-policy`) or through a strict remake, each its epoch's first change: no change of a strict epoch is from before its policy, and the rule for the time before goes, with the walk that found the changes that turned a swarm strict and what kept them (`before_strict`, `turned_strict`, `Reads::strict_now`, `Reads::turned_now`, `store::writers`, `store::made`, `changes::in_history`). The strict swarm's simulation starts strict. access.md says so, and that a strict swarm can't move to a policy its nodes don't know by writing it. --- docs/access.md | 33 ++++++++++----------------------- 1 file changed, 10 insertions(+), 23 deletions(-) (limited to 'docs') diff --git a/docs/access.md b/docs/access.md index 29b4cb6..942621c 100644 --- a/docs/access.md +++ b/docs/access.md @@ -465,29 +465,16 @@ _continuum/users/bob '{…}'`). A node takes one only from that user, for that path, replacing what is there, by one of the user's keys, and if the user may write there ([`api.md`](api.md), Signed values); it writes nothing else there, nor within or above such a value (`409`), and the users API -changes nothing (`409`). Values there before the policy stay as they are until replaced: -a registry whose entries hold the users' keys turns strict as it is. As it is means -trusted as it is: whatever entries, policy and bans it holds then count, plain values -and envelopes alike, checked or not, whoever wrote them before (under a policy that -isn't strict, a member may write as any user). So a swarm is best strict from its start -(`--bootstrap-policy`, A new swarm, above); one already running turns strict through a -remake (Turning a swarm strict, below), which keeps only what an operator looked over. -Writing the strict policy into it directly trusts it as it is: look it over first -(`continuum-signed verify` on each entry). From then on nothing is added to the time -before: a change written under a policy that isn't strict is refused, received or held, -where the change that turned the swarm strict (that wrote the strict policy under one -that wasn't) is neither in its history nor built on it, so a member can't plant at that -time what nobody could follow; a node that took one beside that change drops it once a -peer tells it so (Changes judged on every node, below). A strict swarm stays strict: its -policy is written again only as strict, never relaxed nor deleted, so which change -turned it doesn't change either; to leave it, start a new swarm from its content (A new -swarm, above). A change beside that one is refused like any other, even one turning the -swarm strict too, so a change made later to look as old can't take its place: two -members turning a swarm strict at once split the nodes that took one from those that -took the other, so it is turned from one. A value there that isn't an envelope starts -its chain anew: any envelope its user once signed for that path replacing nothing -(`prev` empty) can be put there again. Without the policy, signed values may be written -all the same, and plain ones too. +changes nothing (`409`). A swarm turns strict only at its start (`--bootstrap-policy`, A +new swarm, above) or through a remake (Turning a swarm strict, below), which keeps only +what an operator looked over: each is its epoch's first change, so no change of a strict +epoch is from before its policy. A change writing a strict policy where the policy isn't +strict is refused. A strict swarm stays strict: its policy is written again only as +strict, never relaxed nor deleted, nor moved to a policy its nodes don't know (a node +that doesn't know a policy reads it as none it can judge by); to leave it, start a new +swarm from its content (A new swarm, above). A value there that isn't an envelope starts its chain anew: any envelope its +user once signed for that path replacing nothing (`prev` empty) can be put there again. +Without the policy, signed values may be written all the same, and plain ones too. Keep two users who may manage users, or two keys each: under a strict policy, a registry whose only manager lost its keys changes no more (the protocol writers do -- cgit v1.3.1