aboutsummaryrefslogtreecommitdiffstats
path: root/docs/access.md
diff options
context:
space:
mode:
Diffstat (limited to 'docs/access.md')
-rw-r--r--docs/access.md33
1 files changed, 10 insertions, 23 deletions
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