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>
This commit is contained in:
1 parent
3418738993
commit
9742884308
54 files changed
+3920
-168
No files matched your search
@@ -8,12 +8,13 @@ from .choosing import answer_signed
|
||||
from .cleanup import cleanup_request
|
||||
from .denying import DENIABLE, DENY_KEYS, denial_note, request_status, request_words
|
||||
from .errors import Conflict, Missing, ToolError
|
||||
from .fields import decode, expect, field
|
||||
from .fields import decode, expect, field, visible
|
||||
from .firewall import settings_request
|
||||
from .gating import gate_request
|
||||
from .offices import office_request
|
||||
from .records import digest, shown
|
||||
from .register import REGISTER, adder, operator_rows, read_register, runnable
|
||||
from .rules import rule_matches, subject_of
|
||||
from .rules import enable_request, rule_matches, subject_of
|
||||
from .signed import (
|
||||
ask_signed,
|
||||
operator_signed,
|
||||
@@ -63,7 +64,12 @@ class Approving:
|
||||
"""Returns:
|
||||
The approval payload over the items, its WebAuthn challenge and the
|
||||
pinned credential ids; payload and challenge are None for no item.
|
||||
|
||||
Raises:
|
||||
ToolError from visible() for an item holding a text no prompt
|
||||
shows as signed, whatever source missed it.
|
||||
"""
|
||||
visible(items)
|
||||
credentials = [key["id"] for key in self.keys()]
|
||||
if not items:
|
||||
return {"payload": None, "challenge": None, "credentials": credentials}
|
||||
@@ -131,7 +137,7 @@ class Approving:
|
||||
|
||||
def automate(self, kind_name: str, record: dict) -> None:
|
||||
now = time.time()
|
||||
subject = subject_of(kind_name, record)
|
||||
subject = subject_of(kind_name, record, self.deciders(kind_name, record))
|
||||
rule = next((rule for rule in self.rules.listed() if rule_matches(rule, kind_name, subject, now)), None)
|
||||
if rule is None:
|
||||
return
|
||||
@@ -189,6 +195,27 @@ class Approving:
|
||||
raise Conflict({"id": raw["id"], "status": "recipient changed", "to": name})
|
||||
return name
|
||||
|
||||
def operator_entry(self, raw: dict, tasks: dict[str, dict]) -> dict:
|
||||
"""Args:
|
||||
raw: a checked inbox entry of kind operator.
|
||||
tasks: the register.
|
||||
|
||||
Returns:
|
||||
The signed item of the operator row raw names, once its task,
|
||||
command and directory pass visible().
|
||||
"""
|
||||
row = next((row for row in operator_rows(tasks) if row["task"] == raw["id"]), None)
|
||||
if row is None:
|
||||
raise Missing(str(raw["id"]))
|
||||
visible({name: row[name] for name in ("task", "command", "directory")})
|
||||
if raw["verb"] == "approve" and not runnable(row):
|
||||
raise ToolError("an operator row is approved only when it holds a directory and a command")
|
||||
if digest(row["command"]) != raw["sha256"]:
|
||||
raise Conflict({"id": row["task"], "status": "changed"})
|
||||
if row["task"] in self.open_jobs():
|
||||
raise Conflict({"id": row["task"], "status": "queued"})
|
||||
return inbox_item(raw, "", row["command"], "", operator_signed(row), self.requester(raw, adder(tasks[row["task"]])))
|
||||
|
||||
def item_of(self, raw: object, tasks: dict[str, dict]) -> dict:
|
||||
if not isinstance(raw, dict):
|
||||
raise ToolError("every item must be an object with kind, id, verb, label and sha256, and a denial also channel, reason and to")
|
||||
@@ -197,16 +224,7 @@ class Approving:
|
||||
if kind_name not in INBOX_KINDS or verb not in VERBS or not isinstance(raw["label"], str) or not isinstance(raw["sha256"], str):
|
||||
raise ToolError(f"kind must be one of {', '.join(INBOX_KINDS)}, verb approve or reject, label and sha256 text")
|
||||
if kind_name == "operator":
|
||||
row = next((row for row in operator_rows(tasks) if row["task"] == raw["id"]), None)
|
||||
if row is None:
|
||||
raise Missing(str(raw["id"]))
|
||||
if verb == "approve" and not runnable(row):
|
||||
raise ToolError("an operator row is approved only when it holds a directory and a command")
|
||||
if digest(row["command"]) != raw["sha256"]:
|
||||
raise Conflict({"id": row["task"], "status": "changed"})
|
||||
if row["task"] in self.open_jobs():
|
||||
raise Conflict({"id": row["task"], "status": "queued"})
|
||||
return inbox_item(raw, "", row["command"], "", operator_signed(row), self.requester(raw, adder(tasks[row["task"]])))
|
||||
return self.operator_entry(raw, tasks)
|
||||
if kind_name == "rule" and verb == "approve":
|
||||
raise ToolError("a rule request is accepted in its row, with the passkey signature over the rule itself")
|
||||
item_id = field(raw, "id")
|
||||
@@ -253,6 +271,11 @@ class Approving:
|
||||
signed = self.task_changes(raw)
|
||||
elif gate_request(raw):
|
||||
signed = self.gate_changes(raw)
|
||||
elif settings_request(raw):
|
||||
signed = self.settings_changes(raw)
|
||||
elif enable_request(raw):
|
||||
signed = self.enable_items(raw)
|
||||
return {**self.challenge_for(signed), "enables": signed[0]["rule"]}
|
||||
else:
|
||||
signed = [item["signed"] for item in self.checked(raw) if item["signed"] is not None]
|
||||
return self.challenge_for(signed)
|
||||
|
||||
@@ -16,6 +16,7 @@ from .fields import (
|
||||
instant,
|
||||
message_text,
|
||||
seconds,
|
||||
visible,
|
||||
)
|
||||
from .signed import ask_signed
|
||||
|
||||
@@ -55,7 +56,9 @@ def option_of(option: object) -> dict:
|
||||
raise ToolError("every option must be an object with label and description")
|
||||
expect(option, ("label", "description"))
|
||||
label = field(option, "label").strip()
|
||||
return {"label": label, "description": bounded(option, "description", DESCRIPTION_LIMIT).strip()}
|
||||
description = bounded(option, "description", DESCRIPTION_LIMIT).strip()
|
||||
visible({"description": description})
|
||||
return {"label": label, "description": description}
|
||||
|
||||
|
||||
class Asking:
|
||||
@@ -64,6 +67,7 @@ class Asking:
|
||||
diff = valid_diff(payload.pop("diff")) if "diff" in payload else None
|
||||
expect(payload, ("tool", *ASK_TEXTS, "timeout"))
|
||||
values = {name: bounded(payload, name, limit) for name, limit in ASK_TEXTS.items()}
|
||||
visible(values)
|
||||
lifetime = seconds(payload, "timeout", ASK_LIFETIME)
|
||||
created = time.time()
|
||||
fields = {**values, "tool": field(payload, "tool").strip(), "status": "pending", "decided": None, "proof": None, "diff_files": None if diff is None else len(diff)}
|
||||
@@ -104,6 +108,7 @@ class Asking:
|
||||
def decision_request(self, arguments: dict) -> dict:
|
||||
expect(arguments, ("question", "options", "agent", "recommended"))
|
||||
question = message_text(arguments, "question")
|
||||
visible({"question": question})
|
||||
options = arguments["options"]
|
||||
if not isinstance(options, list) or not 1 <= len(options) <= OPTION_LIMIT:
|
||||
raise ToolError(f"options must be a list of 1 to {OPTION_LIMIT} objects")
|
||||
|
||||
@@ -5,7 +5,7 @@ import math
|
||||
import re
|
||||
|
||||
from .errors import ToolError
|
||||
from .signed import limits
|
||||
from .signed import limits, signing
|
||||
|
||||
WAIT_CAP = 300
|
||||
TEXT_LIMIT = 20_000
|
||||
@@ -43,9 +43,25 @@ def field(arguments: dict, name: str) -> str:
|
||||
value = arguments[name]
|
||||
if not isinstance(value, str) or not pattern.fullmatch(value):
|
||||
raise ToolError(f"{name} must be {hint}")
|
||||
visible({name: value})
|
||||
return value
|
||||
|
||||
|
||||
def visible(value: object) -> None:
|
||||
"""Args:
|
||||
value: an object of named texts, or a list of them, that reaches a
|
||||
signed payload or the approval prompt.
|
||||
|
||||
Raises:
|
||||
ToolError with the reason signing.hidden_problem() gives for the
|
||||
first text holding an invisible, format, control or look-alike
|
||||
character.
|
||||
"""
|
||||
hidden = signing.hidden_problem(value, "value")
|
||||
if hidden:
|
||||
raise ToolError(hidden)
|
||||
|
||||
|
||||
def bounded(arguments: dict, name: str, limit: int) -> str:
|
||||
value = arguments[name]
|
||||
if not isinstance(value, str) or len(value) > limit:
|
||||
|
||||
@@ -0,0 +1,248 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import difflib
|
||||
import json
|
||||
import re
|
||||
import secrets
|
||||
import time
|
||||
|
||||
from .errors import Conflict, Missing, ToolError
|
||||
from .fields import decode, expect, visible
|
||||
from .ledger import Ledger
|
||||
from .records import read_json, stamp
|
||||
from .rules import EVERY_AGENT, RULE_KINDS
|
||||
from .signed import signing
|
||||
|
||||
VIEW = "view.json"
|
||||
JOB_VERSION = 1
|
||||
ITEM_LIMIT = 10
|
||||
SET_LIMIT = 50
|
||||
DAY_LIMIT = 366
|
||||
NAME = re.compile(r"(?=[^\x00-\x1f\x7f]*\S)[^\x00-\x1f\x7f]{1,80}")
|
||||
RULE_TEXT = re.compile(r"(?P<tool>[^()]+?)(?:\((?P<spec>.*)\))?", re.DOTALL)
|
||||
WORD = re.compile(r"[\s:]")
|
||||
HASH = re.compile(r"[0-9a-f]{64}")
|
||||
PERMISSION_LISTS = ("allow", "ask", "deny")
|
||||
SET_KEYS = ("kind", "tool", "pattern", "scope")
|
||||
CHAINED = "chains, pipes, redirects or substitutions"
|
||||
|
||||
|
||||
def settings_request(raw: object) -> bool:
|
||||
return isinstance(raw, list) and bool(raw) and all(isinstance(entry, dict) and entry.get("kind") == "settings" for entry in raw)
|
||||
|
||||
|
||||
def tool_and_prefix(entry: str) -> tuple[str, str]:
|
||||
"""Returns:
|
||||
The tool of a permission rule such as Bash(git push:*) and the first
|
||||
word of its specifier, for Bash the command; "" without specifier.
|
||||
"""
|
||||
found = RULE_TEXT.fullmatch(entry)
|
||||
if found is None:
|
||||
return entry.strip(), ""
|
||||
return found.group("tool").strip(), WORD.split((found.group("spec") or "").strip(), maxsplit=1)[0]
|
||||
|
||||
|
||||
def grouped(permissions: object) -> list[dict]:
|
||||
"""Returns:
|
||||
The allow, ask and deny entries of a permissions section grouped by
|
||||
tool and prefix, sorted: [{"tool", "prefix", "entries": [{"list",
|
||||
"entry"}]}].
|
||||
"""
|
||||
groups: dict[tuple[str, str], list[dict]] = {}
|
||||
lists = permissions if isinstance(permissions, dict) else {}
|
||||
for name in PERMISSION_LISTS:
|
||||
values = lists.get(name)
|
||||
for entry in values if isinstance(values, list) else []:
|
||||
if isinstance(entry, str):
|
||||
groups.setdefault(tool_and_prefix(entry), []).append({"list": name, "entry": entry})
|
||||
return [{"tool": tool, "prefix": prefix, "entries": entries} for (tool, prefix), entries in sorted(groups.items())]
|
||||
|
||||
|
||||
def sandbox_entries(section: object, path: str) -> list[dict]:
|
||||
"""Returns:
|
||||
Every leaf of a sandbox section under the dotted path, a list as
|
||||
{"key", "values"} and any other value as {"key", "value"}.
|
||||
"""
|
||||
found: list[dict] = []
|
||||
for name, value in section.items() if isinstance(section, dict) else ():
|
||||
key = f"{path}.{name}"
|
||||
if isinstance(value, dict):
|
||||
found += sandbox_entries(value, key)
|
||||
elif isinstance(value, list):
|
||||
found.append({"key": key, "values": [entry if isinstance(entry, str) else json.dumps(entry) for entry in value]})
|
||||
else:
|
||||
found.append({"key": key, "value": value})
|
||||
return found
|
||||
|
||||
|
||||
def shaped_file(entry: object) -> bool:
|
||||
if not isinstance(entry, dict) or not isinstance(entry.get("path"), str) or not isinstance(entry.get("exists"), bool):
|
||||
return False
|
||||
return isinstance(entry.get("settings"), dict) and isinstance(entry.get("sha256"), str) and (entry["sha256"] == "" or bool(HASH.fullmatch(entry["sha256"])))
|
||||
|
||||
|
||||
def section_diff(path: str, before: dict, after: dict) -> str:
|
||||
"""Returns:
|
||||
The unified diff of the permissions and sandbox sections before and
|
||||
after the change, as the host writer applies it.
|
||||
"""
|
||||
lines = difflib.unified_diff(json.dumps(before, indent=2).splitlines(), json.dumps(after, indent=2).splitlines(), fromfile=path, tofile=path, lineterm="", n=3)
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def unique_name(payload: dict, ledger: Ledger) -> str:
|
||||
name = payload["name"]
|
||||
if not isinstance(name, str) or not NAME.fullmatch(name):
|
||||
raise ToolError("name must be one line of 1 to 80 characters")
|
||||
visible({"name": name})
|
||||
if any(record["name"] == name for record in ledger.listed()):
|
||||
raise Conflict({"name": name, "status": "exists"})
|
||||
return name
|
||||
|
||||
|
||||
def dropped(ledger: Ledger, record_id: str) -> dict:
|
||||
if not ledger.remove(record_id):
|
||||
raise Missing(record_id)
|
||||
return {"id": record_id, "deleted": True}
|
||||
|
||||
|
||||
def deny_patterns() -> list[dict]:
|
||||
"""Returns:
|
||||
The commands no ask rule ever grants, as {"label", "pattern"}.
|
||||
"""
|
||||
return [*({"label": label, "pattern": pattern.pattern} for label, pattern in signing.WARNINGS), {"label": CHAINED, "pattern": signing.CHAINED.pattern}]
|
||||
|
||||
|
||||
class Firewall:
|
||||
def settings_files(self) -> tuple[list[dict], dict]:
|
||||
"""Returns:
|
||||
The listed settings files the host writer last read, each
|
||||
{"path", "exists", "sha256", "error", "settings"} with settings
|
||||
only their permissions and sandbox sections, and the view's
|
||||
written time and error.
|
||||
"""
|
||||
view = read_json(self.firewall_spool.root / VIEW)
|
||||
files = view.get("files") if isinstance(view, dict) else None
|
||||
if not isinstance(files, list):
|
||||
return [], {"written": None, "error": "no settings view yet: the kvb-orchestrator-firewall unit writes it on the host"}
|
||||
shown = [{**entry, "settings": signing.settings_view(entry["settings"]), "error": str(entry.get("error") or "")} for entry in files if shaped_file(entry)]
|
||||
return shown, {"written": view.get("written"), "error": ""}
|
||||
|
||||
def firewall(self) -> dict:
|
||||
files, meta = self.settings_files()
|
||||
listed = [{key: entry[key] for key in ("path", "exists", "sha256", "error")} | {"groups": grouped(entry["settings"].get("permissions")), "sandbox": sandbox_entries(entry["settings"].get("sandbox"), "sandbox")} for entry in files]
|
||||
return {**meta, "files": listed, "lists": list(signing.SETTINGS_LISTS), "patterns": deny_patterns(), "groups": self.groups.listed(), "sets": self.rule_sets.listed()}
|
||||
|
||||
def settings_changes(self, raw: object) -> list[dict]:
|
||||
"""Args:
|
||||
raw: the page's items, each {"kind": "settings", "file", "base",
|
||||
"changes"} for one listed file at the sha256 the view shows.
|
||||
|
||||
Returns:
|
||||
The signed items, each one file whose changes apply to the
|
||||
sections the view shows.
|
||||
"""
|
||||
if not isinstance(raw, list) or not 1 <= len(raw) <= ITEM_LIMIT:
|
||||
raise ToolError(f"items must be a list of 1 to {ITEM_LIMIT} settings changes")
|
||||
files = {entry["path"]: entry for entry in self.settings_files()[0]}
|
||||
signed: list[dict] = []
|
||||
for entry in raw:
|
||||
if not isinstance(entry, dict):
|
||||
raise ToolError("every item must be an object with kind, file, base and changes")
|
||||
expect(entry, ("kind", *signing.SETTINGS_KEYS))
|
||||
order = {name: entry[name] for name in signing.SETTINGS_KEYS}
|
||||
problem = signing.settings_problem(order)
|
||||
if problem:
|
||||
raise ToolError(problem)
|
||||
self.applicable(files, order)
|
||||
if any(item["file"] == order["file"] for item in signed):
|
||||
raise ToolError("one item per file: list every change of a file in its changes")
|
||||
signed.append(signing.settings_item(**order))
|
||||
return signed
|
||||
|
||||
def applicable(self, files: dict[str, dict], order: dict) -> dict:
|
||||
shown = files.get(order["file"])
|
||||
if shown is None:
|
||||
raise ToolError(f"{order['file'][:300]} is no settings file the Firewall lists")
|
||||
if shown["sha256"] != order["base"]:
|
||||
raise Conflict({"file": order["file"], "status": "changed", "sha256": shown["sha256"]})
|
||||
try:
|
||||
return signing.apply_changes(shown["settings"], order["changes"])
|
||||
except signing.Refused as error:
|
||||
raise ToolError(str(error)) from None
|
||||
|
||||
def settings_preview(self, body: bytes) -> dict:
|
||||
payload = decode(body)
|
||||
expect(payload, ("items",))
|
||||
items = self.settings_changes(payload["items"])
|
||||
files = {entry["path"]: entry for entry in self.settings_files()[0]}
|
||||
return {"diffs": [{"file": item["file"], "diff": section_diff(item["file"], files[item["file"]]["settings"], self.applicable(files, item))} for item in items]}
|
||||
|
||||
def change_settings(self, body: bytes) -> dict:
|
||||
payload = decode(body)
|
||||
expect(payload, ("items", "proof"))
|
||||
items = self.settings_changes(payload["items"])
|
||||
proof = self.covered(payload["proof"], items, time.time())
|
||||
for item in items:
|
||||
self.operator_proven(proof, item)
|
||||
job_id = secrets.token_hex(8)
|
||||
job = {"v": JOB_VERSION, "id": job_id, "created": stamp(), "items": [{name: item[name] for name in signing.SETTINGS_KEYS} for item in items], "proof": proof}
|
||||
self.firewall_spool.put(job_id, job)
|
||||
lines = [f"{item['file']}: {change['op']} {change['list']} {change['entry']}" for item in items for change in item["changes"]]
|
||||
self.log.add({"kind": "run", "title": f"Settings change signed: {len(lines)}"[:200], "text": "\n".join(lines), "ref": {"firewall": job_id, "status": "queued"}})
|
||||
return {"id": job_id, "status": "queued", "items": job["items"]}
|
||||
|
||||
def settings_state(self, job_id: str) -> dict:
|
||||
result = read_json(self.firewall_spool.results / f"{job_id}.json")
|
||||
if isinstance(result, dict) and isinstance(result.get("items"), list):
|
||||
return {**result, "id": job_id, "status": "done"}
|
||||
if (self.firewall_spool.jobs / f"{job_id}.json").is_file():
|
||||
return {"id": job_id, "status": "queued", "items": []}
|
||||
raise Missing(job_id)
|
||||
|
||||
def add_group(self, body: bytes) -> dict:
|
||||
"""Args:
|
||||
body: {"name", "members"}: members 1 to signing.AGENT_LIMIT
|
||||
sorted session ids the Agent Orchestrator knows.
|
||||
"""
|
||||
payload = decode(body)
|
||||
expect(payload, ("name", "members"))
|
||||
members = payload["members"]
|
||||
problem = signing.agents_problem(members) if members != EVERY_AGENT else "members must name sessions, not every agent"
|
||||
if problem:
|
||||
raise ToolError(problem)
|
||||
self.known_agents(members)
|
||||
record = self.groups.add({"name": unique_name(payload, self.groups), "members": members})
|
||||
self.log.add({"kind": "rule", "title": f"Agent group {record['name']}: {len(members)} agents", "text": ", ".join(members), "ref": {"group": record["id"]}})
|
||||
return record
|
||||
|
||||
def add_set(self, body: bytes) -> dict:
|
||||
"""Args:
|
||||
body: {"name", "days", "rules"}: the ids of 1 to SET_LIMIT stored
|
||||
rules whose kind, tool, pattern and scope the set keeps, and
|
||||
the lifetime in days each rule gets when the set is taken
|
||||
over and signed for an agent, a group or every agent.
|
||||
"""
|
||||
payload = decode(body)
|
||||
expect(payload, ("name", "days", "rules"))
|
||||
days = payload["days"]
|
||||
if isinstance(days, bool) or not isinstance(days, int) or not 1 <= days <= DAY_LIMIT:
|
||||
raise ToolError(f"days must be a whole number from 1 to {DAY_LIMIT}")
|
||||
chosen = self.stored_rules(payload["rules"])
|
||||
record = self.rule_sets.add({"name": unique_name(payload, self.rule_sets), "days": days, "rules": [{key: rule[key] for key in SET_KEYS} for rule in chosen]})
|
||||
self.log.add({"kind": "rule", "title": f"Rule set {record['name']}: {len(chosen)} rules", "text": "\n".join(f"{rule['kind']} {rule['tool']} {rule['pattern']}".replace(" ", " ") for rule in chosen), "ref": {"set": record["id"]}})
|
||||
return record
|
||||
|
||||
def stored_rules(self, ids: object) -> list[dict]:
|
||||
if not isinstance(ids, list) or not 1 <= len(ids) <= SET_LIMIT or len(set(map(str, ids))) != len(ids):
|
||||
raise ToolError(f"rules must list 1 to {SET_LIMIT} distinct rule ids")
|
||||
chosen = [self.rules.get(rule_id) if isinstance(rule_id, str) else None for rule_id in ids]
|
||||
if None in chosen or any(rule["kind"] not in RULE_KINDS for rule in chosen):
|
||||
raise ToolError("rules must name stored rules")
|
||||
return chosen
|
||||
|
||||
def drop_group(self, group_id: str) -> dict:
|
||||
return dropped(self.groups, group_id)
|
||||
|
||||
def drop_set(self, set_id: str) -> dict:
|
||||
return dropped(self.rule_sets, set_id)
|
||||
@@ -62,8 +62,13 @@ SETTINGS_SIGN_ROUTE = "/api/settings/sign"
|
||||
CHOICES_ROUTE = "/api/choices"
|
||||
CHOICES_SIGN_ROUTE = "/api/choices/sign"
|
||||
DIFF_ROUTE = re.compile(r"/api/diffs/(review|ask)/([0-9a-f]{16})")
|
||||
FIREWALL_ROUTE = "/api/firewall"
|
||||
FIREWALL_POSTS = {"/api/firewall/preview": "settings_preview", "/api/firewall/settings": "change_settings", "/api/firewall/groups": "add_group", "/api/firewall/sets": "add_set"}
|
||||
FIREWALL_STATE = re.compile(r"/api/firewall/settings/([0-9a-f]{16})")
|
||||
FIREWALL_DROP = re.compile(r"/api/firewall/(groups|sets)/([0-9a-f]{16})/delete")
|
||||
FIREWALL_STATUS = {"settings_preview": HTTPStatus.OK, "change_settings": HTTPStatus.ACCEPTED, "add_group": HTTPStatus.CREATED, "add_set": HTTPStatus.CREATED}
|
||||
WAV_POSTS = (STT_ROUTE, VOICE_ROUTE)
|
||||
ACTION_POSTS = ("/api/rules", "/api/nl", SETTINGS_ROUTE, TTS_ROUTE, STT_ROUTE, SIGN_ROUTE, RULE_SIGN_ROUTE, CLEANUP_ROUTE, OFFICES_ROUTE, TASKS_ROUTE, VOICE_ROUTE, MESSAGE_SIGN_ROUTE, SETTINGS_SIGN_ROUTE, CHOICES_ROUTE, CHOICES_SIGN_ROUTE, GATES_ROUTE, TOKEN_ROUTE)
|
||||
ACTION_POSTS = ("/api/rules", "/api/nl", SETTINGS_ROUTE, TTS_ROUTE, STT_ROUTE, SIGN_ROUTE, RULE_SIGN_ROUTE, CLEANUP_ROUTE, OFFICES_ROUTE, TASKS_ROUTE, VOICE_ROUTE, MESSAGE_SIGN_ROUTE, SETTINGS_SIGN_ROUTE, CHOICES_ROUTE, CHOICES_SIGN_ROUTE, GATES_ROUTE, TOKEN_ROUTE, *FIREWALL_POSTS)
|
||||
|
||||
|
||||
class Handler(Exchange):
|
||||
@@ -90,10 +95,13 @@ class Handler(Exchange):
|
||||
office = OFFICE_STATE.fullmatch(path)
|
||||
voice = VOICE_ITEM.fullmatch(path)
|
||||
diff = DIFF_ROUTE.fullmatch(path)
|
||||
firewall = self.firewall_reader(path)
|
||||
if self.host() is None:
|
||||
self.send_text(HTTPStatus.FORBIDDEN, "forbidden host")
|
||||
elif path == "/":
|
||||
self.index()
|
||||
elif firewall:
|
||||
self.answer(firewall, HTTPStatus.OK)
|
||||
elif diff:
|
||||
self.answer(lambda: hub.diff_of(diff.group(1), diff.group(2)), HTTPStatus.OK)
|
||||
elif vendored and vendored.group(1) in VENDOR:
|
||||
@@ -190,7 +198,7 @@ class Handler(Exchange):
|
||||
if path == "/api/rules":
|
||||
return lambda body: self.answer(lambda: hub.add_rule(body), HTTPStatus.CREATED)
|
||||
if rule:
|
||||
return lambda _body: self.answer(lambda: hub.rule_action(rule.group(1), rule.group(2)), HTTPStatus.OK)
|
||||
return lambda body: self.answer(lambda: hub.rule_action(rule.group(1), rule.group(2), body), HTTPStatus.OK)
|
||||
if path == "/api/nl":
|
||||
return lambda body: self.answer(lambda: hub.nl(body), HTTPStatus.OK)
|
||||
if path == SETTINGS_ROUTE:
|
||||
@@ -209,10 +217,28 @@ class Handler(Exchange):
|
||||
return lambda body: self.answer(lambda: hub.sign_choices(body), HTTPStatus.OK)
|
||||
if path == CHOICES_ROUTE:
|
||||
return lambda body: self.answer(lambda: hub.request_choices(body), HTTPStatus.CREATED)
|
||||
return self.firewall_action(path)
|
||||
|
||||
def firewall_reader(self, path: str) -> Callable[[], dict] | None:
|
||||
hub = self.server.hub
|
||||
job = FIREWALL_STATE.fullmatch(path)
|
||||
if path == FIREWALL_ROUTE:
|
||||
return hub.firewall
|
||||
return (lambda: hub.settings_state(job.group(1))) if job else None
|
||||
|
||||
def firewall_action(self, path: str) -> Callable[[bytes], None] | None:
|
||||
hub = self.server.hub
|
||||
drop = FIREWALL_DROP.fullmatch(path)
|
||||
if path in FIREWALL_POSTS:
|
||||
method = getattr(hub, FIREWALL_POSTS[path])
|
||||
return lambda body: self.answer(lambda: method(body), FIREWALL_STATUS[FIREWALL_POSTS[path]])
|
||||
if drop:
|
||||
remove = hub.drop_group if drop.group(1) == "groups" else hub.drop_set
|
||||
return lambda _body: self.answer(lambda: remove(drop.group(2)), HTTPStatus.OK)
|
||||
return None
|
||||
|
||||
def posted(self, path: str) -> bool:
|
||||
return any(pattern.fullmatch(path) for pattern in (INBOX_ROUTE, UNDO_ROUTE, RULE_ROUTE, REQUEST_ROUTE, RUNNER_ROUTE))
|
||||
return any(pattern.fullmatch(path) for pattern in (INBOX_ROUTE, UNDO_ROUTE, RULE_ROUTE, REQUEST_ROUTE, RUNNER_ROUTE, FIREWALL_DROP))
|
||||
|
||||
def runner(self, path: str, body: bytes) -> None:
|
||||
hub = self.server.hub
|
||||
|
||||
@@ -16,6 +16,7 @@ from .cleanup import Cleaning, Spool
|
||||
from .denying import Denying
|
||||
from .engines import Engines, Speech
|
||||
from .events import Log, Watch
|
||||
from .firewall import Firewall
|
||||
from .gating import Gating
|
||||
from .icons import sheet
|
||||
from .inbox import Inbox
|
||||
@@ -30,7 +31,7 @@ from .presence import SNAPSHOT
|
||||
from .redirects import Redirects
|
||||
from .requesting import Requesting
|
||||
from .reviewing import Reviewing
|
||||
from .rules import Rules
|
||||
from .rules import Offers, Rules
|
||||
from .settings import Settings
|
||||
from .signed import signing
|
||||
from .skill_scripts import Runner
|
||||
@@ -66,7 +67,7 @@ def environment(templates: Path) -> jinja2.Environment:
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Requesting, Cleaning, Offices, Tasking, Gating, Inbox, Rules, Jobs, Sources, Timeline, View, Language):
|
||||
class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Requesting, Cleaning, Offices, Tasking, Gating, Firewall, Inbox, Rules, Jobs, Sources, Timeline, View, Language):
|
||||
council: Path
|
||||
pages: Path
|
||||
public_port: int
|
||||
@@ -81,6 +82,7 @@ class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Reque
|
||||
scripts: Runner
|
||||
templates: jinja2.Environment
|
||||
rules: Ledger
|
||||
offers: Offers
|
||||
jobs: Ledger
|
||||
marks: Marks
|
||||
log: Log
|
||||
@@ -100,6 +102,9 @@ class Hub(Mcp, Reviewing, Asking, Messaging, Choosing, Approving, Denying, Reque
|
||||
icons: Markup
|
||||
spool: Spool
|
||||
office_spool: Spool
|
||||
firewall_spool: Spool
|
||||
groups: Ledger
|
||||
rule_sets: Ledger
|
||||
touched: Touched
|
||||
voice_notes: VoiceNotes
|
||||
replay: Path
|
||||
@@ -122,12 +127,16 @@ def open_hub(council: Path, pages: Path, public_port: int, state: Path, host_sta
|
||||
icons=sheet(places.vendor, templates),
|
||||
spool=Spool(places.cleanup).ready(),
|
||||
office_spool=Spool(places.offices).ready(),
|
||||
firewall_spool=Spool(state / "firewall").ready(),
|
||||
groups=Ledger(state / "groups.json"),
|
||||
rule_sets=Ledger(state / "rule-sets.json"),
|
||||
touched=Touched(reviews.stored),
|
||||
approvers=approvers,
|
||||
speech=speech,
|
||||
voice_notes=VoiceNotes(state / "voice", host_state / "voice", speech, lambda: {message["voice"] for message in messages.listed() if message.get("voice")}),
|
||||
replay=state / "replay" / "messages.json",
|
||||
rules=Ledger(state / "rules.json"),
|
||||
offers=Offers(),
|
||||
jobs=Ledger(state / "jobs.json"),
|
||||
marks=Marks(state / "marks.json"),
|
||||
log=Log(state / "log.jsonl"),
|
||||
|
||||
@@ -6,7 +6,7 @@ from .denying import request_status, request_words, requester_of
|
||||
from .errors import Conflict, Missing, ToolError
|
||||
from .fields import WAIT_CAP, bounded, decode, expect, field, seconds
|
||||
from .records import iso_epoch
|
||||
from .rules import rule_fields, rule_matches, signed_fields, subject_of
|
||||
from .rules import EVERY_AGENT, rule_fields, rule_matches, signed_fields, subject_of
|
||||
from .signed import signing
|
||||
|
||||
# Trip-wire: MCP carries no caller identity, so an agent may name itself anew for each request; AGENT_CAP only spreads the queue, TOTAL_CAP is the bound.
|
||||
@@ -33,7 +33,7 @@ class Requesting:
|
||||
def rule_request(self, arguments: dict) -> dict:
|
||||
expect(arguments, (*RULE_FIELDS, "agent", "why"))
|
||||
now = time.time()
|
||||
fields = rule_fields(arguments, now)
|
||||
fields = {name: value for name, value in rule_fields(arguments, EVERY_AGENT, now).items() if name in RULE_FIELDS}
|
||||
if fields["kind"] == "decision" and fields["scope"] != "*":
|
||||
raise ToolError("a decision rule takes scope *, as the rules form does")
|
||||
name = field(arguments, "agent").strip()
|
||||
@@ -71,7 +71,7 @@ class Requesting:
|
||||
rule = {**{key: record[key] for key in RULE_FIELDS}, "enabled": True, "proof": {"payload": payload, "assertion": None}}
|
||||
ledger = {"ask": self.asks, "review": self.reviews, "decision": self.decisions}[kind_name]
|
||||
since = now - RECENT_DAYS * 86400
|
||||
subjects = [subject_of(kind_name, entry) for entry in ledger.listed() if created_of(entry) >= since]
|
||||
subjects = [subject_of(kind_name, entry, self.deciders(kind_name, entry)) for entry in ledger.listed() if created_of(entry) >= since]
|
||||
return {"matched": sum(rule_matches(rule, kind_name, subject, now) for subject in subjects), "total": len(subjects), "days": RECENT_DAYS}
|
||||
|
||||
def request_items(self, base: dict, now: float, claims: list[dict]) -> list[dict]:
|
||||
@@ -95,7 +95,7 @@ class Requesting:
|
||||
|
||||
def sign_request(self, request_id: str) -> dict:
|
||||
record = self.pending_request(request_id)
|
||||
return {**self.rule_offer(rule_fields(record, time.time())), "sign": True}
|
||||
return {**self.rule_offer(rule_fields(record, EVERY_AGENT, time.time())), "sign": True}
|
||||
|
||||
def accept_request(self, request_id: str, body: bytes) -> dict:
|
||||
payload = decode(body)
|
||||
@@ -106,9 +106,8 @@ class Requesting:
|
||||
fields = signed_fields(rule, now)
|
||||
if [fields[key] for key in RULE_FIELDS] != [record[key] for key in RULE_FIELDS]:
|
||||
raise ToolError("the signed rule must be exactly the requested one")
|
||||
if self.rules.get(rule["id"]) is not None:
|
||||
raise Conflict({"id": rule["id"], "status": "exists"})
|
||||
proof = self.proven_rule(rule, payload["assertion"])
|
||||
self.offered(rule, now)
|
||||
decided, changed = self.rule_requests.decide(request_id, {"status": "accepted", "rule": rule["id"]})
|
||||
if not changed:
|
||||
raise Conflict(request_state(decided, now))
|
||||
|
||||
@@ -1,13 +1,19 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import fnmatch
|
||||
import threading
|
||||
import time
|
||||
|
||||
from .council import read_claims
|
||||
from .errors import Conflict, Missing, ToolError
|
||||
from .fields import COMMAND_LIMIT, PATH_LIMIT, bounded, decode, expect
|
||||
from .fields import COMMAND_LIMIT, PATH_LIMIT, bounded, decode, expect, visible
|
||||
from .names import Directory
|
||||
from .signed import ask_signed, passkey, review_signed, signing, verifier
|
||||
|
||||
RULE_KINDS = ("ask", "review", "decision")
|
||||
RULE_INPUT = ("kind", "tool", "pattern", "scope", "expires")
|
||||
EVERY_AGENT = [signing.ALL_AGENTS]
|
||||
OFFER_LIMIT = 1000
|
||||
|
||||
|
||||
def rule_matches(rule: dict, kind_name: str, subject: dict, now: float) -> bool:
|
||||
@@ -15,31 +21,73 @@ def rule_matches(rule: dict, kind_name: str, subject: dict, now: float) -> bool:
|
||||
if not rule["enabled"] or rule["expires"] <= now or rule["kind"] != kind_name or proof is None:
|
||||
return False
|
||||
if kind_name == "decision":
|
||||
return subject["recommended"] != "" and fnmatch.fnmatchcase(subject["agent"], rule["pattern"])
|
||||
named = subject["recommended"] != "" and fnmatch.fnmatchcase(subject["agent"], rule["pattern"])
|
||||
return named and signing.reaches(proof["payload"], subject["sessions"])
|
||||
return signing.rule_allows(proof["payload"], subject["item"], subject["gate"], now)
|
||||
|
||||
|
||||
def subject_of(kind_name: str, record: dict) -> dict:
|
||||
def subject_of(kind_name: str, record: dict, sessions: set[str]) -> dict:
|
||||
"""Args:
|
||||
kind_name: ask, review or decision.
|
||||
record: the ask, review or decision.
|
||||
sessions: for a decision, the sessions that held the asking agent's
|
||||
name; empty for an ask or review, whose signed item names its own.
|
||||
|
||||
Returns:
|
||||
What a rule of that kind is matched against.
|
||||
"""
|
||||
if kind_name == "ask":
|
||||
return {"item": ask_signed(record), "gate": ""}
|
||||
if kind_name == "review":
|
||||
return {"item": review_signed(record), "gate": record.get("gate", "")}
|
||||
return {"recommended": record["recommended"], "agent": record["agent"]}
|
||||
return {"recommended": record["recommended"], "agent": record["agent"], "sessions": sessions}
|
||||
|
||||
|
||||
def rule_fields(raw: dict, now: float) -> dict:
|
||||
def rule_fields(raw: dict, agents: object, now: float) -> dict:
|
||||
"""Args:
|
||||
raw: kind, tool, pattern, scope and expires of the rule.
|
||||
agents: EVERY_AGENT, or the sorted session ids of one agent or group.
|
||||
now: the current time in epoch seconds.
|
||||
|
||||
Returns:
|
||||
The checked fields with agents.
|
||||
"""
|
||||
kind_name, expires = raw["kind"], raw["expires"]
|
||||
if kind_name not in RULE_KINDS:
|
||||
raise ToolError(f"kind must be one of {', '.join(RULE_KINDS)}")
|
||||
tool_name, pattern, scope = rule_texts(raw, kind_name)
|
||||
if isinstance(expires, bool) or not isinstance(expires, int | float) or not now + 1 < expires <= now + signing.RULE_LIFETIME:
|
||||
raise ToolError("expires must be a moment within the next 366 days")
|
||||
return {"kind": kind_name, "tool": tool_name, "pattern": pattern, "scope": scope, "expires": int(expires), "agents": target_of(kind_name, agents)}
|
||||
|
||||
|
||||
def rule_texts(raw: dict, kind_name: str) -> tuple[str, str, str]:
|
||||
"""Returns:
|
||||
tool, pattern and scope of raw, once each is one line without a
|
||||
control, format, line or paragraph separator character, as visible()
|
||||
checks, and only an ask rule names a tool.
|
||||
"""
|
||||
tool_name = bounded(raw, "tool", 200).strip()
|
||||
if (kind_name == "ask") != bool(tool_name):
|
||||
raise ToolError("an ask rule names a tool; review and decision rules leave tool empty")
|
||||
pattern, scope = bounded(raw, "pattern", COMMAND_LIMIT), bounded(raw, "scope", PATH_LIMIT)
|
||||
if not pattern.strip() or not scope.strip() or "\n" in pattern or "\n" in scope:
|
||||
raise ToolError("pattern and scope must be one non-empty line each")
|
||||
if isinstance(expires, bool) or not isinstance(expires, int | float) or not now + 1 < expires <= now + signing.RULE_LIFETIME:
|
||||
raise ToolError("expires must be a moment within the next 366 days")
|
||||
return {"kind": kind_name, "tool": tool_name, "pattern": pattern, "scope": scope, "expires": int(expires)}
|
||||
visible({"tool": tool_name, "pattern": pattern, "scope": scope})
|
||||
return tool_name, pattern, scope
|
||||
|
||||
|
||||
def target_of(kind_name: str, agents: object) -> list[str]:
|
||||
"""Returns:
|
||||
agents, once signing.agents_problem() accepts it and a review rule
|
||||
names every agent, since a review names no session.
|
||||
"""
|
||||
problem = signing.agents_problem(agents)
|
||||
if problem:
|
||||
raise ToolError(problem)
|
||||
if kind_name == "review" and agents != EVERY_AGENT:
|
||||
raise ToolError("a review rule applies to every agent: a review names no session")
|
||||
return agents
|
||||
|
||||
|
||||
def signed_fields(rule: object, now: float) -> dict:
|
||||
@@ -49,17 +97,77 @@ def signed_fields(rule: object, now: float) -> dict:
|
||||
raise ToolError(f"rule: {error}") from None
|
||||
if len(rule["kinds"]) != 1:
|
||||
raise ToolError("a rule names exactly one kind")
|
||||
fields = rule_fields({**{name: rule[name] for name in ("tool", "pattern", "scope", "expires")}, "kind": rule["kinds"][0]}, now)
|
||||
agents = EVERY_AGENT
|
||||
if signing.TARGET in rule:
|
||||
agents = rule[signing.TARGET]
|
||||
fields = rule_fields({**{name: rule[name] for name in ("tool", "pattern", "scope", "expires")}, "kind": rule["kinds"][0]}, agents, now)
|
||||
if fields["tool"] != rule["tool"]:
|
||||
raise ToolError("tool must not carry surrounding blanks")
|
||||
return fields
|
||||
|
||||
|
||||
class Offers:
|
||||
def __init__(self) -> None:
|
||||
self.lock = threading.Lock()
|
||||
self.ids: dict[str, float] = {}
|
||||
|
||||
def offer(self, rule_id: str, now: float) -> None:
|
||||
"""Args:
|
||||
rule_id: an id the hub just put into a rule payload for the
|
||||
operator to sign; held in memory only, so a hub restart
|
||||
forgets every offer and refuses their proofs.
|
||||
now: the current time; offers older than signing.LIFETIME and
|
||||
beyond the newest OFFER_LIMIT are dropped.
|
||||
"""
|
||||
with self.lock:
|
||||
self.ids = {key: at for key, at in self.ids.items() if now - at <= signing.LIFETIME}
|
||||
self.ids[rule_id] = now
|
||||
while len(self.ids) > OFFER_LIMIT:
|
||||
del self.ids[next(iter(self.ids))]
|
||||
|
||||
def take(self, rule_id: str, now: float) -> bool:
|
||||
with self.lock:
|
||||
offered = self.ids.pop(rule_id, None)
|
||||
return offered is not None and now - offered <= signing.LIFETIME
|
||||
|
||||
|
||||
class Rules:
|
||||
def rule_offer(self, fields: dict) -> dict:
|
||||
rule = signing.rule_payload(self.rules.fresh(), [fields["kind"]], fields["tool"], fields["pattern"], fields["scope"], fields["expires"])
|
||||
rule = signing.targeted(signing.rule_payload(self.rules.fresh(), [fields["kind"]], fields["tool"], fields["pattern"], fields["scope"], fields["expires"]), fields["agents"])
|
||||
visible(rule)
|
||||
self.offers.offer(rule["id"], time.time())
|
||||
return {"payload": rule, "challenge": signing.challenge(rule), "credentials": [key["id"] for key in self.keys()]}
|
||||
|
||||
def offered(self, rule: dict, now: float) -> None:
|
||||
"""Raises:
|
||||
Conflict unless the hub offered the rule's id and stored no rule
|
||||
under it since, so a signed rule is stored once and never again
|
||||
after its deletion.
|
||||
"""
|
||||
if not self.offers.take(rule["id"], now):
|
||||
raise Conflict({"id": rule["id"], "status": "not offered or already stored: sign the rule anew"})
|
||||
|
||||
def deciders(self, kind_name: str, record: dict) -> set[str]:
|
||||
"""Returns:
|
||||
For a decision, the one session that holds its agent's name now,
|
||||
none when no session or several hold it; empty for every other
|
||||
kind.
|
||||
"""
|
||||
if kind_name != "decision":
|
||||
return set()
|
||||
directory = Directory(self.names.listed())
|
||||
holders = {session for session in directory.aliases(record["agent"]) if directory.now(session) == record["agent"]}
|
||||
return holders if len(holders) == 1 else set()
|
||||
|
||||
def known_agents(self, agents: list[str]) -> None:
|
||||
"""Raises:
|
||||
ToolError unless agents is EVERY_AGENT or every session in it is
|
||||
one the Agent Orchestrator knows.
|
||||
"""
|
||||
unknown = sorted(set(agents) - self.office_sessions(read_claims(self.council))) if agents != EVERY_AGENT else []
|
||||
if unknown:
|
||||
raise ToolError(f"agents must be sessions the Agent Orchestrator knows: {', '.join(unknown)[:200]}")
|
||||
|
||||
def proven_rule(self, rule: dict, assertion: object) -> dict:
|
||||
"""Args:
|
||||
rule: the rule payload, already checked by signed_fields.
|
||||
@@ -80,8 +188,11 @@ class Rules:
|
||||
|
||||
def sign_rule(self, body: bytes) -> dict:
|
||||
payload = decode(body)
|
||||
expect(payload, ("kind", "tool", "pattern", "scope", "expires"))
|
||||
return {**self.rule_offer(rule_fields(payload, time.time())), "sign": True}
|
||||
targeted = "agents" in payload
|
||||
expect(payload, (*RULE_INPUT, "agents") if targeted else RULE_INPUT)
|
||||
fields = rule_fields(payload, payload["agents"] if targeted else EVERY_AGENT, time.time())
|
||||
self.known_agents(fields["agents"])
|
||||
return {**self.rule_offer(fields), "sign": True}
|
||||
|
||||
def add_rule(self, body: bytes) -> dict:
|
||||
payload = decode(body)
|
||||
@@ -91,16 +202,49 @@ class Rules:
|
||||
fields = signed_fields(rule, now)
|
||||
if not isinstance(payload["enabled"], bool):
|
||||
raise ToolError("enabled must be true or false")
|
||||
if self.rules.get(rule["id"]) is not None:
|
||||
raise Conflict({"id": rule["id"], "status": "exists"})
|
||||
return self.store_rule(rule, fields, self.proven_rule(rule, payload["assertion"]), payload["enabled"], now)
|
||||
proof = self.proven_rule(rule, payload["assertion"])
|
||||
self.offered(rule, now)
|
||||
return self.store_rule(rule, fields, proof, payload["enabled"], now)
|
||||
|
||||
def rule_action(self, rule_id: str, verb: str) -> dict:
|
||||
def enable_items(self, raw: list[dict]) -> list[dict]:
|
||||
"""Args:
|
||||
raw: [{"kind": "enable", "rule"}] with the id of a stored rule.
|
||||
|
||||
Returns:
|
||||
The item a fresh approval signs to turn that rule on.
|
||||
"""
|
||||
expect(raw[0], ("kind", "rule"))
|
||||
return [self.enable_subject(raw[0]["rule"])]
|
||||
|
||||
def enable_subject(self, rule_id: object) -> dict:
|
||||
record = self.rules.get(rule_id) if isinstance(rule_id, str) else None
|
||||
if record is None:
|
||||
raise Missing(str(rule_id)[:40])
|
||||
if record.get("proof") is None:
|
||||
raise ToolError("an unsigned rule grants nothing: sign it anew")
|
||||
return signing.enable_item(record["proof"]["payload"])
|
||||
|
||||
def rule_action(self, rule_id: str, verb: str, body: bytes) -> dict:
|
||||
"""Args:
|
||||
rule_id: the stored rule.
|
||||
verb: delete, disable, or enable, which widens what agents may
|
||||
do and so needs {"proof"}: a fresh passkey approval listing
|
||||
signing.enable_item() of the rule.
|
||||
body: the request body.
|
||||
"""
|
||||
if verb == "delete":
|
||||
if not self.rules.remove(rule_id):
|
||||
raise Missing(rule_id)
|
||||
return {"id": rule_id, "deleted": True}
|
||||
if verb == "enable":
|
||||
payload = decode(body)
|
||||
expect(payload, ("proof",))
|
||||
self.operator_proven(payload["proof"], self.enable_subject(rule_id))
|
||||
record = self.rules.change(rule_id, {"enabled": verb == "enable"})
|
||||
if record is None:
|
||||
raise Missing(rule_id)
|
||||
return record
|
||||
|
||||
|
||||
def enable_request(raw: object) -> bool:
|
||||
return isinstance(raw, list) and len(raw) == 1 and isinstance(raw[0], dict) and raw[0].get("kind") == "enable"
|
||||
@@ -210,5 +210,5 @@ class View:
|
||||
def render(self, nonce: str) -> tuple[str, str]:
|
||||
now = time.time()
|
||||
state = self.state(now - RADIO_WINDOW, now, now, 0)
|
||||
page = self.templates.get_template("index.html.j2").render(nonce=nonce, state=state, icons=self.icons)
|
||||
page = self.templates.get_template("index.html.j2").render(nonce=nonce, state=state, icons=self.icons, emoji_bases=sorted(signing.EMOJI_BASES))
|
||||
return page, INDEX_CSP.format(nonce, " ".join(["'self'", *state["media"]]))
|
||||
Reference in new issue
Block a user