Files
Homelab-manager/server/test/hardening.test.ts
T
bobbanandClaude Sonnet 5.5 5c70956f78 Linux agent unit: keep only the root powers it uses; make unit files readable
The systemd unit now bounds the agent's capabilities to the three jobs it does as root --
reading every user's crontab (DAC_OVERRIDE, DAC_READ_SEARCH), running "crontab -l -u"
(SETUID, SETGID) and naming the program behind each socket (SYS_PTRACE) -- and adds
ProtectClock, ProtectHostname, MemoryDenyWriteExecute and DevicePolicy=closed. It does not
use PrivateDevices, which would hide /dev/log (crontab logs each read there), nor anything
that hides other processes or users, since the agent needs both.

The installer's umask 077 (for the token file) also left the unit files readable by root only;
they now get chmod 644, so "systemctl cat" works for any user.

The test renders the unit through the installer's own heredoc, so a stray backtick or $ would
show up, and pins the capability list: tightening it silently drops tasks or process names.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-06 22:48:50 +02:00

566 lines
29 KiB
TypeScript

/**
* Regression tests for the second security pass: where the server may be pointed, what an agent may send, and how the agent
* scripts handle the token.
*
* - utils/networkGuard.ts: loopback, link-local (cloud metadata) and similar addresses are refused for the certificate check,
* the WHOIS lookup and the port scanner; the connection goes to the address that was checked.
* - the agent endpoint checks the token before reading a body, takes a large report, and trims rather than rejects.
* - the Linux agent keeps the token off curl's command line and out of a fixed /tmp file; its systemd unit is locked down.
* - the Windows installer gives the SYSTEM task's folder explicit permissions.
*
* Run with: npm test --workspace server
*/
import { test, describe, before, after } from "node:test";
import assert from "node:assert/strict";
import { mkdtempSync, mkdirSync, readFileSync, existsSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { fileURLToPath } from "node:url";
import { spawn, spawnSync } from "node:child_process";
import http from "node:http";
const dir = mkdtempSync(join(tmpdir(), "hm-hardening-test-"));
process.env.DATABASE_PATH = join(dir, "test.sqlite");
process.env.SESSION_DIR = join(dir, "sessions");
process.env.CREDENTIALS_ENCRYPTION_KEY = "ab".repeat(32);
const repoRoot = fileURLToPath(new URL("../../", import.meta.url));
const { classifyAddress, resolveTarget, BlockedTargetError } = await import("../src/utils/networkGuard.js");
const { fetchCertExpiry } = await import("../src/services/tlsCheck.js");
const { defaultDeps } = await import("../src/services/domainLookup.js");
const { resolveScanTarget } = await import("../src/services/portScan.js");
const { runMigrations } = await import("../src/db/migrate.js");
await runMigrations();
const blocked = (kind?: string) => (err: unknown) => err instanceof BlockedTargetError && (kind === undefined || err.kind === kind);
// ─── Where the server may be pointed ────────────────────────────────────────
describe("networkGuard", () => {
test("classifies addresses, including IPv4 wrapped in IPv6", () => {
const expected: Record<string, string> = {
"127.0.0.1": "loopback",
"127.9.9.9": "loopback",
"::1": "loopback",
"::ffff:127.0.0.1": "loopback",
"0.0.0.0": "unspecified",
"::": "unspecified",
"169.254.169.254": "metadata",
"::ffff:169.254.169.254": "metadata",
"fd00:ec2::254": "metadata",
"100.100.100.200": "metadata",
"169.254.1.1": "link-local",
"fe80::1": "link-local",
"224.0.0.1": "multicast",
"255.255.255.255": "multicast",
"10.1.2.3": "private",
"172.16.5.5": "private",
"192.168.1.10": "private",
"100.64.0.5": "private",
"fd12:3456::1": "private",
"::ffff:10.0.0.1": "private",
"172.32.0.1": "public",
"8.8.8.8": "public",
"2606:4700::1111": "public",
"::ffff:8.8.8.8": "public",
};
for (const [ip, kind] of Object.entries(expected)) assert.equal(classifyAddress(ip), kind, ip);
});
test("refuses what is never allowed, and resolves names before judging them", async () => {
for (const host of ["127.0.0.1", "::1", "::ffff:127.0.0.1", "0.0.0.0", "169.254.169.254", "fe80::1", "fd00:ec2::254", "localhost"]) {
await assert.rejects(() => resolveTarget(host, { allowPrivate: true }), blocked(), host);
}
});
test("private ranges: allowed when asked for, refused when not", async () => {
assert.equal(await resolveTarget("192.168.1.10", { allowPrivate: true }), "192.168.1.10");
assert.equal(await resolveTarget("8.8.8.8", { allowPrivate: false }), "8.8.8.8");
await assert.rejects(() => resolveTarget("192.168.1.10", { allowPrivate: false }), blocked("private"));
});
test("odd spellings of loopback don't get through (they're refused or don't resolve)", async () => {
for (const host of ["2130706433", "0x7f000001", "127.1", "0177.0.0.1"]) {
await assert.rejects(() => resolveTarget(host, { allowPrivate: true }), blocked(), host);
}
});
});
describe("certificate check", () => {
test("won't connect to loopback, link-local or metadata addresses", async () => {
for (const host of ["127.0.0.1", "localhost", "::1", "::ffff:127.0.0.1", "0.0.0.0", "169.254.169.254", "fd00:ec2::254", "100.100.100.200", "2130706433"]) {
await assert.rejects(() => fetchCertExpiry(host, 443, 500), blocked(), host);
}
});
test("LAN and public hosts get past the check (and fail only on the connection)", async () => {
// Nothing answers on these, so what comes back is a timeout or an unreachable error — never a refusal by the guard.
for (const host of ["192.0.2.1", "10.255.255.1"]) {
await assert.rejects(
() => fetchCertExpiry(host, 443, 400),
(err: unknown) => !(err instanceof BlockedTargetError),
host,
);
}
});
});
describe("WHOIS server", () => {
test("must look like a hostname and must be neither this machine, metadata nor private", async () => {
for (const server of ["127.0.0.1", "localhost", "169.254.169.254", "10.0.0.1", "192.168.1.1"]) {
await assert.rejects(() => defaultDeps.whoisQuery(server, "example.se"), blocked(), server);
}
for (const server of ["not a host", "evil.com/x", "a;b", "", "fd00::1", "[::1]"]) {
await assert.rejects(() => defaultDeps.whoisQuery(server, "example.se"), /not a hostname/, JSON.stringify(server));
}
});
});
describe("port scanner", () => {
test("refuses loopback and the cloud metadata address, still scans the LAN", async () => {
await assert.rejects(() => resolveScanTarget("127.0.0.1"));
await assert.rejects(() => resolveScanTarget("169.254.169.254"), /metadata/);
await assert.rejects(() => resolveScanTarget("8.8.8.8"), /private network/);
assert.equal(await resolveScanTarget("192.168.1.10"), "192.168.1.10");
assert.equal(await resolveScanTarget("100.64.1.2"), "100.64.1.2");
});
});
// ─── Routes ─────────────────────────────────────────────────────────────────
let port = 0;
let server: http.Server;
let operator = "";
/** Sends a path exactly as written, with a raw body. Resolves with the status and the reply text. */
function send(method: string, path: string, opts: { cookie?: string; token?: string; json?: object; raw?: string } = {}): Promise<{ status: number; text: string }> {
return new Promise((resolve, reject) => {
const payload = opts.raw ?? (opts.json ? JSON.stringify(opts.json) : undefined);
const headers: Record<string, string> = {};
if (opts.cookie) headers.cookie = opts.cookie;
if (opts.token) headers.authorization = `Bearer ${opts.token}`;
if (payload !== undefined) {
headers["content-type"] = "application/json";
headers["content-length"] = String(Buffer.byteLength(payload));
}
const req = http.request({ host: "127.0.0.1", port, method, path, headers }, (res) => {
let text = "";
res.on("data", (c) => (text += c));
res.on("end", () => resolve({ status: res.statusCode ?? 0, text }));
});
// The server may answer (and close) before it has taken the whole body; that's the point of some of these tests.
req.on("error", (err) => (/EPIPE|ECONNRESET/.test(String(err)) ? undefined : reject(err)));
if (payload !== undefined) req.write(payload);
req.end();
});
}
let agentToken = "";
let agentServerId = 0;
before(async () => {
const express = (await import("express")).default;
const session = (await import("express-session")).default;
const { db } = await import("../src/db/client.js");
const { users, servers } = await import("../src/db/schema.js");
const { generateApiToken } = await import("../src/services/tokens.js");
const { secretsRouter } = await import("../src/routes/secrets.js");
const { agentReportRouter } = await import("../src/routes/agentReport.js");
const { apiErrorHandler } = await import("../src/utils/apiErrorHandler.js");
await db.insert(users).values({ oidcSub: "op", email: "op@x", name: "Operator", role: "operator" });
const { token, prefix, hash } = generateApiToken();
agentToken = token;
agentServerId = (await db.insert(servers).values({ name: "agent-host", apiTokenHash: hash, apiTokenPrefix: prefix }).returning())[0].id;
// The same order index.ts uses: the agent endpoint first, then the app-wide JSON parser and sessions, then everything else.
const app = express();
app.use("/api/agent/report", agentReportRouter);
app.use(express.json());
app.use(session({ secret: "t", resave: false, saveUninitialized: true }));
app.post("/login", (req, res) => {
req.session.user = { sub: "op" } as never;
res.json({});
});
app.use("/api/secrets", secretsRouter);
app.use(apiErrorHandler);
server = app.listen(0);
port = (server.address() as { port: number }).port;
operator = ((await fetch(`http://127.0.0.1:${port}/login`, { method: "POST" })).headers.get("set-cookie") as string).split(";")[0];
});
after(() => {
server?.close();
try {
rmSync(dir, { recursive: true, force: true });
} catch {
// Windows keeps the SQLite file locked until the process exits.
}
});
describe("secrets: the certificate check can't be aimed at the server itself", () => {
test("a blocked host is refused with a clear reason", async () => {
for (const checkHost of ["127.0.0.1", "169.254.169.254", "localhost"]) {
const res = await send("POST", "/api/secrets", { cookie: operator, json: { name: "probe", type: "ssl_certificate", checkHost, checkPort: 8080 } });
assert.equal(res.status, 400, `${checkHost}: ${res.text}`);
assert.match(res.text, /can't be used/, checkHost);
}
});
test("with a typed-in expiry the secret is saved, and the check records why it wasn't done — it never connects", async () => {
const res = await send("POST", "/api/secrets", {
cookie: operator,
json: { name: "manual", type: "ssl_certificate", checkHost: "127.0.0.1", checkPort: 8080, expiryDate: "2030-01-01" },
});
assert.equal(res.status, 201, res.text);
assert.match(JSON.parse(res.text).secret.lastCheckError, /loopback/);
});
});
// ─── The agent endpoint ─────────────────────────────────────────────────────
describe("agent endpoint", () => {
const report = (extra: object = {}) => ({ hostname: "agent-host", os_type: "linux", tasks: [], ...extra });
test("is mounted ahead of the app-wide JSON parser and the session store", () => {
const index = readFileSync(join(repoRoot, "server/src/index.ts"), "utf8");
const agent = index.indexOf('app.use("/api/agent/report"');
assert.ok(agent > 0, "agent route not found in index.ts");
assert.ok(agent < index.indexOf("app.use(express.json())"), "the agent route must come before the 100 KB JSON parser");
assert.ok(agent < index.indexOf("session({"), "the agent route must come before the session store");
});
test("answers 401 without reading a body when the token is missing or wrong", async () => {
const huge = JSON.stringify(report({ hostname: "x".repeat(3_000_000) }));
assert.equal((await send("POST", "/api/agent/report", { raw: huge })).status, 401);
assert.equal((await send("POST", "/api/agent/report", { token: "hlm_" + "0".repeat(48), raw: huge })).status, 401);
assert.equal((await send("POST", "/api/agent/report", { token: "nonsense", json: report() })).status, 401);
});
test("takes an ordinary report", async () => {
const res = await send("POST", "/api/agent/report", { token: agentToken, json: report({ hostname: "web-1" }) });
assert.equal(res.status, 202, res.text);
});
test("takes a big report (well past the 100 KB the rest of the API allows) from a real agent", async () => {
const ports = Array.from({ length: 2500 }, (_, i) => ({ protocol: "tcp", port: 1000 + i, address: "0.0.0.0", process: "some-process-name" }));
const body = JSON.stringify(report({ system: { listening_ports: ports } }));
assert.ok(body.length > 150_000, `the test report should be larger than 100 KB, was ${body.length}`);
const res = await send("POST", "/api/agent/report", { token: agentToken, raw: body });
assert.equal(res.status, 202, res.text);
const { db } = await import("../src/db/client.js");
const row = await db.query.servers.findFirst({ where: (s, { eq }) => eq(s.id, agentServerId) });
assert.equal(JSON.parse(row!.listeningPorts!).length, 2500);
});
test("a body over the limit is a 413, not a server error", async () => {
const res = await send("POST", "/api/agent/report", { token: agentToken, raw: JSON.stringify(report({ hostname: "x".repeat(4_500_000) })) });
assert.equal(res.status, 413, res.text);
assert.match(res.text, /payload_too_large/);
});
test("malformed JSON is a 400", async () => {
const res = await send("POST", "/api/agent/report", { token: agentToken, raw: "{not json" });
assert.equal(res.status, 400);
assert.match(res.text, /invalid_json/);
});
test("overlong text is trimmed instead of costing the host its whole report", async () => {
const res = await send("POST", "/api/agent/report", {
token: agentToken,
json: report({
hostname: "h".repeat(300),
system: { ip_addresses: Array.from({ length: 300 }, (_, i) => `10.0.${Math.floor(i / 250)}.${i % 250}`) },
tasks: [
{ schedule_type: "cron", name: "n".repeat(600), command: "c".repeat(20_000), schedule_expression: "* * * * *" },
{ schedule_type: "cron", name: "big-metadata", metadata: { blob: "m".repeat(60_000) } },
{ schedule_type: "cron", name: "small-metadata", metadata: { user: "root" } },
],
}),
});
assert.equal(res.status, 202, res.text);
const { db } = await import("../src/db/client.js");
const row = await db.query.servers.findFirst({ where: (s, { eq }) => eq(s.id, agentServerId) });
assert.equal(row!.hostname!.length, 255);
assert.equal(JSON.parse(row!.ipAddresses!).length, 200);
const tasks = await db.query.scheduledTasks.findMany({ where: (t, { eq }) => eq(t.serverId, agentServerId) });
const long = tasks.find((t) => t.name.startsWith("nnn"))!;
assert.equal(long.name.length, 500);
assert.equal(long.command!.length, 8000);
assert.equal(tasks.find((t) => t.name === "big-metadata")!.rawMetadata, null, "oversize metadata is dropped, the task kept");
assert.equal(tasks.find((t) => t.name === "small-metadata")!.rawMetadata, JSON.stringify({ user: "root" }));
});
});
// ─── The Linux agent ────────────────────────────────────────────────────────
const agentScript = join(repoRoot, "agent/linux/report-tasks.sh");
const installScript = join(repoRoot, "agent/linux/install.sh");
const haveBash = spawnSync("bash", ["-c", "command -v curl"]).status === 0;
const posix = (p: string) => p.replace(/\\/g, "/");
/** Runs a command without blocking this process (the fake server in these tests lives in it, so a blocking spawn would deadlock). */
function run(cmd: string, args: string[], env: NodeJS.ProcessEnv): Promise<{ status: number | null; stdout: string; stderr: string }> {
return new Promise((resolve, reject) => {
const child = spawn(cmd, args, { env });
let stdout = "";
let stderr = "";
const timer = setTimeout(() => child.kill(), 30_000);
child.stdout.on("data", (c) => (stdout += c));
child.stderr.on("data", (c) => (stderr += c));
child.on("error", reject);
child.on("close", (status) => {
clearTimeout(timer);
resolve({ status, stdout, stderr });
});
});
}
describe("Linux agent", () => {
test("both scripts are valid bash", { skip: !haveBash }, () => {
for (const script of [agentScript, installScript]) {
const r = spawnSync("bash", ["-n", posix(script)], { encoding: "utf8" });
assert.equal(r.status, 0, r.stderr);
}
});
test("the token never goes on a command line and nothing is written to a fixed /tmp path", () => {
const text = readFileSync(agentScript, "utf8");
assert.doesNotMatch(text, /-H\s+"Authorization/, "the token must not be passed with -H");
assert.doesNotMatch(text, /\/tmp\/hlm/, "no fixed file name in /tmp");
assert.match(text, /mktemp -d/);
assert.match(text, /trap 'rm -rf "\$HLM_TMPDIR"' EXIT/);
assert.match(text, /curl .* -K -/, "curl should read its config (with the token) from stdin");
});
test("the systemd unit, as the installer writes it, is locked down and keeps what the agent needs", { skip: !haveBash }, async () => {
// Run the installer's own heredoc, so a stray $, backtick or backslash in the unit shows up here exactly as it would on a server.
const text = readFileSync(installScript, "utf8").replace(/\r\n/g, "\n");
const start = text.indexOf('cat > "$SYSTEMD_DIR/homelab-manager-agent.service" <<EOF');
const end = text.indexOf("\nEOF\n", start) + "\nEOF\n".length;
assert.ok(start > 0 && end > start, "the unit's heredoc wasn't found in install.sh");
const out = mkdtempSync(join(tmpdir(), "hm-unit-"));
try {
writeFileSync(join(out, "render.sh"), `set -euo pipefail\nCONFIG_DIR=/etc\nINSTALL_DIR=/usr/local/bin\nSYSTEMD_DIR=$(cygpath -u "$OUT_DIR" 2>/dev/null || echo "$OUT_DIR")\n${text.slice(start, end)}`);
const r = await run("bash", [posix(join(out, "render.sh"))], { ...process.env, OUT_DIR: posix(out) });
assert.equal(r.status, 0, r.stderr);
assert.equal(r.stdout.trim(), "", "rendering the unit ran a command (a backtick or $( ) in the heredoc?)");
const rendered = readFileSync(join(out, "homelab-manager-agent.service"), "utf8");
const settings = new Map<string, string>();
for (const line of rendered.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("["))) {
const eq = line.indexOf("=");
assert.ok(eq > 0, `not a Key=Value line: ${JSON.stringify(line)}`);
settings.set(line.slice(0, eq), line.slice(eq + 1));
}
// The two intended expansions, and nothing else turned into something unexpected.
assert.equal(settings.get("EnvironmentFile"), "/etc/homelab-manager-agent.env");
assert.equal(settings.get("ExecStart"), "/usr/local/bin/homelab-manager-agent.sh");
assert.doesNotMatch(rendered, /[`\\]/);
for (const [key, value] of Object.entries({
UMask: "0077", NoNewPrivileges: "yes", PrivateTmp: "yes", ProtectSystem: "strict", ProtectHome: "read-only",
ProtectKernelTunables: "yes", ProtectKernelModules: "yes", ProtectKernelLogs: "yes", ProtectControlGroups: "yes",
ProtectClock: "yes", ProtectHostname: "yes", MemoryDenyWriteExecute: "yes", RestrictSUIDSGID: "yes",
RestrictRealtime: "yes", RestrictNamespaces: "yes", LockPersonality: "yes", DevicePolicy: "closed",
})) {
assert.equal(settings.get(key), value, key);
}
assert.equal(settings.get("RestrictAddressFamilies"), "AF_UNIX AF_INET AF_INET6 AF_NETLINK");
// Of root's powers only these three jobs are kept: read every user's crontab, switch user for `crontab -l -u`, and name the
// program behind each socket. Tightening this further silently drops tasks or process names; loosening it undoes the point.
assert.deepEqual(
new Set((settings.get("CapabilityBoundingSet") ?? "").split(/\s+/)),
new Set(["CAP_DAC_OVERRIDE", "CAP_DAC_READ_SEARCH", "CAP_SYS_PTRACE", "CAP_SETUID", "CAP_SETGID"]),
);
// It has to keep seeing every process (that is how it names the program behind a listening port), real user IDs (for
// crontab -l -u), and /dev/log (crontab writes to it each time the agent reads a crontab).
for (const key of ["ProtectProc", "ProcSubset", "PrivateUsers", "PrivateDevices"]) assert.equal(settings.has(key), false, `${key} would break the agent`);
} finally {
try {
rmSync(out, { recursive: true, force: true });
} catch {
// best effort
}
}
});
test("unit files are made readable by everyone (the umask above them is for the token file)", () => {
const text = readFileSync(installScript, "utf8").replace(/\r\n/g, "\n");
assert.match(text, /chmod 644 "\$SYSTEMD_DIR\/homelab-manager-agent\.service" "\$SYSTEMD_DIR\/homelab-manager-agent\.timer"/);
// ...and it comes after both files are written and before systemd is asked to read them.
const chmodAt = text.indexOf('chmod 644 "$SYSTEMD_DIR');
assert.ok(chmodAt > text.indexOf("homelab-manager-agent.timer\" <<EOF") && chmodAt < text.indexOf("systemctl daemon-reload"));
});
describe("the upload, run against a fake server", { skip: !haveBash }, () => {
let fake: http.Server;
let fakePort = 0;
let seen: { authorization?: string; contentType?: string; body: string }[] = [];
let work = "";
before(async () => {
work = mkdtempSync(join(tmpdir(), "hm-agent-upload-"));
fake = http.createServer((req, res) => {
let body = "";
req.on("data", (c) => (body += c));
req.on("end", () => {
seen.push({ authorization: req.headers.authorization, contentType: req.headers["content-type"], body });
res.writeHead(202, { "content-type": "application/json" });
res.end(JSON.stringify({ ok: true }));
});
});
await new Promise<void>((r) => fake.listen(0, "127.0.0.1", r));
fakePort = (fake.address() as { port: number }).port;
// A curl that records its own arguments and then runs the real one — to prove what is, and isn't, on the command line.
writeFileSync(join(work, "curl"), '#!/usr/bin/env bash\nprintf \'%s\\n\' "$@" >> "$ARGV_LOG"\nexec "$REAL_CURL" "$@"\n');
});
after(() => {
fake?.close();
try {
rmSync(work, { recursive: true, force: true });
} catch {
// best effort
}
});
/** Runs the script's own post_report function (cut out of the real file) the way the script does. */
async function upload(token: string, payload: string) {
seen = [];
const argvLog = join(work, "argv.log");
const tmpRecord = join(work, "tmpdir.txt");
rmSync(argvLog, { force: true });
const harness = [
"set -euo pipefail",
'REAL_CURL=$(command -v curl); export REAL_CURL ARGV_LOG="$(cygpath -u "$ARGV_LOG_WIN" 2>/dev/null || echo "$ARGV_LOG_WIN")"',
// A "C:/..." directory can't go in PATH on Windows bash (the colon splits it), so convert it the way bash itself would.
'SHIM_UNIX=$(cygpath -u "$SHIM_DIR" 2>/dev/null || echo "$SHIM_DIR")',
'chmod +x "$SHIM_UNIX/curl"; PATH="$SHIM_UNIX:$PATH"',
'source <(sed -n "/^# >>> post_report/,/^# <<< post_report/p" "$AGENT_SCRIPT")',
"CURL_INSECURE_FLAG=()",
'HLM_TMPDIR=$(mktemp -d); printf "%s" "$HLM_TMPDIR" > "$TMP_RECORD"',
"trap 'rm -rf \"$HLM_TMPDIR\"' EXIT",
"response=$(post_report)",
'echo "HTTP=$response"',
].join("\n");
const r = await run("bash", ["-c", harness], {
...process.env,
API_URL: `http://127.0.0.1:${fakePort}`,
API_TOKEN: token,
PAYLOAD: payload,
SHIM_DIR: posix(work),
AGENT_SCRIPT: posix(agentScript),
ARGV_LOG_WIN: argvLog,
TMP_RECORD: posix(tmpRecord),
});
const argv = existsSync(argvLog) ? readFileSync(argvLog, "utf8") : "";
return { ...r, argv, tmpdir: existsSync(tmpRecord) ? readFileSync(tmpRecord, "utf8") : "" };
}
test("an ordinary report arrives with the token as a header, and the token isn't in curl's arguments", async () => {
const r = await upload("hlm_abc123", '{"hostname":"web-1","tasks":[]}');
assert.equal(r.status, 0, r.stderr);
assert.match(r.stdout, /HTTP=202/);
assert.equal(seen.length, 1);
assert.equal(seen[0].authorization, "Bearer hlm_abc123");
assert.equal(seen[0].contentType, "application/json");
assert.equal(seen[0].body, '{"hostname":"web-1","tasks":[]}');
assert.ok(r.argv.length > 0, "the curl shim recorded nothing, so the test proves nothing");
assert.doesNotMatch(r.argv, /hlm_abc123/, "the token was on curl's command line");
assert.doesNotMatch(r.argv, /Authorization/i);
});
test("a token with quotes, a backslash and a space arrives intact", async () => {
const token = 'hlm_a"b\\c d';
const r = await upload(token, "{}");
assert.equal(r.status, 0, r.stderr);
assert.equal(seen[0].authorization, `Bearer ${token}`);
});
test("a large report goes through (it isn't limited by the length of a command line)", async () => {
const payload = JSON.stringify({ tasks: [], padding: "p".repeat(600_000) });
const r = await upload("hlm_big", payload);
assert.equal(r.status, 0, r.stderr);
assert.equal(seen[0].body.length, payload.length);
assert.doesNotMatch(r.argv, /ppppppppppppppppppppppppp/, "the payload was on curl's command line");
});
test("a token with a line break is refused and nothing is sent", async () => {
const r = await upload("hlm_x\nX-Injected: yes", "{}");
assert.notEqual(r.status, 0);
assert.match(r.stderr, /line break/);
assert.equal(seen.length, 0);
});
test("the private temporary directory is gone afterwards", async () => {
const r = await upload("hlm_clean", "{}");
assert.equal(r.status, 0, r.stderr);
assert.ok(r.tmpdir.length > 0);
const gone = spawnSync("bash", ["-c", `test ! -e "${r.tmpdir}"`]);
assert.equal(gone.status, 0, `${r.tmpdir} still exists`);
});
});
});
// ─── The Windows installer ──────────────────────────────────────────────────
const pwsh = process.platform === "win32" ? spawnSync("pwsh", ["-NoProfile", "-Command", "$PSVersionTable.PSVersion.Major"], { encoding: "utf8" }) : null;
const havePwsh = pwsh?.status === 0;
describe("Windows installer", { skip: !havePwsh }, () => {
test("the folder the SYSTEM task runs from is writable only by SYSTEM and Administrators", () => {
const work = mkdtempSync(join(tmpdir(), "hm-acl-"));
const target = join(work, "HomelabManager");
mkdirSync(target);
const script = `
$ErrorActionPreference = 'Stop'
. '${join(repoRoot, "agent", "windows", "install.ps1").replace(/'/g, "''")}'
$me = [Security.Principal.WindowsIdentity]::GetCurrent().User.Value
Protect-InstallDir '${target.replace(/'/g, "''")}' -ExtraGrants @("*\${me}:(OI)(CI)(F)") # lets this un-elevated test keep access to its own folder
$file = Join-Path '${target.replace(/'/g, "''")}' 'homelab-manager-agent.ps1'
Set-Content -Path $file -Value 'x'
function Describe($p) {
$acl = Get-Acl $p
foreach ($rule in $acl.GetAccessRules($true, $true, [Security.Principal.SecurityIdentifier])) { '{0}|{1}' -f $rule.IdentityReference.Value, $rule.IsInherited }
}
'DIR'; Describe '${target.replace(/'/g, "''")}'
'FILE'; Describe $file
'ME=' + $me
`;
const scriptFile = join(work, "check-acl.ps1");
writeFileSync(scriptFile, script);
const r = spawnSync("pwsh", ["-NoProfile", "-NonInteractive", "-File", scriptFile], { encoding: "utf8" });
try {
// No error output and a complete listing; the exit status is left out because PowerShell's -File status isn't reliable across hosts here.
assert.equal(r.stderr.trim(), "", `PowerShell reported an error:
${r.stderr}
${r.stdout}`);
assert.ok(r.stdout.includes("ME="), `the script did not finish:
${r.stdout}`);
const lines = r.stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
const me = lines.find((l) => l.startsWith("ME="))!.slice(3);
const part = (from: string, to: string | null) => lines.slice(lines.indexOf(from) + 1, to ? lines.indexOf(to) : lines.findIndex((l) => l.startsWith("ME="))).map((l) => l.split("|"));
const dir = part("DIR", "FILE");
const file = part("FILE", null);
const allowed = new Set(["S-1-5-18", "S-1-5-32-544", me]);
assert.deepEqual(new Set(dir.map(([sid]) => sid)), allowed, `folder ACL: ${JSON.stringify(dir)}`);
assert.ok(dir.every(([, inherited]) => inherited === "False"), "the folder must not inherit ProgramData's permissions");
assert.deepEqual(new Set(file.map(([sid]) => sid)), allowed, `file ACL: ${JSON.stringify(file)}`);
for (const everyone of ["S-1-5-32-545" /* Users */, "S-1-5-11" /* Authenticated Users */, "S-1-1-0" /* Everyone */]) {
assert.ok(!dir.some(([sid]) => sid === everyone) && !file.some(([sid]) => sid === everyone), `${everyone} has access`);
}
} finally {
try {
rmSync(work, { recursive: true, force: true });
} catch {
// best effort
}
}
});
});