547d4d9822
The proxy adds the shared token to every upstream request and drops any client copy. The peer relay accepts only tailnet, LAN, ts.net and discovered hosts, resolves each name once and pins the checked address, and flags ws:// endpoints with insecure_transport.
212 lines
7.3 KiB
JavaScript
212 lines
7.3 KiB
JavaScript
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;
|
|
}
|
|
}
|