~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/socialweb-computer-console

console.socialweb.computer: kcp, kubectl and ssh compiled to wasm in a browser tab with a terminal; a kcp fork

0
0
main
176 lines · 11.0 KB Raw History
// Copyright 2026 The KCP Authors.
// SPDX-License-Identifier: Apache-2.0

// Page half of the policy suite (run all of it: scripts/browser-dev/policy-suite.sh).
// Test names start with the scenario names of socialweb's policy tests.
//
// The bundled requester-tangled-vouch action runs under socialweb's action
// shim (workflow/action.go) in the sandbox Worker, with trust seeded as the
// run reconciler does (cache trust/<counterparty> = trust.Snapshot.CacheFiles(),
// whose vouchedBy[self] is the union of the trusted operators' sets, rc124).
// The DIDs do not exist, so verdicts come only from the seeded snapshot.
// verdict() is the Go side's reading: allow only on exit 0 with a result line
// and a strict allow=true output; anything else (throw, timeout, kill) denies.
// Needs the build's socialweb mirror; without it every case FAILS (no skip:
// a skip knob on a security gate is a bypass).

import { rewriteNodeImports, runInWorker } from "./policy_sandbox.js";

function assert(cond, message) {
  if (!cond) throw new Error(message);
}

const mirror = new URL("../../.work/socialweb-mirror/internal/policyengine/", import.meta.url);
const haveMirror = await Deno.stat(new URL("workflow/action.go", mirror)).then(() => true, () => false);

const self = "did:plc:suiteself0000000000000000", selfOp = "did:plc:suiteselfoperator000000000";
const bidder = "did:plc:suitebidder00000000000000", bidderOp = "did:plc:suitebidderoperator0000000";

// trust.Snapshot.CacheFiles (ActionVouchedBy merges the trusted operators'
// sets into the first one, self).
function cacheFiles({ operatorOf, vouchedBy, trustedOperators }) {
  const merged = { ...vouchedBy };
  merged[trustedOperators[0]] = [...new Set(trustedOperators.flatMap((op) => vouchedBy[op] ?? []))].sort();
  const file = (value) => ({ data: JSON.stringify(value), encoding: "text" });
  return { "operatorOf.json": file(operatorOf), "vouchedBy.json": file(merged), "trustedOperators.json": file(trustedOperators) };
}

// spy: every program the runner receives
let runs = 0;

async function tangledVouch(mode, { trust, prelude = "", timeoutMs = 30_000, kill = false }) {
  if (!haveMirror) {
    throw new Error(`no socialweb mirror at ${mirror.pathname}: copy .work from a built worktree (cp -a <worktree>/.work .) or run scripts/browser-dev/build-page.sh`);
  }
  const go = await Deno.readTextFile(new URL("workflow/action.go", mirror));
  const shim = go.match(/const actionShim = `([\s\S]*?)`/)[1];
  const footer = go.match(/const actionFooter = `([\s\S]*?)`/)[1];
  const action = await Deno.readTextFile(new URL("bundled-actions/tangy/policy-requester-tangled-vouch/dist/index.js", mirror));
  const cache = trust ? { [`trust/${bidder}`]: trust } : {};
  const env = {
    GITHUB_OUTPUT: "/gh/output", GITHUB_ENV: "/gh/env", GITHUB_CACHE: "/gh/cache", GITHUB_EVENT_PATH: "/gh/event",
    "INPUT_SELF-DID": self, "INPUT_COUNTERPARTY-DID": bidder, "INPUT_SUBJECT-DID": bidder, "INPUT_ROOT-REQUESTER-DID": self,
    "INPUT_MODE": mode,
  };
  const source = shim.replace("__PE_ENV_JSON__", JSON.stringify(env))
    .replace("__PE_CACHE_JSON__", JSON.stringify(JSON.stringify(cache)))
    .replace("__PE_EVENT_JSON__", JSON.stringify(JSON.stringify({ inputs: {} })))
    .replaceAll("__PE_RESULT_MARKER__", JSON.stringify("__PE_RESULT__")) + "\n" + prelude + "\n" + action + "\n" + footer;
  runs++;
  const pending = runInWorker({ source, env, timeoutMs });
  if (kill) setTimeout(() => pending.kill(), 200);
  return verdict(await pending);
}

// ran: "decision" (the action wrote an allow output and exited 0), "threw"
// (the action failed; the shim's exit handler reported code != 0), "fetched"
// (the action reached the network spy), "unanswered" (killed; a killed
// Worker's output is lost, so the only evidence is the runner spy).
function verdict(r) {
  const line = r.stdout.split("\n").find((l) => l.startsWith("__PE_RESULT__"));
  const result = line ? JSON.parse(line.slice("__PE_RESULT__".length)) : undefined;
  const allows = [...String(result?.vfs?.["/gh/output"] ?? "").matchAll(/^allow=(.*)$/gm)].map((m) => m[1]);
  const allow = !r.timedOut && result?.code === 0 && allows.length > 0 && allows.every((a) => a === "true");
  const ran = new Set();
  if (result?.code === 0 && allows.length > 0) ran.add("decision");
  if (result && result.code !== 0) ran.add("threw");
  if (r.stderr.includes("__PE_SPY_FETCH__")) ran.add("fetched");
  if (r.timedOut) ran.add("unanswered");
  return { allow, ran, timedOut: r.timedOut, code: result?.code, why: `${r.stdout.slice(-300)} ${r.stderr.slice(-300)}` };
}

const vouched = (vouchedBy, operatorOf = { [self]: self, [bidder]: bidderOp }, trustedOperators = [self]) =>
  cacheFiles({ operatorOf, vouchedBy, trustedOperators });

const spyFetch = (answer) => `globalThis.fetch = (url) => { console.error("__PE_SPY_FETCH__ " + url); return ${answer}; };`;
const offline = spyFetch(`Promise.reject(new TypeError("offline"))`);
// A stall after the trust check: the action decides from a valid snapshot,
// then its output write never returns, so only the deadline or a kill ends
// the run (the action makes no network call once the host seeds trust).
const stalledOutput = `{ const write = Deno.writeTextFile; Deno.writeTextFile = (path, ...rest) =>
  String(path) === "/gh/output" ? new Promise(() => {}) : write(path, ...rest); }`;

// [scenario, want allow, evidence the policy ran, opts]
const cases = [
  // self vouches the bidder itself; neither side has an operator.
  ["vouch-direct-allow", true, ["decision"], { trust: vouched({ [self]: [bidder] }, { [self]: self }) }],
  // self vouches the bidder's verified operator.
  ["vouch-direct-allow (operator of bidder)", true, ["decision"], { trust: vouched({ [self]: [bidderOp] }) }],
  // operator union (rc124): self vouches nobody, its own operator vouches the
  // bidder's operator; the seeding gives self that set.
  ["vouch-operator-allow", true, ["decision"], {
    trust: vouched({ [self]: [], [selfOp]: [bidderOp], [bidderOp]: [] }, { [self]: selfOp, [bidder]: bidderOp }, [self, selfOp]),
  }],
  ["unvouched-deny", false, ["decision"], { trust: vouched({ [self]: [], [bidderOp]: [] }) }],
  // the bidder claims bidderOp (vouched by self) but the claim did not
  // verify, so the snapshot has no operator for it.
  ["vouch-unverified-operator-deny", false, ["decision"], { trust: vouched({ [self]: [bidderOp] }, { [self]: self }) }],
  // PT-1: only the reverse vouch exists (the bidder's verified operator
  // vouches self); that is no reason to trust the bidder.
  ["counterparty-operator-vouches-self-only", false, ["decision"], { trust: vouched({ [self]: [], [bidderOp]: [self] }) }],
  // PT-3: self vouched the bidder DID itself; the bidder also has a verified
  // operator (that self does not vouch).
  ["vouched-directly-with-verified-operator", true, ["decision"], { trust: vouched({ [self]: [bidder], [bidderOp]: [] }) }],
  // PT-4: the bidder's verified operator is self.
  ["counterparty-operated-by-self", true, ["decision"], { trust: vouched({ [self]: [] }, { [self]: self, [bidder]: self }) }],
  // fail-closed: a garbage snapshot makes the action throw (exit 1).
  ["trust-host-error-deny (fail-closed: malformed snapshot)", false, ["threw"], {
    trust: { ...vouched({ [self]: [bidder] }), "vouchedBy.json": { data: "{not json", encoding: "text" } },
  }],
  // fail-closed/no-trust-snapshot (socialweb B2): trust comes only from the
  // host snapshot; without a whole one the action denies at once and never
  // touches the network (the offline spy records any fetch).
  ["no-trust-snapshot-deny (fail-closed: no snapshot, no fetch)", false, ["decision", "!fetched"], { prelude: offline }],
  ["no-trust-snapshot-deny (fail-closed: half a snapshot, no fetch)", false, ["decision", "!fetched"], {
    prelude: offline, trust: { "operatorOf.json": vouched({ [self]: [bidder] })["operatorOf.json"] },
  }],
  // fail-closed/deadline and /cancelled: an allowing snapshot, but the action
  // stalls after deciding; killed at the deadline or cancelled, nothing is
  // sent (no result line) and nothing fetched, so the run denies.
  ["deadline-deny (fail-closed: stalled after an allow, killed at the deadline)", false, ["unanswered", "!decision", "!fetched"], {
    prelude: offline + stalledOutput, trust: vouched({ [self]: [bidder] }, { [self]: self }), timeoutMs: 1_000,
  }],
  ["cancelled-deny (fail-closed: stalled after an allow, run cancelled)", false, ["unanswered", "!decision", "!fetched"], {
    prelude: offline + stalledOutput, trust: vouched({ [self]: [bidder] }, { [self]: self }), timeoutMs: 60_000, kill: true,
  }],
];

for (const mode of ["scope", "full"]) {
  for (const [name, want, evidence, opts] of cases) {
    Deno.test({ name: `always-run/page/requester-tangled-vouch/${mode}/${name}`, fn: async () => {
      const before = runs;
      const r = await tangledVouch(mode, opts);
      assert(runs === before + 1, "the runner did not receive the policy program");
      // "x" must be in ran, "!x" must not.
      assert(evidence.every((e) => e.startsWith("!") ? !r.ran.has(e.slice(1)) : r.ran.has(e)), `ran=${[...r.ran]}, want ${evidence}: ${r.why}`);
      assert(r.allow === want, `allow=${r.allow}, want ${want} (code=${r.code} timedOut=${r.timedOut}): ${r.why}`);
    } });
  }
}

Deno.test("fail-closed/verdict: every non-answer denies (malformed-output-deny, missing-allow-output-deny)", () => {
  const ok = { stdout: `__PE_RESULT__{"code":0,"vfs":{"/gh/output":"allow=true\\n"}}\n`, stderr: "", timedOut: false };
  assert(verdict(ok).allow, "strict allow=true allows");
  for (const [what, r] of [
    ["no result line", { ...ok, stdout: "allow=true\n" }],
    ["exit 1", { ...ok, stdout: ok.stdout.replace(`"code":0`, `"code":1`) }],
    ["timed out", { ...ok, timedOut: true }],
    ["no allow output", { ...ok, stdout: ok.stdout.replace("allow=true", "violations=[]") }],
    ["allow not strict", { ...ok, stdout: ok.stdout.replace("allow=true", "allow=yes") }],
    ["one allow=false", { ...ok, stdout: ok.stdout.replace("allow=true\\n", "allow=true\\nallow=false\\n") }],
  ]) assert(!verdict(r).allow, what);
});

// WebKit denies static data: imports in the opaque-origin Worker, so after
// the rewrite a bundled action must have no static import of node: or data:
// left (Deno would accept one, so the runs above do not show it).
Deno.test("always-run/page/bundled actions keep no static node: or data: import after the rewrite", async () => {
  if (!haveMirror) throw new Error(`no socialweb mirror at ${mirror.pathname}`);
  for (const name of ["policy-requester-tangled-vouch", "policy-requester-mutuals", "policy-bidder-mutuals"]) {
    const src = await Deno.readTextFile(new URL(`bundled-actions/tangy/${name}/dist/index.js`, mirror));
    const out = rewriteNodeImports(src);
    const statics = [...out.matchAll(/\b(import|export)\s*[\w${*][^;\n(]{0,200}?\bfrom\s*["'](node|data):/g), ...out.matchAll(/\bimport\s*["'](node|data):/g)];
    if (statics.length) throw new Error(`${name}: static import left: ${statics[0][0].slice(0, 80)}`);
    if (/["']node:/.test(out)) throw new Error(`${name}: a node: specifier was not rewritten`);
  }
});