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.
110 lines
5.4 KiB
JavaScript
110 lines
5.4 KiB
JavaScript
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);
|
|
});
|