import { readFile } from "node:fs/promises"; import { describe, expect, it } from "vitest"; import { findProviderSandboxNamespaceFailure, findSystemTestPrerequisiteFailures, formatSystemTestPrerequisiteReport, NAMESPACE_PROBE_ARGUMENTS, type SystemTestHost, } from "../../scripts/check-system-test-prerequisites.ts"; import { systemdRunPrerequisiteProbeArguments, systemdRunProviderArguments, } from "../../scripts/lib/provider-cgroup.ts"; import { PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS } from "../../scripts/lib/provider-sandbox-namespaces.ts"; type SpawnCall = Readonly<{ command: string; args: readonly string[] }>; type SpawnResult = ReturnType; const RTM_NEWADDR = "bwrap: loopback: Failed RTM_NEWADDR: Operation not permitted"; const PROBE_UNIT = "ca-provider-prerequisite-4242-0123456789abcdef01234567.scope"; type HostOverrides = Readonly<{ files?: Readonly>; missing?: readonly string[]; userManager?: SpawnResult; systemdRun?: SpawnResult; }>; /** A host that has every prerequisite, except what `bwrap` and the overrides say. */ function fakeHost( bwrap: SpawnResult, options: HostOverrides = {}, ): { host: SystemTestHost; calls: SpawnCall[] } { const calls: SpawnCall[] = []; const host: SystemTestHost = { access: async (target) => { if (options.missing?.includes(target)) throw new Error(`EACCES: ${target}`); }, readFile: async (target) => { if (target === "/sys/fs/cgroup/cgroup.controllers") return "cpuset cpu io memory pids\n"; const content = options.files?.[target]; if (content === undefined) throw new Error(`ENOENT: ${target}`); return content; }, spawn: (command, args) => { calls.push({ command, args }); if (command === "/usr/bin/systemctl" && args[0] === "--user") { return options.userManager ?? { status: 0, stdout: "255\n", stderr: "" }; } if (command === "/usr/bin/systemctl") return { status: 0, stdout: "", stderr: "" }; if (command === "/usr/bin/systemd-run") return options.systemdRun ?? { status: 0, stdout: "", stderr: "" }; if (command === "/usr/bin/bwrap") return bwrap; throw new Error(`unexpected spawn: ${command}`); }, probeUnitName: () => PROBE_UNIT, }; return { host, calls }; } // 1105/12-01. The check looked only for the bwrap executable, so a host that // refuses unprivileged user namespaces printed PASS and then failed 18 // provider tests with bwrap's raw netlink error. describe("system test prerequisites (1105/12-01)", () => { it("passes when bubblewrap creates the provider sandbox's namespaces", async () => { const { host, calls } = fakeHost({ status: 0, stderr: "" }); expect(await findSystemTestPrerequisiteFailures(host)).toEqual([]); const probes = calls.filter(({ command }) => command === "/usr/bin/bwrap"); expect(probes).toHaveLength(1); expect(probes[0]?.args).toEqual(NAMESPACE_PROBE_ARGUMENTS); expect(probes[0]?.args.at(-1)).toBe("/bin/true"); }); it("probes with exactly the namespace options the provider sandbox uses", async () => { expect(PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS).toEqual([ "--unshare-pid", "--unshare-ipc", "--unshare-uts", "--unshare-net", ]); expect(NAMESPACE_PROBE_ARGUMENTS.slice(0, PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS.length)).toEqual( PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS, ); // The provider takes the list from the same module instead of its own copy. const provider = await readFile("scripts/run-and-validate-provider.ts", "utf8"); expect(provider).toContain("...PROVIDER_SANDBOX_NAMESPACE_ARGUMENTS,"); expect(provider).not.toMatch(/"--unshare-/u); }); it("fails with the namespace restriction, bwrap's stderr and what to do when bwrap cannot set up loopback", async () => { const { host } = fakeHost( { status: 1, stderr: `${RTM_NEWADDR}\n` }, { files: { "/proc/sys/kernel/apparmor_restrict_unprivileged_userns": "1\n" } }, ); const failures = await findSystemTestPrerequisiteFailures(host); expect(failures).toHaveLength(1); const failure = failures[0] ?? ""; expect(failure).toMatch(/^this host does not allow unprivileged user and network namespaces/u); expect(failure).toContain("--unshare-net"); expect(failure).toContain(`bwrap stderr: ${RTM_NEWADDR}`); expect(failure).toContain("kernel.apparmor_restrict_unprivileged_userns = 1"); expect(failure).toMatch(/AppArmor profile/u); expect(failure).toMatch(/sysctl kernel\.apparmor_restrict_unprivileged_userns=0/u); expect(failure).toMatch(/another runner/u); expect(formatSystemTestPrerequisiteReport(failures)).toContain( " - this host does not allow unprivileged user and network namespaces", ); }); it("fails the same way when the probe cannot run to the end", async () => { const { host } = fakeHost({ status: null, stderr: "", error: new Error("spawnSync /usr/bin/bwrap ETIMEDOUT") }); const failures = await findSystemTestPrerequisiteFailures(host); expect(failures).toHaveLength(1); expect(failures[0]).toMatch(/^this host does not allow unprivileged user and network namespaces/u); expect(failures[0]).toContain("did not finish: spawnSync /usr/bin/bwrap ETIMEDOUT"); }); it("keeps the executable, cgroup v2 and systemd checks, and probes bwrap only when it is there", async () => { const calls: SpawnCall[] = []; const host: SystemTestHost = { access: async (target) => { if (target === "/usr/bin/bwrap") throw new Error(`EACCES: ${target}`); }, readFile: async () => "\n", spawn: (command, args) => { calls.push({ command, args }); return { status: 1, stderr: "Failed to connect to bus" }; }, }; const failures = await findSystemTestPrerequisiteFailures(host); expect(failures.slice(0, 2)).toEqual([ "bubblewrap is required at /usr/bin/bwrap", "cgroup v2 controllers are unavailable", ]); expect(failures[2]).toMatch(/^a reachable systemd user manager is required/u); expect(failures).toHaveLength(3); expect(calls.map(({ command }) => command)).toEqual(["/usr/bin/systemctl"]); }); }); // 1112/08-03. The check looked at the system manager bus while the provider // asks the user manager for its version and starts a `systemd-run --user // --scope`, so a host without a user manager, with an old one, or without // prlimit, systemd-run or delegated controllers printed PASS and then failed // each provider test with `provider cgroup unavailable: ...`. describe("system test prerequisites match the provider's own calls (1112/08-03)", () => { it("fails by name when the system manager answers but the user manager does not", async () => { const { host, calls } = fakeHost( { status: 0, stderr: "" }, { userManager: { status: 1, stdout: "", stderr: "Failed to connect to bus: No medium found\n" } }, ); const failures = await findSystemTestPrerequisiteFailures(host); expect(failures).toHaveLength(1); expect(failures[0]).toMatch(/^a reachable systemd user manager is required/u); expect(failures[0]).toContain("/usr/bin/systemctl --user show --property=Version --value exited 1"); expect(failures[0]).toContain("systemctl stderr: Failed to connect to bus: No medium found"); expect(calls.some(({ command }) => command === "/usr/bin/systemd-run")).toBe(false); }); it("fails when the user manager is older than the provider needs", async () => { const { host } = fakeHost({ status: 0, stderr: "" }, { userManager: { status: 0, stdout: "253\n", stderr: "" } }); expect(await findSystemTestPrerequisiteFailures(host)).toEqual([ 'systemd user manager 254 or newer is required (/usr/bin/systemctl --user show --property=Version --value reported "253")', ]); }); it("requires the prlimit and systemd-run executables the provider runs", async () => { const { host } = fakeHost({ status: 0, stderr: "" }, { missing: ["/usr/bin/prlimit", "/usr/bin/systemd-run"] }); expect(await findSystemTestPrerequisiteFailures(host)).toEqual([ "prlimit is required at /usr/bin/prlimit", "systemd-run is required at /usr/bin/systemd-run", ]); }); it("starts the provider's own scope once and names a scope that cannot enforce its limits", async () => { const { host, calls } = fakeHost( { status: 0, stderr: "" }, { systemdRun: { status: 125, stdout: "", stderr: "provider cgroup enforcement failed: cannot read memory.max\n" } }, ); const failures = await findSystemTestPrerequisiteFailures(host); expect(failures).toHaveLength(1); expect(failures[0]).toMatch(/^systemd-run could not start the provider's cgroup scope/u); expect(failures[0]).toContain("exited 125"); expect(failures[0]).toContain("systemd-run stderr: provider cgroup enforcement failed: cannot read memory.max"); expect(failures[0]).toMatch(/memory, pids and cpu controllers delegated/u); const scopes = calls.filter(({ command }) => command === "/usr/bin/systemd-run"); expect(scopes).toHaveLength(1); expect(scopes[0]?.args).toEqual(systemdRunPrerequisiteProbeArguments(PROBE_UNIT)); expect(scopes[0]?.args.at(-1)).toBe("/bin/true"); }); it("probes with the provider scope's properties and enforcement gate, not a copy", () => { const probe = systemdRunPrerequisiteProbeArguments(PROBE_UNIT); const provider = systemdRunProviderArguments( "ca-provider-vulnerability-4242-0123456789abcdef01234567.scope", 60_000, 60, "/usr/bin/node", "/opt/wrapper.ts", "/tmp/report.json", 1, 1, ); const options = (args: readonly string[]) => args.filter((arg) => arg.startsWith("--") && !arg.startsWith("--unit=") && !arg.startsWith("--property=RuntimeMaxSec=")); expect(options(probe)).toEqual(options(provider)); const gate = (args: readonly string[]) => args[args.indexOf("-c") + 1]; expect(gate(probe)).toBe(gate(provider)); expect(gate(probe)).toContain("require_cgroup_value memory.max"); expect(() => systemdRunPrerequisiteProbeArguments("ca-provider-vulnerability-1-0123456789abcdef01234567.scope")) .toThrow(/unit is invalid/u); }); }); // 1101/13-03. The release provider jobs run the same sandbox on whatever // runner picks them up. The supervisor checked only that the executables // exist, so a host that refuses the namespaces failed later with bwrap's raw // error and without the host settings. describe("provider sandbox namespace check (1101/13-03)", () => { it("passes on a host that creates the namespaces and probes only with bwrap", async () => { const { host, calls } = fakeHost({ status: 0, stderr: "" }); expect(await findProviderSandboxNamespaceFailure(host)).toBeUndefined(); expect(calls).toEqual([{ command: "/usr/bin/bwrap", args: NAMESPACE_PROBE_ARGUMENTS }]); }); it("names the restriction, bwrap's stderr and the host settings on a host that refuses them", async () => { const { host } = fakeHost( { status: 1, stderr: `${RTM_NEWADDR}\n` }, { files: { "/proc/sys/kernel/apparmor_restrict_unprivileged_userns": "1\n" } }, ); const failure = (await findProviderSandboxNamespaceFailure(host)) ?? ""; expect(failure).toMatch(/^this host does not allow unprivileged user and network namespaces/u); expect(failure).toContain(`bwrap stderr: ${RTM_NEWADDR}`); expect(failure).toContain("kernel.apparmor_restrict_unprivileged_userns = 1"); }); it("runs before the provider supervisor launches anything", async () => { const provider = await readFile("scripts/run-and-validate-provider.ts", "utf8"); const check = provider.indexOf("await findProviderSandboxNamespaceFailure()"); expect(check).toBeGreaterThan(0); expect(check).toBeLessThan(provider.indexOf("superviseProviderEvidence({")); }); });