The Firewall page becomes Controls with three tabs: Tools lists every MCP server, plugin and feature switch of ~/.claude/settings.json with each other settings file that sets it differently, Rules keeps the settings lists and the hub rule form, Groups the groups and sets. A flip stages a change in one shared Apply bar; Apply shows the diff and signs it with the passkey as before. The signer writes deniedMcpServers rules, enabledPlugins entries and switches only in the own file and refuses wrong types and no-op flips; switching, the capability views and the per-item checks are one function each. 🎯 Fix: 88 % 💥 Break: 6 % 💸 Tokens: – ⏱️ Velocity: – 🛡️ Security: 100 % 🏆 Score: 83 🚦 Gate: ⛔ fix 88 % < 90, break 6 % > 5 Created-with: https://s.veen.world/skills Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
460 lines
36 KiB
Python
460 lines
36 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, 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_the_tools_tab_switches_servers_plugins_and_features_of_the_own_file_only(self):
|
|
capabilities = {"deniedMcpServers": [{"serverName": "blender"}], "enabledPlugins": {"caveman@caveman": True, "ponytail@ponytail": False}}
|
|
project_tools = {"deniedMcpServers": [{"serverName": "kvb-orchestrator"}], "enabledPlugins": {"ponytail@ponytail": True, "caveman@caveman": True}, "enableArtifact": False}
|
|
files = [{**self.home_view(), "own": True, "settings": {**self.home_view()["settings"], **capabilities}}, {"path": PROJECT_FILE, "exists": False, "sha256": "", "error": "", "settings": project_tools, "own": False}]
|
|
known = {"servers": ["blender", "kvb-orchestrator", "hid\u200bden", 5], "plugins": ["caveman@caveman", "tokeneconomizer@tokeneconomizer", "no id"]}
|
|
(self.state / "firewall" / "view.json").write_text(json.dumps({"written": time.time(), "files": files, "known": known}), encoding="utf-8")
|
|
tools = self.firewall()["tools"]
|
|
overridden = {(group["list"], row["name"]): row["overrides"] for group in tools["groups"] for row in group["rows"] if row["overrides"]}
|
|
self.assertEqual(overridden, {
|
|
("deniedMcpServers", "kvb-orchestrator"): [{"file": PROJECT_FILE, "on": False}],
|
|
("enabledPlugins", "ponytail@ponytail"): [{"file": PROJECT_FILE, "on": True}],
|
|
("switches", "enableArtifact"): [{"file": PROJECT_FILE, "on": False}],
|
|
})
|
|
groups = {group["list"]: (group["off"], [(row["name"], row["on"]) for row in group["rows"]]) for group in tools["groups"]}
|
|
self.assertEqual(groups, {
|
|
"deniedMcpServers": ("add", [("blender", False), ("kvb-orchestrator", True)]),
|
|
"enabledPlugins": ("remove", [("caveman@caveman", True), ("ponytail@ponytail", False), ("tokeneconomizer@tokeneconomizer", False)]),
|
|
"switches": ("remove", [("enableArtifact", True)]),
|
|
})
|
|
changes = [{"list": "deniedMcpServers", "op": "remove", "entry": "blender"}, {"list": "enabledPlugins", "op": "add", "entry": "ponytail@ponytail"}, {"list": "switches", "op": "remove", "entry": "enableArtifact"}]
|
|
item = {"kind": "settings", "file": HOME_FILE, "base": SHA, "changes": changes}
|
|
status, body = self.post("/api/firewall/preview", {"items": [item]})
|
|
self.assertEqual(status, 200, body)
|
|
changed = {line[0] + line[1:].strip() for line in json.loads(body)["diffs"][0]["diff"].splitlines() if line[:1] in "+-" and line[:3] not in ("+++", "---")}
|
|
self.assertLessEqual({'-"serverName": "blender"', '-"ponytail@ponytail": false', '+"ponytail@ponytail": true', '+"enableArtifact": false'}, changed)
|
|
proof = self.pin().proof(self.prepare([item])["payload"], self.origin)
|
|
self.assertEqual(self.post("/api/firewall/settings", {"items": [item], "proof": proof})[0], 202)
|
|
project = {"kind": "settings", "file": PROJECT_FILE, "base": "", "changes": [{"list": "deniedMcpServers", "op": "add", "entry": "blender"}]}
|
|
for name, items, reason in (
|
|
("project file", [project], "only in ~/.claude/settings.json"),
|
|
("chained name", [{**item, "changes": [{**changes[0], "op": "add", "entry": "x;rm"}]}], "no valid deniedMcpServers name"),
|
|
("unknown switch", [{**item, "changes": [{**changes[2], "entry": "hooks"}]}], "no valid switches name"),
|
|
("already on", [{**item, "changes": [{**changes[1], "entry": "caveman@caveman"}]}], "enabled already"),
|
|
):
|
|
with self.subTest(name=name):
|
|
status, body = self.post("/api/firewall/preview", {"items": items})
|
|
self.assertEqual(status, 400, body)
|
|
self.assertIn(reason, body.decode("utf-8"))
|
|
broken = {**files[0], "settings": {**files[0]["settings"], "enabledPlugins": None, "deniedMcpServers": None}}
|
|
(self.state / "firewall" / "view.json").write_text(json.dumps({"written": time.time(), "files": [broken], "known": known}), encoding="utf-8")
|
|
rows = {group["list"]: [row["name"] for row in group["rows"]] for group in self.firewall()["tools"]["groups"]}
|
|
self.assertEqual(rows["enabledPlugins"], ["caveman@caveman", "tokeneconomizer@tokeneconomizer"])
|
|
status, body = self.post("/api/firewall/preview", {"items": [{**item, "changes": changes[1:2]}]})
|
|
self.assertEqual(status, 400, body)
|
|
self.assertIn("holds the wrong type", body.decode("utf-8"))
|
|
(self.state / "firewall" / "view.json").write_text(json.dumps({"written": time.time(), "files": [{**files[0], "own": "yes"}], "known": known}), encoding="utf-8")
|
|
self.assertIsNone(self.firewall()["tools"])
|
|
|
|
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))
|