From d9be7138b7bc26ec10603607f7b0cfb34b6db1b6 Mon Sep 17 00:00:00 2001 From: Aiden Cline <63023139+rekram1-node@users.noreply.github.com> Date: Thu, 29 Oct 2026 21:56:25 -0500 Subject: [PATCH] fix(codemode): copy extension results without trusting their own methods (#58031) --- packages/codemode/src/interpreter/errors.ts | 31 +++- .../codemode/src/interpreter/extensions.ts | 110 +++++++----- packages/codemode/test/extensions.test.ts | 159 +++++++++++++++++- 3 files changed, 254 insertions(+), 46 deletions(-) diff --git a/packages/codemode/src/interpreter/errors.ts b/packages/codemode/src/interpreter/errors.ts index ab9beaa70e6..9699c3b941c 100644 --- a/packages/codemode/src/interpreter/errors.ts +++ b/packages/codemode/src/interpreter/errors.ts @@ -23,6 +23,25 @@ import type { Eval } from "./runner.js" import { toPrimitiveString } from "./callback.js" import { formatValue } from "../stdlib/console.js" +/** + * A host error's message as text. A host can store anything there; an object must not cross as itself, and turning it + * into text would run its own methods. + */ +export const errorMessage = (error: Error): string => { + const message: unknown = error.message + if (typeof message === "string") return message + if (message === undefined || typeof message === "function" || (typeof message === "object" && message !== null)) { + return "" + } + return String(message) +} + +/** A host error's name as a program error type, read once so a getter cannot pass the check and then change. */ +export const errorType = (error: Error): ErrorType => { + const name: unknown = error.name + return typeof name === "string" && isErrorType(name) ? name : "Error" +} + export const normalizeError = (error: unknown): Diagnostic => { if (error instanceof PendingThrow) { const location = error.node?.loc ? sourceLocation(error.node) : undefined @@ -63,7 +82,7 @@ export const normalizeError = (error: unknown): Diagnostic => { return { kind: "ExecutionFailure", message: `Uncaught: ${message}` } } - if (error instanceof RangeError && /call stack|recursion/i.test(error.message)) { + if (error instanceof RangeError && /call stack|recursion/i.test(errorMessage(error))) { return { kind: "ExecutionFailure", message: "Execution exceeded the maximum nesting depth.", @@ -73,7 +92,7 @@ export const normalizeError = (error: unknown): Diagnostic => { if (error instanceof Error) { return { kind: error.name === "SyntaxError" ? "ParseError" : "ExecutionFailure", - message: error.message, + message: errorMessage(error), } } @@ -93,7 +112,7 @@ export const locate = (error: unknown, node?: AstNode): unknown => { return error } if (error instanceof Error && !(error instanceof ToolError) && !(error instanceof ToolRuntimeError)) { - return new PendingThrow(isErrorType(error.name) ? error.name : "Error", error.message, node) + return new PendingThrow(errorType(error), errorMessage(error), node) } return error } @@ -109,8 +128,10 @@ export const materialize = (ctx: Interpreter, thrown: unknown): Value => { } return thrown.value } - const type = thrown instanceof Error && isErrorType(thrown.name) ? thrown.name : "Error" - return createErrorValue(builtins[type], normalizeError(thrown).message) + return createErrorValue( + builtins[thrown instanceof Error ? errorType(thrown) : "Error"], + normalizeError(thrown).message, + ) } /** Error.prototype.toString: `name: message`, omitting whichever side is empty. */ diff --git a/packages/codemode/src/interpreter/extensions.ts b/packages/codemode/src/interpreter/extensions.ts index 181cf352491..d79362e1f52 100644 --- a/packages/codemode/src/interpreter/extensions.ts +++ b/packages/codemode/src/interpreter/extensions.ts @@ -1,10 +1,11 @@ import { Effect } from "effect" import { type Extension, isAsync } from "../extension.js" import { type ExtensionInvocation, hooked } from "../tool-runtime.js" +import { errorMessage, errorType } from "./errors.js" import type { Interpreter } from "./interpreter.js" -import { createErrorValue, isErrorType } from "./intrinsics.js" -import { MAX_VALUE_DEPTH } from "./limits.js" -import { type AstNode, PendingThrow, Throw, typeError } from "./model.js" +import { createErrorValue } from "./intrinsics.js" +import { MAX_ARRAY_LENGTH, MAX_VALUE_DEPTH } from "./limits.js" +import { type AstNode, PendingThrow, rangeError, Throw, typeError } from "./model.js" import { fn } from "./native.js" import { define, @@ -79,18 +80,29 @@ export const extensionGlobals = ( if (typeof value === "function") return wrap(value, label) if (value !== null && typeof value === "object") { const next = (item: unknown, path: string) => fromHost(item, path, depth + 1, seen) - if (value instanceof Date) return new DateObj(builtins.Date, value.getTime()) + // Nothing a host value hands back is kept: results are read as primitives or copied. Where the value's own + // method could hand back host storage or an object (`getTime`, `slice`, `map`), its internal data is read. + if (value instanceof Date) return new DateObj(builtins.Date, Date.prototype.getTime.call(value)) if (value instanceof RegExp) return new RegExpObj(builtins.RegExp, value.source, value.flags) if (value instanceof Uint8Array) return new Bytes(builtins.Uint8Array, new Uint8Array(value)) - if (value instanceof ArrayBuffer) return new Bytes(builtins.Uint8Array, new Uint8Array(value.slice(0))) + if (value instanceof ArrayBuffer) { + const view = new Uint8Array(value) + // Only a real buffer has bytes to view; anything else would be read as array-like and lose them silently. + if (view.buffer !== value) + throw typeError(`${label} produced ${describeHost(value)}, which the program cannot hold.`) + return new Bytes(builtins.Uint8Array, new Uint8Array(view)) + } if (value instanceof Error) { if (seen.has(value)) throw typeError(`${label} produced a circular value.`) seen.add(value) - const copied = createErrorValue(builtins[isErrorType(value.name) ? value.name : "Error"], value.message) + const copied = createErrorValue(builtins[errorType(value)], errorMessage(value)) const fields = value as unknown as Record for (const key of new Set(["cause", ...Object.keys(value)])) { - if (uncrossed.has(key) || !(key in value) || typeof fields[key] === "function") continue - const item = crossing(() => next(fields[key], `${label}.${key}`)) + if (uncrossed.has(key) || !(key in value)) continue + // Read once: a getter could pass the check and then hand back a function. + const field = fields[key] + if (typeof field === "function") continue + const item = crossing(() => next(field, `${label}.${key}`)) if (item === left) continue define(copied, key, item, key === "cause" ? hidden : undefined) } @@ -115,12 +127,18 @@ export const extensionGlobals = ( if (seen.has(value)) throw typeError(`${label} produced a circular value.`) seen.add(value) if (Array.isArray(value)) { - const copied = new Arr( - builtins.Array, - value.map((item, index) => next(item, `${label}[${index}]`)), - ) + const length = value.length + if (length > MAX_ARRAY_LENGTH) { + throw rangeError(`${label} produced an array of ${length} items; at most ${MAX_ARRAY_LENGTH} can cross.`) + } + // Filled in order so the copy stays a dense array; holes stay holes, as a copy made with `map` would leave them. + const items: Array = [] + for (let index = 0; index < length; index += 1) { + if (index in value) items[index] = next(value[index], `${label}[${index}]`) + } + items.length = length seen.delete(value) - return copied + return new Arr(builtins.Array, items) } const prototype = Object.getPrototypeOf(value) if (prototype === Object.prototype || prototype === null) { @@ -137,29 +155,39 @@ export const extensionGlobals = ( // the host function is called, so a call it denies never reaches the host. The host's result, or what it threw, // crosses out so the program catches a copy, and `extension.after` sees how the call ended. Functions inside // results are part of a value's API and skip the hooks. - const wrap = (value: Function, label: string, describe?: (args: ReadonlyArray) => ExtensionInvocation) => - fn(builtins, value.name, value.length, function* (_, values, site) { - const args = values.map((item, index) => toHost(item, `Argument ${index + 1} to ${label}`)) - const cross = (reason: unknown) => new Throw(fromHost(reason, label)) - const call = describe?.(args) - const hooks = ctx.tools.hooks - const before = call && hooks["extension.before"]?.(call).pipe(Effect.mapError(cross)) - const after = call && hooks["extension.after"] - const settle = (effect: Effect.Effect) => - (after ? hooked(call, undefined, after, effect) : effect).pipe( - Effect.mapBoth({ onFailure: cross, onSuccess: (result) => fromHost(result, label) }), - ) - // A denied call fails the way the global would: an async global rejects its promise, a sync one throws. - if (isAsync(value)) - return pending( - Effect.andThen(before ?? Effect.void, settle(Effect.suspend(() => callHost(value, args).effect))), - site, - ) - if (before) yield ctx.runner.blocking(before) - const host = callHost(value, args) - if (host.async) return pending(settle(host.effect), site) - return (yield ctx.runner.blocking(settle(host.effect))) as Value - }) + const wrap = (value: Function, label: string, describe?: (args: ReadonlyArray) => ExtensionInvocation) => { + // The host function's own `name` and `length` can be anything, even getters: each is read once, and only text + // and a count cross. + const name: unknown = value.name + const length: unknown = value.length + return fn( + builtins, + typeof name === "string" ? name : "", + typeof length === "number" && Number.isSafeInteger(length) && length >= 0 ? length : 0, + function* (_, values, site) { + const args = values.map((item, index) => toHost(item, `Argument ${index + 1} to ${label}`)) + const cross = (reason: unknown) => new Throw(fromHost(reason, label)) + const call = describe?.(args) + const hooks = ctx.tools.hooks + const before = call && hooks["extension.before"]?.(call).pipe(Effect.mapError(cross)) + const after = call && hooks["extension.after"] + const settle = (effect: Effect.Effect) => + (after ? hooked(call, undefined, after, effect) : effect).pipe( + Effect.mapBoth({ onFailure: cross, onSuccess: (result) => fromHost(result, label) }), + ) + // A denied call fails the way the global would: an async global rejects its promise, a sync one throws. + if (isAsync(value)) + return pending( + Effect.andThen(before ?? Effect.void, settle(Effect.suspend(() => callHost(value, args).effect))), + site, + ) + if (before) yield ctx.runner.blocking(before) + const host = callHost(value, args) + if (host.async) return pending(settle(host.effect), site) + return (yield ctx.runner.blocking(settle(host.effect))) as Value + }, + ) + } // An asynchronous host call: the program holds a promise that settles when the host's work does. const pending = (work: Effect.Effect, site: AstNode | undefined) => { @@ -199,10 +227,11 @@ const callHost = (value: Function, args: ReadonlyArray) => { /** * An error crosses as its name, message, `cause`, and own enumerable fields, such as Node's `code`, `errno`, - * `syscall`, and `path`. `stack` stays on its own side, and no field may shadow an Error method. A field that cannot - * cross (a socket, a handle, a function) is left behind so the error itself always arrives. + * `syscall`, and `path`. `stack` stays on its own side, `message` crosses once as text, and no field may shadow an + * Error method. A field that cannot cross (a socket, a handle, a function) is left behind so the error itself always + * arrives. */ -const uncrossed = new Set(["stack", "constructor", "toString", "__proto__"]) +const uncrossed = new Set(["stack", "message", "constructor", "toString", "__proto__"]) const left = Symbol("left behind") const crossing = (convert: () => T): T | typeof left => { try { @@ -233,5 +262,6 @@ const isPrimitive = (value: unknown): value is string | number | boolean | null const describeHost = (value: unknown): string => { if (typeof value !== "object" || value === null) return `a ${typeof value}` const name = (value as { constructor?: { name?: string } }).constructor?.name - return name === undefined || name === "" ? "an object" : `a ${name}` + if (name === undefined || name === "") return "an object" + return `${/^[AEIO]/.test(name) ? "an" : "a"} ${name}` } diff --git a/packages/codemode/test/extensions.test.ts b/packages/codemode/test/extensions.test.ts index 4f861e75c3b..55dd763c05a 100644 --- a/packages/codemode/test/extensions.test.ts +++ b/packages/codemode/test/extensions.test.ts @@ -250,7 +250,164 @@ describe("values are converted at the boundary, never shared", () => { const target = CodeMode.make({ extensions: [Extension.make({ name: "odd", globals: { detached: () => new Other() } })], }) - expect((await failure(`detached()`, target)).message).toContain("produced a Other, which the program cannot hold") + expect((await failure(`detached()`, target)).message).toContain("produced an Other, which the program cannot hold") + }) +}) + +describe("host values with overridden methods still cross as copies", () => { + const returning = (sample: unknown) => + CodeMode.make({ extensions: [Extension.make({ name: "odd", globals: { sample: () => sample } })] }) + + // A host object whose own `toString` runs when converted to text, counting the conversions. + const textual = () => { + const counter = { conversions: 0 } + const object = { + toString() { + counter.conversions += 1 + return "host text" + }, + } + return { counter, object } + } + + test("an array whose map returns itself is still copied by index, holes and all", async () => { + const host = [1, , 3, ,] + Object.defineProperty(host, "map", { value: () => host }) + expect( + await value(`const x = sample(); x[0] = 99; return [x.length, 1 in x, x[2], 3 in x]`, returning(host)), + ).toEqual([4, false, 3, false]) + expect(host[0]).toBe(1) + }) + + test("an array whose species hands back a kept array is still copied", async () => { + const kept = [1, 2] + const host = [1, 2] + Object.defineProperty(host, "constructor", { + value: { + [Symbol.species]: function () { + return kept + }, + }, + }) + expect(await value(`const x = sample(); x[0] = 99; return x`, returning(host))).toEqual([99, 2]) + expect(kept).toEqual([1, 2]) + expect(host).toEqual([1, 2]) + }) + + test("an array longer than a program may hold is refused with a clear error", async () => { + const host: Array = [] + host.length = 2 ** 32 - 1 + expect( + await value(`try { sample(); return "crossed" } catch (e) { return [e.name, e.message] }`, returning(host)), + ).toEqual(["RangeError", "sample produced an array of 4294967295 items; at most 10000000 can cross."]) + }) + + test("an ArrayBuffer whose species hands back a kept buffer is still copied", async () => { + const kept = new ArrayBuffer(4) + const host = new ArrayBuffer(4) + new Uint8Array(host).set([5, 6]) + Object.defineProperty(host, "constructor", { value: { [Symbol.species]: () => kept } }) + expect(await value(`const x = sample(); x[0] = 99; return [x[0], x[1]]`, returning(host))).toEqual([99, 6]) + expect([...new Uint8Array(kept)]).toEqual([0, 0, 0, 0]) + expect([...new Uint8Array(host)]).toEqual([5, 6, 0, 0]) + }) + + test("something that only claims to be an ArrayBuffer is refused rather than emptied", async () => { + const buffer = new ArrayBuffer(4) + expect( + await value( + `try { sample(); return "crossed" } catch (e) { return e.message.includes("cannot hold") }`, + returning(new Proxy(buffer, {})), + ), + ).toBe(true) + }) + + test("an ArrayBuffer whose slice returns itself is still copied", async () => { + const host = new ArrayBuffer(2) + new Uint8Array(host).set([1, 2]) + Object.defineProperty(host, "slice", { value: () => host }) + expect(await value(`const x = sample(); x[0] = 99; return x[0]`, returning(host))).toBe(99) + expect([...new Uint8Array(host)]).toEqual([1, 2]) + }) + + test("a Date whose getTime is overridden crosses with its real time", async () => { + const { counter, object } = textual() + const host = new Date(0) + Object.defineProperty(host, "getTime", { value: () => object }) + expect(await value(`return sample().getTime()`, returning(host))).toBe(0) + expect(counter.conversions).toBe(0) + }) + + test("an Error whose message is an object crosses without it", async () => { + const { counter, object } = textual() + const host = new Error("x") + Object.defineProperty(host, "message", { value: object }) + expect(await value(`const e = sample(); return [typeof e.message, e.message]`, returning(host))).toEqual([ + "string", + "", + ]) + expect(counter.conversions).toBe(0) + }) + + test("an Error message that is undefined or own and enumerable crosses as text", async () => { + const missing = new Error("x") + Object.defineProperty(missing, "message", { value: undefined }) + expect(await value(`const e = sample(); return [e.message, String(e)]`, returning(missing))).toEqual(["", "Error"]) + const own = new Error("x") + Object.defineProperty(own, "message", { value: { a: 1 }, enumerable: true }) + expect(await value(`return typeof sample().message`, returning(own))).toBe("string") + }) + + test("an Error name that changes between reads cannot reach the host Object prototype", async () => { + let reads = 0 + const host = new Error("x") + Object.defineProperty(host, "name", { get: () => (reads++ === 0 ? "TypeError" : "constructor") }) + expect( + await value( + `const e = sample(); return [Object.getPrototypeOf(e) === Error.prototype || e instanceof TypeError, typeof Object.getPrototypeOf(e)]`, + returning(host), + ), + ).toEqual([true, "object"]) + }) + + test("a host error with an object message thrown while copying is caught with text", async () => { + const { counter, object } = textual() + const thrown = new Error("x") + Object.defineProperty(thrown, "message", { value: object }) + const host = { + get field() { + throw thrown + }, + } + expect( + await value( + `try { sample(); return "crossed" } catch (e) { return [typeof e.message, e.message] }`, + returning(host), + ), + ).toEqual(["string", ""]) + expect(counter.conversions).toBe(0) + }) + + test("a function whose name and length change between reads crosses with text and a count", async () => { + const { counter, object } = textual() + const host = () => null + let names = 0 + let lengths = 0 + Object.defineProperty(host, "name", { get: () => (names++ === 0 ? "safe" : object) }) + Object.defineProperty(host, "length", { get: () => (lengths++ < 2 ? 1 : object) }) + expect( + await value(`const f = sample(); return [typeof f.name, f.name, typeof f.length, f.length]`, returning(host)), + ).toEqual(["string", "safe", "number", 1]) + expect(counter.conversions).toBe(0) + }) + + test("a function whose name and length are objects crosses with neither", async () => { + const { counter, object } = textual() + const host = () => null + Object.defineProperty(host, "name", { value: object }) + Object.defineProperty(host, "length", { value: object }) + expect(await value(`const f = sample(); return [f.name, f.length]`, returning(host))).toEqual(["", 0]) + expect(counter.conversions).toBe(0) }) })