UNPKG

@bitkyc08/opencodex

Version:

Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code

293 lines (287 loc) • 15.6 kB
import { createHash } from "node:crypto"; import { win32 } from "node:path"; import type { Library, Symbols } from "bun:ffi"; import { MAX_NATIVE_BACKING_BYTES } from "./cli-installation-limits"; const KERNEL_SYMBOLS = { GetDriveTypeW: { args: ["ptr"], returns: "u32" }, GetVolumeNameForVolumeMountPointW: { args: ["ptr", "ptr", "u32"], returns: "i32" }, CreateFileW: { args: ["ptr", "u32", "u32", "ptr", "u32", "u32", "u64"], returns: "u64" }, GetFileInformationByHandleEx: { args: ["u64", "i32", "ptr", "u32"], returns: "i32" }, GetFileType: { args: ["u64"], returns: "u32" }, GetFinalPathNameByHandleW: { args: ["u64", "ptr", "u32", "u32"], returns: "u32" }, ReadFile: { args: ["u64", "ptr", "u32", "ptr", "ptr"], returns: "i32" }, CloseHandle: { args: ["u64"], returns: "i32" }, } as const satisfies Symbols; const NT_SYMBOLS = { NtCreateFile: { args: ["ptr", "u32", "ptr", "ptr", "ptr", "u32", "u32", "u32", "u32", "ptr", "u32"], returns: "i32" }, } as const satisfies Symbols; export interface WindowsInstallationFileRequest { readonly path: string; readonly maxBytes: number; readonly hashOnly?: boolean; /** Validate and hold the path without reading its contents. */ readonly metadataOnly?: boolean; /** Read at most maxBytes from the start instead of refusing an oversized file. */ readonly prefixOnly?: boolean; /** Same held stream, domain-separated archive/readback comparison. Default remains raw SHA-256. */ readonly installationDigest?: boolean; /** Hold a directory rather than a file; requires metadataOnly. */ readonly directory?: boolean; /** Refuse aliases unless the held object's normalized DOS name matches the input. */ readonly requireCanonicalPath?: boolean; } export interface WindowsInstallationFileIdentity { readonly volumeSerial: string; readonly fileId: string; readonly size: number; readonly lastWriteTime: string; readonly changeTime: string; } export type WindowsInstallationFilesResult = | { kind: "observed"; files: { path: string; identity: WindowsInstallationFileIdentity; bytes: Uint8Array; digest: string; }[] } | { kind: "refused"; reason: "unsupported-platform" | "invalid-request" | "native-api-unavailable" | "volume-unavailable" | "not-found" | "open-refused" | "reparse-point" | "not-regular-file" | "size-limit" | "read-failed" | "identity-changed" | "inspection-failed" }; type Refusal = Extract<WindowsInstallationFilesResult, { kind: "refused" }>["reason"]; /** Only these two NTSTATUS values prove that a candidate or its ancestor is absent. */ export function ntCreateFileRefusal(status: number): Refusal { switch (status >>> 0) { case 0xc0000034: // STATUS_OBJECT_NAME_NOT_FOUND case 0xc000003a: // STATUS_OBJECT_PATH_NOT_FOUND return "not-found"; default: return "open-refused"; } } class InspectionRefusal extends Error { constructor(readonly reason: Refusal) { super(reason); } } const MIB = 1024 * 1024; // One native backing, the unchanged production Node bound, and at most twelve // bounded text requests. This is an I/O ceiling; hash-only buffers stay empty. const MAX_REQUEST_BYTES = MAX_NATIVE_BACKING_BYTES + (128 + 12) * MIB; const REPARSE = 0x400; const DIRECTORY = 0x10; const INVALID_HANDLE = 0xffffffffffffffffn; /** Compare the normalized DOS long name returned by an already-held handle. */ export function windowsCanonicalPathMatches(path: string, canonical: string): boolean { return canonical.startsWith("\\\\?\\") && canonical.slice(4).toLowerCase() === win32.normalize(path).toLowerCase(); } let openedForTests: (() => void) | undefined; /** Runs after handles are held, for real Windows sharing/rename regression fixtures. */ export function setWindowsInstallationFilesOpenedForTests(callback?: () => void): void { openedForTests = callback; } let readForTests: ((path: string, bytesRead: number) => void) | undefined; /** Runs once per request with its streamed content bytes (0 for metadata-only), for read accounting. */ export function setWindowsInstallationFilesReadForTests(callback?: (path: string, bytesRead: number) => void): void { readForTests = callback; } function components(path: string): { drive: string; names: string[] } | null { if (typeof path !== "string" || path.length > 8192 || !/^[A-Za-z]:[\\/]/.test(path)) return null; const names = path.slice(3).split(/[\\/]/); if (!names.length || names.length > 64 || names.some(name => !name || name === "." || name === ".." || /[\x00-\x1f<>:"|?*]/.test(name) || /[. ]$/.test(name) || /^(?:con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(name))) return null; return { drive: `${path[0]!.toUpperCase()}:\\`, names }; } /** * An explicit, read-only snapshot; never installation authority or a runtime-selection proof. * All component opens are relative to held directory handles, not checked-then-reopened paths. * Windows x64 only: the UNICODE_STRING/OBJECT_ATTRIBUTES layouts below are the x64 ABI. * No candidate runs and no shell/compiler is started. Disk/driver latency is not a hard deadline. * API contracts: learn.microsoft.com/windows/win32/api/winternl/nf-winternl-ntcreatefile * and /windows/win32/api/fileapi/nf-fileapi-getvolumenameforvolumemountpointw. */ export async function inspectWindowsInstallationFiles( requests: readonly WindowsInstallationFileRequest[], finalize?: (files: Extract<WindowsInstallationFilesResult, { kind: "observed" }>["files"]) => boolean | Promise<boolean>, ): Promise<WindowsInstallationFilesResult> { if (!Array.isArray(requests) || requests.length === 0 || requests.length > 12) { return { kind: "refused", reason: "invalid-request" }; } let ceiling = 0; const parsed = requests.map(request => { const parsedPath = request && components(request.path); if (!parsedPath || !Number.isSafeInteger(request.maxBytes) || request.maxBytes < 0 || (request.hashOnly !== undefined && typeof request.hashOnly !== "boolean") || (request.metadataOnly !== undefined && typeof request.metadataOnly !== "boolean") || (request.prefixOnly !== undefined && typeof request.prefixOnly !== "boolean") || (request.installationDigest !== undefined && typeof request.installationDigest !== "boolean") || (request.directory !== undefined && typeof request.directory !== "boolean") || (request.requireCanonicalPath !== undefined && typeof request.requireCanonicalPath !== "boolean") || (request.directory && !request.metadataOnly) || request.maxBytes > (request.hashOnly ? MAX_NATIVE_BACKING_BYTES : MIB)) return null; ceiling += request.maxBytes; return parsedPath; }); if (parsed.some(path => path === null) || ceiling > MAX_REQUEST_BYTES) { return { kind: "refused", reason: "invalid-request" }; } if (process.platform !== "win32" || process.arch !== "x64") { return { kind: "refused", reason: "unsupported-platform" }; } // Loading FFI is itself opt-in; importing this module performs no Windows inspection. let ffi: typeof import("bun:ffi"); try { ffi = await import("bun:ffi"); } catch { return { kind: "refused", reason: "native-api-unavailable" }; } let kernel: Library<typeof KERNEL_SYMBOLS> | undefined; let nt: Library<typeof NT_SYMBOLS> | undefined; const handles: bigint[] = []; try { try { kernel = ffi.dlopen("kernel32.dll", KERNEL_SYMBOLS); nt = ffi.dlopen("ntdll.dll", NT_SYMBOLS); } catch { throw new InspectionRefusal("native-api-unavailable"); } const k = kernel.symbols; const wide = (text: string): Buffer => Buffer.from(`${text}\0`, "utf16le"); const keep = (handle: bigint): bigint => { if (handle === 0n || handle === INVALID_HANDLE) throw new InspectionRefusal("open-refused"); handles.push(handle); return handle; }; const info = (handle: bigint, infoClass: number, length: number): Buffer => { const buffer = Buffer.alloc(length); if (!k.GetFileInformationByHandleEx!(handle, infoClass, ffi.ptr(buffer), length)) { throw new InspectionRefusal("inspection-failed"); } return buffer; }; const inspect = (handle: bigint, directory: boolean): WindowsInstallationFileIdentity => { if (k.GetFileType!(handle) !== 1) throw new InspectionRefusal("not-regular-file"); // FILE_TYPE_DISK const basic = info(handle, 0, 40); // FILE_BASIC_INFO: 4 LARGE_INTEGERs, attributes. const attributes = basic.readUInt32LE(32); if (attributes & REPARSE) throw new InspectionRefusal("reparse-point"); if (Boolean(attributes & DIRECTORY) !== directory) throw new InspectionRefusal("not-regular-file"); const id = info(handle, 18, 24); // FILE_ID_INFO: volume serial and 128-bit file ID. const standard = info(handle, 1, 24); // FILE_STANDARD_INFO.EndOfFile const size = standard.readBigInt64LE(8); if (size < 0n || size > BigInt(Number.MAX_SAFE_INTEGER)) throw new InspectionRefusal("size-limit"); return { volumeSerial: id.readBigUInt64LE(0).toString(16), fileId: id.subarray(8, 24).toString("hex"), size: Number(size), lastWriteTime: basic.readBigInt64LE(16).toString(), changeTime: basic.readBigInt64LE(24).toString() }; }; const roots = new Map<string, bigint>(); const root = (drive: string): bigint => { const held = roots.get(drive); if (held !== undefined) return held; const mount = wide(drive); const name = Buffer.alloc(100 * 2); if (![2, 3, 5, 6].includes(Number(k.GetDriveTypeW!(ffi.ptr(mount))))) { throw new InspectionRefusal("volume-unavailable"); } // Root-only volume management query, never a candidate-controlled ancestor traversal. // This API does not support SMB; only a strict local volume GUID reaches CreateFileW. if (!k.GetVolumeNameForVolumeMountPointW!(ffi.ptr(mount), ffi.ptr(name), 100)) { throw new InspectionRefusal("volume-unavailable"); } const guid = name.toString("utf16le").split("\0", 1)[0]!; if (!/^\\\\\?\\Volume\{[0-9a-f-]{36}\}\\$/i.test(guid)) throw new InspectionRefusal("volume-unavailable"); const path = wide(guid); const handle = keep(BigInt(k.CreateFileW!(ffi.ptr(path), 0x100081, 1, null, 3, 0x02200000, 0n))); inspect(handle, true); roots.set(drive, handle); return handle; }; const relativeOpen = (parent: bigint, component: string, directory: boolean): bigint => { const name = wide(component); const unicode = Buffer.alloc(16); unicode.writeUInt16LE(name.length - 2, 0); unicode.writeUInt16LE(name.length, 2); unicode.writeBigUInt64LE(BigInt(ffi.ptr(name)), 8); const attributes = Buffer.alloc(48); attributes.writeUInt32LE(48, 0); attributes.writeBigUInt64LE(parent, 8); attributes.writeBigUInt64LE(BigInt(ffi.ptr(unicode)), 16); attributes.writeUInt32LE(0x40, 24); // OBJ_CASE_INSENSITIVE; one component only. const output = Buffer.alloc(8); const status = Buffer.alloc(16); // FILE_OPEN; FILE_SYNCHRONOUS_IO_NONALERT; FILE_OPEN_REPARSE_POINT. // Share READ only: while held, writes/reparse edits and delete/rename opens are refused. const result = nt!.symbols.NtCreateFile!(ffi.ptr(output), 0x100081, ffi.ptr(attributes), ffi.ptr(status), null, 0, 1, 1, 0x200020 | (directory ? 1 : 0), null, 0); if (result < 0) throw new InspectionRefusal(ntCreateFileRefusal(result)); const handle = keep(output.readBigUInt64LE(0)); inspect(handle, directory); return handle; }; const directories = new Map<string, bigint>(); const checkCanonicalPath = (handle: bigint, path: string): void => { const output = Buffer.alloc(32768 * 2); // FILE_NAME_NORMALIZED | VOLUME_NAME_DOS: a final long name from the // already held, reparse-refusing handle, never realpath/check/reopen. const length = k.GetFinalPathNameByHandleW!(handle, ffi.ptr(output), 32768, 0); if (!length || length >= 32768) throw new InspectionRefusal("inspection-failed"); const canonical = output.toString("utf16le", 0, length * 2); if (!windowsCanonicalPathMatches(path, canonical)) { throw new InspectionRefusal("invalid-request"); } }; const files = requests.map((request, index) => { const { drive, names } = parsed[index]!; let parent = root(drive); let key = drive; for (const component of names.slice(0, -1)) { key += `${component}\\`; let handle = directories.get(key); if (handle === undefined) { handle = relativeOpen(parent, component, true); directories.set(key, handle); } parent = handle; } const handle = relativeOpen(parent, names[names.length - 1]!, Boolean(request.directory)); const identity = inspect(handle, Boolean(request.directory)); if (request.requireCanonicalPath) checkCanonicalPath(handle, request.path); if (!request.metadataOnly && !(request.prefixOnly && !request.hashOnly) && identity.size > request.maxBytes) throw new InspectionRefusal("size-limit"); return { request, handle, identity }; }); openedForTests?.(); const observed = files.map(({ request, handle, identity }) => { const hash = createHash("sha256"); if (request.installationDigest) hash.update("codex-cli-observed-file-v1\0"); if (request.metadataOnly) { readForTests?.(request.path, 0); return { path: request.path, identity, bytes: new Uint8Array(), digest: "" }; } const truncated = Boolean(request.prefixOnly) && !request.hashOnly && identity.size > request.maxBytes; const readLimit = truncated ? request.maxBytes : identity.size; const bytes = request.hashOnly ? new Uint8Array() : new Uint8Array(readLimit); const chunk = Buffer.alloc(Math.min(MIB, Math.max(1, readLimit))); const read = Buffer.alloc(4); let offset = 0; while (offset < readLimit) { const length = Math.min(chunk.length, readLimit - offset); if (!k.ReadFile!(handle, ffi.ptr(chunk), length, ffi.ptr(read), null)) throw new InspectionRefusal("read-failed"); const count = read.readUInt32LE(0); if (!count || count > length) throw new InspectionRefusal("read-failed"); if (!request.hashOnly) bytes.set(chunk.subarray(0, count), offset); if (!truncated) hash.update(chunk.subarray(0, count)); offset += count; } if (!truncated) { if (!k.ReadFile!(handle, ffi.ptr(chunk), 1, ffi.ptr(read), null) || read.readUInt32LE(0) !== 0) { throw new InspectionRefusal("identity-changed"); } } readForTests?.(request.path, offset); return { path: request.path, identity, bytes, digest: truncated ? "" : hash.digest("hex") }; }); if (finalize && !await finalize(observed)) throw new InspectionRefusal("identity-changed"); for (const file of files) { if (file.request.requireCanonicalPath) checkCanonicalPath(file.handle, file.request.path); if (JSON.stringify(inspect(file.handle, Boolean(file.request.directory))) !== JSON.stringify(file.identity)) { throw new InspectionRefusal("identity-changed"); } } return { kind: "observed", files: observed }; } catch (error) { return { kind: "refused", reason: error instanceof InspectionRefusal ? error.reason : "inspection-failed" }; } finally { for (const handle of handles.reverse()) kernel?.symbols.CloseHandle?.(handle); nt?.close(); kernel?.close(); } }