// #1873 triage-host: the binds of a session the Console hosts in no organization. From the data root // it gets its own run directory and the health directory, read-only, and nothing else; every source // inside the run directory must be what the host made, never a link. import { test } from "node:test"; import assert from "node:assert/strict"; import { createServer } from "node:net"; import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs"; import { dirname, join } from "node:path"; import { HOSTED_MOUNTS_MAX, RUNNER_FILES, checkHostedRoute, hostedArgv, hostedBinds } from "../src/sandbox.mjs"; function layout(t) { const root = mkdtempSync(join(process.env.TMPDIR, "hb-")); const dataRoot = join(root, "data"); const runDir = join(dataRoot, "triage", "agent"); const healthDir = join(dataRoot, "triage", "health"); for (const d of [join(dataRoot, "orgs"), join(dataRoot, "triage", "host"), healthDir, join(runDir, "bundle"), join(runDir, "tmp"), join(runDir, "work", "health")]) mkdirSync(d, { recursive: true }); writeFileSync(join(runDir, "session.json"), "{}"); const install = join(root, "install"); mkdirSync(install); const adapter = join(install, "adapter.sh"); writeFileSync(adapter, "exit 0\n"); return new Promise((resolve) => { const server = createServer().listen(join(runDir, "relay.sock"), () => { t.after(() => server.close()); resolve({ root, dataRoot, runDir, healthDir, adapter, install, relaySocket: join(runDir, "relay.sock"), installRoots: [install], protectedPaths: [dataRoot] }); }); }); } test("hosted binds hold the run directory and the health directory of the data root, and nothing else of it", async (t) => { const p = await layout(t); const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }); const fromData = list.filter((b) => typeof b.src === "string" && b.src.startsWith(p.dataRoot + "/")); assert.deepEqual(fromData.map((b) => [b.kind, b.src, b.dest ?? null]), [ ["rw", p.runDir, null], ["ro", p.healthDir, join(p.runDir, "work", "health")], ["ro", join(p.runDir, "bundle"), null], ["ro", join(p.runDir, "session.json"), null], ["ro", p.relaySocket, null], ["rw", join(p.runDir, "tmp"), "/tmp"], ]); for (const f of RUNNER_FILES) assert.ok(list.some((b) => b.kind === "ro" && b.src === f), f); assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter)); assert.ok(!list.some((b) => b.src === p.root || b.src === p.dataRoot || (typeof b.src === "string" && b.src.startsWith(join(p.dataRoot, "orgs"))))); assert.ok(!list.some((b) => b.src === process.env.HOME || b.dest === process.env.HOME)); assert.ok(list.every((b) => typeof b.why === "string" && b.why.length > 0)); }); test("hosted binds refuse a relay socket elsewhere, and any source in the run directory that the host did not make", async (t) => { const p = await layout(t); const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }; assert.throws(() => hostedBinds({ ...base, relaySocket: join(p.root, "bus.sock") }), /relay socket must be the run directory's relay\.sock/); // A link in place of each directory the binds read: bwrap would follow it on the host. for (const d of ["bundle", "tmp", "work"]) { rmSync(join(p.runDir, d), { recursive: true }); symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, d)); assert.throws(() => hostedBinds(base), /is not a directory/, d); rmSync(join(p.runDir, d)); mkdirSync(join(p.runDir, d === "work" ? join("work", "health") : d), { recursive: true }); } rmSync(join(p.runDir, "work", "health"), { recursive: true }); symlinkSync(join(p.dataRoot, "triage", "host"), join(p.runDir, "work", "health")); assert.throws(() => hostedBinds(base), /is not a directory/); rmSync(join(p.runDir, "work", "health")); mkdirSync(join(p.runDir, "work", "health")); rmSync(join(p.runDir, "session.json")); symlinkSync(join(p.dataRoot, "orgs"), join(p.runDir, "session.json")); assert.throws(() => hostedBinds(base), /session\.json is not what the host made/); rmSync(join(p.runDir, "session.json")); writeFileSync(join(p.runDir, "session.json"), "{}"); assert.throws(() => hostedBinds({ ...base, healthDir: join(p.root, "absent") }), /the health directory is missing/); hostedBinds(base); }); test("the hosted command line sets no git identity and runs the command under the namespaces", async (t) => { const p = await layout(t); const argv = hostedArgv(hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }), p.runDir, ["node", "runner.mjs", p.runDir], { bwrap: "/b/bwrap" }); assert.equal(argv[0], "/b/bwrap"); assert.deepEqual(argv.slice(1, 5), ["--unshare-user", "--unshare-pid", "--unshare-ipc", "--as-pid-1"]); assert.deepEqual(argv.slice(-3), ["node", "runner.mjs", p.runDir]); assert.ok(!argv.some((a) => a.startsWith("GIT_"))); const home = argv.indexOf("HOME"); assert.equal(argv[home + 1], join(p.runDir, "home")); assert.ok(argv.includes("--remount-ro")); }); // #1873 triage-fences: hostedBinds checks the adapter and the mounts again, so a caller that skips // the host's own check still binds nothing outside the install roots. test("hosted binds refuse without install roots or protected paths, and refuse an adapter or a mount source outside the roots or in a protected path", async (t) => { const p = await layout(t); const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }; const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label); refused({ installRoots: undefined }, "roots", "no roots"); refused({ installRoots: [] }, "roots", "empty roots"); refused({ installRoots: ["/"] }, "roots", "root /"); refused({ installRoots: [join(p.root, "absent")] }, "roots", "missing root"); refused({ installRoots: [p.adapter] }, "roots", "a file as root"); refused({ protectedPaths: undefined }, "protected", "no protected paths"); refused({ protectedPaths: ["relative"] }, "protected", "relative protected path"); writeFileSync(join(p.root, "out.sh"), "x"); refused({ adapter: join(p.root, "out.sh") }, "adapter", "adapter outside"); symlinkSync(join(p.root, "out.sh"), join(p.install, "link.sh")); refused({ adapter: join(p.install, "link.sh") }, "adapter", "adapter link out"); refused({ adapter: p.install }, "adapter", "adapter is a directory"); refused({ harnessMounts: [{ src: join(p.install, "link.sh"), why: "w" }] }, "mount-src", "mount link out"); refused({ harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }], installRoots: [p.root] }, "mount-src", "mount in the data root"); refused({ harnessMounts: [{ src: p.root, why: "w" }], installRoots: [p.root] }, "mount-src", "mount around the data root"); mkdirSync(join(p.install, "secrets")); writeFileSync(join(p.install, "secrets", "k"), "x"); refused({ harnessMounts: [{ src: join(p.install, "secrets", "k"), why: "w" }] }, "mount-src", "mount in secrets"); writeFileSync(join(p.install, "m"), "x"); refused({ harnessMounts: Array.from({ length: HOSTED_MOUNTS_MAX + 1 }, (_, i) => ({ src: join(p.install, "m"), dest: `/opt/m${i}`, why: "w" })) }, "mounts", "too many"); refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/tmp/m", why: "w" }] }, "mount-dest", "dest under /tmp"); refused({ harnessMounts: [{ src: join(p.install, "m"), dest: p.runDir, why: "w" }] }, "mount-dest", "dest is the run dir"); refused({ harnessMounts: [{ src: join(p.install, "m"), dest: join(p.runDir, "session.json"), why: "w" }] }, "mount-dest", "dest is session.json"); refused({ harnessMounts: [{ src: join(p.install, "m"), dest: "/usr", why: "w" }] }, "mount-dest", "dest is a system bind"); refused({ harnessMounts: [{ src: join(p.install, "m"), dest: dirname(RUNNER_FILES[0]), why: "w" }] }, "mount-dest", "dest holds a runner file"); refused({ harnessMounts: [{ src: join(p.install, "m"), why: "w", kind: "rw" }] }, "mounts", "a kind of its own"); }); test("hosted binds bind the real file of a link that stays inside the install root, at the path the route named", async (t) => { const p = await layout(t); writeFileSync(join(p.install, "real.mjs"), "x"); symlinkSync(join(p.install, "real.mjs"), join(p.install, "named.mjs")); symlinkSync(p.adapter, join(p.install, "adapter-link.sh")); const list = hostedBinds({ runDir: p.runDir, healthDir: p.healthDir, adapter: join(p.install, "adapter-link.sh"), relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths, harnessMounts: [{ src: join(p.install, "named.mjs"), why: "w" }, { src: join(p.install, "real.mjs"), dest: "/opt/real.mjs", why: "w2" }], }); assert.ok(list.some((b) => b.kind === "ro" && b.src === p.adapter && b.dest === join(p.install, "adapter-link.sh"))); assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === join(p.install, "named.mjs") && b.why === "w")); assert.ok(list.some((b) => b.kind === "ro" && b.src === join(p.install, "real.mjs") && b.dest === "/opt/real.mjs" && b.why === "w2")); assert.ok(!list.some((b) => b.src === join(p.install, "named.mjs"))); }); test("a protected path that holds the code root (HOME over a copy or a worktree) does not refuse a source inside the code root; everything else still holds", async (t) => { const p = await layout(t); // home/ holds the code root code/, which holds the install root. const home = join(p.root, "home"); const code = join(home, "code"); const inst = join(code, "inst"); mkdirSync(join(inst, "secrets"), { recursive: true }); for (const f of ["adapter.sh", "m", join("secrets", "k")]) writeFileSync(join(inst, f), "x"); writeFileSync(join(home, "outside"), "x"); mkdirSync(join(code, "data")); const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: join(inst, "adapter.sh"), relaySocket: p.relaySocket, installRoots: [inst], protectedPaths: [p.dataRoot, home], codeRoot: code, codeHolder: home }; const refused = (opts, fence, label) => assert.throws(() => hostedBinds({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence, label); const list = hostedBinds({ ...base, harnessMounts: [{ src: join(inst, "m"), dest: "/opt/m", why: "w" }] }); assert.ok(list.some((b) => b.src === join(inst, "adapter.sh")) && list.some((b) => b.src === join(inst, "m") && b.dest === "/opt/m")); // Without the code root, HOME refuses the same adapter. refused({ codeRoot: null }, "adapter", "no code root"); // A code root that is HOME itself sets nothing aside. refused({ codeRoot: home }, "adapter", "code root is HOME"); // A source under HOME outside the code root, even inside an install root. refused({ installRoots: [home], adapter: join(home, "outside") }, "adapter", "outside the code root"); // A link inside the code root to a file outside it. symlinkSync(join(home, "outside"), join(inst, "out")); refused({ installRoots: [inst, home], harnessMounts: [{ src: join(inst, "out"), why: "w" }] }, "mount-src", "link out of the code root"); // A protected path inside the code root still refuses. writeFileSync(join(code, "data", "f"), "x"); refused({ installRoots: [code], protectedPaths: [p.dataRoot, home, join(code, "data")], harnessMounts: [{ src: join(code, "data", "f"), why: "w" }] }, "mount-src", "protected path in the code root"); // The secrets check still holds inside the code root. refused({ harnessMounts: [{ src: join(inst, "secrets", "k"), why: "w" }] }, "mount-src", "secrets in the code root"); // The run directory and the fixed list are never set aside, and a code root around them is refused. refused({ codeRoot: p.root, installRoots: [p.root], harnessMounts: [{ src: join(p.dataRoot, "orgs"), why: "w" }] }, "protected", "code root holds the run dir"); refused({ codeRoot: "/srv/mosaic/x" }, "protected", "code root in a fixed path"); refused({ codeRoot: "relative" }, "protected", "relative code root"); // Only the named holder sets the code aside: another protected path that holds the code still refuses. refused({ protectedPaths: [p.dataRoot, home, p.root] }, "adapter", "a second protected path holds the code"); refused({ codeHolder: null }, "protected", "no holder"); refused({ codeHolder: join(p.root, "elsewhere") }, "protected", "a holder that is not a protected path"); // A run directory named through a link: a code root in its real path is refused before any check. const realRun = join(home, "run"); mkdirSync(join(realRun, "code", "inst"), { recursive: true }); writeFileSync(join(realRun, "code", "inst", "a.sh"), "x"); symlinkSync(realRun, join(p.root, "runlink")); assert.throws(() => checkHostedRoute({ adapter: join(realRun, "code", "inst", "a.sh"), harnessMounts: [], installRoots: [join(realRun, "code", "inst")], protectedPaths: [p.dataRoot, home], codeRoot: join(realRun, "code"), codeHolder: home, runDir: join(p.root, "runlink") }), (e) => e.fence === "protected", "code root in the run dir's real path"); }); test("a fixed path named through a link: a code root in its real path is refused before any guard, and a source there is refused by its guard", async (t) => { const p = await layout(t); // None of the shipped fixed paths is a link on a test host, so the test hook adds a stand-in. const home = join(p.root, "home"); // The real path lies outside HOME and the data root, so only the stand-in's own guard can refuse // a source there. const real = join(p.root, "fixedreal"); const inst = join(real, "code", "inst"); mkdirSync(inst, { recursive: true }); writeFileSync(join(inst, "a.sh"), "x"); const link = join(p.root, "fixedlink"); symlinkSync(real, link); const base = { adapter: join(inst, "a.sh"), harnessMounts: [], installRoots: [inst], protectedPaths: [p.dataRoot, home], codeHolder: home, runDir: p.runDir, alsoFixed: [link] }; const refused = (opts, fence, message, label) => assert.throws(() => checkHostedRoute({ ...base, ...opts }), (e) => e.code === "hosted-binds-refused" && e.fence === fence && message.test(e.message), label); // The code root lies in the stand-in's real path, not under the name the list gives. refused({ codeRoot: join(real, "code") }, "protected", /never set aside/, "code root in a fixed path's real path"); // With the code root in HOME, the source in the stand-in's real path is refused by the stand-in's // guard, which holds the same real spelling. No other guard holds that path. mkdirSync(join(home, "code"), { recursive: true }); refused({ codeRoot: join(home, "code") }, "adapter", /protected path/, "source in a fixed path's real path"); // The same source passes without the stand-in: only the stand-in refused it. assert.equal(checkHostedRoute({ ...base, alsoFixed: [], codeRoot: join(home, "code") }).adapter.src, join(inst, "a.sh")); // The hook adds fixed paths and never removes one, and takes only a list of clean absolute paths. refused({ alsoFixed: [], codeRoot: "/srv/mosaic/x" }, "protected", /never set aside/, "shipped fixed path with an empty hook"); refused({ alsoFixed: ["relative"], codeRoot: join(real, "code") }, "protected", /clean absolute/, "relative stand-in"); refused({ alsoFixed: "/x", codeRoot: join(real, "code") }, "protected", /clean absolute|list/, "a hook that is not a list"); }); test("a list that answers one length to the check and another later is read once", async (t) => { const p = await layout(t); const items = []; for (let i = 0; i <= HOSTED_MOUNTS_MAX; i++) { writeFileSync(join(p.install, `m${i}`), "x"); items.push({ src: join(p.install, `m${i}`), dest: `/opt/m${i}`, why: "w" }); } let reads = 0; const mounts = new Proxy(items, { get: (o, k) => (k === "length" ? (reads++ === 0 ? 1 : o.length) : o[k]) }); assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: mounts, installRoots: p.installRoots, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "mounts"); // Install roots: two short answers pass the count, then a long one would add roots the count never saw. const roots = []; for (let i = 0; i <= 16; i++) { roots.push(join(p.root, `r${i}`)); mkdirSync(roots[i]); } writeFileSync(join(roots[16], "a.sh"), "x"); let rootReads = 0; const rootList = new Proxy(roots, { get: (o, k) => (k === "length" ? (rootReads++ < 2 ? 1 : o.length) : o[k]) }); assert.throws(() => checkHostedRoute({ adapter: join(roots[16], "a.sh"), harnessMounts: [], installRoots: rootList, protectedPaths: p.protectedPaths, runDir: p.runDir }), (e) => e.fence === "adapter"); // Protected paths: the holder check sees HOME, then a shorter answer would leave HOME unguarded. const home = join(p.root, "home"); mkdirSync(join(home, "code"), { recursive: true }); writeFileSync(join(home, "f"), "x"); let guardReads = 0; const guards = new Proxy([p.dataRoot, home], { get: (o, k) => (k === "length" ? (guardReads++ === 0 ? 2 : 1) : o[k]) }); assert.throws(() => checkHostedRoute({ adapter: p.adapter, harnessMounts: [{ src: join(home, "f"), dest: "/opt/f", why: "w" }], installRoots: [p.install, home], protectedPaths: guards, codeRoot: join(home, "code"), codeHolder: home, runDir: p.runDir }), (e) => e.fence === "protected" || e.fence === "mount-src"); }); test("each mount field is read once, and no mount's dest lies in or around another's", async (t) => { const p = await layout(t); const base = { runDir: p.runDir, healthDir: p.healthDir, adapter: p.adapter, relaySocket: p.relaySocket, installRoots: p.installRoots, protectedPaths: p.protectedPaths }; writeFileSync(join(p.install, "m"), "x"); writeFileSync(join(p.install, "n"), "x"); let reads = 0; const list = hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), why: "w", get dest() { return reads++ === 0 ? undefined : "/opt/../tmp"; } }] }); assert.equal(reads, 1); assert.ok(list.some((b) => b.src === join(p.install, "m") && b.dest === undefined)); assert.ok(!list.some((b) => b.dest === "/opt/../tmp")); for (const [a, b] of [["/opt/x", "/opt/x/f"], ["/opt/x/f", "/opt/x"], ["/opt/x", "/opt/x"]]) { assert.throws(() => hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: a, why: "w" }, { src: join(p.install, "n"), dest: b, why: "w" }] }), (e) => e.fence === "mount-dest", `${a} then ${b}`); } assert.equal(hostedBinds({ ...base, harnessMounts: [{ src: join(p.install, "m"), dest: "/opt/x", why: "w" }, { src: join(p.install, "n"), dest: "/opt/xy", why: "w" }] }).filter((b) => b.dest?.startsWith("/opt/")).length, 2); });