aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-15 20:18:07 +0000
committertv <tv@krebsco.de>2026-11-15 20:18:07 +0000
commit9ebdd9011d086bc74351c527f6626fe403ef3348 (patch)
tree00157c5de9b899f5b0f4ce4bcf130222a8cba9bb
parentcb3ccc5c6107cc4fd96c4d7b184cc9b811857db1 (diff)
rules: a strict swarm stays strict
A strict policy could be written over with one that isn't, or deleted, by a user who may manage the policy. While the swarm was relaxed so, nothing was asked of the time before it turned strict: a change written beside that turn was taken, and once the swarm turned strict again, built on, a node judging that change while strict from the first turn (one back from away, a joiner) refused it, and every node it told dropped it with the second turn and everything after. Under a strict policy, the policy is now written again only as strict: an envelope there whose value isn't a strict policy, a signed `null` among them, is refused. So a strict swarm has one change that turned it, and the time before it stays closed; to leave it, start a new swarm from its content. A swarm that isn't strict writes its policy as it did.
-rw-r--r--docs/access.md50
-rw-r--r--src/access/rules.rs32
2 files changed, 57 insertions, 25 deletions
diff --git a/docs/access.md b/docs/access.md
index ee48b8d..75f8db2 100644
--- a/docs/access.md
+++ b/docs/access.md
@@ -461,30 +461,32 @@ curl -u alice -X POST -H 'Content-Type: application/json' \
Under a strict policy, the same, as part of bob's entry, signed (`continuum-signed put
_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). The policy
-written again later doesn't change which change that is. One written beside it 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.
+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.
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
diff --git a/src/access/rules.rs b/src/access/rules.rs
index 745dd7e..c84adc9 100644
--- a/src/access/rules.rs
+++ b/src/access/rules.rs
@@ -533,8 +533,19 @@ fn signed_values(at: &At<'_>, ops: &[Op]) -> Result<(), String> {
}
_ => None,
};
- super::envelope::check(at, envelope, path, previous.as_deref())
+ let checked = super::envelope::check(at, envelope, path, previous.as_deref())
.map_err(|why| format!("{}: {why}", shown(path)))?;
+ // A strict swarm stays strict: its policy is written again only as strict,
+ // never relaxed nor deleted, so the time before it turned strict stays what
+ // it was (`before_strict`).
+ if *path == super::policy::path()
+ && !super::policy::read(&checked.payload.value).strict()
+ {
+ return Err(format!(
+ "{}: a strict policy is written again only as strict",
+ shown(path)
+ ));
+ }
} else if super::envelope::signed_path(&signed, path).is_some() {
return Err(format!("{} is within a value its user signs", shown(path)));
} else if op.action != Action::Within
@@ -1118,6 +1129,25 @@ mod tests {
// Elsewhere: as without the policy.
assert!(judged(&doc, vec![op("notes/x", Action::PutString("x".to_owned()))]).is_ok());
assert!(refused(judged(&doc, vec![op("", Action::Nowhere)])));
+ // The policy itself: written again only as strict, never relaxed nor deleted.
+ let policy = |value: serde_json::Value| {
+ let payload = envelope::Payload {
+ value,
+ swarm: "s".to_owned(),
+ path: path("_continuum/access/policy"),
+ user: "alice".to_owned(),
+ at: 1,
+ seq: 0,
+ prev: String::new(),
+ };
+ let bytes = payload.signed();
+ let sealed =
+ envelope::seal(&bytes, &sshsig::sign(&key, envelope::NAMESPACE, &bytes)).unwrap();
+ vec![op("_continuum/access/policy", Action::PutString(sealed))]
+ };
+ assert!(judged(&doc, policy(json!({"version": 1, "values": "signed"}))).is_ok());
+ assert!(refused(judged(&doc, policy(json!({"version": 1})))));
+ assert!(refused(judged(&doc, policy(json!(null)))));
}
/// Where values are declared sealed: only sealed ones, as declared, with or without