Compare commits

..

2 Commits

Author SHA1 Message Date
diegosouzapw
0cddfb918b Merge remote-tracking branch 'origin/release/v3.8.55' into fix/usage-command-json-account-scope 2026-11-17 23:50:40 -03:00
diegosouzapw
90481eb9b3 fix(security): keep shared provider accounts out of the usage command JSON for client keys
GET /api/usage/om-usage?format=json returned every active provider connection
(ids, plans, raw quota windows, resets) to any key with allowUsageCommand.
provider/providers are now returned only to keys with self:account-quota or a
management scope, the rule /v1/me/status already applies; other keys get their
personal quota only. Missing scopes fail closed.

Co-authored-by: Witroch4 <175152067+Witroch4@users.noreply.github.com>
2026-11-17 12:35:55 -03:00
9 changed files with 107 additions and 526 deletions

View File

@@ -1 +0,0 @@
- **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

@@ -0,0 +1 @@
- 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,12 +624,7 @@ 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`). 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.
dedicated port (see `src/lib/services/embedWsProxy.ts`).
**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,23 +186,6 @@ 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;
@@ -210,8 +193,9 @@ export async function bootstrapEmbeddedServices(): Promise<void> {
const row = await getVersionManagerTool(cfg.tool);
if (!row || row.status === "not_installed") continue;
const apiKey = await loadServiceApiKey(cfg);
if (apiKey === null) continue;
const apiKey = cfg.needsApiKey
? await getOrCreateApiKey(cfg.tool).catch(() => "placeholder")
: "";
// CLIProxyAPI's generated key is management-only; /v1/models uses its dedicated data-plane key.
const modelSyncApiKey =
cfg.tool === "cliproxy"

View File

@@ -13,15 +13,8 @@
* - 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
* (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.
* is set explicitly. The OmniRoute LOCAL_ONLY rule is enforced at the
* dashboard layer; the proxy itself is loopback-only as defence-in-depth.
* - 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
@@ -34,13 +27,6 @@ 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,
@@ -143,96 +129,7 @@ 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]);
@@ -348,13 +245,13 @@ export function resolveEmbedWsHost(): string {
* Start the embed WebSocket proxy server.
* Idempotent — safe to call multiple times.
*/
export function initEmbedWsProxy(): http.Server | undefined {
export function initEmbedWsProxy(): void {
// 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 undefined;
if (globalThis.__omnirouteEmbedWsStarted) return;
const host = resolveEmbedWsHost();
const port = parseInt(process.env.EMBED_WS_PROXY_PORT ?? String(DEFAULT_PORT), 10);
@@ -387,8 +284,6 @@ export function initEmbedWsProxy(): http.Server | undefined {
globalThis.__omnirouteEmbedWsStarted = true;
console.log(`[EmbedWsProxy] Listening on ${host}:${port}`);
});
return server;
}
// ─── Exported for testing ────────────────────────────────────────────────────

View File

@@ -4,6 +4,8 @@ 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.";
@@ -23,6 +25,21 @@ 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 {
@@ -547,7 +564,9 @@ 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`.
* connection-level `quotaWindowThresholds` — ONLY to keys allowed to read the
* shared accounts ({@link canReadSharedAccountQuota}). Every other key gets
* `provider: null` and `providers: []`.
* - In contrast, text output (`buildUsageCommandText` / terminal `@@om-usage`)
* renders cutoff-adjusted remaining percentages (`NN% left`) via
* {@link effectiveRemainingPercent}, where the configured cutoff reserve
@@ -591,6 +610,9 @@ 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

@@ -1,61 +0,0 @@
/**
* 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

@@ -1,329 +0,0 @@
/**
* 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,11 +32,14 @@ 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 },
@@ -223,3 +226,75 @@ 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"]);
});