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 = []; let size = 0; for await (const chunk of req) { size += chunk.length; if (size > 65536) throw new Error("Request too large"); chunks.push(chunk); } return JSON.parse(Buffer.concat(chunks).toString("utf8")); } export class PeerRegistry { constructor(scopeFor, policy = new PeerAddressPolicy()) { this.scopeFor = scopeFor; this.policy = policy; this.sessions = new Map(); } owner(req) { const token = this.scopeFor(req); if (!token) throw new Error("Sign in first"); const key = createHash("sha256").update(token).digest("hex"); for (const [old, value] of this.sessions) { if (Date.now() - value.used > 12 * 3600000) { for (const peer of value.peers.values()) for (const socket of peer.sockets) socket.destroy(); this.sessions.delete(old); } } if (!this.sessions.has(key)) { if (this.sessions.size >= 256) throw new Error("Too many browser sessions"); this.sessions.set(key, { peers: new Map(), versions: new Map(), used: Date.now(), }); } const owner = this.sessions.get(key); owner.used = Date.now(); return owner; } forget(req) { try { const token = this.scopeFor(req); if (!token) return; const key = createHash("sha256").update(token).digest("hex"); const owner = this.sessions.get(key); if (!owner) return; for (const peer of owner.peers.values()) for (const socket of peer.sockets) socket.destroy(); this.sessions.delete(key); } catch {} } async api(req, res) { const parsed = new URL(req.url, "http://localhost"); const match = /^\/api\/peers\/([^/]+)$/.exec(parsed.pathname); if (!match) return false; if ( !sameOriginUpgrade(req.headers.origin, req.headers.host) || (["POST", "DELETE"].includes(req.method) && !req.headers.origin) ) { json(res, 403, { error: "Same-origin request required" }); return true; } try { const id = decodeURIComponent(match[1]); if (!id || id.length > 256) throw new Error("Invalid server id"); const owner = this.owner(req); if (req.method === "DELETE") { owner.versions.set(id, (owner.versions.get(id) ?? 0) + 1); const previous = owner.peers.get(id); if (previous) for (const socket of previous.sockets) socket.destroy(); owner.peers.delete(id); json(res, 200, { connected: false, needs_password: false }); return true; } if (req.method === "GET") { const peer = owner.peers.get(id); json(res, 200, { connected: Boolean(peer?.connected), needs_password: !peer?.connected, ...(peer && plaintext([peer.active]) ? { insecure_transport: true } : {}), }); return true; } if ( req.method !== "POST" || !String(req.headers["content-type"]).startsWith("application/json") ) { json(res, 405, { error: "POST JSON required" }); return true; } const data = await body(req); if ( !Array.isArray(data.endpoints) || data.endpoints.length < 1 || data.endpoints.length > 8 || (data.password !== undefined && (typeof data.password !== "string" || data.password.length > 4096)) ) throw new Error("Invalid server addresses"); const urls = [ ...new Set(data.endpoints.map((value) => endpoint(value).href)), ]; const previous = owner.peers.get(id); if (!previous && owner.peers.size >= 64) throw new Error("Too many saved servers"); const sameEndpoints = previous && previous.endpoints.length === urls.length && 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); } const peer = { endpoints: urls, cookies: new Map(), sockets: new Set(), connected: false, active: urls[0], }; 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) ?? "") : ""; const status = await authenticate( new URL(value), old, data.password, pin.lookup, ); if (status.connected) { peer.cookies.set(value, status.cookie); peer.active = value; peer.connected = true; } return status; } catch { return { connected: false, needs_password: false }; } }), ); if (owner.versions.get(id) !== version) { json(res, 409, { error: "Server selection changed during sign-in" }); return true; } if (sameEndpoints && !peer.connected) { json(res, 200, { connected: false, needs_password: results.some((r) => r.needs_password), previous_connection_kept: true, error: "Sign-in failed. The existing connection was kept.", }); return true; } if (sameEndpoints) peer.sockets = previous.sockets; 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), ...(!peer.connected && !results.some((r) => r.needs_password) ? { error: "Server could not be reached" } : {}), }); } catch { json(res, 400, { error: "Server registration failed. Check the addresses and sign-in.", }); } return true; } }