Compare commits

..

1 Commits

Author SHA1 Message Date
diegosouzapw
0328768396 fix(security): authorize embedded-service WebSocket proxy upgrades
The embedded-services WebSocket proxy (EMBED_WS_PROXY_PORT, default 20131)
tunnelled any upgrade to the target service and added the service's own
Authorization header, without checking who asked. It now applies the same
decision as the HTTP embed route (LOCAL_ONLY + management auth) before it
opens a tunnel:

- the TCP peer must be loopback and carry no reverse-proxy hop header;
- a browser Origin must be one of the dashboard origins (same allow-list
  as the Live dashboard socket);
- the caller needs a dashboard session or a management-scope API key,
  unless dashboard login is disabled (same bar as the HTTP embed route).

A rejected upgrade gets 401/403 and never reaches the service, so the
service credential is only sent on behalf of an authorized caller. Auth
backend errors fail closed (503).

Service bootstrap no longer starts a service with a fixed fallback
credential when its stored key cannot be loaded; the service is skipped
and the on-demand /api/services/<name>/* path reports the key error.
2026-11-18 00:37:52 -03:00
9 changed files with 526 additions and 107 deletions

View File

@@ -0,0 +1 @@
- **fix(security):** the embedded-services WebSocket proxy now authorizes every upgrade like the HTTP embed route (loopback peer, dashboard Origin, dashboard session or management-scope key) before it opens a tunnel with the service credential, and service bootstrap no longer starts a service with a fallback credential when its key cannot be loaded

View File

@@ -1 +0,0 @@
- Return the shared provider accounts in the usage command JSON (`?format=json`) only to keys with `self:account-quota` or a management scope, the same rule `/v1/me/status` uses; other keys get their personal quota only (thanks @Witroch4).

View File

@@ -624,7 +624,12 @@ This proxy:
- Rewrites HTML responses to inject `<base href>` and normalize absolute paths (`/foo` → `/dashboard/.../embed/foo`)
WebSocket upgrades for the embedded dashboard are handled by a companion server on a
dedicated port (see `src/lib/services/embedWsProxy.ts`).
dedicated port (see `src/lib/services/embedWsProxy.ts`). Every upgrade is authorized
before the tunnel opens, with the same rules as the HTTP embed route: the peer must be
loopback with no reverse-proxy forwarding header, a browser `Origin` must be a dashboard
origin (`LIVE_WS_ALLOWED_ORIGINS` / `LIVE_WS_ALLOWED_HOSTS` extend the loopback
defaults), and the caller needs a dashboard session or a management-scope API key unless
dashboard login is disabled.
**Security:** The embed proxy routes are classified under `LOCAL_ONLY_API_PREFIXES`
and can only be reached from loopback. An attacker who obtains a JWT via a

View File

@@ -186,6 +186,23 @@ function buildSpawnArgsFactory(
return () => cliproxySpawnArgs(cfg.port, apiKey);
}
/**
* The service's own credential (API key / admin token), "" when it needs none,
* or null when it cannot be loaded. A null key means the service is not started:
* a guessable stand-in would be worse than no service, and the on-demand
* /api/services/<tool>/* path reports the key error to the operator.
*/
async function loadServiceApiKey(cfg: ServiceEntry): Promise<string | null> {
if (!cfg.needsApiKey) return "";
try {
return await getOrCreateApiKey(cfg.tool);
} catch (err: unknown) {
const msg = err instanceof Error ? err.message : String(err);
console.warn(`[Services] Not supervising ${cfg.tool}: its API key is unavailable. ${msg}`);
return null;
}
}
export async function bootstrapEmbeddedServices(): Promise<void> {
for (const cfg of SERVICES) {
if (getSupervisor(cfg.tool)) continue;
@@ -193,9 +210,8 @@ export async function bootstrapEmbeddedServices(): Promise<void> {
const row = await getVersionManagerTool(cfg.tool);
if (!row || row.status === "not_installed") continue;
const apiKey = cfg.needsApiKey
? await getOrCreateApiKey(cfg.tool).catch(() => "placeholder")
: "";
const apiKey = await loadServiceApiKey(cfg);
if (apiKey === null) continue;
// CLIProxyAPI's generated key is management-only; /v1/models uses its dedicated data-plane key.
const modelSyncApiKey =
cfg.tool === "cliproxy"

View File

@@ -13,8 +13,15 @@
* - Target host is always 127.0.0.1 and port comes from the registry — never
* from user input. No SSRF risk.
* - Server binds to 127.0.0.1 only (loopback) unless EMBED_WS_PROXY_HOST
* is set explicitly. The OmniRoute LOCAL_ONLY rule is enforced at the
* dashboard layer; the proxy itself is loopback-only as defence-in-depth.
* (or LIVE_WS_HOST) is set explicitly.
* - Every upgrade is authorized before the tunnel opens
* (authorizeEmbedWsUpgrade), with the same decision as the HTTP embed route
* (LOCAL_ONLY + management auth, Hard Rule #17): the TCP peer must be
* loopback with no reverse-proxy hop header, a browser Origin must be one of
* the dashboard origins, and the caller must hold a dashboard session or a
* management-scope API key (unless dashboard login is disabled). A rejected
* upgrade never reaches the service, so the injected service credential is
* only ever sent on behalf of an authorized caller. Errors fail closed.
* - Max 50 concurrent connections per service. The 51st request receives 503.
* - Idle timeout: 5 minutes without any data → both sockets are destroyed.
* - Hop-by-hop headers cookie/authorization/origin are stripped from the
@@ -27,6 +34,13 @@ import type { IncomingMessage } from "node:http";
import { getSupervisor } from "./registry";
import { getOrCreateApiKey } from "./apiKey";
import { getApiKeyMetadata } from "@/lib/db/apiKeys";
import { hasProxyHopHeader } from "@/server/authz/proxyHeaders";
import { isLoopbackHost } from "@/server/authz/routeGuard";
import { isOriginAllowed } from "@/server/ws/liveServerAllowList";
import { hasManageScope } from "@/shared/constants/managementScopes";
import { isAuthRequired, isDashboardSessionAuthenticated } from "@/shared/utils/apiAuth";
import { extractApiKey, isValidApiKey } from "@/sse/services/auth";
import {
attachRequestStreamGuards,
installProcessCrashGuard,
@@ -129,7 +143,96 @@ function buildUpstreamHeaders(rawHeaders: string[], port: number, apiKey: string
return lines;
}
export type EmbedWsUpgradeVerdict =
| { allow: true; via: "anonymous" | "dashboard_session" | "management_key" }
| { allow: false; status: number; message: string };
function deny(status: number, message: string): EmbedWsUpgradeVerdict {
return { allow: false, status, message };
}
/** True when the upgrade's real TCP peer is this machine and no proxy hop relayed it. */
function isLocalUpgradePeer(req: IncomingMessage): boolean {
if (hasProxyHopHeader(req.headers)) return false;
return isLoopbackHost(req.socket?.remoteAddress ?? null);
}
/**
* A browser always sends Origin on a WebSocket upgrade; it must be one of the
* dashboard origins (same allow-list as the Live dashboard socket:
* LIVE_WS_ALLOWED_ORIGINS / LIVE_WS_ALLOWED_HOSTS on top of the loopback
* defaults). A client without Origin is not a browser page; it still has to be
* local and authenticated.
*/
function isUpgradeOriginAllowed(origin: string | string[] | undefined): boolean {
if (origin === undefined) return true;
if (typeof origin !== "string" || origin.length === 0) return false;
return isOriginAllowed(origin, process.env);
}
function toHeaders(headers: IncomingMessage["headers"]): Headers {
const out = new Headers();
for (const [name, value] of Object.entries(headers)) {
if (typeof value === "string") out.set(name, value);
else if (Array.isArray(value)) {
out.set(name, value.join(name.toLowerCase() === "cookie" ? "; " : ", "));
}
}
return out;
}
/**
* Decide whether an upgrade may open a tunnel. Mirrors the management policy the
* HTTP embed route (`/dashboard/providers/services/<name>/embed/`) goes through:
* loopback only, then anonymous when dashboard login is off, otherwise a
* dashboard session or an API key with a management scope. Header-only
* credentials; a URL-borne token never counts.
*/
export async function authorizeEmbedWsUpgrade(
req: IncomingMessage
): Promise<EmbedWsUpgradeVerdict> {
if (!isLocalUpgradePeer(req)) {
return deny(403, "The embedded service WebSocket proxy only accepts local connections");
}
if (!isUpgradeOriginAllowed(req.headers.origin)) {
return deny(403, "Origin not allowed");
}
const authRequest = {
url: "http://127.0.0.1/dashboard/providers/services/embed-ws",
method: "GET",
headers: toHeaders(req.headers),
};
try {
if (!(await isAuthRequired(authRequest, { loopback: true }))) {
return { allow: true, via: "anonymous" };
}
if (await isDashboardSessionAuthenticated(authRequest)) {
return { allow: true, via: "dashboard_session" };
}
const apiKey = extractApiKey(authRequest, { allowUrl: false });
if (apiKey && (await isValidApiKey(apiKey))) {
const meta = await getApiKeyMetadata(apiKey);
if (meta && hasManageScope(meta.scopes ?? [])) {
return { allow: true, via: "management_key" };
}
}
return apiKey ? deny(403, "Invalid management token") : deny(401, "Authentication required");
} catch {
return deny(503, "Authentication backend unavailable");
}
}
async function proxyUpgrade(req: IncomingMessage, socket: net.Socket, head: Buffer): Promise<void> {
// Authorize before anything else: an unauthorized caller learns nothing about
// the registered services and never gets a tunnel carrying the service key.
const verdict = await authorizeEmbedWsUpgrade(req);
if (!verdict.allow) {
writeError(socket, verdict.status, verdict.message);
return;
}
const rawUrl = req.url ?? "/";
const match = PATH_RE.exec(rawUrl.split("?")[0]);
@@ -245,13 +348,13 @@ export function resolveEmbedWsHost(): string {
* Start the embed WebSocket proxy server.
* Idempotent — safe to call multiple times.
*/
export function initEmbedWsProxy(): void {
export function initEmbedWsProxy(): http.Server | undefined {
// Safety net: a client aborting a connection can emit `Error: aborted`/
// ECONNRESET on the request stream; without this the single missed listener
// becomes an uncaughtException that kills the server. Benign aborts are
// swallowed; genuine errors still crash loudly (#fix-dev-server-aborted).
installProcessCrashGuard();
if (globalThis.__omnirouteEmbedWsStarted) return;
if (globalThis.__omnirouteEmbedWsStarted) return undefined;
const host = resolveEmbedWsHost();
const port = parseInt(process.env.EMBED_WS_PROXY_PORT ?? String(DEFAULT_PORT), 10);
@@ -284,6 +387,8 @@ export function initEmbedWsProxy(): void {
globalThis.__omnirouteEmbedWsStarted = true;
console.log(`[EmbedWsProxy] Listening on ${host}:${port}`);
});
return server;
}
// ─── Exported for testing ────────────────────────────────────────────────────

View File

@@ -4,8 +4,6 @@ import {
type ApiKeyUsageLimitStatus,
} from "@/lib/usage/apiKeyUsageLimits";
import { buildErrorBody } from "@omniroute/open-sse/utils/error";
import { hasManageScope } from "@/shared/constants/managementScopes";
import { hasSelfAccountQuotaScope } from "@/shared/constants/selfServiceScopes";
export const INTERNAL_USAGE_COMMAND = "@@om-usage";
export const USAGE_COMMAND_DISABLED_MESSAGE = "Usage command is disabled for this API key.";
@@ -25,21 +23,6 @@ export interface UsageCommandApiKeyMetadata {
dailyUsageLimitUsd?: number | null;
weeklyUsageLimitUsd?: number | null;
fiveHourUsageLimitUsd?: number | null;
scopes?: string[] | null;
}
/**
* The shared provider accounts behind a key (plan, raw quota windows, reset
* times, connection ids) are operator data, not the key holder's. Only a key
* explicitly granted `self:account-quota` (the same scope that gates
* `accountQuotas` on /v1/me/status) or a management key may read them; any other
* key gets its own personal quota and nothing else. Missing scopes fail closed.
*/
export function canReadSharedAccountQuota(scopes: readonly string[] | null | undefined): boolean {
const list = Array.isArray(scopes)
? scopes.filter((s): s is string => typeof s === "string")
: [];
return hasSelfAccountQuotaScope(list) || hasManageScope(list);
}
interface ProviderConnectionLike {
@@ -564,9 +547,7 @@ function appendQuotaBlock(
* NOTE on percentage semantics (#15530):
* - JSON `provider.quotas` and `providers[].quotas` expose raw upstream
* snapshots (unadjusted usage and remaining numbers/percentages), alongside
* connection-level `quotaWindowThresholds` — ONLY to keys allowed to read the
* shared accounts ({@link canReadSharedAccountQuota}). Every other key gets
* `provider: null` and `providers: []`.
* connection-level `quotaWindowThresholds`.
* - In contrast, text output (`buildUsageCommandText` / terminal `@@om-usage`)
* renders cutoff-adjusted remaining percentages (`NN% left`) via
* {@link effectiveRemainingPercent}, where the configured cutoff reserve
@@ -610,9 +591,6 @@ export async function buildUsageCommandJson(
{ now: resolvedDeps.now }
)
: null;
if (!canReadSharedAccountQuota(metadata.scopes)) {
return { allowed: true, personal, provider: null, providers: [] };
}
const snapshots = await collectUsageSnapshots(metadata, resolvedDeps);
const provider = selectUsageSnapshot(snapshots, selection);
return { allowed: true, personal, provider, providers: snapshots };

View File

@@ -0,0 +1,61 @@
/**
* bootstrapEmbeddedServices must not supervise a service whose API key cannot be
* loaded. The key is the service's own credential (9router API key, Mux auth token,
* Dario admin token, ...): starting the service with a fixed fallback string would hand
* it a credential anyone can guess. The service is skipped instead; the on-demand
* /api/services/<name>/* path then surfaces the key error to the operator.
*/
import { after, before, test } from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
const ORIGINAL_STORAGE_KEY = process.env.STORAGE_ENCRYPTION_KEY;
const ORIGINAL_DATA_DIR = process.env.DATA_DIR;
// Own database directory: another test file may share the inherited DATA_DIR.
const TEST_DATA_DIR = fs.mkdtempSync(
path.join(process.env.DATA_DIR || os.tmpdir(), "bootstrap-service-key-")
);
process.env.DATA_DIR = TEST_DATA_DIR;
// Without a storage key an encrypted column cannot be decrypted, which is the
// degraded state this test needs.
delete process.env.STORAGE_ENCRYPTION_KEY;
const core = await import("../../../src/lib/db/core.ts");
const { upsertVersionManagerTool } = await import("../../../src/lib/db/versionManager.ts");
const { getSupervisor, unregisterSupervisor } =
await import("../../../src/lib/services/registry.ts");
const { bootstrapEmbeddedServices } = await import("../../../src/lib/services/bootstrap.ts");
before(() => {
core.resetDbInstance();
});
after(() => {
unregisterSupervisor("mux");
unregisterSupervisor("9router");
core.resetDbInstance();
fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
if (ORIGINAL_DATA_DIR === undefined) delete process.env.DATA_DIR;
else process.env.DATA_DIR = ORIGINAL_DATA_DIR;
if (ORIGINAL_STORAGE_KEY === undefined) delete process.env.STORAGE_ENCRYPTION_KEY;
else process.env.STORAGE_ENCRYPTION_KEY = ORIGINAL_STORAGE_KEY;
});
test("a service whose stored key cannot be decrypted is not supervised", async () => {
// Installed, not auto-started, with an encrypted key that cannot be read back.
await upsertVersionManagerTool({
tool: "mux",
status: "installed",
autoStart: false,
apiKey: "enc:v1:00:00:00",
});
// A healthy service next to it keeps working.
await upsertVersionManagerTool({ tool: "9router", status: "installed", autoStart: false });
await bootstrapEmbeddedServices();
assert.equal(getSupervisor("mux"), null, "mux must not run with a fallback credential");
assert.notEqual(getSupervisor("9router"), null, "services with a readable key still register");
});

View File

@@ -0,0 +1,329 @@
/**
* The embedded-services WebSocket proxy (initEmbedWsProxy, default :20131) tunnels a
* client into an embedded service and adds that service's own Authorization header to
* the tunnel. It must therefore apply the same decision as the HTTP embed route
* (`/dashboard/providers/services/<name>/embed/`, LOCAL_ONLY + management auth) before
* it opens the tunnel:
*
* - the TCP peer is loopback and no reverse-proxy hop header is present;
* - a browser Origin, when sent, is one of the dashboard origins;
* - the caller holds a dashboard session or a management-scope API key, unless the
* dashboard itself runs without login (then loopback + Origin is the same bar the
* HTTP embed route applies).
*
* A rejected upgrade never reaches the upstream service, so the service credential is
* never sent for an unauthorized caller.
*
* The test drives the real server (initEmbedWsProxy) over TCP against a fake upstream
* that records what it receives.
*/
import { after, before, describe, test } from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import net from "node:net";
import os from "node:os";
import path from "node:path";
import { createManagementSessionToken } from "../../helpers/managementSession.ts";
const ENV_KEYS = [
"DATA_DIR",
"JWT_SECRET",
"API_KEY_SECRET",
"OMNIROUTE_API_KEY",
"ROUTER_API_KEY",
"INITIAL_PASSWORD",
"EMBED_WS_PROXY_HOST",
"EMBED_WS_PROXY_PORT",
"LIVE_WS_HOST",
"LIVE_WS_ALLOWED_ORIGINS",
"LIVE_WS_ALLOWED_HOSTS",
"PORT",
"DASHBOARD_PORT",
] as const;
const ORIGINAL_ENV = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]]));
function getFreePort(): Promise<number> {
return new Promise((resolve, reject) => {
const srv = net.createServer();
srv.once("error", reject);
srv.listen(0, "127.0.0.1", () => {
const addr = srv.address();
const port = addr && typeof addr === "object" ? addr.port : null;
srv.close(() => (port ? resolve(port) : reject(new Error("no port"))));
});
});
}
const PROXY_PORT = await getFreePort();
// Own database directory: another test file may share the inherited DATA_DIR.
const TEST_DATA_DIR = fs.mkdtempSync(
path.join(process.env.DATA_DIR || os.tmpdir(), "embed-ws-upgrade-auth-")
);
process.env.DATA_DIR = TEST_DATA_DIR;
process.env.JWT_SECRET = "test-jwt-secret-embed-ws-upgrade-auth";
process.env.API_KEY_SECRET = "test-api-key-secret-embed-ws-upgrade-auth";
// The env master key is materialised with `manage` scope — keep it out of the matrix.
delete process.env.OMNIROUTE_API_KEY;
delete process.env.ROUTER_API_KEY;
delete process.env.INITIAL_PASSWORD;
delete process.env.LIVE_WS_HOST;
delete process.env.LIVE_WS_ALLOWED_ORIGINS;
delete process.env.LIVE_WS_ALLOWED_HOSTS;
delete process.env.PORT;
delete process.env.DASHBOARD_PORT;
// Bind every interface so the test can also reach the proxy from a non-loopback
// address of this machine (the documented LIVE_WS_HOST=0.0.0.0 exposure).
process.env.EMBED_WS_PROXY_HOST = "0.0.0.0";
process.env.EMBED_WS_PROXY_PORT = String(PROXY_PORT);
const core = await import("../../../src/lib/db/core.ts");
const apiKeysDb = await import("../../../src/lib/db/apiKeys.ts");
const { updateSettings } = await import("../../../src/lib/db/settings.ts");
const { upsertVersionManagerTool } = await import("../../../src/lib/db/versionManager.ts");
const { getOrCreateApiKey } = await import("../../../src/lib/services/apiKey.ts");
const { registerSupervisor, unregisterSupervisor } =
await import("../../../src/lib/services/registry.ts");
const embedWsProxy = await import("../../../src/lib/services/embedWsProxy.ts");
const DASHBOARD_ORIGIN = "http://127.0.0.1:20128";
const FOREIGN_ORIGIN = "https://attacker.example";
/** First non-internal IPv4 address of this machine, if any. */
function lanAddress(): string | null {
for (const list of Object.values(os.networkInterfaces())) {
for (const iface of list ?? []) {
if (iface.family === "IPv4" && !iface.internal) return iface.address;
}
}
return null;
}
// ── fake upstream service ──────────────────────────────────────────────────
const upstreamRequests: string[] = [];
const upstream = net.createServer((sock) => {
let buf = "";
let answered = false;
sock.on("data", (chunk) => {
buf += chunk.toString("latin1");
if (!answered && buf.includes("\r\n\r\n")) {
answered = true;
upstreamRequests.push(buf);
sock.write(
"HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n"
);
}
});
sock.on("error", () => {});
});
/**
* Send a raw WebSocket upgrade for /9router/ws to the proxy and resolve with the
* response status code (0 when the connection closed without a status line).
*/
function attemptUpgrade(host: string, extraHeaders: Record<string, string> = {}): Promise<number> {
return new Promise((resolve, reject) => {
const sock = net.connect(PROXY_PORT, host);
let buf = "";
const timer = setTimeout(() => {
sock.destroy();
reject(new Error("timed out waiting for the upgrade response"));
}, 8000);
const finish = () => {
clearTimeout(timer);
const m = /^HTTP\/1\.1 (\d{3})/.exec(buf);
sock.destroy();
resolve(m ? Number(m[1]) : 0);
};
sock.on("connect", () => {
const lines = [
"GET /9router/ws HTTP/1.1",
`Host: ${host}:${PROXY_PORT}`,
"Connection: Upgrade",
"Upgrade: websocket",
"Sec-WebSocket-Version: 13",
"Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==",
...Object.entries(extraHeaders).map(([k, v]) => `${k}: ${v}`),
];
sock.write(`${lines.join("\r\n")}\r\n\r\n`);
});
sock.on("data", (chunk) => {
buf += chunk.toString("latin1");
if (buf.includes("\r\n\r\n")) finish();
});
sock.on("close", finish);
sock.on("error", () => {});
});
}
/** Run one upgrade and report the status plus how many requests reached upstream. */
async function probe(host: string, headers: Record<string, string> = {}) {
const before = upstreamRequests.length;
const status = await attemptUpgrade(host, headers);
const forwarded = upstreamRequests.slice(before);
return { status, forwarded };
}
async function waitForProxy(): Promise<void> {
const deadline = Date.now() + 10_000;
while (!globalThis.__omnirouteEmbedWsStarted) {
if (Date.now() > deadline) throw new Error("embed WS proxy did not start");
await new Promise((r) => setTimeout(r, 20));
}
}
let proxyServer: { close: (cb?: () => void) => unknown } | undefined;
let serviceKey = "";
let manageKey = "";
let readKey = "";
let sessionCookie = "";
before(async () => {
core.resetDbInstance();
await new Promise<void>((resolve) => upstream.listen(0, "127.0.0.1", () => resolve()));
const upstreamPort = (upstream.address() as net.AddressInfo).port;
await upsertVersionManagerTool({ tool: "9router", status: "installed", port: upstreamPort });
serviceKey = await getOrCreateApiKey("9router");
registerSupervisor({
getStatus: () => ({
tool: "9router",
state: "running",
port: upstreamPort,
pid: null,
health: "healthy",
startedAt: null,
lastError: null,
}),
} as never);
manageKey = (await apiKeysDb.createApiKey("operator", "machine-embed-ws", ["manage"])).key;
readKey = (await apiKeysDb.createApiKey("inference", "machine-embed-ws", ["read"])).key;
sessionCookie = `auth_token=${await createManagementSessionToken()}`;
globalThis.__omnirouteEmbedWsStarted = undefined;
proxyServer = embedWsProxy.initEmbedWsProxy() as typeof proxyServer;
await waitForProxy();
});
after(async () => {
unregisterSupervisor("9router");
await new Promise<void>((resolve) => upstream.close(() => resolve()));
if (proxyServer) await new Promise<void>((resolve) => proxyServer!.close(() => resolve()));
globalThis.__omnirouteEmbedWsStarted = undefined;
core.resetDbInstance();
fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
for (const k of ENV_KEYS) {
if (ORIGINAL_ENV[k] === undefined) delete process.env[k];
else process.env[k] = ORIGINAL_ENV[k];
}
});
describe("embed WS proxy — login required", () => {
before(async () => {
await updateSettings({ requireLogin: true, password: "hashed-password-for-test" });
});
test("an upgrade without any credential is rejected and never reaches the service", async () => {
const { status, forwarded } = await probe("127.0.0.1", { Origin: DASHBOARD_ORIGIN });
assert.equal(status, 401);
assert.equal(forwarded.length, 0, "the service must not see the upgrade");
});
test("an API key without a management scope is rejected", async () => {
const { status, forwarded } = await probe("127.0.0.1", {
Origin: DASHBOARD_ORIGIN,
Authorization: `Bearer ${readKey}`,
});
assert.equal(status, 403);
assert.equal(forwarded.length, 0);
});
test("a management key opens the tunnel and only the service credential is forwarded", async () => {
const { status, forwarded } = await probe("127.0.0.1", {
Origin: DASHBOARD_ORIGIN,
Authorization: `Bearer ${manageKey}`,
});
assert.equal(status, 101);
assert.equal(forwarded.length, 1);
const sent = forwarded[0];
assert.match(sent, new RegExp(`\\r\\nAuthorization: Bearer ${serviceKey}\\r\\n`));
assert.ok(!sent.includes(manageKey), "the caller's own key must not reach the service");
assert.ok(!/\r\norigin:/i.test(sent), "Origin is not forwarded");
});
test("a dashboard session cookie opens the tunnel and the cookie is not forwarded", async () => {
const { status, forwarded } = await probe("127.0.0.1", {
Origin: DASHBOARD_ORIGIN,
Cookie: sessionCookie,
});
assert.equal(status, 101);
assert.equal(forwarded.length, 1);
assert.ok(!/\r\ncookie:/i.test(forwarded[0]));
});
test("a foreign Origin is rejected even with a valid management key", async () => {
const { status, forwarded } = await probe("127.0.0.1", {
Origin: FOREIGN_ORIGIN,
Authorization: `Bearer ${manageKey}`,
});
assert.equal(status, 403);
assert.equal(forwarded.length, 0);
});
test("a request relayed by a reverse proxy is not treated as local", async () => {
const { status, forwarded } = await probe("127.0.0.1", {
Origin: DASHBOARD_ORIGIN,
Authorization: `Bearer ${manageKey}`,
"X-Forwarded-For": "203.0.113.9",
});
assert.equal(status, 403);
assert.equal(forwarded.length, 0);
});
test("a non-loopback peer is rejected even with a valid management key", async (t) => {
const lan = lanAddress();
if (!lan) {
t.skip("no non-loopback IPv4 interface on this machine");
return;
}
const { status, forwarded } = await probe(lan, {
Origin: DASHBOARD_ORIGIN,
Authorization: `Bearer ${manageKey}`,
});
assert.equal(status, 403);
assert.equal(forwarded.length, 0);
});
});
describe("embed WS proxy — dashboard login disabled", () => {
before(async () => {
await updateSettings({ requireLogin: false });
});
test("a loopback upgrade from the dashboard origin is accepted, as on the HTTP embed route", async () => {
const { status, forwarded } = await probe("127.0.0.1", { Origin: DASHBOARD_ORIGIN });
assert.equal(status, 101);
assert.equal(forwarded.length, 1);
});
test("a foreign Origin is still rejected", async () => {
const { status, forwarded } = await probe("127.0.0.1", { Origin: FOREIGN_ORIGIN });
assert.equal(status, 403);
assert.equal(forwarded.length, 0);
});
test("a non-loopback peer is still rejected", async (t) => {
const lan = lanAddress();
if (!lan) {
t.skip("no non-loopback IPv4 interface on this machine");
return;
}
const { status, forwarded } = await probe(lan, { Origin: DASHBOARD_ORIGIN });
assert.equal(status, 403);
assert.equal(forwarded.length, 0);
});
});

View File

@@ -32,14 +32,11 @@ function allowedDeps(overrides: Record<string, unknown> = {}) {
return {
now: () => NOW,
isValidApiKey: async (apiKey: string) => apiKey === "sk-allowed",
// The panel key is explicitly granted the shared-account view; a plain
// client key (self:usage only) is covered by the tests at the bottom.
getApiKeyMetadata: async () => ({
id: "key-allowed",
name: "panel key",
allowUsageCommand: true,
usageLimitEnabled: true,
scopes: ["self:usage", "self:account-quota"],
}),
getProviderConnections: async () => [
{ id: "conn-claude", provider: "claude", isActive: true },
@@ -226,75 +223,3 @@ test("om-usage preserves raw quota in json while text scales remaining quota by
assert.match(text, /Weekly/);
assert.match(text, /20% left/);
});
// A client key with the usage command could read, through ?format=json, every
// shared provider account: connection ids, plan, raw quota and resets. Those
// belong to the operator, not to the key holder.
function failingProviderCollectors() {
const fail = () => {
throw new Error("provider accounts must not be read for this key");
};
return {
getProviderConnections: async () => fail(),
getAllProviderLimitsCache: () => fail(),
getProviderConnectionById: async () => fail(),
getProviderLimitsCache: () => fail(),
};
}
for (const [label, scopes] of [
["a plain client key (self:usage only)", ["self:usage"]],
["a key whose metadata carries no scopes", undefined],
] as const) {
test(`om-usage ?format=json hides the shared provider accounts from ${label}`, async () => {
const response = await handleInternalUsageCommandHttpRequest(
new Request("http://localhost/api/usage/om-usage?format=json", {
headers: { Authorization: "Bearer sk-allowed" },
}),
allowedDeps({
getApiKeyMetadata: async () => ({
id: "key-client",
name: "client key",
allowUsageCommand: true,
usageLimitEnabled: true,
...(scopes ? { scopes: [...scopes] } : {}),
}),
...failingProviderCollectors(),
})
);
assert.equal(response.status, 200);
const body = (await response.json()) as {
allowed: boolean;
personal: { weeklySpentUsd: number } | null;
provider: unknown;
providers: unknown[];
};
assert.equal(body.allowed, true);
assert.equal(body.personal?.weeklySpentUsd, 8);
assert.equal(body.provider, null);
assert.deepEqual(body.providers, []);
assert.doesNotMatch(JSON.stringify(body), /conn-claude|conn-codex|Claude Max|Codex Pro/);
});
}
test("om-usage ?format=json still shows the shared accounts to a management key", async () => {
const response = await handleInternalUsageCommandHttpRequest(
new Request("http://localhost/api/usage/om-usage?format=json", {
headers: { Authorization: "Bearer sk-allowed" },
}),
allowedDeps({
getApiKeyMetadata: async () => ({
id: "key-admin",
name: "operator key",
allowUsageCommand: true,
usageLimitEnabled: false,
scopes: ["manage", "self:usage"],
}),
})
);
assert.equal(response.status, 200);
const body = (await response.json()) as { providers: Array<{ provider: string }> };
assert.deepEqual(body.providers.map((s) => s.provider).sort(), ["claude", "codex"]);
});