diff --git a/web/serve.mjs b/web/serve.mjs index 1f8e316d..dc82c191 100644 --- a/web/serve.mjs +++ b/web/serve.mjs @@ -13,8 +13,9 @@ // upgrade whose Origin host does not match the request Host — a browser would // get 403 from a cross-origin page (a Node/curl client sends no Origin and is // unaffected, which is why the smoke test passes). Proxying makes the page -// same-origin, and the Origin header is dropped on the way through because the -// server has no authentication and needs none. +// same-origin, and the Origin header is dropped on the way through (the server +// refuses any /connect carrying Origin). Every request to the server carries the +// shared server token (src/serverToken.js, docs/notes/security-boundary.md). // // The default host is 127.0.0.1. Use --host 0.0.0.0 only on a trusted LAN/VPN. import { createServer, request } from "node:http"; @@ -26,6 +27,7 @@ import { extname, join, normalize, resolve, sep } from "node:path"; import { fileURLToPath } from "node:url"; import net from "node:net"; import { sameOriginUpgrade } from "./src/proxySecurity.js"; +import { withServerToken } from "./src/serverToken.js"; import { PeerRelay, proxyDiscovery } from "./src/peerRelay.js"; // The proxy's own directory holds the sign-in page's icons. @@ -376,7 +378,13 @@ async function serveIndex(res) { * export would all 404 while the WebSocket worked. */ function proxyArtifact(req, res) { - const headers = { ...req.headers }; + let headers; + try { + headers = withServerToken(req.headers); + } catch { + res.writeHead(503, { "Content-Type": "text/plain; charset=utf-8" }).end("Server token unavailable"); + return; + } delete headers.origin; headers.host = `${targetHost}:${targetPort}`; const upstream = request( @@ -543,8 +551,14 @@ const targetPort = Number(pipelinesTarget.split(":").at(-1)); const targetHost = pipelinesTarget.slice(0, pipelinesTarget.lastIndexOf(":")) || "127.0.0.1"; function proxyUpgrade(req, clientSocket, clientHead) { + let headers; + try { + headers = withServerToken(req.headers); + } catch { + clientSocket.end("HTTP/1.1 503 Service Unavailable\r\nContent-Length: 0\r\n\r\n"); + return; + } const upstream = net.connect(targetPort, targetHost, () => { - const headers = { ...req.headers }; delete headers.origin; // see the header comment: the server forbids a mismatched Origin headers.host = `${targetHost}:${targetPort}`; const block = Object.entries(headers) diff --git a/web/src/peerAddress.js b/web/src/peerAddress.js new file mode 100644 index 00000000..7e7f8250 --- /dev/null +++ b/web/src/peerAddress.js @@ -0,0 +1,139 @@ +// Which machines the peer relay may reach (docs/notes/security-boundary.md). +// +// A signed-in browser names other Pipelines machines by URL and this proxy +// fetches /login, /files, /artifacts, /updates and /connect from them, so an +// unrestricted address would let any signed-in user make this machine request +// its own loopback services, link-local cloud metadata or arbitrary hosts. +// Allowed by default: tailnet addresses (100.64.0.0/10 and fd7a:115c:a1e0::/48, +// minus Tailscale's own 100.100.100.100 service), private LANs (RFC 1918 and +// IPv6 unique-local fc00::/7), and public addresses only for *.ts.net names +// (Tailscale Funnel) or hosts this machine's own discovery reported. Loopback, +// unspecified, link-local, metadata, multicast and reserved addresses are always +// refused. PIPELINES_PEER_ALLOW=loopback,public,link-local,metadata (or "any") +// widens the policy explicitly. +// +// A name is resolved once per request and the connection is pinned to the +// checked address (the request's `lookup`), so a DNS answer cannot change +// between the check and the connect (rebinding). +import { lookup as dnsLookup } from "node:dns/promises"; +import net from "node:net"; + +const ALWAYS_REFUSED = new Set(["unspecified", "multicast", "reserved"]); +const OPTIONAL = new Set(["loopback", "public", "link-local", "metadata"]); + +// Hosts the local server's LAN discovery returned (proxyDiscovery), bounded. +export const discoveredHosts = new Set(); +export function rememberDiscovered(body) { + try { + for (const server of JSON.parse(body)?.discovered_servers ?? []) { + const host = new URL(server.endpoint).hostname.toLowerCase(); + if (discoveredHosts.size >= 256) discoveredHosts.delete(discoveredHosts.values().next().value); + discoveredHosts.add(host); + } + } catch {} +} + +function v4(address) { + const parts = address.split(".").map(Number); + return ((parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]) >>> 0; +} +const inV4 = (value, base, bits) => bits === 0 || value >>> (32 - bits) === v4(base) >>> (32 - bits); + +function classifyV4(address) { + const value = v4(address); + if (inV4(value, "0.0.0.0", 8)) return "unspecified"; + if (inV4(value, "127.0.0.0", 8)) return "loopback"; + if (value === v4("169.254.169.254") || value === v4("100.100.100.100")) return "metadata"; + if (inV4(value, "169.254.0.0", 16)) return "link-local"; + if (inV4(value, "100.64.0.0", 10)) return "tailnet"; + if (inV4(value, "10.0.0.0", 8) || inV4(value, "172.16.0.0", 12) || inV4(value, "192.168.0.0", 16)) return "private"; + if (inV4(value, "224.0.0.0", 4)) return "multicast"; + if (inV4(value, "240.0.0.0", 4)) return "reserved"; + return "public"; +} + +// The 8 hextets of an IPv6 literal (already validated by net.isIPv6). +function hextets(address) { + let text = address.toLowerCase().split("%")[0]; + const dotted = /(\d+\.\d+\.\d+\.\d+)$/.exec(text); + if (dotted) { + const value = v4(dotted[1]); + text = text.slice(0, -dotted[1].length) + `${(value >>> 16).toString(16)}:${(value & 0xffff).toString(16)}`; + } + const [head, tail] = text.split("::"); + const left = head ? head.split(":") : []; + const right = tail === undefined ? [] : tail ? tail.split(":") : []; + const fill = tail === undefined ? [] : Array(8 - left.length - right.length).fill("0"); + return [...left, ...fill, ...right].map((part) => parseInt(part, 16)); +} + +function classifyV6(address) { + const h = hextets(address); + if (h.every((part) => part === 0)) return "unspecified"; + if (h.slice(0, 7).every((part) => part === 0) && h[7] === 1) return "loopback"; + if (h.slice(0, 5).every((part) => part === 0) && h[5] === 0xffff) + return classifyV4(`${h[6] >> 8}.${h[6] & 255}.${h[7] >> 8}.${h[7] & 255}`); + if ((h[0] & 0xffc0) === 0xfe80) return "link-local"; + if ((h[0] & 0xff00) === 0xff00) return "multicast"; + if (h[0] === 0xfd7a && h[1] === 0x115c && h[2] === 0xa1e0) + return h.slice(3, 7).every((part) => part === 0) && h[7] === 0x53 ? "metadata" : "tailnet"; + // AWS's IPv6 instance metadata endpoint sits inside the unique-local range. + if (h[0] === 0xfd00 && h[1] === 0x0ec2) return "metadata"; + if ((h[0] & 0xfe00) === 0xfc00) return "private"; + return "public"; +} + +export function classify(address) { + if (net.isIPv4(address)) return classifyV4(address); + if (net.isIPv6(address)) return classifyV6(address); + return "reserved"; +} + +export function allowedCategories(env = process.env) { + const extra = String(env.PIPELINES_PEER_ALLOW ?? "") + .split(",") + .map((value) => value.trim().toLowerCase()) + .filter(Boolean); + const any = extra.includes("any"); + return new Set(["tailnet", "private", ...(any ? OPTIONAL : extra.filter((value) => OPTIONAL.has(value)))]); +} + +export class PeerAddressError extends Error {} + +export class PeerAddressPolicy { + constructor({ env = process.env, lookup = dnsLookup, discovered = discoveredHosts } = {}) { + this.allowed = allowedCategories(env); + this.lookup = lookup; + this.discovered = discovered; + } + permits(hostname, category) { + if (ALWAYS_REFUSED.has(category)) return false; + if (this.allowed.has(category)) return true; + if (category !== "public") return false; + return hostname.endsWith(".ts.net") || this.discovered.has(hostname); + } + // Resolve once, check every answer, and return a `lookup` that pins the + // request's connection to the first checked address. + async pin(url) { + const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase(); + const answers = net.isIP(hostname) + ? [{ address: hostname, family: net.isIP(hostname) }] + : await this.lookup(hostname, { all: true, verbatim: true }); + if (!answers.length) throw new PeerAddressError("Server address did not resolve"); + for (const { address } of answers) { + const category = classify(address); + if (!this.permits(hostname, category)) + throw new PeerAddressError(`Server address is not allowed (${category})`); + } + const { address, family } = answers[0]; + return { + address, + family, + lookup: (_name, options, callback) => { + const done = typeof options === "function" ? options : callback; + if (options?.all) done(null, [{ address, family }]); + else done(null, address, family); + }, + }; + } +} diff --git a/web/src/peerRegistry.js b/web/src/peerRegistry.js index 6af2a649..a6f65ca9 100644 --- a/web/src/peerRegistry.js +++ b/web/src/peerRegistry.js @@ -1,6 +1,12 @@ import { createHash } from "node:crypto"; import { authenticate, endpoint, json } from "./peerTransport.js"; import { sameOriginUpgrade } from "./proxySecurity.js"; +import { PeerAddressError, PeerAddressPolicy } from "./peerAddress.js"; + +// A password or session cookie sent to a ws:// endpoint crosses the network +// unencrypted (unless the path is a tailnet's WireGuard tunnel); the response +// says so, so the app can warn before the operator types a password. +const plaintext = (urls) => urls.some((url) => url.startsWith("ws:")); async function body(req) { const chunks = []; @@ -14,8 +20,9 @@ async function body(req) { } export class PeerRegistry { - constructor(scopeFor) { + constructor(scopeFor, policy = new PeerAddressPolicy()) { this.scopeFor = scopeFor; + this.policy = policy; this.sessions = new Map(); } owner(req) { @@ -82,6 +89,7 @@ export class PeerRegistry { json(res, 200, { connected: Boolean(peer?.connected), needs_password: !peer?.connected, + ...(peer && plaintext([peer.active]) ? { insecure_transport: true } : {}), }); return true; } @@ -113,6 +121,24 @@ export class PeerRegistry { urls.every((url) => previous.endpoints.includes(url)); const version = (owner.versions.get(id) ?? 0) + 1; owner.versions.set(id, version); + // Every address is checked (and its DNS answer pinned) before any + // request leaves this machine; a refused address is never contacted. + const pins = new Map(); + const refused = []; + await Promise.all( + urls.map(async (value) => { + try { + pins.set(value, await this.policy.pin(new URL(value))); + } catch (error) { + if (error instanceof PeerAddressError) + refused.push({ endpoint: value, error: error.message }); + } + }), + ); + if (refused.length === urls.length) { + json(res, 400, { error: refused[0].error, refused_endpoints: refused }); + return true; + } if (previous && !sameEndpoints) { for (const socket of previous.sockets) socket.destroy(); owner.peers.delete(id); @@ -127,6 +153,8 @@ export class PeerRegistry { const results = await Promise.all( urls.map(async (value) => { try { + const pin = pins.get(value); + if (!pin) return { connected: false, needs_password: false }; const old = previous?.endpoints.includes(value) ? (previous.cookies.get(value) ?? "") : ""; @@ -134,6 +162,7 @@ export class PeerRegistry { new URL(value), old, data.password, + pin.lookup, ); if (status.connected) { peer.cookies.set(value, status.cookie); @@ -163,6 +192,8 @@ export class PeerRegistry { owner.peers.set(id, peer); json(res, 200, { connected_endpoints: [...peer.cookies.keys()], + ...(plaintext(urls) ? { insecure_transport: true } : {}), + ...(refused.length ? { refused_endpoints: refused } : {}), connected: peer.connected, needs_password: !peer.connected && results.some((r) => r.needs_password), diff --git a/web/src/peerRelay.js b/web/src/peerRelay.js index 18525a84..77708ac3 100644 --- a/web/src/peerRelay.js +++ b/web/src/peerRelay.js @@ -6,6 +6,8 @@ import { json, } from "./peerTransport.js"; import { PeerRegistry } from "./peerRegistry.js"; +import { withServerToken } from "./serverToken.js"; +import { rememberDiscovered } from "./peerAddress.js"; // Peer files are untrusted content, never privileged control-UI documents. // Apply this even for older peers whose /files endpoint has no sandbox header. @@ -39,6 +41,22 @@ export class PeerRelay extends PeerRegistry { throw new Error("Remote origin changed"); return { url, cookie: peer.cookies.get(selected), peer }; } + // Resolve the peer once for this request, check the answer against the + // address policy (peerAddress.js) and connect only to that address. + pinned(target, reply, send) { + this.policy + .pin(target.url) + .then((pin) => { + if (!reply.destroyed) send(pin.lookup); + }) + .catch(() => { + if (typeof reply.writeHead !== "function") + reply.end("HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n"); + else if (!reply.headersSent) + json(reply, 403, { error: "Server address is not allowed" }); + else reply.destroy(); + }); + } http(req, res) { if (!req.url.startsWith("/peers/")) return false; try { @@ -52,59 +70,62 @@ export class PeerRelay extends PeerRegistry { json(res, 404, { error: "Unsupported remote resource" }); return true; } - const headers = { ...(target.cookie ? { cookie: target.cookie } : {}) }; - for (const name of [ - "content-type", - "content-length", - "range", - "x-file-name", - "x-upload-name", - "x-chat-file-name", - "x-pipelines-upload-name", - ]) - if (req.headers[name]) headers[name] = req.headers[name]; - const upstream = remoteRequest(target.url, { - method: req.method, - headers, - }); - upstream.setTimeout(30000, () => upstream.destroy()); - upstream.on("response", (response) => { - const safe = {}; + this.pinned(target, res, (lookup) => { + const headers = { ...(target.cookie ? { cookie: target.cookie } : {}) }; for (const name of [ "content-type", "content-length", - "content-range", - "accept-ranges", - "content-disposition", + "range", + "x-file-name", + "x-upload-name", + "x-chat-file-name", + "x-pipelines-upload-name", ]) - if (response.headers[name]) safe[name] = response.headers[name]; - res.writeHead( - response.statusCode >= 300 && response.statusCode < 400 - ? 502 - : response.statusCode, - { - ...safe, - "Cache-Control": "private, no-store", - // Multiple CSP policies intersect: preserve a peer's stricter - // restrictions while always imposing the local sandbox boundary. - "Content-Security-Policy": response.headers[ - "content-security-policy" - ] - ? [response.headers["content-security-policy"], contentPolicy] - : contentPolicy, - "X-Content-Type-Options": "nosniff", - }, - ); - response.pipe(res); + if (req.headers[name]) headers[name] = req.headers[name]; + const upstream = remoteRequest(target.url, { + method: req.method, + lookup, + headers, + }); + upstream.setTimeout(30000, () => upstream.destroy()); + upstream.on("response", (response) => { + const safe = {}; + for (const name of [ + "content-type", + "content-length", + "content-range", + "accept-ranges", + "content-disposition", + ]) + if (response.headers[name]) safe[name] = response.headers[name]; + res.writeHead( + response.statusCode >= 300 && response.statusCode < 400 + ? 502 + : response.statusCode, + { + ...safe, + "Cache-Control": "private, no-store", + // Multiple CSP policies intersect: preserve a peer's stricter + // restrictions while always imposing the local sandbox boundary. + "Content-Security-Policy": response.headers[ + "content-security-policy" + ] + ? [response.headers["content-security-policy"], contentPolicy] + : contentPolicy, + "X-Content-Type-Options": "nosniff", + }, + ); + response.pipe(res); + }); + upstream.on("error", () => { + if (!res.headersSent) + json(res, 502, { error: "Remote server unavailable" }); + else res.destroy(); + }); + req.on("aborted", () => upstream.destroy()); + res.on("close", () => upstream.destroy()); + req.pipe(upstream); }); - upstream.on("error", () => { - if (!res.headersSent) - json(res, 502, { error: "Remote server unavailable" }); - else res.destroy(); - }); - req.on("aborted", () => upstream.destroy()); - res.on("close", () => upstream.destroy()); - req.pipe(upstream); } catch { json(res, 401, { error: "Sign in to the remote server again" }); } @@ -122,47 +143,49 @@ export class PeerRelay extends PeerRegistry { "sec-websocket-version": "13", ...(target.cookie ? { cookie: target.cookie } : {}), }; - const upstream = remoteRequest(target.url, { headers }); - upstream.setTimeout(10000, () => upstream.destroy()); - upstream.on("upgrade", (response, remote, remoteHead) => { - socket.write( - `HTTP/1.1 101 Switching Protocols\r\n${Object.entries( - response.headers, - ) - .filter(([k]) => - [ - "upgrade", - "connection", - "sec-websocket-accept", - "sec-websocket-protocol", - ].includes(k), + this.pinned(target, socket, (lookup) => { + const upstream = remoteRequest(target.url, { headers, lookup }); + upstream.setTimeout(10000, () => upstream.destroy()); + upstream.on("upgrade", (response, remote, remoteHead) => { + socket.write( + `HTTP/1.1 101 Switching Protocols\r\n${Object.entries( + response.headers, ) - .map(([k, v]) => `${k}: ${v}`) - .join("\r\n")}\r\n\r\n`, - ); - target.peer.sockets.add(socket); - remote.setTimeout(0); - socket.once("close", () => { - target.peer.sockets.delete(socket); - remote.destroy(); + .filter(([k]) => + [ + "upgrade", + "connection", + "sec-websocket-accept", + "sec-websocket-protocol", + ].includes(k), + ) + .map(([k, v]) => `${k}: ${v}`) + .join("\r\n")}\r\n\r\n`, + ); + target.peer.sockets.add(socket); + remote.setTimeout(0); + socket.once("close", () => { + target.peer.sockets.delete(socket); + remote.destroy(); + }); + remote.once("close", () => socket.destroy()); + socket.on("error", () => remote.destroy()); + remote.on("error", () => socket.destroy()); + if (head?.length) remote.write(head); + if (remoteHead?.length) socket.write(remoteHead); + remote.pipe(socket); + socket.pipe(remote); }); - remote.once("close", () => socket.destroy()); - socket.on("error", () => remote.destroy()); - remote.on("error", () => socket.destroy()); - if (head?.length) remote.write(head); - if (remoteHead?.length) socket.write(remoteHead); - remote.pipe(socket); - socket.pipe(remote); + upstream.on("response", (response) => { + response.resume(); + socket.end( + `HTTP/1.1 ${response.statusCode === 401 ? 401 : 502} Remote Unavailable\r\nContent-Length: 0\r\n\r\n`, + ); + }); + upstream.on("error", () => socket.destroy()); + socket.once("close", () => upstream.destroy()); + upstream.end(); }); - upstream.on("response", (response) => { - response.resume(); - socket.end( - `HTTP/1.1 ${response.statusCode === 401 ? 401 : 502} Remote Unavailable\r\nContent-Length: 0\r\n\r\n`, - ); - }); - upstream.on("error", () => socket.destroy()); - socket.once("close", () => upstream.destroy()); - upstream.end(); } catch { socket.end("HTTP/1.1 401 Unauthorized\r\nContent-Length: 0\r\n\r\n"); } @@ -176,7 +199,9 @@ export async function proxyDiscovery(req, res, host, port) { new URL( `http://${host.includes(":") ? `[${host}]` : host}:${port}/discovery`, ), + { headers: withServerToken({}) }, ); + if (response.status === 200) rememberDiscovered(response.body); res .writeHead(response.status, { "Content-Type": "application/json", diff --git a/web/src/peerTransport.js b/web/src/peerTransport.js index ffcbc2f7..61a422e0 100644 --- a/web/src/peerTransport.js +++ b/web/src/peerTransport.js @@ -28,12 +28,14 @@ export function remoteRequest(url, options = {}) { // Never follows redirects or sends local browser cookies to another machine. export function boundedRequest( url, - { method = "GET", cookie = "", body = "", headers = {} } = {}, + { method = "GET", cookie = "", body = "", headers = {}, lookup } = {}, ) { return new Promise((resolve, reject) => { const request = remoteRequest(url, { method, headers: { ...headers, ...(cookie ? { Cookie: cookie } : {}) }, + // A pinned peer address (peerAddress.js) is connected to directly. + ...(lookup ? { lookup } : {}), }); const timer = setTimeout( () => request.destroy(new Error("Server timed out")), @@ -79,7 +81,7 @@ export function sessionCookie(response) { .join("; "); } -export async function authenticate(url, cookie, password) { +export async function authenticate(url, cookie, password, lookup) { const login = new URL("/login", webOrigin(url)); let response; if (password !== undefined) { @@ -88,6 +90,7 @@ export async function authenticate(url, cookie, password) { method: "POST", body, cookie, + lookup, headers: { "Content-Type": "application/x-www-form-urlencoded", "Content-Length": Buffer.byteLength(body), @@ -99,7 +102,7 @@ export async function authenticate(url, cookie, password) { return { connected: false, needs_password: true, cookie: "" }; } } - response = await boundedRequest(login, { cookie }); + response = await boundedRequest(login, { cookie, lookup }); if ([302, 303].includes(response.status)) return { connected: true, needs_password: false, cookie }; if ( @@ -111,7 +114,7 @@ export async function authenticate(url, cookie, password) { if (response.status === 200) return { connected: true, needs_password: false, cookie }; if (response.status === 404) { - const health = await boundedRequest(new URL("/healthz", webOrigin(url))); + const health = await boundedRequest(new URL("/healthz", webOrigin(url)), { lookup }); if (health.status === 200 && JSON.parse(health.body)?.healthy === true) return { connected: true, needs_password: false, cookie: "" }; } diff --git a/web/src/serverToken.js b/web/src/serverToken.js new file mode 100644 index 00000000..490974c8 --- /dev/null +++ b/web/src/serverToken.js @@ -0,0 +1,48 @@ +// The shared secret between this proxy and the local Pipelines server +// (internal/servertoken, docs/notes/security-boundary.md). The installer writes +// it to a private file beside web-auth.json; the server, when configured with +// it, refuses any request without it. Only requests to the local upstream carry +// it: the peer relay never forwards it to another machine. +import { lstatSync, readFileSync } from "node:fs"; +import { homedir } from "node:os"; +import { join } from "node:path"; + +export const SERVER_TOKEN_HEADER = "x-pipelines-token"; + +export function serverTokenPath(env = process.env) { + if (env.PIPELINES_SERVER_TOKEN_FILE) return env.PIPELINES_SERVER_TOKEN_FILE; + return join(env.XDG_CONFIG_HOME || join(homedir(), ".config"), "pipelines", "server-token"); +} + +let cached = { key: "", token: "" }; + +// The token, re-read when the file changes; "" when no file exists. A file +// another user could read or replace is refused (same rule as the Go reader). +export function serverToken(path = serverTokenPath()) { + let info; + try { + info = lstatSync(path); + } catch { + return ""; + } + if (!info.isFile()) throw new Error(`server token ${path} is not a regular file`); + if (typeof process.getuid === "function" && (info.uid !== process.getuid() || info.mode & 0o077)) + throw new Error(`server token ${path} must be owned by this user and private (chmod 600)`); + const key = `${path}:${info.ino}:${info.mtimeMs}:${info.size}`; + if (cached.key !== key) { + const token = readFileSync(path, "utf8").trim(); + if (token.length < 32 || /\s/.test(token)) throw new Error(`server token ${path} is malformed`); + cached = { key, token }; + } + return cached.token; +} + +// Headers for the local upstream: any client-supplied token is dropped and the +// proxy's own is set, so the browser never chooses what the server sees. +export function withServerToken(headers, token = serverToken()) { + const result = { ...headers }; + for (const name of Object.keys(result)) + if (name.toLowerCase() === SERVER_TOKEN_HEADER) delete result[name]; + if (token) result[SERVER_TOKEN_HEADER] = token; + return result; +} diff --git a/web/test/peerAddress.test.mjs b/web/test/peerAddress.test.mjs new file mode 100644 index 00000000..ebe5ece6 --- /dev/null +++ b/web/test/peerAddress.test.mjs @@ -0,0 +1,175 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createServer } from "node:http"; +import { once } from "node:events"; +import { spawn } from "node:child_process"; +import { mkdtemp, writeFile, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { fileURLToPath } from "node:url"; +import { classify, PeerAddressPolicy, PeerAddressError } from "../src/peerAddress.js"; +import { remoteRequest } from "../src/peerTransport.js"; + +const fakeDns = (answers) => { + const calls = []; + const lookup = async (name) => { + calls.push(name); + const value = answers[name]; + return Array.isArray(value) ? value : value === undefined ? [] : [value]; + }; + return { lookup, calls }; +}; +const v4 = (address) => ({ address, family: 4 }); +const v6 = (address) => ({ address, family: 6 }); + +test("addresses are classified by range", () => { + const cases = { + "127.0.0.1": "loopback", "127.8.9.10": "loopback", "::1": "loopback", "::ffff:127.0.0.1": "loopback", + "0.0.0.0": "unspecified", "::": "unspecified", + "169.254.169.254": "metadata", "100.100.100.100": "metadata", "fd7a:115c:a1e0::53": "metadata", "fd00:ec2::254": "metadata", + "169.254.10.1": "link-local", "fe80::1": "link-local", + "100.64.0.1": "tailnet", "100.127.255.254": "tailnet", "fd7a:115c:a1e0:ab12::1": "tailnet", + "10.1.2.3": "private", "172.16.0.1": "private", "172.31.255.255": "private", "192.168.1.2": "private", "fd12:3456::1": "private", + "172.32.0.1": "public", "100.128.0.1": "public", "8.8.8.8": "public", "2606:4700::1111": "public", "::ffff:8.8.8.8": "public", + "224.0.0.251": "multicast", "ff02::fb": "multicast", "255.255.255.255": "reserved", + }; + for (const [address, category] of Object.entries(cases)) assert.equal(classify(address), category, address); +}); + +test("loopback, metadata, link-local and public peers are refused by default", async () => { + const dns = fakeDns({ "evil.example": v4("127.0.0.1"), "public.example": v4("93.184.216.34") }); + const policy = new PeerAddressPolicy({ env: {}, lookup: dns.lookup, discovered: new Set() }); + for (const url of [ + "ws://127.0.0.1:8080/connect", "ws://localhost.:8080/connect", "ws://[::1]:8083/connect", + "ws://169.254.169.254/connect", "ws://[fe80::1]:8083/connect", "ws://0.0.0.0:8083/connect", + "ws://100.100.100.100/connect", "ws://evil.example:8083/connect", "ws://public.example:8083/connect", + "ws://8.8.8.8:8083/connect", "ws://unresolved.example/connect", + ]) { + await assert.rejects(policy.pin(new URL(url)), PeerAddressError, url); + } +}); + +test("tailnet, LAN, ts.net and discovered peers are accepted", async () => { + const dns = fakeDns({ + "box.tail1234.ts.net": v4("100.101.102.103"), + "funnel.tail1234.ts.net": v4("203.0.113.9"), + "desktop.local": [v4("192.168.1.20"), v6("fd12::20")], + "lab.example": v4("198.51.100.7"), + }); + const policy = new PeerAddressPolicy({ env: {}, lookup: dns.lookup, discovered: new Set(["lab.example"]) }); + for (const [url, address] of [ + ["ws://100.64.1.2:8083/connect", "100.64.1.2"], + ["wss://box.tail1234.ts.net/connect", "100.101.102.103"], + ["wss://funnel.tail1234.ts.net/connect", "203.0.113.9"], + ["ws://desktop.local:8083/connect", "192.168.1.20"], + ["ws://10.0.0.75:8083/connect", "10.0.0.75"], + ["ws://[fd7a:115c:a1e0::1]:8083/connect", "fd7a:115c:a1e0::1"], + ["ws://lab.example:8083/connect", "198.51.100.7"], + ]) + assert.equal((await policy.pin(new URL(url))).address, address, url); + // A name that also resolves to a refused address is refused outright. + const mixed = new PeerAddressPolicy({ env: {}, lookup: fakeDns({ "mixed.local": [v4("192.168.1.2"), v4("127.0.0.1")] }).lookup }); + await assert.rejects(mixed.pin(new URL("ws://mixed.local/connect")), PeerAddressError); + // Discovery never unlocks loopback or metadata. + const discovered = new PeerAddressPolicy({ env: {}, lookup: fakeDns({ "self.local": v4("127.0.0.1") }).lookup, discovered: new Set(["self.local"]) }); + await assert.rejects(discovered.pin(new URL("ws://self.local/connect")), PeerAddressError); +}); + +test("PIPELINES_PEER_ALLOW widens the policy explicitly", async () => { + const loopback = new PeerAddressPolicy({ env: { PIPELINES_PEER_ALLOW: "loopback" } }); + assert.equal((await loopback.pin(new URL("ws://127.0.0.1:1/connect"))).address, "127.0.0.1"); + await assert.rejects(loopback.pin(new URL("ws://169.254.169.254/connect")), PeerAddressError); + const any = new PeerAddressPolicy({ env: { PIPELINES_PEER_ALLOW: "any" } }); + assert.equal((await any.pin(new URL("ws://169.254.169.254/connect"))).address, "169.254.169.254"); + await assert.rejects(any.pin(new URL("ws://0.0.0.0/connect")), PeerAddressError); +}); + +test("the checked DNS answer is pinned for the request (no rebinding)", async (t) => { + const answers = { "peer.example": v4("192.168.1.9") }; + const dns = fakeDns(answers); + const policy = new PeerAddressPolicy({ env: {}, lookup: dns.lookup }); + const pin = await policy.pin(new URL("ws://peer.example:8083/connect")); + // The name now "rebinds" to loopback; the pinned lookup still answers the checked address. + answers["peer.example"] = v4("127.0.0.1"); + const one = await new Promise((done) => pin.lookup("peer.example", {}, (e, a, f) => done([a, f]))); + const all = await new Promise((done) => pin.lookup("peer.example", { all: true }, (e, list) => done(list))); + assert.deepEqual(one, ["192.168.1.9", 4]); + assert.deepEqual(all, [{ address: "192.168.1.9", family: 4 }]); + assert.deepEqual(dns.calls, ["peer.example"]); + // A real request connects to the pinned address while naming the original host. + const server = createServer((req, res) => res.end(req.headers.host)); + server.listen(0, "127.0.0.1"); + await once(server, "listening"); + t.after(() => server.close()); + const port = server.address().port; + const pinnedLoopback = await new PeerAddressPolicy({ env: { PIPELINES_PEER_ALLOW: "loopback" }, lookup: fakeDns({ "never-resolves.invalid": v4("127.0.0.1") }).lookup }) + .pin(new URL(`ws://never-resolves.invalid:${port}/connect`)); + const host = await new Promise((done, fail) => { + const request = remoteRequest(new URL(`http://never-resolves.invalid:${port}/`), { lookup: pinnedLoopback.lookup }); + request.on("response", async (response) => { + let body = ""; + for await (const chunk of response) body += chunk; + done(body); + }); + request.on("error", fail); + request.end(); + }); + assert.equal(host, `never-resolves.invalid:${port}`); +}); + +test("the relay refuses a loopback peer without contacting it and flags plain http", async (t) => { + const seen = []; + const remote = createServer((req, res) => { + seen.push(req.url); + res.writeHead(302, { Location: "/" }).end(); + }); + remote.listen(0, "127.0.0.1"); + await once(remote, "listening"); + t.after(() => remote.close()); + const dir = await mkdtemp(join(tmpdir(), "peer-address-")); + 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 start = async (allow) => { + const child = spawn(process.execPath, ["serve.mjs", "--port", String(port), "--pipelines", `127.0.0.1:${remote.address().port}`], { + cwd: fileURLToPath(new URL("..", import.meta.url)), + env: { ...process.env, PIPELINES_WEB_AUTH: "", PIPELINES_WEB_AUTH_FILE: auth, PIPELINES_PEER_ALLOW: allow, PIPELINES_SERVER_TOKEN_FILE: join(dir, "absent") }, + stdio: ["ignore", "pipe", "inherit"], + }); + await once(child.stdout, "data"); + const base = `http://127.0.0.1:${port}`; + const login = await fetch(base + "/login", { method: "POST", body: new URLSearchParams({ password: "local-password" }), redirect: "manual" }); + const cookie = login.headers.get("set-cookie").split(";")[0]; + const register = (endpoints) => + fetch(base + "/api/peers/p", { + method: "POST", + headers: { Cookie: cookie, Origin: base, "Content-Type": "application/json" }, + body: JSON.stringify({ endpoints, password: "remote-password" }), + }); + return { child, register }; + }; + const strict = await start(""); + for (const endpoint of [`ws://127.0.0.1:${remote.address().port}/connect`, "ws://169.254.169.254/connect", `ws://[::1]:${remote.address().port}/connect`]) { + const reply = await strict.register([endpoint]); + assert.equal(reply.status, 400, endpoint); + const body = await reply.json(); + assert.match(body.error, /not allowed/); + assert.equal(body.refused_endpoints[0].endpoint, endpoint); + } + assert.deepEqual(seen, []); + const stopped = once(strict.child, "exit"); + strict.child.kill(); + await stopped; + const allowed = await start("loopback"); + t.after(() => allowed.child.kill()); + const reply = await allowed.register([`ws://127.0.0.1:${remote.address().port}/connect`]); + const body = await reply.json(); + assert.equal(reply.status, 200); + assert.equal(body.connected, true); + assert.equal(body.insecure_transport, true); + assert.ok(seen.includes("/login")); +}); diff --git a/web/test/peerRelay.test.mjs b/web/test/peerRelay.test.mjs index 77aa60e7..e6cabd53 100644 --- a/web/test/peerRelay.test.mjs +++ b/web/test/peerRelay.test.mjs @@ -175,6 +175,8 @@ async function fixture(t) { ...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"], }, diff --git a/web/test/serverToken.test.mjs b/web/test/serverToken.test.mjs new file mode 100644 index 00000000..1715f274 --- /dev/null +++ b/web/test/serverToken.test.mjs @@ -0,0 +1,109 @@ +import test from "node:test"; +import assert from "node:assert/strict"; +import { createServer, request } from "node:http"; +import { createHash } from "node:crypto"; +import { once } from "node:events"; +import { spawn } from "node:child_process"; +import { mkdtemp, writeFile, chmod, rm } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { fileURLToPath } from "node:url"; +import { serverToken, withServerToken } from "../src/serverToken.js"; + +const TOKEN = "proxy-token-0123456789abcdef0123456789abcdef"; + +async function freePort() { + 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)); + return port; +} + +test("the token file must be private and is never taken from the client", async (t) => { + const dir = await mkdtemp(join(tmpdir(), "server-token-")); + t.after(() => rm(dir, { recursive: true, force: true })); + const path = join(dir, "server-token"); + assert.equal(serverToken(path), ""); + await writeFile(path, TOKEN + "\n", { mode: 0o600 }); + await chmod(path, 0o600); + assert.equal(serverToken(path), TOKEN); + await chmod(path, 0o644); + assert.throws(() => serverToken(path), /private/); + assert.deepEqual(withServerToken({ "X-Pipelines-Token": "browser-chosen", a: "b" }, TOKEN), { a: "b", "x-pipelines-token": TOKEN }); + assert.deepEqual(withServerToken({ "x-pipelines-token": "browser-chosen" }, ""), {}); +}); + +test("the proxy sends the server token on every upstream request and the relay never forwards it", async (t) => { + const dir = await mkdtemp(join(tmpdir(), "server-token-")); + t.after(() => rm(dir, { recursive: true, force: true })); + const tokenFile = join(dir, "server-token"); + await writeFile(tokenFile, TOKEN, { mode: 0o600 }); + await chmod(tokenFile, 0o600); + const seen = []; + const upstream = createServer((req, res) => { + seen.push({ path: req.url.split("?")[0], token: req.headers["x-pipelines-token"], host: req.headers.host, origin: req.headers.origin }); + if (req.url === "/discovery") { + res.setHeader("Content-Type", "application/json"); + res.end(JSON.stringify({ discovered_servers: [] })); + return; + } + if (req.url === "/login") { + res.writeHead(302, { Location: "/" }).end(); + return; + } + res.end("ok"); + }); + upstream.on("upgrade", (req, socket) => { + seen.push({ path: req.url, token: req.headers["x-pipelines-token"], host: req.headers.host, origin: req.headers.origin }); + const accept = createHash("sha1").update(req.headers["sec-websocket-key"] + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").digest("base64"); + socket.end(`HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: ${accept}\r\n\r\n`); + }); + upstream.listen(0, "127.0.0.1"); + await once(upstream, "listening"); + t.after(() => { upstream.closeAllConnections(); upstream.close(); }); + const upstreamHost = `127.0.0.1:${upstream.address().port}`; + const port = await freePort(); + const child = spawn(process.execPath, ["serve.mjs", "--port", String(port), "--pipelines", upstreamHost], { + cwd: fileURLToPath(new URL("..", import.meta.url)), + env: { ...process.env, PIPELINES_WEB_AUTH: "disabled", PIPELINES_SERVER_TOKEN_FILE: tokenFile, PIPELINES_PEER_ALLOW: "loopback" }, + stdio: ["ignore", "pipe", "inherit"], + }); + t.after(() => child.kill()); + await once(child.stdout, "data"); + const base = `http://127.0.0.1:${port}`; + const forged = { "X-Pipelines-Token": "browser-chosen" }; + assert.equal((await fetch(`${base}/files?path=a.txt`, { headers: forged })).status, 200); + assert.equal((await fetch(`${base}/artifacts/1/1/a.txt`, { headers: forged })).status, 200); + assert.equal((await fetch(`${base}/chat-uploads`, { method: "POST", headers: forged, body: "x" })).status, 200); + assert.equal((await fetch(`${base}/api/discovery`, { headers: forged })).status, 200); + const upgraded = await new Promise((done, fail) => { + const req = request(`${base}/connect`, { + headers: { Connection: "Upgrade", Upgrade: "websocket", "Sec-WebSocket-Version": "13", "Sec-WebSocket-Key": "dGhlIHNhbXBsZSBub25jZQ==", Origin: base, ...forged }, + }); + req.on("upgrade", (response, socket) => { socket.destroy(); done(response.statusCode); }); + req.on("response", (response) => done(response.statusCode)); + req.on("error", fail); + req.end(); + }); + assert.equal(upgraded, 101); + const local = seen.filter((entry) => entry.path !== "/login"); + assert.deepEqual(local.map((entry) => entry.path), ["/files", "/artifacts/1/1/a.txt", "/chat-uploads", "/discovery", "/connect"]); + for (const entry of local) { + assert.equal(entry.token, TOKEN, entry.path); + assert.equal(entry.host, upstreamHost, entry.path); + assert.equal(entry.origin, undefined, entry.path); + } + // A peer machine (here the same fixture, reached through the relay) never + // receives this machine's server token. + seen.length = 0; + const reg = await fetch(`${base}/api/peers/peer`, { + method: "POST", + headers: { Origin: base, "Content-Type": "application/json" }, + body: JSON.stringify({ endpoints: [`ws://${upstreamHost}/connect`] }), + }); + assert.equal((await reg.json()).connected, true); + assert.equal((await fetch(`${base}/peers/peer/files?path=a.txt`, { headers: forged })).status, 200); + assert.ok(seen.length >= 2); + for (const entry of seen) assert.equal(entry.token, undefined, entry.path); +});