Requirement 001 S6: the hub gets a Firewall view of the Claude Code permission and sandbox settings. The operator signs each change with the passkey; a host settings writer (systemd path unit) applies only exact, signed changes to allowlisted settings files through O_NOFOLLOW directory and file descriptors, and a timer refreshes the view. Every signed text and every page sink refuses or marks hidden characters: Cc, Cf, Zl, Zp, every space but U+0020 and the Default_Ignorable set, with U+FE0E/U+FE0F allowed only after one of the 359 non-ASCII emoji bases of Unicode 16 (shared table, validated at import, the same pair rule on the page). Removal of a deny, ask or denyRead entry is exempt only as an exact single remove. The permission hook prints the hub's refusal reason, cleaned of hidden characters. Accepted MEDUSA false positives (independent review, operator pick): 38 this round, mainly the Unicode defence tables read as attack patterns, generic MM-SCAN-058 heuristics, WEB-FLASK-004 at view.py:213 (ints from the validated table via tojson), EXF26-TOOL-004 on the non-secret WebAuthn challenge, PRIV-SCAN-060 on the office-action shape check and PQC007 on a picker key. 🎯 Fix: 95 % 💥 Break: 3 % 💸 Cost: – ⏱️ Time: – 🛡️ Security: 100 % 🏆 Score: 92 🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
367 lines
28 KiB
Python
367 lines
28 KiB
Python
from __future__ import annotations
|
|
|
|
import functools
|
|
import json
|
|
import time
|
|
from unittest import mock
|
|
|
|
from hub_case import HubCase
|
|
from hub_support import ASK, PRESENT, key, signing, verifier
|
|
from kvb_orchestrator import batches, rules
|
|
|
|
HOME_FILE = "/home/op/.claude/settings.json"
|
|
PROJECT_FILE = "/home/op/Repositories/demo/.claude/settings.json"
|
|
SHA = "ab" * 32
|
|
PERMISSIONS = {
|
|
"allow": ["Bash(make test:*)", "Bash(make lint:*)", "Bash(git status:*)", "WebFetch(domain:example.org)", "mcp__memory__search"],
|
|
"ask": ["Bash(git push:*)"],
|
|
"deny": ["Read(~/.ssh/**)", 7],
|
|
}
|
|
SANDBOX = {"enabled": True, "filesystem": {"allowWrite": ["/tmp", "~/Repositories"]}, "network": {"allowLocalBinding": False}}
|
|
ADD = {"list": "permissions.allow", "op": "add", "entry": "Bash(make build:*)"}
|
|
|
|
|
|
class TestHubFirewall(HubCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.claim("s1", "Skills")
|
|
self.claim("s2", "Stage")
|
|
self.snapshot()
|
|
|
|
def view(self, files: list[dict]) -> None:
|
|
(self.state / "firewall" / "view.json").write_text(json.dumps({"written": time.time(), "files": files}), encoding="utf-8")
|
|
|
|
def home_view(self) -> dict:
|
|
return {"path": HOME_FILE, "exists": True, "sha256": SHA, "error": "", "settings": {"permissions": PERMISSIONS, "sandbox": SANDBOX, "env": {"EXAMPLE_FLAG": "fixture-value-not-a-secret"}}}
|
|
|
|
def firewall(self) -> dict:
|
|
status, _, body = self.get("/api/firewall")
|
|
self.assertEqual(status, 200, body)
|
|
return json.loads(body)
|
|
|
|
def post(self, path: str, payload: object) -> tuple[int, bytes]:
|
|
status, _, body = self.post_json(path, payload, self.guard(self.host))
|
|
return status, body
|
|
|
|
def test_the_firewall_groups_the_settings_by_tool_and_prefix_and_lists_the_deny_patterns(self):
|
|
self.assertEqual(self.firewall()["files"], [])
|
|
self.assertIn("kvb-orchestrator-firewall", self.firewall()["error"])
|
|
self.view([self.home_view(), {"path": PROJECT_FILE, "exists": False, "sha256": "", "error": "", "settings": {}}, {"path": "/x", "exists": "yes", "sha256": "", "settings": {}}])
|
|
found = self.firewall()
|
|
self.assertEqual([entry["path"] for entry in found["files"]], [HOME_FILE, PROJECT_FILE])
|
|
groups = [(group["tool"], group["prefix"], [(entry["list"], entry["entry"]) for entry in group["entries"]]) for group in found["files"][0]["groups"]]
|
|
self.assertEqual(groups, [
|
|
("Bash", "git", [("allow", "Bash(git status:*)"), ("ask", "Bash(git push:*)")]),
|
|
("Bash", "make", [("allow", "Bash(make test:*)"), ("allow", "Bash(make lint:*)")]),
|
|
("Read", "~/.ssh/**", [("deny", "Read(~/.ssh/**)")]),
|
|
("WebFetch", "domain", [("allow", "WebFetch(domain:example.org)")]),
|
|
("mcp__memory__search", "", [("allow", "mcp__memory__search")]),
|
|
])
|
|
self.assertEqual(found["files"][0]["sandbox"], [{"key": "sandbox.enabled", "value": True}, {"key": "sandbox.filesystem.allowWrite", "values": ["/tmp", "~/Repositories"]}, {"key": "sandbox.network.allowLocalBinding", "value": False}])
|
|
self.assertEqual(found["lists"], list(signing.SETTINGS_LISTS))
|
|
self.assertEqual([pattern["label"] for pattern in found["patterns"]][:len(signing.WARNINGS)], [label for label, _ in signing.WARNINGS])
|
|
self.assertNotIn("fixture-value-not-a-secret", json.dumps(found))
|
|
for path in ("/api/firewall/preview", "/api/firewall/settings", "/api/firewall/groups", "/api/firewall/sets", "/api/firewall/groups/0123456789abcdef/delete"):
|
|
with self.subTest(path=path):
|
|
self.assertEqual(self.get(path)[0], 405)
|
|
self.assertEqual(self.get("/api/firewall/settings/0123456789abcdef")[0], 404)
|
|
|
|
def test_a_settings_change_is_previewed_signed_and_queued_for_the_host(self):
|
|
self.view([self.home_view()])
|
|
item = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [ADD, {"list": "permissions.ask", "op": "remove", "entry": "Bash(git push:*)"}]}
|
|
status, body = self.post("/api/firewall/preview", {"items": [item]})
|
|
self.assertEqual(status, 200, body)
|
|
diff = json.loads(body)["diffs"][0]["diff"]
|
|
changed = [line for line in diff.splitlines() if line[:1] in "+-" and line[:3] not in ("+++", "---")]
|
|
self.assertEqual([line[0] + line[1:].strip() for line in changed], ['-"mcp__memory__search"', '+"mcp__memory__search",', '+"Bash(make build:*)"', '-"ask": [', '-"Bash(git push:*)"', '-],', '+"ask": [],'])
|
|
self.assertNotIn("EXAMPLE_FLAG", diff)
|
|
signed = signing.settings_item(HOME_FILE, SHA, item["changes"])
|
|
self.assertEqual(self.prepare([item])["payload"]["items"], [signing.item_hash(signed)])
|
|
signer = self.pin()
|
|
proof = signer.proof(self.prepare([item])["payload"], self.origin)
|
|
for name, items, proven, expected in (
|
|
("no proof", [item], None, 400),
|
|
("forged", [item], key(-7, "intruder").proof(self.prepare([item])["payload"], self.origin), 400),
|
|
("stale base", [{**item, "base": "cd" * 32}], proof, 409),
|
|
("unlisted file", [{**item, "file": PROJECT_FILE}], proof, 400),
|
|
("hooks list", [{**item, "changes": [{**ADD, "list": "hooks.Stop"}]}], proof, 400),
|
|
("added twice", [{**item, "changes": [{**ADD, "entry": "Bash(make test:*)"}]}], proof, 400),
|
|
("two items for one file", [item, item], proof, 400),
|
|
("other item signed", [{**item, "changes": [ADD]}], proof, 400),
|
|
):
|
|
with self.subTest(name=name):
|
|
self.assertEqual(self.post("/api/firewall/settings", {"items": items, "proof": proven})[0], expected)
|
|
self.assertEqual(self.post_json("/api/firewall/settings", {"items": [item], "proof": proof}, {"Host": self.host})[0], 403)
|
|
self.assertEqual(list((self.state / "firewall" / "jobs").iterdir()), [])
|
|
status, body = self.post("/api/firewall/settings", {"items": [item], "proof": proof})
|
|
self.assertEqual(status, 202, body)
|
|
job_id = json.loads(body)["id"]
|
|
written = self.state / "firewall" / "jobs" / f"{job_id}.json"
|
|
job = json.loads(written.read_text(encoding="utf-8"))
|
|
self.assertEqual((sorted(job), job["items"], job["proof"]), (["created", "id", "items", "proof", "v"], [{name: signed[name] for name in signing.SETTINGS_KEYS}], proof))
|
|
self.assertEqual(written.stat().st_mode & 0o777, 0o600)
|
|
self.assertEqual(self.post("/api/firewall/settings", {"items": [item], "proof": proof})[0], 400)
|
|
self.assertEqual(json.loads(self.get(f"/api/firewall/settings/{job_id}")[2])["status"], "queued")
|
|
result = {"id": job_id, "finished": time.time(), "items": [{**job["items"][0], "status": "done", "reason": ""}]}
|
|
(self.state / "firewall" / "results" / f"{job_id}.json").write_text(json.dumps(result), encoding="utf-8")
|
|
self.assertEqual(json.loads(self.get(f"/api/firewall/settings/{job_id}")[2])["status"], "done")
|
|
|
|
def test_a_settings_entry_or_path_with_an_invisible_format_character_is_refused_before_it_reaches_a_prompt(self):
|
|
self.view([self.home_view()])
|
|
for name, item, code in (
|
|
("bidi override in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make build{chr(0x202E)}:*)"}]}, "U+202E"),
|
|
("zero-width space in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make{chr(0x200B)} build:*)"}]}, "U+200B"),
|
|
("no-break space in a deny entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "permissions.deny", "op": "add", "entry": f"Bash(rm{chr(0xA0)}-r:*)"}]}, "U+00A0"),
|
|
("ideographic space in a deny entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "permissions.deny", "op": "add", "entry": f"Bash(rm{chr(0x3000)}-r:*)"}]}, "U+3000"),
|
|
("Hangul filler in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make{chr(0x3164)} build:*)"}]}, "U+3164"),
|
|
("grapheme joiner in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make{chr(0x34F)} build:*)"}]}, "U+034F"),
|
|
("variation selector in an entry", {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"Bash(make build{chr(0xE0100)}:*)"}]}, "U+E0100"),
|
|
("Hangul filler in a path", {"kind": "settings", "file": f"/home/op{chr(0xFFA0)}/.claude/settings.json", "base": SHA, "changes": [ADD]}, "U+FFA0"),
|
|
):
|
|
with self.subTest(name=name):
|
|
for path in ("/api/firewall/preview", "/api/sign"):
|
|
status, body = self.post(path, {"items": [item]})
|
|
self.assertEqual(status, 400)
|
|
self.assertIn(code, body.decode("utf-8"))
|
|
self.assertIn("U+2067", signing.settings_problem({"file": f"/home/op{chr(0x2067)}/.claude/settings.json", "base": SHA, "changes": [ADD]}))
|
|
self.assertIn("U+FEFF", signing.settings_problem({"file": HOME_FILE, "base": SHA, "changes": [{**ADD, "entry": f"{chr(0xFEFF)}Bash(make build:*)"}]}))
|
|
self.assertIsNone(signing.settings_problem({"file": HOME_FILE, "base": SHA, "changes": [ADD]}))
|
|
self.assertEqual(self.post("/api/firewall/preview", {"items": [{"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [ADD]}]})[0], 200)
|
|
|
|
def test_removing_a_settings_entry_with_a_hidden_character_is_offered_and_adding_one_is_not(self):
|
|
hidden = f"Bash(make{chr(0x202E)} build:*)"
|
|
self.view([{**self.home_view(), "settings": {"permissions": {**PERMISSIONS, "allow": [*PERMISSIONS["allow"], hidden]}, "sandbox": SANDBOX}}])
|
|
removal = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "permissions.allow", "op": "remove", "entry": hidden}]}
|
|
addition = {**removal, "changes": [{"list": "permissions.ask", "op": "add", "entry": hidden}]}
|
|
for path in ("/api/firewall/preview", "/api/sign"):
|
|
with self.subTest(path=path):
|
|
self.assertEqual(self.post(path, {"items": [removal]})[0], 200)
|
|
status, body = self.post(path, {"items": [addition]})
|
|
self.assertEqual(status, 400)
|
|
self.assertIn("U+202E", body.decode("utf-8"))
|
|
self.assertIsNone(signing.hidden_problem(removal["changes"][0], "change"))
|
|
for name, value in (
|
|
("no list", {"op": "remove", "entry": hidden}),
|
|
("extra key", {**removal["changes"][0], "note": "x"}),
|
|
("unknown list", {**removal["changes"][0], "list": "permissions.other"}),
|
|
("an ask with op remove", {"kind": "ask", "op": "remove", "entry": hidden}),
|
|
("nested in an item", {"kind": "review", "branch": {"op": "remove", "entry": hidden}}),
|
|
):
|
|
with self.subTest(name=name):
|
|
self.assertIn("U+202E", signing.hidden_problem(value, "item"))
|
|
|
|
def test_a_group_set_addressee_legacy_rule_or_pattern_with_a_hidden_character_is_never_offered_for_a_signature(self):
|
|
rlo = chr(0x202E)
|
|
signer = self.pin()
|
|
rule = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600, "agents": ["s1"]})
|
|
for path, payload in (("/api/firewall/groups", {"name": f"ci{rlo}", "members": ["s1"]}), ("/api/firewall/sets", {"name": f"ci{rlo}", "days": 7, "rules": [rule["id"]]})):
|
|
with self.subTest(path=path):
|
|
status, body = self.post(path, payload)
|
|
self.assertEqual(status, 400)
|
|
self.assertIn("U+202E", body.decode("utf-8"))
|
|
for code in (0x2028, 0x2029, 0x85, 0x0B, 0x0D, 0x34F, 0xFE0F, 0xE0100, 0x3164, 0x1160, 0xA0, 0x3000):
|
|
with self.subTest(code=code):
|
|
status, body = self.post("/api/rules/sign", {"kind": "ask", "tool": "Bash", "pattern": f"make test{chr(code)}in /safe", "scope": "/repo*", "expires": time.time() + 3600})
|
|
self.assertEqual(status, 400)
|
|
self.assertIn(f"U+{code:04X}", body.decode("utf-8"))
|
|
stored = self.httpd.hub.rules.get(rule["id"])
|
|
legacy = {key: value for key, value in stored["proof"]["payload"].items() if key != signing.TARGET}
|
|
self.httpd.hub.rules.change(rule["id"], {"enabled": False, "proof": {**stored["proof"], "payload": {**legacy, "pattern": f"make test{rlo}*"}}})
|
|
status, body = self.post("/api/sign", {"items": [{"kind": "enable", "rule": rule["id"]}]})
|
|
self.assertEqual(status, 400)
|
|
self.assertIn("U+202E", body.decode("utf-8"))
|
|
self.claim("s1", f"Skills{rlo}")
|
|
ask_id = self.create_ask(ASK)
|
|
shown = next(item for item in self.snapshot()["inbox"] if item["id"] == ask_id)
|
|
self.assertIn(rlo, shown["to"])
|
|
status, body = self.post("/api/sign", {"items": [{**self.entry("ask", ask_id, "", ""), "verb": "reject", "channel": "post", "reason": "no", "to": shown["to"]}]})
|
|
self.assertEqual(status, 400)
|
|
self.assertIn("U+202E", body.decode("utf-8"))
|
|
self.assertEqual(self.post("/api/sign", {"items": [self.entry("ask", ask_id, "", "")]})[0], 200)
|
|
|
|
def test_the_hub_keeps_only_permissions_and_sandbox_and_refuses_a_view_unsafe_to_copy(self):
|
|
self.view([self.home_view()])
|
|
files, _ = self.httpd.hub.settings_files()
|
|
self.assertEqual(sorted(files[0]["settings"]), ["permissions", "sandbox"])
|
|
domain = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": [{"list": "sandbox.network.allowedDomains", "op": "add", "entry": "example.org"}]}
|
|
status, body = self.post("/api/firewall/preview", {"items": [domain]})
|
|
self.assertEqual(status, 200, body)
|
|
self.assertNotIn('"env"', json.loads(body)["diffs"][0]["diff"])
|
|
deep = functools.reduce(lambda inner, _: {"x": inner}, range(600), {})
|
|
for name, extra, reason in (("600 levels", deep, "nests deeper than 64"), ("lone surrogate", "\ud800", "lone surrogate")):
|
|
with self.subTest(name=name):
|
|
self.view([{**self.home_view(), "settings": {"permissions": {**PERMISSIONS, "extra": extra}, "sandbox": SANDBOX}}])
|
|
status, body = self.post("/api/firewall/preview", {"items": [{**domain, "changes": [ADD]}]})
|
|
self.assertEqual(status, 400, body)
|
|
self.assertIn(reason, body.decode("utf-8"))
|
|
|
|
def test_groups_and_rule_sets_hold_known_agents_and_stored_rules(self):
|
|
for name, payload, expected in (
|
|
("unknown session", {"name": "builders", "members": ["s1", "s9"]}, 400),
|
|
("every agent", {"name": "builders", "members": ["*"]}, 400),
|
|
("unsorted", {"name": "builders", "members": ["s2", "s1"]}, 400),
|
|
("empty name", {"name": " ", "members": ["s1"]}, 400),
|
|
("extra key", {"name": "builders", "members": ["s1"], "rule": "x"}, 400),
|
|
):
|
|
with self.subTest(name=name):
|
|
self.assertEqual(self.post("/api/firewall/groups", payload)[0], expected)
|
|
status, body = self.post("/api/firewall/groups", {"name": "builders", "members": ["s1", "s2"]})
|
|
self.assertEqual(status, 201, body)
|
|
group = json.loads(body)
|
|
self.assertEqual(self.post("/api/firewall/groups", {"name": "builders", "members": ["s1"]})[0], 409)
|
|
self.assertEqual([(entry["name"], entry["members"]) for entry in self.firewall()["groups"]], [("builders", ["s1", "s2"])])
|
|
signer = self.pin()
|
|
rule = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600, "agents": ["s1"]})
|
|
for name, payload in (("no days", {"name": "ci", "days": 0, "rules": [rule["id"]]}), ("unknown rule", {"name": "ci", "days": 7, "rules": ["0123456789abcdef"]}), ("no rules", {"name": "ci", "days": 7, "rules": []})):
|
|
with self.subTest(name=name):
|
|
self.assertEqual(self.post("/api/firewall/sets", payload)[0], 400)
|
|
status, body = self.post("/api/firewall/sets", {"name": "ci", "days": 7, "rules": [rule["id"]]})
|
|
self.assertEqual(status, 201, body)
|
|
stored = json.loads(body)
|
|
self.assertEqual((stored["days"], stored["rules"]), (7, [{"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*"}]))
|
|
for path, ident in (("groups", group["id"]), ("sets", stored["id"])):
|
|
with self.subTest(path=path):
|
|
self.assertEqual(self.call("POST", f"/api/firewall/{path}/{ident}/delete", b"", self.guard(self.host))[0], 200)
|
|
self.assertEqual(self.call("POST", f"/api/firewall/{path}/{ident}/delete", b"", self.guard(self.host))[0], 404)
|
|
|
|
def signed_rule(self, signer, fields: dict) -> dict:
|
|
status, _, body = self.post_json("/api/rules/sign", fields, self.guard(self.host))
|
|
self.assertEqual(status, 200, body)
|
|
payload = json.loads(body)["payload"]
|
|
status, _, body = self.post_json("/api/rules", {"rule": payload, "assertion": signer.assertion(payload, self.origin, "localhost", PRESENT, 0), "enabled": True}, self.guard(self.host))
|
|
self.assertEqual(status, 201, body)
|
|
return json.loads(body)
|
|
|
|
def test_a_rule_applies_to_one_agent_a_group_or_every_agent(self):
|
|
signer = self.pin()
|
|
now = time.time()
|
|
base = {"kind": "ask", "tool": "Bash", "scope": "/repo*", "expires": now + 3600}
|
|
for name, agents in (("unknown agent", ["s9"]), ("unsorted group", ["s2", "s1"]), ("pseudo agent", ["name:Docs"]), ("empty", [])):
|
|
with self.subTest(name=name):
|
|
self.assertEqual(self.post_json("/api/rules/sign", {**base, "pattern": "make *", "agents": agents}, self.guard(self.host))[0], 400)
|
|
self.assertEqual(self.post_json("/api/rules/sign", {"kind": "review", "tool": "", "pattern": "feature/*", "scope": "/repo/*", "expires": now + 3600, "agents": ["s1"]}, self.guard(self.host))[0], 400)
|
|
one = self.signed_rule(signer, {**base, "pattern": "make one", "agents": ["s1"]})
|
|
group = self.signed_rule(signer, {**base, "pattern": "make group", "agents": ["s1", "s2"]})
|
|
every = self.signed_rule(signer, {**base, "pattern": "make every"})
|
|
self.assertEqual((one["agents"], group["agents"], every["agents"]), (["s1"], ["s1", "s2"], ["*"]))
|
|
self.assertEqual(one["proof"]["payload"]["agents"], ["s1"])
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
asks = {(command, session): self.create_ask({**ASK, "command": command, "session": session}) for command in ("make one", "make group", "make every") for session in ("s1", "s2", "s3")}
|
|
time.sleep(0.6)
|
|
statuses = {pair: self.ask_status(ask_id, "0") for pair, ask_id in asks.items()}
|
|
self.assertEqual(statuses, {
|
|
("make one", "s1"): "allowed", ("make one", "s2"): "pending", ("make one", "s3"): "pending",
|
|
("make group", "s1"): "allowed", ("make group", "s2"): "allowed", ("make group", "s3"): "pending",
|
|
("make every", "s1"): "allowed", ("make every", "s2"): "allowed", ("make every", "s3"): "allowed",
|
|
})
|
|
hook = verifier.Trust(approvers=self.approvers, replay=self.replay / "hook.json", origin=self.origin)
|
|
relayed = json.loads(self.get(f"/api/asks/{asks[('make one', 's1')]}?wait=0")[2])["proof"]
|
|
verifier.check(relayed, signing.ask_item(asks[("make one", "s1")], "Bash", "make one", "/repo", "s1"), "", hook, time.time())
|
|
with self.assertRaisesRegex(signing.Refused, "does not match"):
|
|
verifier.check(relayed, signing.ask_item(asks[("make one", "s2")], "Bash", "make one", "/repo", "s2"), "", hook, time.time())
|
|
|
|
def test_a_decision_rule_scoped_to_an_agent_decides_only_decisions_under_the_name_it_holds_now(self):
|
|
for session, name in (("s1", "Docs"), ("s1", "Main"), ("s1", "Skills"), ("s2", "Main")):
|
|
time.sleep(1.1)
|
|
self.claim(session, name)
|
|
self.snapshot()
|
|
held = {(entry["session"], entry["name"]) for entry in self.httpd.hub.names.listed()}
|
|
self.assertLessEqual({("s1", "Docs"), ("s1", "Main"), ("s1", "Skills"), ("s2", "Main")}, held)
|
|
signer = self.pin()
|
|
self.signed_rule(signer, {"kind": "decision", "tool": "", "pattern": "*", "scope": "*", "expires": time.time() + 3600, "agents": ["s1"]})
|
|
options = [{"label": "Yes", "description": ""}, {"label": "No", "description": ""}]
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
asked = {name: self.tool("decision_request", {"question": "Merge?", "options": options, "agent": name, "recommended": "Yes"})["structuredContent"]["id"] for name in ("Skills", "Main", "Docs", "Stage")}
|
|
self.settle(lambda: self.choice(asked["Skills"]) == "Yes")
|
|
time.sleep(0.3)
|
|
self.assertEqual({name: self.choice(decision) for name, decision in asked.items()}, {"Skills": "Yes", "Main": None, "Docs": None, "Stage": None})
|
|
self.claim("s3", "Skills")
|
|
self.snapshot()
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
shared = self.tool("decision_request", {"question": "Merge?", "options": options, "agent": "Skills", "recommended": "Yes"})["structuredContent"]["id"]
|
|
time.sleep(0.6)
|
|
self.assertIsNone(self.choice(shared))
|
|
|
|
def test_turning_a_rule_on_needs_a_fresh_passkey_signature_and_turning_it_off_none(self):
|
|
signer = self.pin()
|
|
rule = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600})
|
|
other = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make other", "scope": "/repo*", "expires": time.time() + 3600})
|
|
enable = f"/api/rules/{rule['id']}/enable"
|
|
self.assertEqual(self.call("POST", f"/api/rules/{rule['id']}/disable", b"", self.guard(self.host))[0], 200)
|
|
unsigned = (("no body", b""), ("no proof", b'{"proof": null}'), ("the rule's own signature", json.dumps({"proof": rule["proof"]}).encode()))
|
|
for name, body in unsigned:
|
|
with self.subTest(name=name):
|
|
self.assertEqual(self.call("POST", enable, body, self.guard(self.host))[0], 400)
|
|
self.assertFalse(self.httpd.hub.rules.get(rule["id"])["enabled"])
|
|
offer = self.prepare([{"kind": "enable", "rule": rule["id"]}])
|
|
self.assertEqual((offer["enables"], offer["payload"]["items"]), (rule["proof"]["payload"], [signing.item_hash(signing.enable_item(rule["proof"]["payload"]))]))
|
|
self.assertEqual(self.post("/api/sign", {"items": [{"kind": "enable", "rule": "0123456789abcdef"}]})[0], 404)
|
|
proof = signer.proof(offer["payload"], self.origin)
|
|
foreign = signer.proof(self.prepare([{"kind": "enable", "rule": other["id"]}])["payload"], self.origin)
|
|
for name, body in (("forged", {"proof": key(-7, "intruder").proof(offer["payload"], self.origin)}), ("another rule's approval", {"proof": foreign})):
|
|
with self.subTest(name=name):
|
|
self.assertEqual(self.post(enable, body)[0], 400)
|
|
self.assertFalse(self.httpd.hub.rules.get(rule["id"])["enabled"])
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
waiting = self.create_ask({**ASK, "command": "make x", "session": "s1"})
|
|
time.sleep(0.6)
|
|
self.assertEqual(self.ask_status(waiting, "0"), "pending")
|
|
status, body = self.post(enable, {"proof": proof})
|
|
self.assertEqual((status, json.loads(body)["enabled"]), (200, True), body)
|
|
self.assertEqual(self.call("POST", f"/api/rules/{rule['id']}/disable", b"", self.guard(self.host))[0], 200)
|
|
self.assertEqual(self.post(enable, {"proof": proof})[0], 400)
|
|
self.assertFalse(self.httpd.hub.rules.get(rule["id"])["enabled"])
|
|
|
|
def test_a_deleted_rule_never_comes_back_with_its_old_proof_and_a_fresh_signature_does(self):
|
|
signer = self.pin()
|
|
fields = {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600}
|
|
rule = self.signed_rule(signer, fields)
|
|
old = {"rule": rule["proof"]["payload"], "assertion": rule["proof"]["assertion"], "enabled": True}
|
|
self.assertEqual(self.post("/api/rules", old)[0], 409)
|
|
self.assertEqual(self.call("POST", f"/api/rules/{rule['id']}/delete", b"", self.guard(self.host))[0], 200)
|
|
self.assertEqual(self.post("/api/rules", old)[0], 409)
|
|
self.assertIsNone(self.httpd.hub.rules.get(rule["id"]))
|
|
unsigned = json.loads(self.post("/api/rules/sign", fields)[1])["payload"]
|
|
object.__setattr__(self.httpd.hub, "offers", rules.Offers())
|
|
self.assertEqual(self.post("/api/rules", {"rule": unsigned, "assertion": signer.assertion(unsigned, self.origin, "localhost", PRESENT, 0), "enabled": True})[0], 409)
|
|
fresh = self.signed_rule(signer, fields)
|
|
self.assertEqual([stored["id"] for stored in self.httpd.hub.rules.listed()], [fresh["id"]])
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
asked = self.create_ask({**ASK, "command": "make x", "session": "s1"})
|
|
time.sleep(0.6)
|
|
self.assertEqual(self.ask_status(asked, "0"), "allowed")
|
|
|
|
def test_a_group_changed_after_signing_grants_nothing_beyond_the_signed_members(self):
|
|
self.claim("s3", "Evil")
|
|
self.snapshot()
|
|
signer = self.pin()
|
|
group = json.loads(self.post("/api/firewall/groups", {"name": "builders", "members": ["s1", "s2"]})[1])
|
|
self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make *", "scope": "/repo*", "expires": time.time() + 3600, "agents": group["members"]})
|
|
self.assertEqual(self.call("POST", f"/api/firewall/groups/{group['id']}/delete", b"", self.guard(self.host))[0], 200)
|
|
self.assertEqual(self.post("/api/firewall/groups", {"name": "builders", "members": ["s1", "s2", "s3"]})[0], 201)
|
|
with mock.patch.object(batches, "UNDO", 0.05):
|
|
asks = {session: self.create_ask({**ASK, "command": "make x", "session": session}) for session in ("s1", "s3")}
|
|
time.sleep(0.6)
|
|
self.assertEqual({session: self.ask_status(ask_id, "0") for session, ask_id in asks.items()}, {"s1": "allowed", "s3": "pending"})
|
|
|
|
def test_the_signed_target_decides_and_an_untargeted_rule_reaches_every_agent(self):
|
|
now = time.time()
|
|
plain = signing.rule_payload("0123456789abcdef", ["ask"], "Bash", "make *", "*", int(now) + 600)
|
|
item = signing.ask_item("fedcba9876543210", "Bash", "make x", "/repo", "s2")
|
|
self.assertTrue(signing.rule_allows(plain, item, "", now))
|
|
self.assertTrue(signing.rule_allows(signing.targeted(plain, ["*"]), item, "", now))
|
|
self.assertTrue(signing.rule_allows(signing.targeted(plain, ["s1", "s2"]), item, "", now))
|
|
self.assertFalse(signing.rule_allows(signing.targeted(plain, ["s1"]), item, "", now))
|
|
review = signing.rule_payload("0123456789abcdef", ["review"], "", "*", "*", int(now) + 600)
|
|
commit = signing.review_item("fedcba9876543210", "/repo/.git", "/repo", "feature/x", "0" * 40)
|
|
self.assertTrue(signing.rule_allows(review, commit, "pass", now))
|
|
self.assertFalse(signing.rule_allows(signing.targeted(review, ["s1"]), commit, "pass", now))
|
|
for agents in ([], ["s2", "s1"], ["s1", "s1"], ["*", "s1"], "s1", [3]):
|
|
with self.subTest(agents=agents), self.assertRaises(signing.Refused):
|
|
signing.checked_rule(signing.targeted(plain, agents), now)
|
|
subject = {"recommended": "Yes", "agent": "Skills", "sessions": {"s1"}}
|
|
stored = {"kind": "decision", "pattern": "*", "enabled": True, "expires": now + 600}
|
|
targeted = {**stored, "proof": {"payload": signing.targeted(review, ["s2"])}}
|
|
self.assertFalse(rules.rule_matches(targeted, "decision", subject, now))
|
|
self.assertTrue(rules.rule_matches({**stored, "proof": {"payload": signing.targeted(review, ["s1"])}}, "decision", subject, now))
|