Files
skills/tests/test_hub_firewall.py
T

411 lines
32 KiB
Python
Raw Normal View History

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, firewall, requesting, 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_the_rule_table_counts_hits_of_the_last_seven_days_from_the_ask_ledger_with_the_dry_run_matcher(self):
permissions = {"allow": ["Bash(make deploy:*)"], "ask": ["Bash(make deploy:*)", "Bash(git push:*)", "Bash(make clean:*)", "Bash"], "deny": ["Bash(make deploy --prod:*)"]}
self.view([{**self.home_view(), "settings": {"permissions": permissions, "sandbox": SANDBOX}}])
for command, session in (("make deploy", "s1"), ("make deploy --dry", "s1"), ("make deploy", "s2"), ("make deploy && rm -rf /", "s1"), ("git push origin main", "s1"), ("make test", "s1")):
self.create_ask({**ASK, "command": command, "session": session})
old = self.create_ask({**ASK, "command": "make deploy"})
self.httpd.hub.asks.change(old, {"created_ts": time.time() - 8 * 86400})
signer = self.pin()
later = time.time() + 3600
mine = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make deploy*", "scope": "/repo*", "expires": later, "agents": ["s1"]})
elsewhere = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "make deploy*", "scope": "/elsewhere*", "expires": later})
pushing = self.signed_rule(signer, {"kind": "ask", "tool": "Bash", "pattern": "git push *", "scope": "*", "expires": later})
review = self.signed_rule(signer, {"kind": "review", "tool": "", "pattern": "feature/*", "scope": "/repo/*", "expires": later})
self.assertEqual(self.call("POST", f"/api/rules/{mine['id']}/disable", b"", self.guard(self.host))[0], 200)
found = self.firewall()
entries = {(entry["list"], entry["entry"]): (entry["spec"], entry["hits"], entry["never"]) for group in found["files"][0]["groups"] for entry in group["entries"]}
self.assertEqual(entries, {
("allow", "Bash(make deploy:*)"): ("make deploy:*", None, ""),
("ask", "Bash(make deploy:*)"): ("make deploy:*", 3, ""),
("ask", "Bash(git push:*)"): ("git push:*", None, "pushes"),
("ask", "Bash(make clean:*)"): ("make clean:*", 0, ""),
("ask", "Bash"): ("", 4, ""),
("deny", "Bash(make deploy --prod:*)"): ("make deploy --prod:*", None, ""),
})
self.assertEqual(found["days"], requesting.RECENT_DAYS)
self.assertEqual(found["rules"], {mine["id"]: {"hits": 2, "never": ""}, elsewhere["id"]: {"hits": 0, "never": ""}, pushing["id"]: {"hits": None, "never": "pushes"}, review["id"]: {"hits": None, "never": ""}})
def test_an_entry_becomes_the_rule_the_dry_run_matcher_counts_and_a_hit_needs_the_rule_to_match(self):
now = time.time()
for entry, rule in (
("Bash(make test:*)", {"kind": "ask", "tool": "Bash", "pattern": "make test*", "scope": "*"}),
("Bash(npm run *)", {"kind": "ask", "tool": "Bash", "pattern": "npm run *", "scope": "*"}),
("Bash", {"kind": "ask", "tool": "Bash", "pattern": "*", "scope": "*"}),
("mcp__memory__search", {"kind": "ask", "tool": "mcp__memory__search", "pattern": "*", "scope": "*"}),
):
with self.subTest(entry=entry):
self.assertEqual(firewall.entry_rule(entry), rule)
asks = [rules.subject_of("ask", {"id": "0123456789abcdef", "tool": "Bash", "command": command, "cwd": "/repo", "session": "s1"}, set()) for command in ("make test", "make test-unit", "make lint")]
self.assertEqual(firewall.hits(firewall.entry_rule("Bash(make test:*)"), asks, now), {"hits": 2, "never": ""})
self.assertEqual(firewall.hits(firewall.entry_rule("Bash(make build:*)"), asks, now), {"hits": 0, "never": ""})
self.assertEqual(firewall.hits(firewall.entry_rule("Bash(make test | sh:*)"), asks, now), {"hits": None, "never": "pipes into a shell"})
self.assertEqual(firewall.hits(firewall.entry_rule("Bash(make test; make lint)"), asks, now), {"hits": None, "never": firewall.CHAINED})
with mock.patch.object(requesting, "rule_matches", return_value=False):
self.assertEqual(firewall.hits(firewall.entry_rule("Bash(make test:*)"), asks, now), {"hits": 0, "never": ""})
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))