From 908a42bb20b14329f7fa9a7b6e415ed1e558f7db Mon Sep 17 00:00:00 2001 From: Tiisetso Date: Tue, 20 Oct 2026 11:28:04 +0200 Subject: [PATCH] fix(desktop): bound browser requests and document backend trust --- packages/cm-browser/SECURITY.md | 32 +++++++++++++ packages/cm-browser/src/port.ts | 18 ++++++- packages/cm-browser/src/protocol.ts | 16 +++++++ packages/cm-browser/test/port.test.ts | 47 +++++++++++++++++++ packages/cm-browser/test/wire.test.ts | 25 ++++++++++ .../desktop/src/main/browser/bridge.test.ts | 32 +++++++++++++ packages/desktop/src/main/browser/bridge.ts | 19 +++++++- .../desktop/src/main/browser/v2-channel.ts | 21 +++++---- 8 files changed, 199 insertions(+), 11 deletions(-) create mode 100644 packages/cm-browser/SECURITY.md create mode 100644 packages/cm-browser/test/wire.test.ts diff --git a/packages/cm-browser/SECURITY.md b/packages/cm-browser/SECURITY.md new file mode 100644 index 0000000000..48120368b8 --- /dev/null +++ b/packages/cm-browser/SECURITY.md @@ -0,0 +1,32 @@ +# Browser bridge trust and resource limits + +The authenticated local OpenCode backend is trusted to identify sessions. Session IDs +are routing identities, not credentials. Desktop main owns browser grants and checks +task/tab ownership, revocation and delivery authority. Delegated child requests retain +their existing admission checks. Isolation after compromise of the shared backend is +outside this guarantee: per-task secrets held by that same backend cannot provide it. +This records the trust decision for trmosala/opencode#83. + +CookieMonster starts the managed service without a hostname override. Server process +startup defaults to 127.0.0.1, and desktop setup requires Basic authentication. The +all-interface override applies only to isolated non-CookieMonster development builds. +Explicit custom server exposure requires a separate review. + +Request envelopes have a 128 KiB UTF-8 JSON budget, including unused fields and routing +metadata. This accommodates 10,000 characters of escaped text (up to 60,000 bytes) and +the existing 8 KiB site-tool argument budget. Sender admission checks before transmission; +desktop checks before parsing the inner JSON. Invalid or oversized inbound messages +close the channel. The outer SSE/RPC allocation already exists at this point: this is +not a transport-level or process-wide memory bound. Response limits are unchanged. + +Each sender port and desktop bridge allows 256 ordinary outstanding requests plus 16 +reserved revocation slots. Cancellation remains available at capacity. Overload returns +an unavailable result. Sender waiters are removed on completion, cancellation, timeout +or disconnect. Desktop native operations occupy capacity until settlement even after a +cancellation/timeout reply, because aborting does not prove native work has stopped. +Bridge shutdown aborts work and clears tracking. Duplicate IDs preserve original waiters. + +Existing router, delegation, bridge and session-resolver tests cover foreign tabs, +revoked grants, failed session lookups, delivery authority and valid operations. Wire +and port tests cover request size and admission limits. No capability system or worker +isolation is introduced; the separate transcript/CDP leak investigations are unchanged. diff --git a/packages/cm-browser/src/port.ts b/packages/cm-browser/src/port.ts index 4d482a933e..01ee573cc4 100644 --- a/packages/cm-browser/src/port.ts +++ b/packages/cm-browser/src/port.ts @@ -1,6 +1,9 @@ import { randomUUID } from "node:crypto" import { OPERATION_TIMEOUT_MS, + MAX_BROWSER_REQUEST_BYTES, + MAX_BROWSER_PENDING, + MAX_BROWSER_CONTROL_PENDING, failure, parseBrowserIpcResult, type BrowserIpcRequest, @@ -75,6 +78,19 @@ export function ipcPort( ...(actionRequest(request) ? { actionStatus: "not_dispatched" as const } : {}), }) const id = randomUUID() + const message: BrowserIpcRequest = { type: "browser_request", id, sessionID, request } + const oversized = Buffer.byteLength(JSON.stringify(message)) > MAX_BROWSER_REQUEST_BYTES + if ( + oversized || + pending.size >= MAX_BROWSER_PENDING + (request.op === "revoke_tabs" ? MAX_BROWSER_CONTROL_PENDING : 0) + ) + return Promise.resolve({ + ...failure( + oversized ? "bad_request" : "unavailable", + oversized ? "Browser request exceeds the size limit." : "Browser request capacity reached.", + ), + ...(actionRequest(request) ? { actionStatus: "not_dispatched" as const } : {}), + }) return new Promise((resolve) => { let dispatched = false let cancelTimeout: ReturnType | undefined @@ -134,7 +150,7 @@ export function ipcPort( if (signal?.aborted) return abort() try { dispatched = true - parent.postMessage({ type: "browser_request", id, sessionID, request }) + parent.postMessage(message) } catch { finish( { diff --git a/packages/cm-browser/src/protocol.ts b/packages/cm-browser/src/protocol.ts index d6ef695263..4685209f67 100644 --- a/packages/cm-browser/src/protocol.ts +++ b/packages/cm-browser/src/protocol.ts @@ -1,5 +1,10 @@ import { isAbsolute, join } from "node:path" +// Request envelopes allow escaped 10,000-character text plus routing metadata. +export const MAX_BROWSER_REQUEST_BYTES = 128 * 1024 +export const MAX_BROWSER_PENDING = 256 +export const MAX_BROWSER_CONTROL_PENDING = 16 + export const ALLOWLIST_FILENAME = "cm-browser-allowlist.json" export const STATE_DIRECTORY_NAME = "CookieMonster" export const MAX_URL_LENGTH = 2_048 @@ -1117,3 +1122,14 @@ export function hostAllowed(url: string, allowlist: readonly string[]): boolean return Boolean(allowed) && (host === allowed || host.endsWith(`.${allowed}`)) }) } + +// Reject before parsing the inner request; the outer transport allocation already exists. +export function parseBrowserWireRequest(message: string) { + if (Buffer.byteLength(message) > MAX_BROWSER_REQUEST_BYTES) return + try { + const value: unknown = JSON.parse(message) + return parseBrowserIpcRequest(value) ?? parseBrowserIpcCancel(value) + } catch { + return + } +} diff --git a/packages/cm-browser/test/port.test.ts b/packages/cm-browser/test/port.test.ts index 07b400fd84..70a25d89a8 100644 --- a/packages/cm-browser/test/port.test.ts +++ b/packages/cm-browser/test/port.test.ts @@ -3,6 +3,9 @@ import { EventEmitter, getEventListeners } from "node:events" import { ipcPort } from "../src/port" import { OPERATION_TIMEOUT_MS, + MAX_BROWSER_PENDING, + MAX_BROWSER_CONTROL_PENDING, + MAX_BROWSER_REQUEST_BYTES, failure, success, type BrowserIpcRequest, @@ -134,3 +137,47 @@ test("correlates out-of-order utility-process results", async () => { expect(firstResult.ok ? firstResult.result.url : "").toBe("https://one.test") expect(secondResult.ok ? secondResult.result.url : "").toBe("https://two.test") }) + +test("request capacity rejects immediately and completion and disconnect restore capacity", async () => { + const f = fixture() + const pending = Array.from({ length: MAX_BROWSER_PENDING }, () => f.port.send("session", { op: "list_tabs" })) + expect(await f.port.send("session", { op: "list_tabs" })).toMatchObject({ code: "unavailable" }) + expect(f.sent).toHaveLength(MAX_BROWSER_PENDING) + f.reply(f.sent[0].id) + const next = f.port.send("session", { op: "list_tabs" }) + expect(f.sent).toHaveLength(MAX_BROWSER_PENDING + 1) + f.port.disconnect() + await Promise.all([...pending, next]) + expect(f.parent.listenerCount("message")).toBe(0) + const reopened = f.port.send("session", { op: "list_tabs" }) + f.reply(f.sent.at(-1)!.id) + expect(await reopened).toMatchObject({ code: "no_target" }) +}) + +test("oversized envelopes never dispatch or retain a listener", async () => { + const f = fixture() + expect(await f.port.send("x".repeat(MAX_BROWSER_REQUEST_BYTES), { op: "list_tabs" })).toMatchObject({ + code: "bad_request", + }) + expect(f.sent).toHaveLength(0) + expect(f.parent.listenerCount("message")).toBe(0) +}) + +test("revocations have bounded reserved capacity and cancellation still dispatches", async () => { + const f = fixture() + const controller = new AbortController() + const pending = Array.from({ length: MAX_BROWSER_PENDING }, () => + f.port.send("session", { op: "list_tabs" }, controller.signal), + ) + const revocations = Array.from({ length: MAX_BROWSER_CONTROL_PENDING }, (_, id) => + f.port.send("session", { op: "revoke_tabs", executionID: String(id) }), + ) + expect(f.sent).toHaveLength(MAX_BROWSER_PENDING + MAX_BROWSER_CONTROL_PENDING) + expect(await f.port.send("session", { op: "revoke_tabs", executionID: "overflow" })).toMatchObject({ + code: "unavailable", + }) + controller.abort() + expect(f.sent.filter((message) => message.type === "browser_cancel")).toHaveLength(MAX_BROWSER_PENDING) + f.port.disconnect() + await Promise.all([...pending, ...revocations]) +}) diff --git a/packages/cm-browser/test/wire.test.ts b/packages/cm-browser/test/wire.test.ts new file mode 100644 index 0000000000..bb20a16f01 --- /dev/null +++ b/packages/cm-browser/test/wire.test.ts @@ -0,0 +1,25 @@ +import { expect, test } from "bun:test" +import { MAX_BROWSER_REQUEST_BYTES, parseBrowserWireRequest } from "../src/protocol" + +test("wire boundary includes unused fields and UTF-8 bytes in the budget", () => { + const request = { type: "browser_request", id: "one", sessionID: "session", request: { op: "list_tabs" } } as const + expect(parseBrowserWireRequest(JSON.stringify(request))).toEqual(request) + expect(parseBrowserWireRequest(JSON.stringify(request).padEnd(MAX_BROWSER_REQUEST_BYTES, " "))).toEqual(request) + expect(parseBrowserWireRequest(JSON.stringify(request).padEnd(MAX_BROWSER_REQUEST_BYTES + 1, " "))).toBeUndefined() + expect(parseBrowserWireRequest(JSON.stringify({ ...request, unused: "x".repeat(1024 * 1024) }))).toBeUndefined() + expect( + parseBrowserWireRequest(JSON.stringify({ ...request, unused: "界".repeat(MAX_BROWSER_REQUEST_BYTES / 2) })), + ).toBeUndefined() + expect(parseBrowserWireRequest("{")).toBeUndefined() + expect( + parseBrowserWireRequest( + JSON.stringify({ + ...request, + request: { + op: "prepare_write", + request: { op: "fill", tabID: "one", ref: "one", text: "\u0000".repeat(10000) }, + }, + }), + ), + ).toBeDefined() +}) diff --git a/packages/desktop/src/main/browser/bridge.test.ts b/packages/desktop/src/main/browser/bridge.test.ts index 60c78a3f3e..cbe7fe0aea 100644 --- a/packages/desktop/src/main/browser/bridge.test.ts +++ b/packages/desktop/src/main/browser/bridge.test.ts @@ -469,3 +469,35 @@ test.each([ stop() } }) + +test("bridge reports overload and admits work again after settlement", async () => { + const replies: BrowserIpcResult[] = [] + const pending = Promise.withResolvers>() + const child = Object.assign(new EventEmitter(), { postMessage: (reply: BrowserIpcResult) => replies.push(reply) }) + const stop = attachBrowserBridge(child, () => pending.promise) + + try { + Array.from({ length: 256 }, (_, id) => + child.emit("message", { + type: "browser_request", + id: String(id), + sessionID: "one", + request: { op: "list_tabs" }, + }), + ) + child.emit("message", { type: "browser_request", id: "overflow", sessionID: "one", request: { op: "list_tabs" } }) + expect(replies).toHaveLength(1) + expect(replies[0]).toMatchObject({ + id: "overflow", + response: { code: "unavailable", actionStatus: "not_dispatched" }, + }) + pending.resolve(failure("no_target", "fixture")) + await new Promise((resolve) => setImmediate(resolve)) + child.emit("message", { type: "browser_request", id: "next", sessionID: "one", request: { op: "list_tabs" } }) + await new Promise((resolve) => setImmediate(resolve)) + expect(replies.at(-1)).toMatchObject({ id: "next", response: { code: "no_target" } }) + } finally { + stop() + pending.resolve(failure("no_target", "fixture")) + } +}) diff --git a/packages/desktop/src/main/browser/bridge.ts b/packages/desktop/src/main/browser/bridge.ts index b1b2695fee..e609c7c78a 100644 --- a/packages/desktop/src/main/browser/bridge.ts +++ b/packages/desktop/src/main/browser/bridge.ts @@ -1,5 +1,7 @@ import { OPERATION_TIMEOUT_MS, + MAX_BROWSER_PENDING, + MAX_BROWSER_CONTROL_PENDING, failure, parseBrowserIpcCancel, parseBrowserIpcRequest, @@ -88,7 +90,22 @@ export function attachBrowserBridge(child: Sidecar, route = routeBrowserRequest, // An occupied correlation ID belongs to its original waiter, even across sessions. if (active.has(request.id)) return - if (active.size >= 256 && request.request.op !== "revoke_tabs") return + if (active.size >= MAX_BROWSER_PENDING + (request.request.op === "revoke_tabs" ? MAX_BROWSER_CONTROL_PENDING : 0)) { + post( + { + type: "browser_result", + id: request.id, + response: { + ...failure("unavailable", "Browser request capacity reached."), + actionStatus: "not_dispatched", + }, + }, + request.request.op, + ) + + return + } + const controller = new AbortController() active.set(request.id, { sessionID: request.sessionID, diff --git a/packages/desktop/src/main/browser/v2-channel.ts b/packages/desktop/src/main/browser/v2-channel.ts index 59e50f598d..32fcbdb07a 100644 --- a/packages/desktop/src/main/browser/v2-channel.ts +++ b/packages/desktop/src/main/browser/v2-channel.ts @@ -5,11 +5,7 @@ import { BrowserRpc } from "@cookiemonster/cm-browser/rpc" import { SidecarCredentials } from "../service/sidecar-credentials" import { attachBrowserBridge } from "./bridge" import { createBrowserSessionResolver } from "./session-resolver" -import { - parseBrowserIpcRequest, - parseBrowserIpcCancel, - type BrowserIpcResult, -} from "@cookiemonster/cm-browser/protocol" +import { parseBrowserWireRequest, type BrowserIpcResult } from "@cookiemonster/cm-browser/protocol" let current: ReturnType | undefined @@ -33,6 +29,7 @@ function createChannel(endpoint: SidecarCredentials.Data, password: string) { baseUrl: endpoint.url, headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString("base64")}` }, }) + const rpc = client.rpc(BrowserRpc) const locations = new Map }>() const requests = new Map() @@ -88,13 +85,19 @@ function createChannel(endpoint: SidecarCredentials.Data, password: string) { "request", (event) => { if (event.data.connectionID !== connectionID) return - const value: unknown = JSON.parse(event.data.message) - const parsed = parseBrowserIpcRequest(value) ?? parseBrowserIpcCancel(value) + const parsed = parseBrowserWireRequest(event.data.message) + + if (!parsed) { + controller.abort(new Error("Invalid or oversized browser request.")) - if (!parsed) return + return + } - if (parsed.type === "browser_request") + if (parsed.type === "browser_request") { + if (requests.has(parsed.id)) return requests.set(parsed.id, { directory, connectionID, signal: controller.signal }) + } + child.emit("message", parsed) }, { signal: controller.signal },