import test from "node:test"; import assert from "node:assert/strict"; import { createServer, request } from "node:http"; import { createHash, randomBytes } from "node:crypto"; import { once } from "node:events"; import { mkdtemp, writeFile, rm } from "node:fs/promises"; import { tmpdir } from "node:os"; import { join } from "node:path"; import { PeerRegistry } from "../src/peerRegistry.js"; import { spawn } from "node:child_process"; import { fileURLToPath } from "node:url"; async function fixture(t) { const observations = []; const gates = {}; const hold = (name) => { let release, enter; const promise = new Promise((done) => { release = done; }); const entered = new Promise((done) => { enter = done; }); gates[name] = { promise, enter }; t.after(release); return { entered, release }; }; const remotes = []; for (const name of ["one", "two"]) { const server = createServer(async (req, res) => { observations.push({ name, path: req.url, cookie: req.headers.cookie, upload: req.headers["x-pipelines-upload-name"], }); if (req.url === "/login" && req.method === "GET" && gates[name]) { gates[name].enter(); await gates[name].promise; } if (req.url === "/discovery") { res.setHeader("Content-Type", "application/json"); res.end( JSON.stringify({ discovered_servers: [ { name: "Linux desktop", endpoint: "ws://192.168.1.2:8083/connect", auth: "password", version: "test", }, ], }), ); return; } if (req.url === "/login" && req.method === "POST") { let body = ""; for await (const chunk of req) body += chunk; if (new URLSearchParams(body).get("password") !== `password-${name}`) { res.writeHead(401).end(); return; } res .writeHead(303, { "Set-Cookie": `pipelines_session=remote-${name}; HttpOnly`, Location: "/", }) .end(); return; } if (req.url === "/login") { if (req.headers.cookie === `pipelines_session=remote-${name}`) res.writeHead(302, { Location: "/" }).end(); else res.end(''); return; } res.setHeader("Set-Cookie", "do-not-forward=private"); if (req.method === "POST") { let body = ""; for await (const chunk of req) body += chunk; res.end( JSON.stringify({ name, method: req.method, url: req.url, cookie: req.headers.cookie, upload: req.headers["x-pipelines-upload-name"], type: req.headers["content-type"], body, }), ); return; } if ( req.url.startsWith("/artifacts/") || req.url.includes("untrusted.svg") ) { res.setHeader( "Content-Type", req.url.startsWith("/artifacts/") ? "text/html" : "image/svg+xml", ); if (req.url.startsWith("/artifacts/")) { res.setHeader( "Content-Security-Policy", "sandbox; default-src 'none'; img-src 'none'", ); } res.end( '', ); return; } res.end( JSON.stringify({ name, url: req.url, cookie: req.headers.cookie }), ); }); server.on("upgrade", (req, socket) => { observations.push({ name, path: req.url, cookie: req.headers.cookie, origin: req.headers.origin, }); if (req.headers.cookie !== `pipelines_session=remote-${name}`) { socket.end("HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n"); return; } const accept = createHash("sha1") .update( req.headers["sec-websocket-key"] + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11", ) .digest("base64"); socket.write( `HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`, ); const message = Buffer.from(JSON.stringify({ name })); socket.write( Buffer.concat([Buffer.from([0x81, message.length]), message]), ); socket.on("error", () => {}); }); server.listen(0, "127.0.0.1"); await once(server, "listening"); t.after(() => { server.closeAllConnections(); server.close(); }); remotes.push(`ws://127.0.0.1:${server.address().port}/connect`); } const dir = await mkdtemp(join(tmpdir(), "peer-relay-")); t.after(() => rm(dir, { recursive: true, force: true })); const auth = join(dir, "auth.json"); await writeFile( auth, JSON.stringify({ password: "local-password", secret: "s".repeat(40) }), ); const reserve = createServer().listen(0, "127.0.0.1"); await once(reserve, "listening"); const port = reserve.address().port; await new Promise((done) => reserve.close(done)); const child = spawn( process.execPath, [ "serve.mjs", "--port", String(port), "--pipelines", new URL(remotes[0]).host, ], { cwd: fileURLToPath(new URL("..", import.meta.url)), env: { ...process.env, PIPELINES_WEB_AUTH: "", PIPELINES_WEB_AUTH_FILE: auth, // The fixture machines listen on loopback, which the relay refuses by default. PIPELINES_PEER_ALLOW: "loopback", }, stdio: ["ignore", "pipe", "inherit"], }, ); t.after(async () => { const exited = once(child, "exit"); child.kill(); await exited; }); await once(child.stdout, "data"); const base = `http://127.0.0.1:${port}`; const login = async () => { const reply = await fetch(base + "/login", { method: "POST", body: new URLSearchParams({ password: "local-password" }), redirect: "manual", }); return reply.headers.get("set-cookie").split(";")[0]; }; const cookie = await login(); const register = (id, data, who = cookie, origin = base) => fetch(base + "/api/peers/" + id, { method: "POST", headers: { Cookie: who, Origin: origin, "Content-Type": "application/json", }, body: JSON.stringify(data), }); return { base, cookie, remotes, observations, register, login, hold }; } test("browser can authenticate both machines, relay files and keep local credentials isolated", async (t) => { const f = await fixture(t); assert.equal( (await f.register("one", { endpoints: [f.remotes[0]] }, "")).status, 401, ); const needing = await f.register("one", { endpoints: [f.remotes[0]] }); assert.equal((await needing.json()).needs_password, true); assert.equal( ( await ( await f.register("one", { endpoints: [f.remotes[0]], password: "password-one", }) ).json() ).connected, true, ); assert.equal( ( await ( await f.register("two", { endpoints: [f.remotes[1]], password: "password-two", }) ).json() ).connected, true, ); for (const [id, name] of [ ["one", "one"], ["two", "two"], ]) { const reply = await fetch( f.base + `/peers/${id}/files?path=%2Fhome%2Freport`, { headers: { Cookie: f.cookie } }, ); assert.equal(reply.status, 200); assert.equal(reply.headers.get("set-cookie"), null); assert.deepEqual(await reply.json(), { name, url: "/files?path=%2Fhome%2Freport", cookie: `pipelines_session=remote-${name}`, }); } const otherCookie = await f.login(); assert.notEqual(otherCookie, f.cookie); assert.equal( ( await fetch(f.base + "/peers/one/files", { headers: { Cookie: otherCookie }, }) ).status, 401, ); assert.equal( ( await f.register( "one", { endpoints: [f.remotes[0]], password: "password-one" }, f.cookie, "http://evil.test", ) ).status, 403, ); assert.equal( ( await f.register("bad", { endpoints: ["ws://user:secret@localhost/connect"], }) ).status, 400, ); assert.equal( ( await fetch(f.base + "/peers/one//evil.test/files", { headers: { Cookie: f.cookie }, }) ).status, 401, ); assert.equal( ( await fetch(f.base + "/peers/one/other", { headers: { Cookie: f.cookie }, }) ).status, 404, ); assert.equal( f.observations.some((x) => x.cookie === f.cookie), false, ); }); test("file uploads relay to the chosen machine's home folder and other POSTs are refused", async (t) => { const f = await fixture(t); await f.register("one", { endpoints: [f.remotes[0]], password: "password-one", }); const upload = (path, headers = {}) => fetch(f.base + `/peers/one${path}`, { method: "POST", headers: { Cookie: f.cookie, "Content-Type": "text/plain", "X-Pipelines-Upload-Name": "notes%20two.txt", ...headers, }, body: "hello upload", }); const reply = await upload("/files?path=%2Fhome%2Fproject"); assert.equal(reply.status, 200); assert.equal(reply.headers.get("set-cookie"), null); assert.deepEqual(await reply.json(), { name: "one", method: "POST", url: "/files?path=%2Fhome%2Fproject", cookie: "pipelines_session=remote-one", upload: "notes%20two.txt", type: "text/plain", body: "hello upload", }); // The remote never sees a POST the relay does not allow. const before = f.observations.length; assert.equal((await upload("/artifacts/1/2/report.txt")).status, 404); assert.equal((await upload("/discovery")).status, 404); assert.equal(f.observations.length, before); assert.equal( (await upload("/files?path=%2Fhome", { Cookie: await f.login() })).status, 401, ); }); test("websocket relay authenticates the chosen machine without forwarding browser Origin", async (t) => { const f = await fixture(t); await f.register("two", { endpoints: [f.remotes[1]], password: "password-two", }); const result = await new Promise((resolve, reject) => { const req = request( f.base + "/peers/two/connect?endpoint=" + encodeURIComponent(f.remotes[1]), { headers: { Cookie: f.cookie, Origin: f.base, Connection: "Upgrade", Upgrade: "websocket", "Sec-WebSocket-Key": randomBytes(16).toString("base64"), "Sec-WebSocket-Version": "13", }, }, ); req.on("upgrade", (res, socket, head) => { const receive = (chunk) => { socket.destroy(); resolve({ status: res.statusCode, text: chunk.subarray(2).toString() }); }; if (head.length) receive(head); else socket.once("data", receive); }); req.on("response", (res) => reject(new Error(String(res.statusCode)))); req.on("error", reject); req.end(); }); assert.equal(result.status, 101); assert.deepEqual(JSON.parse(result.text), { name: "two" }); const observed = f.observations.find( (x) => x.name === "two" && x.path === "/connect", ); assert.equal(observed.cookie, "pipelines_session=remote-two"); assert.equal(observed.origin, undefined); }); test("removing or changing a profile revokes its previous remote route", async (t) => { const f = await fixture(t); await f.register("server", { endpoints: [f.remotes[0]], password: "password-one", }); await f.register("server", { endpoints: [f.remotes[1]], password: "password-two", }); assert.equal( ( await fetch( f.base + "/peers/server/files?endpoint=" + encodeURIComponent(f.remotes[0]), { headers: { Cookie: f.cookie } }, ) ).status, 401, ); const removed = await fetch(f.base + "/api/peers/server", { method: "DELETE", headers: { Cookie: f.cookie, Origin: f.base }, }); assert.equal(removed.status, 200); assert.equal( ( await fetch(f.base + "/peers/server/files", { headers: { Cookie: f.cookie }, }) ).status, 401, ); }); test("browser discovery is authenticated and served from the hosting machine", async (t) => { const f = await fixture(t); assert.equal((await fetch(f.base + "/api/discovery")).status, 401); const result = await fetch(f.base + "/api/discovery", { headers: { Cookie: f.cookie }, }); assert.equal(result.status, 200); assert.equal( (await result.json()).discovered_servers[0].name, "Linux desktop", ); assert.equal(f.observations.filter((x) => x.path === "/discovery").length, 1); }); test("failed password retry keeps the previous authenticated route and socket", async (t) => { const f = await fixture(t); await f.register("one", { endpoints: [f.remotes[0]], password: "password-one", }); const live = await new Promise((resolve, reject) => { const req = request(f.base + "/peers/one/connect", { headers: { Cookie: f.cookie, Origin: f.base, Connection: "Upgrade", Upgrade: "websocket", "Sec-WebSocket-Key": randomBytes(16).toString("base64"), "Sec-WebSocket-Version": "13", }, }); req.on("upgrade", (res, socket) => resolve(socket)); req.on("response", (res) => reject(new Error(String(res.statusCode)))); req.on("error", reject); req.end(); }); t.after(() => live.destroy()); const failed = await f.register("one", { endpoints: [f.remotes[0]], password: "wrong-password", }); const status = await failed.json(); assert.equal(status.previous_connection_kept, true); assert.equal(status.needs_password, true); const file = await fetch(f.base + "/peers/one/files", { headers: { Cookie: f.cookie }, }); assert.equal(file.status, 200); assert.equal((await file.json()).cookie, "pipelines_session=remote-one"); assert.equal(live.destroyed, false); }); test("changed aliases revoke immediately and late sign-in cannot resurrect a deleted profile", async (t) => { const f = await fixture(t); await f.register("server", { endpoints: [f.remotes[0]], password: "password-one", }); const gate = f.hold("two"); const changing = f.register("server", { endpoints: [f.remotes[1]], password: "password-two", }); await gate.entered; assert.equal( ( await fetch( f.base + "/peers/server/files?endpoint=" + encodeURIComponent(f.remotes[0]), { headers: { Cookie: f.cookie } }, ) ).status, 401, ); await fetch(f.base + "/api/peers/server", { method: "DELETE", headers: { Cookie: f.cookie, Origin: f.base }, }); gate.release(); assert.equal((await changing).status, 409); assert.equal( ( await fetch(f.base + "/peers/server/files", { headers: { Cookie: f.cookie }, }) ).status, 401, ); }); test("expired registry owners are closed and pruned before the capacity check", () => { const registry = new PeerRegistry((req) => req.token); let closed = 0; for (let i = 0; i < 256; i++) registry.sessions.set(String(i), { used: 0, versions: new Map(), peers: new Map([ [ "x", { sockets: new Set([ { destroy() { closed++; }, }, ]), }, ], ]), }); registry.owner({ token: "new-session" }); assert.equal(closed, 256); assert.equal(registry.sessions.size, 1); const before = registry.sessions.size; registry.forget({ token: "unknown-invalid-session" }); assert.equal(registry.sessions.size, before); }); test("raw peer HTML and legacy SVG files retain a local sandbox and no cookie authority", async (t) => { const f = await fixture(t); await f.register("one", { endpoints: [f.remotes[0]], password: "password-one", }); for (const path of [ "/artifacts/7/2/raw.html", "/files?path=%2Fhome%2Funtrusted.svg", ]) { const response = await fetch(f.base + "/peers/one" + path, { headers: { Cookie: f.cookie }, }); assert.equal(response.status, 200); const policy = response.headers.get("content-security-policy"); for (const directive of [ "sandbox;", "default-src 'none'", "script-src 'none'", "connect-src 'none'", "base-uri 'none'", "form-action 'none'", "frame-ancestors 'self'", ]) { assert.ok(policy.includes(directive), directive); } assert.equal(policy.includes("allow-same-origin"), false); assert.equal(policy.includes("allow-scripts"), false); assert.equal(response.headers.get("x-content-type-options"), "nosniff"); assert.equal(response.headers.get("cache-control"), "private, no-store"); assert.equal(response.headers.get("set-cookie"), null); if (path.startsWith("/artifacts/")) assert.ok( policy.includes("img-src 'none'"), "stricter remote policy preserved", ); // The response boundary, not text rewriting, isolates generated documents. assert.match(await response.text(), /