Files
skills/tests/test_settings_writer.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 9742884308 feat(orchestrator): firewall view with signed settings changes (001 S6)
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>
2026-11-13 18:14:17 +00:00

505 lines
30 KiB
Python

from __future__ import annotations
import contextlib
import errno
import hashlib
import importlib.util
import io
import json
import os
import secrets
import stat
import subprocess
import sys
import tempfile
import time
import unittest
from pathlib import Path
from unittest import mock
import test_hub_spool_links as spool_links
from hub_support import HUB, ORIGIN, key, signing, verifier
WRITER = HUB / "client" / "settings_writer.py"
WRITER_SPEC = importlib.util.spec_from_file_location("kvb_orchestrator_settings_writer", WRITER)
host = importlib.util.module_from_spec(WRITER_SPEC)
WRITER_SPEC.loader.exec_module(host)
ORIGINAL = {
"model": "x",
"env": {"EXAMPLE_FLAG": "fixture-value-not-a-secret"},
"hooks": {"Stop": [{"matcher": "", "hooks": [{"type": "command", "command": "true"}]}]},
"permissions": {"allow": ["Bash(make test:*)", "Bash(git status:*)"], "deny": ["Read(~/.ssh/**)"]},
"sandbox": {"enabled": True, "filesystem": {"allowWrite": ["/tmp"]}},
}
ADD_LINT = {"list": "permissions.allow", "op": "add", "entry": "Bash(make lint:*)"}
def sha(data: bytes) -> str:
return hashlib.sha256(data).hexdigest()
class TestSettingsWriter(unittest.TestCase):
def setUp(self):
tmp = tempfile.TemporaryDirectory()
self.addCleanup(tmp.cleanup)
self.base = Path(tmp.name)
self.home = self.base / "home"
self.settings = self.home / ".claude" / "settings.json"
self.project = self.base / "repo"
self.project_settings = self.project / ".claude" / "settings.json"
self.elsewhere = self.base / "elsewhere" / ".claude" / "settings.json"
for path in (self.settings, self.elsewhere):
path.parent.mkdir(parents=True)
path.write_text(json.dumps(ORIGINAL, indent=2) + "\n", encoding="utf-8")
path.chmod(0o640)
self.project_settings.parent.mkdir(parents=True)
self.tree = self.base / "tree" / "branch-tree.json"
self.tree.parent.mkdir()
self.tree.write_text(json.dumps({"repos": [{"path": str(self.project), "known": True, "default": "main"}, {"path": str(self.elsewhere.parent.parent), "known": False}]}), encoding="utf-8")
self.jobs, self.results = self.base / "jobs", self.base / "results"
self.jobs.mkdir(mode=0o700)
self.results.mkdir(mode=0o700)
self.approvers = self.base / "config" / "approvers.json"
self.trust = verifier.Trust(approvers=self.approvers, replay=self.base / "replay" / "firewall.json", origin=ORIGIN)
self.signer = key(-7, "main")
self.signer.pin(self.approvers, ORIGIN)
self.writer = host.Writer(self.trust, self.home, self.tree)
def item(self, path: Path, changes: list[dict]) -> dict:
return {"file": str(path), "base": sha(path.read_bytes()) if path.exists() else "", "changes": changes}
def proof(self, items: list[dict], signer) -> dict:
hashes = [signing.item_hash(signing.settings_item(**item)) for item in items]
return signer.proof(signing.approval_payload(hashes, secrets.token_hex(16), int(time.time()) + 600), ORIGIN)
def write_job(self, job_id: str, items: list[dict], proof: object) -> None:
(self.jobs / f"{job_id}.json").write_text(json.dumps({"v": 1, "id": job_id, "created": "x", "items": items, "proof": proof}), encoding="utf-8")
def result(self, job_id: str) -> dict:
return json.loads((self.results / f"{job_id}.json").read_text(encoding="utf-8"))
def run_job(self, items: list[dict], proof: object) -> dict:
job_id = secrets.token_hex(8)
self.write_job(job_id, items, proof)
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 1)
self.assertEqual(list(self.jobs.iterdir()), [])
return self.result(job_id)
def unit(self, view: Path, marker: dict[str, str]) -> subprocess.CompletedProcess:
trust = ["--approvers", str(self.approvers), "--replay", str(self.trust.replay)]
command = [sys.executable, str(WRITER), "--port", ORIGIN.rsplit(":", 1)[1], "--jobs", str(self.jobs), "--results", str(self.results), "--view", str(view), *trust, "--tree", str(self.tree)]
return subprocess.run(command, capture_output=True, text=True, timeout=60, check=False, env={"PATH": "/usr/bin:/bin", "HOME": str(self.home), **marker})
def signed(self, item: dict) -> dict:
return self.run_job([item], self.proof([item], self.signer))["items"][0]
def files(self) -> dict[str, tuple[int, str]]:
found = {}
for root in (self.home, self.project, self.elsewhere.parent.parent):
for path in sorted(root.rglob("*")):
if path.is_file() or path.is_symlink():
found[str(path)] = (path.lstat().st_mode, sha(path.read_bytes()) if path.is_file() else os.readlink(path))
return found
def test_a_signed_change_writes_exactly_it_keeps_every_other_key_and_a_backup_with_the_mode(self):
before = self.settings.read_bytes()
changes = [ADD_LINT, {"list": "permissions.deny", "op": "remove", "entry": "Read(~/.ssh/**)"}, {"list": "sandbox.network.allowedDomains", "op": "add", "entry": "example.org"}]
result = self.signed(self.item(self.settings, changes))
self.assertEqual((result["status"], result["reason"]), ("done", ""), result)
expected = json.loads(json.dumps(ORIGINAL))
expected["permissions"]["allow"].append("Bash(make lint:*)")
expected["permissions"]["deny"] = []
expected["sandbox"]["network"] = {"allowedDomains": ["example.org"]}
written = self.settings.read_bytes()
self.assertEqual(json.loads(written), expected)
self.assertEqual(list(json.loads(written)), list(ORIGINAL))
self.assertEqual(result["sha256"], sha(written))
backup = Path(result["backup"])
self.assertEqual((backup.parent, backup.read_bytes()), (self.settings.parent, before))
self.assertEqual({path.name: path.stat().st_mode & 0o777 for path in self.settings.parent.iterdir()}, {"settings.json": 0o640, backup.name: 0o640})
def test_a_missing_project_file_is_created_private_with_only_the_change(self):
result = self.signed(self.item(self.project_settings, [ADD_LINT]))
self.assertEqual((result["status"], result["backup"]), ("done", ""), result)
self.assertEqual(json.loads(self.project_settings.read_text(encoding="utf-8")), {"permissions": {"allow": ["Bash(make lint:*)"]}})
self.assertEqual(self.project_settings.stat().st_mode & 0o777, 0o600)
def test_a_forged_changed_stale_unlisted_or_impossible_job_changes_nothing(self):
good = self.item(self.settings, [ADD_LINT])
rule = self.signer.proof(signing.rule_payload(secrets.token_hex(8), ["settings"], "", "*", "*", int(time.time()) + 600), ORIGIN)
swapped = {**good, "changes": [{**ADD_LINT, "entry": "Bash(rm -rf:*)"}]}
stale = {**good, "base": sha(b"{}")}
unlisted = self.item(self.elsewhere, [ADD_LINT])
twice = self.item(self.settings, [{**ADD_LINT, "entry": "Bash(make test:*)"}])
absent = self.item(self.settings, [{**ADD_LINT, "op": "remove"}])
cases = (
("forged signature", good, self.proof([good], key(-7, "intruder")), "no valid operator signature"),
("missing signature", good, None, "no signature"),
("rule instead of an approval", good, rule, "no valid operator signature"),
("changed after signing", swapped, self.proof([good], self.signer), "does not list this item"),
("stale base", stale, self.proof([stale], self.signer), "changed since the signature"),
("unlisted file", unlisted, self.proof([unlisted], self.signer), "unlisted file"),
("added twice", twice, self.proof([twice], self.signer), "lists Bash(make test:*)"),
("removed absent", absent, self.proof([absent], self.signer), "does not list"),
)
for name, item, proof, reason in cases:
with self.subTest(name=name):
before = self.files()
result = self.run_job([item], proof)["items"][0]
self.assertEqual(result["status"], "refused", result)
self.assertIn(reason, result["reason"])
self.assertEqual(self.files(), before)
def test_the_host_refuses_to_add_a_hidden_character_and_removes_one_already_in_the_file(self):
hidden = f"Bash(make{chr(0x202E)} build:*)"
before = self.files()
addition = self.item(self.settings, [{**ADD_LINT, "entry": hidden}])
self.assertEqual(self.run_job([addition], self.proof([addition], self.signer))["error"], "malformed job: refused, nothing changed")
self.assertEqual(self.files(), before)
settings = json.loads(self.settings.read_text(encoding="utf-8"))
settings["permissions"]["allow"].append(hidden)
self.settings.write_text(json.dumps(settings, indent=2) + "\n", encoding="utf-8")
result = self.signed(self.item(self.settings, [{"list": "permissions.allow", "op": "remove", "entry": hidden}]))
self.assertEqual(result["status"], "done", result)
self.assertEqual(json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"], ORIGINAL["permissions"]["allow"])
def test_a_replayed_signature_changes_nothing_even_when_the_file_is_back_at_its_base(self):
before = self.settings.read_bytes()
item = self.item(self.settings, [ADD_LINT])
proof = self.proof([item], self.signer)
self.assertEqual(self.run_job([item], proof)["items"][0]["status"], "done")
self.settings.write_bytes(before)
again = self.run_job([item], proof)["items"][0]
self.assertEqual(again["status"], "refused")
self.assertIn("already used", again["reason"])
self.assertEqual(self.settings.read_bytes(), before)
def test_a_link_on_the_path_or_at_the_file_is_refused(self):
outside = self.base / "outside"
(outside / ".claude").mkdir(parents=True)
target = outside / ".claude" / "settings.json"
target.write_text("{}\n", encoding="utf-8")
self.project_settings.parent.rmdir()
(self.project / ".claude").symlink_to(outside / ".claude")
result = self.signed({"file": str(self.project_settings), "base": sha(b"{}\n"), "changes": [ADD_LINT]})
self.assertEqual(result["status"], "refused", result)
self.assertIn("link", result["reason"])
(self.project / ".claude").unlink()
(self.project / ".claude").mkdir()
self.project_settings.symlink_to(target)
result = self.signed({"file": str(self.project_settings), "base": sha(b"{}\n"), "changes": [ADD_LINT]})
self.assertEqual(result["status"], "refused", result)
self.assertIn("link", result["reason"])
self.assertEqual((target.read_text(encoding="utf-8"), self.project_settings.is_symlink()), ("{}\n", True))
def test_a_failed_replace_keeps_the_file_and_leaves_no_temporary(self):
before = self.settings.read_bytes()
replace = os.replace
def failing(source: str, target: str, **kwargs: int) -> None:
if target == "settings.json":
raise OSError(errno.EIO, "disk gone")
replace(source, target, **kwargs)
with mock.patch.object(host.os, "replace", failing):
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual(result["status"], "failed", result)
self.assertEqual(self.settings.read_bytes(), before)
self.assertEqual(sorted(path.name for path in self.settings.parent.iterdir() if path.name.startswith(".")), [])
def test_a_malformed_or_linked_job_writes_nothing(self):
good = self.item(self.settings, [ADD_LINT])
before = self.files()
for name, items in (
("command smuggled in", [{**good, "command": "rm -rf ~"}]),
("local settings", [{**good, "file": str(self.settings.with_name("settings.local.json"))}]),
("climbing path", [{**good, "file": f"{self.home}/../home/.claude/settings.json"}]),
("no changes", [{**good, "changes": []}]),
("hooks list", [{**good, "changes": [{**ADD_LINT, "list": "hooks.PermissionRequest"}]}]),
("replace op", [{**good, "changes": [{**ADD_LINT, "op": "replace"}]}]),
("two lines", [{**good, "changes": [{**ADD_LINT, "entry": "a\nb"}]}]),
("lone surrogate entry", [{**good, "changes": [{**ADD_LINT, "entry": "Bash(make \ud800:*)"}]}]),
("lone surrogate path", [{**good, "file": f"{self.home}/\ud800/.claude/settings.json"}]),
("twice the same entry", [{**good, "changes": [ADD_LINT, ADD_LINT]}]),
("no items", []),
):
with self.subTest(name=name):
result = self.run_job(items, self.proof([good], self.signer))
self.assertEqual(result["items"], [])
self.assertIn("malformed job", result["error"])
job_id = secrets.token_hex(8)
planted = self.base / "planted.json"
planted.write_text(json.dumps({"v": 1, "id": job_id, "created": "x", "items": [good], "proof": self.proof([good], self.signer)}), encoding="utf-8")
(self.jobs / f"{job_id}.json").symlink_to(planted)
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 1)
self.assertIn("unreadable job", self.result(job_id)["error"])
pipe = secrets.token_hex(8)
os.mkfifo(self.jobs / f"{pipe}.json")
renamed = secrets.token_hex(8)
self.write_job(renamed, [good], self.proof([good], self.signer))
(self.jobs / f"{renamed}.json").rename(self.jobs / f"{'0' * 16}.json")
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 2)
self.assertIn("not a regular file", self.result(pipe)["error"])
self.assertEqual((self.result("0" * 16)["items"], self.result("0" * 16)["error"]), ([], "malformed job: refused, nothing changed"))
self.assertEqual((list(self.jobs.iterdir()), self.files()), ([], before))
def test_a_file_json_readers_could_read_differently_fails_and_stays_byte_identical(self):
for name, text, reason in (
("overflowing number", '{"model": 1e400}', "beyond the double range"),
("NaN", '{"model": NaN}', "holds NaN"),
("Infinity", '{"model": Infinity}', "holds Infinity"),
("minus Infinity", '{"model": -Infinity}', "holds -Infinity"),
("repeated key", '{"permissions": {"allow": []}, "permissions": {"deny": []}}', "repeats a key"),
("lone surrogate", '{"model": "\\ud800"}', "lone surrogate"),
("600 levels", '{"model": ' + "[" * 600 + "]" * 600 + "}", "nests deeper than 64"),
("no object", "[]", "no JSON object"),
("no JSON", "{", "no strict JSON"),
):
with self.subTest(name=name):
self.settings.write_text(text + "\n", encoding="utf-8")
before = self.files()
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual(result["status"], "failed", result)
self.assertIn(reason, result["reason"])
self.assertNotIn("model", result["reason"])
self.assertEqual(self.files(), before)
shown = self.writer.view()["files"][0]
self.assertEqual((reason in shown["error"], shown["settings"]), (True, {}), shown)
def test_a_poisoned_file_fails_only_its_job_and_the_unit_applies_the_next_and_rewrites_the_view(self):
second = self.base / "second" / ".claude" / "settings.json"
second.parent.mkdir(parents=True)
self.tree.write_text(json.dumps({"repos": [{"path": str(self.project), "known": True, "default": "main"}, {"path": str(second.parent.parent), "known": True, "default": "main"}]}), encoding="utf-8")
self.project_settings.write_text('{"model": "\\ud800"}\n', encoding="utf-8")
second.write_text('{"model": ' + "[" * 600 + "]" * 600 + "}\n", encoding="utf-8")
poisoned = {path: path.read_bytes() for path in (self.project_settings, second)}
jobs = {"0" * 16: self.item(self.project_settings, [ADD_LINT]), "1" * 16: self.item(second, [ADD_LINT]), "f" * 16: self.item(self.settings, [ADD_LINT])}
for job_id, item in jobs.items():
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / "view.json"
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(list(self.jobs.iterdir()), [])
found = [(self.result(job_id)["items"][0]["status"], self.result(job_id)["items"][0]["reason"]) for job_id in jobs]
self.assertEqual([status for status, _ in found], ["failed", "failed", "done"], found)
self.assertIn("lone surrogate", found[0][1])
self.assertIn("nests deeper than 64", found[1][1])
self.assertEqual({path: path.read_bytes() for path in poisoned}, poisoned)
self.assertEqual([sorted(child.name for child in path.parent.iterdir()) for path in poisoned], [["settings.json"], ["settings.json"]])
self.assertIn("Bash(make lint:*)", json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"])
shown = {entry["path"]: entry for entry in json.loads(view.read_text(encoding="utf-8"))["files"]}
self.assertEqual(shown[str(self.settings)]["sha256"], sha(self.settings.read_bytes()))
self.assertIn("lone surrogate", shown[str(self.project_settings)]["error"])
self.assertIn("nests deeper than 64", shown[str(second)]["error"])
def test_a_bad_tree_path_or_a_deep_tree_marks_only_itself_and_the_unit_still_applies_and_rewrites_the_view(self):
nul, surrogate = f"{self.base}/nul\x00dir", f"{self.base}/\ud800dir"
for name, text, bad, error in (
("NUL in a path", json.dumps({"repos": [{"path": nul, "known": True}]}), f"{nul}{signing.SETTINGS_FILE}", "unreadable: ValueError"),
("lone surrogate in a path", json.dumps({"repos": [{"path": surrogate, "known": True}]}), f"{surrogate}{signing.SETTINGS_FILE}", "unreadable: UnicodeEncodeError"),
("tree nested 100000 levels", '{"repos": ' + "[" * 100000 + "]" * 100000 + "}", None, None),
):
with self.subTest(name=name):
self.tree.write_text(text, encoding="utf-8")
self.settings.write_text(json.dumps(ORIGINAL, indent=2) + "\n", encoding="utf-8")
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / f"{job_id}.json"
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(self.result(job_id)["items"][0]["status"], "done")
shown = {entry["path"]: entry for entry in json.loads(view.read_text(encoding="utf-8"))["files"]}
self.assertEqual(sorted(shown), sorted([str(self.settings), *([bad] if bad else [])]))
self.assertEqual((shown[str(self.settings)]["sha256"], shown[str(self.settings)]["error"]), (sha(self.settings.read_bytes()), ""))
if bad:
self.assertEqual((shown[bad]["error"], shown[bad]["settings"]), (error, {}))
def test_the_view_is_rewritten_even_when_a_result_cannot_be_written(self):
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
self.results.chmod(0o500)
self.addCleanup(self.results.chmod, 0o700)
view = self.base / "state" / "view.json"
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(f"no result for {job_id}.json", done.stderr)
self.assertEqual((list(self.jobs.iterdir()), list(self.results.iterdir())), ([], []))
self.assertEqual(json.loads(view.read_text(encoding="utf-8"))["files"][0]["sha256"], sha(self.settings.read_bytes()))
def test_a_view_that_cannot_be_written_ends_the_unit_with_one_line_and_keeps_the_results(self):
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / "view.json"
view.mkdir(mode=0o700, parents=True)
done = self.unit(view, {})
self.assertEqual((done.returncode, "Traceback" in done.stderr), (0, False), done.stderr)
self.assertIn("view not written", done.stderr)
self.assertEqual((self.result(job_id)["items"][0]["status"], view.is_dir()), ("done", True))
def test_a_directory_sync_failing_after_the_replace_reports_the_written_change(self):
real = os.fsync
def failing(fd: int) -> None:
if stat.S_ISDIR(os.fstat(fd).st_mode):
raise OSError(errno.EIO, "Input/output error")
real(fd)
with mock.patch.object(host.os, "fsync", side_effect=failing):
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual(result["status"], "done", result)
self.assertIn("written, but its directory sync failed: Input/output error", result["reason"])
self.assertIn("Bash(make lint:*)", json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"])
self.assertEqual(result["sha256"], sha(self.settings.read_bytes()))
def test_the_unit_makes_no_directory_and_writes_nothing_through_a_linked_spool(self):
victim = self.base / "victim"
victim.mkdir(mode=0o700)
spool = self.base / "spool"
spool.symlink_to(victim)
self.jobs, self.results = spool / "jobs", spool / "results"
done = self.unit(spool / "view.json", {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("refused, nothing done", done.stderr)
self.assertIn("view not written", done.stderr)
self.assertEqual(list(victim.iterdir()), [])
def test_a_view_in_a_linked_or_foreign_spool_is_refused_and_a_linked_view_file_replaced(self):
victim = self.base / "victim"
victim.mkdir(mode=0o700)
(victim / "view.json").write_text("victim", encoding="utf-8")
linked, shared, real = self.base / "linked", self.base / "shared", self.base / "real"
linked.symlink_to(victim)
shared.mkdir()
shared.chmod(0o770)
real.mkdir(mode=0o700)
(real / "view.json").symlink_to(victim / "view.json")
for folder in (linked, shared, real):
stderr = io.StringIO()
with contextlib.redirect_stderr(stderr):
host.write_view(folder / "view.json", self.writer.view())
with self.subTest(folder=folder.name):
self.assertEqual("view not written" in stderr.getvalue(), folder != real, stderr.getvalue())
self.assertEqual(([path.name for path in victim.iterdir()], (victim / "view.json").read_text(encoding="utf-8"), list(shared.iterdir())), (["view.json"], "victim", []))
self.assertFalse((real / "view.json").is_symlink())
self.assertEqual(json.loads((real / "view.json").read_text(encoding="utf-8"))["files"][0]["path"], str(self.settings))
def test_an_unexpected_crash_fails_only_its_job_or_item_and_names_only_its_kind(self):
apply, problem = signing.apply_changes, signing.settings_problem
crashes = iter([RecursionError("planted depth"), UnicodeEncodeError("utf-8", "planted text", 0, 1, "planted")])
checked = []
def crashing_apply(settings: dict, changes: list[dict]) -> dict:
error = next(crashes, None)
if error is not None:
raise error
return apply(settings, changes)
def crashing_problem(item: object) -> str | None:
checked.append(item)
if len(checked) == 1:
raise KeyError("planted key")
return problem(item)
item = self.item(self.settings, [ADD_LINT])
for job_id in ("0" * 16, "1" * 16, "2" * 16, "f" * 16):
self.write_job(job_id, [item], self.proof([item], self.signer))
with mock.patch.object(host.signing, "apply_changes", crashing_apply), mock.patch.object(host.signing, "settings_problem", crashing_problem):
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 4)
self.assertEqual((self.result("0" * 16)["items"], self.result("0" * 16)["error"]), ([], "failed: KeyError; nothing changed"))
found = [(self.result(job_id)["items"][0]["status"], self.result(job_id)["items"][0]["reason"]) for job_id in ("1" * 16, "2" * 16, "f" * 16)]
self.assertEqual(found, [("failed", "RecursionError; the file kept its content"), ("failed", "UnicodeEncodeError; the file kept its content"), ("done", "")])
self.assertEqual(json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"].count("Bash(make lint:*)"), 1)
self.assertEqual(list(self.jobs.iterdir()), [])
def test_a_non_finite_number_never_reaches_the_file_even_past_the_parser(self):
before = self.files()
with mock.patch.object(host, "parsed", return_value={"model": float("inf")}):
result = self.signed(self.item(self.settings, [ADD_LINT]))
self.assertEqual((result["status"], result["reason"]), ("failed", "ValueError; the file kept its content"))
self.assertEqual(self.files(), before)
def test_a_planted_temporary_link_is_never_followed(self):
outside = self.base / "outside.json"
outside.write_text("{}\n", encoding="utf-8")
before = self.settings.read_bytes()
item = self.item(self.settings, [ADD_LINT])
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
fixed = "0" * 16
(self.settings.parent / f".settings.json.{fixed}").symlink_to(outside)
with mock.patch.object(host.secrets, "token_hex", return_value=fixed):
self.assertEqual(host.cycle(self.jobs, self.results, self.writer), 1)
self.assertEqual(self.result(job_id)["items"][0]["status"], "failed")
self.assertEqual((self.settings.read_bytes(), self.settings.is_symlink(), outside.read_text(encoding="utf-8")), (before, False, "{}\n"))
def test_a_file_of_another_uid_is_refused(self):
before = self.files()
item = self.item(self.settings, [ADD_LINT])
proof = self.proof([item], self.signer)
with mock.patch.object(host.os, "getuid", return_value=os.getuid() + 1):
result = self.run_job([item], proof)["items"][0]
self.assertEqual(result["status"], "refused", result)
self.assertIn(f"belongs to uid {os.getuid()}", result["reason"])
self.assertEqual(self.files(), before)
def test_a_settings_path_that_is_no_regular_file_is_refused(self):
os.mkfifo(self.project_settings)
result = self.signed({"file": str(self.project_settings), "base": sha(b""), "changes": [ADD_LINT]})
self.assertEqual(result["status"], "refused", result)
self.assertIn("no regular file", result["reason"])
self.assertTrue(stat.S_ISFIFO(self.project_settings.lstat().st_mode))
def test_the_view_lists_the_fixed_files_with_only_permissions_and_sandbox(self):
view = self.writer.view()
self.assertEqual([entry["path"] for entry in view["files"]], [str(self.settings), str(self.project_settings)])
own, project = view["files"]
self.assertEqual((own["exists"], own["sha256"], own["error"]), (True, sha(self.settings.read_bytes()), ""))
self.assertEqual(own["settings"], {"permissions": ORIGINAL["permissions"], "sandbox": ORIGINAL["sandbox"]})
self.assertEqual((project["exists"], project["sha256"], project["settings"]), (False, "", {}))
self.assertNotIn("fixture-value-not-a-secret", json.dumps(view))
def test_a_missing_directory_shows_in_the_view_as_the_writer_handles_it(self):
self.project_settings.parent.rmdir()
shown = self.writer.view()["files"][1]
self.assertEqual((shown["exists"], shown["error"]), (False, host.MISSING_DIRECTORY))
result = self.signed({"file": str(self.project_settings), "base": "", "changes": [ADD_LINT]})
self.assertEqual((result["status"], self.project_settings.parent.exists()), ("refused", False), result)
self.project_settings.parent.mkdir()
self.assertEqual(self.writer.view()["files"][1]["error"], "")
self.assertEqual(self.signed({"file": str(self.project_settings), "base": "", "changes": [ADD_LINT]})["status"], "done")
def test_the_unit_runs_once_outside_any_agent_and_refuses_inside_one(self):
item = self.item(self.settings, [ADD_LINT])
before = self.settings.read_bytes()
job_id = secrets.token_hex(8)
self.write_job(job_id, [item], self.proof([item], self.signer))
view = self.base / "state" / "view.json"
for marker in host.AGENT_MARKERS:
with self.subTest(marker=marker):
inside = self.unit(view, {marker: "1"})
self.assertEqual(inside.returncode, 2, inside.stderr)
self.assertIn("refused", inside.stderr)
self.assertEqual((self.settings.read_bytes(), view.exists(), len(list(self.jobs.iterdir()))), (before, False, 1))
done = self.unit(view, {})
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(list(self.jobs.iterdir()), [])
result = self.result(job_id)
self.assertEqual(result["items"][0]["status"], "done", result)
self.assertIn("Bash(make lint:*)", json.loads(self.settings.read_text(encoding="utf-8"))["permissions"]["allow"])
self.assertEqual(((self.results / f"{job_id}.json").stat().st_mode & 0o777, view.stat().st_mode & 0o777), (0o600, 0o600))
self.assertEqual(json.loads(view.read_text(encoding="utf-8"))["files"][0]["sha256"], sha(self.settings.read_bytes()))
class TestSettingsWriterSpoolLinks(spool_links.SpoolLinks, unittest.TestCase):
module = host
def unit(self, trust: verifier.Trust, base: Path):
return host.Writer(trust, base / "home", base / "tree.json")
if __name__ == "__main__":
unittest.main()