import { endpoint, webOrigin, boundedRequest, remoteRequest, json, } from "./peerTransport.js"; import { PeerRegistry } from "./peerRegistry.js"; // Peer files are untrusted content, never privileged control-UI documents. // Apply this even for older peers whose /files endpoint has no sandbox header. const contentPolicy = "sandbox; default-src 'none'; script-src 'none'; connect-src 'none'; style-src 'unsafe-inline'; img-src 'self' data:; media-src 'self' data:; base-uri 'none'; form-action 'none'; frame-ancestors 'self'"; const allowed = (path) => path === "/files" || path === "/chat-uploads" || path.startsWith("/artifacts/") || path.startsWith("/updates/"); // Raw-body uploads: chat attachments and files stored into a home folder. const postable = (path) => path === "/chat-uploads" || path === "/files"; export class PeerRelay extends PeerRegistry { target(req, path) { const parsed = new URL(req.url, "http://localhost"); const match = /^\/peers\/([^/]+)\/(.*)$/.exec(parsed.pathname); if (!match) return null; const owner = this.owner(req); const peer = owner.peers.get(decodeURIComponent(match[1])); if (!peer) throw new Error("Select and sign in to this server again"); const selected = endpoint( parsed.searchParams.get("endpoint") ?? peer.active, ).href; if (!peer.endpoints.includes(selected) || !peer.cookies.has(selected)) throw new Error("Server address is not signed in"); parsed.searchParams.delete("endpoint"); const url = new URL(path ?? `/${match[2]}`, webOrigin(selected)); url.search = parsed.search; if (url.origin !== webOrigin(selected).origin) throw new Error("Remote origin changed"); return { url, cookie: peer.cookies.get(selected), peer }; } http(req, res) { if (!req.url.startsWith("/peers/")) return false; try { const target = this.target(req); if ( !target || !allowed(target.url.pathname) || !["GET", "HEAD", "POST"].includes(req.method) || (req.method === "POST" && !postable(target.url.pathname)) ) { 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 = {}; 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); } catch { json(res, 401, { error: "Sign in to the remote server again" }); } return true; } upgrade(req, socket, head) { if (!req.url.startsWith("/peers/")) return false; try { const target = this.target(req, "/connect"); const headers = { host: target.url.host, connection: "Upgrade", upgrade: "websocket", "sec-websocket-key": req.headers["sec-websocket-key"], "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), ) .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); }); 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"); } return true; } } export async function proxyDiscovery(req, res, host, port) { try { const response = await boundedRequest( new URL( `http://${host.includes(":") ? `[${host}]` : host}:${port}/discovery`, ), ); res .writeHead(response.status, { "Content-Type": "application/json", "Cache-Control": "no-store", }) .end(response.body); } catch { json(res, 503, { error: "LAN discovery unavailable" }); } }