50535dc5ea
# Conflicts: # cmd/pipelines-server/main.go # internal/server/websocket.go # scripts/manage.py # scripts/setup-native.py # web/serve.mjs # web/src/peerRelay.js
217 lines
7.8 KiB
JavaScript
217 lines
7.8 KiB
JavaScript
import {
|
|
endpoint,
|
|
webOrigin,
|
|
boundedRequest,
|
|
remoteRequest,
|
|
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.
|
|
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 };
|
|
}
|
|
// 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 {
|
|
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;
|
|
}
|
|
this.pinned(target, res, (lookup) => {
|
|
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",
|
|
// The remote machine's own step-up token (POST /files).
|
|
"x-pipelines-elevation",
|
|
])
|
|
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);
|
|
});
|
|
} 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 } : {}),
|
|
};
|
|
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,
|
|
)
|
|
.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`,
|
|
),
|
|
{ headers: withServerToken({}) },
|
|
);
|
|
if (response.status === 200) rememberDiscovered(response.body);
|
|
res
|
|
.writeHead(response.status, {
|
|
"Content-Type": "application/json",
|
|
"Cache-Control": "no-store",
|
|
})
|
|
.end(response.body);
|
|
} catch {
|
|
json(res, 503, { error: "LAN discovery unavailable" });
|
|
}
|
|
}
|