UNPKG

@bitkyc08/opencodex

Version:

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

266 lines (258 loc) • 12.6 kB
import { randomBytes } from "node:crypto"; import { closeSync, constants, fchmodSync, fstatSync, lstatSync, mkdirSync, openSync, readSync, renameSync, unlinkSync, writeFileSync, type BigIntStats } from "node:fs"; import { basename, dirname, join } from "node:path"; import { withClientLifecycleSync } from "../../client/lifecycle-lock"; import { forgetEphemeralSecretPath, hardenSecretDir, hardenSecretPath, windowsSecretAclApplies } from "../../lib/windows-secret-acl"; import { assertLocalCaWindowsAcl } from "./local-ca-windows"; const NOFOLLOW = constants.O_NOFOLLOW ?? 0; const NONBLOCK = constants.O_NONBLOCK ?? 0; const MAX_PEM_BYTES = 64 * 1024; const KEY = "ca.key"; const CERT = "ca.pem"; type FileMode = 0o600 | 0o644; type AclLevel = "owner" | "inherited" | "private"; type AclCheck = ((path: string, stat: BigIntStats, level?: AclLevel) => void) & { forget(stat: BigIntStats): void }; type FileHooks = { beforeRead?: (path: string) => void; beforeWrite?: (path: string) => void; beforePublish?: (path: string) => void }; let hooks: FileHooks = {}; /** Boundary fault injection for substitution and zero-secret-write assertions. */ export function setLocalCaFileHooksForTests(next: FileHooks | null): void { hooks = next ?? {}; } function unsafe(): Error { return Object.assign(new Error("Local CA requires safe owner-controlled files and directory"), { code: "local_ca_path_unsafe" }); } function missing(error: unknown): boolean { return (error as NodeJS.ErrnoException)?.code === "ENOENT"; } function owned(stat: BigIntStats, directory = false, mode: FileMode = 0o600): void { if (stat.isSymbolicLink() || !(directory ? stat.isDirectory() : stat.isFile() && stat.nlink === 1n)) throw unsafe(); if (!windowsSecretAclApplies()) { if (typeof process.geteuid !== "function" || stat.uid !== BigInt(process.geteuid())) throw unsafe(); const forbidden = directory || mode === 0o600 ? 0o077 : 0o022; if ((Number(stat.mode) & forbidden) !== 0) throw unsafe(); } } function same(path: string, expected: BigIntStats, directory = false, mode: FileMode = 0o600): BigIntStats { const stat = lstatSync(path, { bigint: true }); owned(stat, directory, mode); if (stat.dev !== expected.dev || stat.ino !== expected.ino || stat.ino === 0n) throw unsafe(); return stat; } function inspect(path: string, mode: FileMode, checkAcl: AclCheck, sqliteSidecar = false): BigIntStats | null { let stat: BigIntStats; try { stat = lstatSync(path, { bigint: true }); } catch (error) { if (missing(error)) return null; throw error; } owned(stat, false, mode); if (windowsSecretAclApplies()) { if (sqliteSidecar) checkAcl(path, stat, "inherited"); else { try { checkAcl(path, stat); } catch { // Legacy files may inherit only trusted grants; verify before narrowing. checkAcl(path, stat, "inherited"); same(path, stat, false, mode); hardenSecretPath(path, { required: true }); same(path, stat, false, mode); checkAcl(path, stat); } } } same(path, stat, false, mode); return stat; } function protectNew(path: string, fd: number, mode: FileMode, checkAcl: AclCheck): void { const created = fstatSync(fd, { bigint: true }); owned(created, false, mode); if (windowsSecretAclApplies()) { // Only O_CREAT|O_EXCL entries reach here. Narrow the empty file we created, // then strictly verify before writing; an Administrators default owner still fails closed. same(path, created, false, mode); hardenSecretPath(path, { required: true }); checkAcl(path, created); } else fchmodSync(fd, mode); same(path, created, false, mode); } function readPinned(path: string, expected: BigIntStats, mode: FileMode, assertDirectory: () => void, checkAcl: AclCheck): string { hooks.beforeRead?.(path); assertDirectory(); same(path, expected, false, mode); const fd = openSync(path, constants.O_RDONLY | NOFOLLOW | NONBLOCK); try { const opened = fstatSync(fd, { bigint: true }); owned(opened, false, mode); if (opened.dev !== expected.dev || opened.ino !== expected.ino || opened.size > BigInt(MAX_PEM_BYTES)) throw unsafe(); checkAcl(path, opened); same(path, opened, false, mode); const bytes = Buffer.alloc(MAX_PEM_BYTES + 1); let length = 0; while (length < bytes.length) { const count = readSync(fd, bytes, length, bytes.length - length, length); if (!count) break; length += count; } const after = fstatSync(fd, { bigint: true }); owned(after, false, mode); if (length > MAX_PEM_BYTES || BigInt(length) !== after.size || after.mtimeNs !== opened.mtimeNs || after.ctimeNs !== opened.ctimeNs) throw unsafe(); same(path, opened, false, mode); assertDirectory(); return bytes.subarray(0, length).toString("utf8"); } finally { closeSync(fd); } } export interface LocalCaFiles { readPair(): { certPem: string; keyPem: string } | null; writePair(pair: { certPem: string; keyPem: string }): void; } function stage(path: string, contents: string, mode: FileMode, assertDirectory: () => void, checkAcl: AclCheck): { publish(): void; dispose(): void } { assertDirectory(); const previous = inspect(path, mode, checkAcl); const temp = join(dirname(path), `.${basename(path)}.${process.pid}.${randomBytes(16).toString("hex")}.tmp`); const fd = openSync(temp, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | NOFOLLOW | NONBLOCK, mode); let created: BigIntStats; try { created = fstatSync(fd, { bigint: true }); } catch (error) { closeSync(fd); throw error; } let closed = false; let removed = false; const dispose = (): void => { if (!closed) { closed = true; closeSync(fd); } if (removed) return; try { same(temp, created, false, mode); unlinkSync(temp); removed = true; } catch (error) { if (missing(error)) removed = true; else throw error; } if (removed) { checkAcl.forget(created); forgetEphemeralSecretPath(temp); } }; try { protectNew(temp, fd, mode, checkAcl); assertDirectory(); hooks.beforeWrite?.(temp); same(temp, created, false, mode); assertDirectory(); checkAcl(temp, created); writeFileSync(fd, contents, { encoding: "utf8" }); same(temp, created, false, mode); return { publish() { hooks.beforePublish?.(path); assertDirectory(); same(temp, created, false, mode); checkAcl(temp, created); const current = inspect(path, mode, checkAcl); if (previous ? !current || previous.dev !== current.dev || previous.ino !== current.ino : current !== null) throw unsafe(); renameSync(temp, path); if (current) checkAcl.forget(current); removed = true; forgetEphemeralSecretPath(temp); same(path, created, false, mode); assertDirectory(); }, dispose, }; } catch (error) { try { dispose(); } catch { /* preserve safety failure; never remove a substituted path */ } throw error; } } /** Guard every CA entry before SQLite or PEM access. The directory and lock stay pinned. */ export function withLocalCaPublication<T>(dir: string, lockName: string, work: (files: LocalCaFiles) => T): T { if (basename(lockName) !== lockName || [KEY, CERT, ".", ".."].includes(lockName)) throw unsafe(); mkdirSync(dirname(dir), { recursive: true, mode: 0o700 }); let created = false; try { mkdirSync(dir, { mode: 0o700 }); created = true; } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; } // Publication-local only: a private DACL can be changed only by the owner, // SYSTEM or Administrators. Every memo hit still checks lstat identity via same(). // bigint birthtimeNs adds discrimination for recycled SQLite sidecar file IDs; it is not a // uniqueness guarantee (NTFS tunneling can restore creation times). Safety rests on the // verified-private directory DACL. Creation time survives same-volume rename, so staged // entries keep their memo. const verified = new Map<string, AclLevel>(); const strength = { owner: 0, inherited: 1, private: 2 }; const checkAcl: AclCheck = Object.assign((path: string, stat: BigIntStats, level: AclLevel = "private") => { if (!windowsSecretAclApplies()) return; const identity = same(path, stat, stat.isDirectory()); const key = `${identity.dev}:${identity.ino}:${identity.birthtimeNs}`; const prior = verified.get(key); if (prior !== undefined && strength[prior] >= strength[level]) return; assertLocalCaWindowsAcl(path, level); same(path, stat, stat.isDirectory()); verified.set(key, level); }, { // An identity this publication unlinked or replaced is retired; a recycled id must be re-inspected. forget(stat: BigIntStats): void { verified.delete(`${stat.dev}:${stat.ino}:${stat.birthtimeNs}`); }, }); const directory = lstatSync(dir, { bigint: true }); owned(directory, true); const dirFd = windowsSecretAclApplies() ? null : openSync(dir, constants.O_RDONLY | (constants.O_DIRECTORY ?? 0) | NOFOLLOW); let lockFd: number | undefined; try { if (dirFd !== null) { const opened = fstatSync(dirFd, { bigint: true }); if (opened.dev !== directory.dev || opened.ino !== directory.ino) throw unsafe(); owned(opened, true); } else { let needsHardening = created; // A successful mkdir created this directory; strict verification after narrowing // still refuses an Administrators default owner before any CA access. if (!created) { try { checkAcl(dir, directory); } catch { checkAcl(dir, directory, "inherited"); needsHardening = true; } } if (needsHardening) { same(dir, directory, true); hardenSecretDir(dir, { required: true }); same(dir, directory, true); checkAcl(dir, directory); } } const assertDirectory = (): void => { same(dir, directory, true); }; assertDirectory(); const lockPath = join(dir, lockName); const assertEntries = (): void => { assertDirectory(); inspect(join(dir, KEY), 0o600, checkAcl); inspect(join(dir, CERT), 0o644, checkAcl); inspect(lockPath, 0o600, checkAcl); // SQLite creates sidecars itself, inheriting only the protected directory's // current-user ACE. Inspect every grant and owner; an inherited DACL is valid here. for (const suffix of ["-journal", "-wal", "-shm"]) inspect(`${lockPath}${suffix}`, 0o600, checkAcl, true); assertDirectory(); }; assertEntries(); try { lockFd = openSync(lockPath, constants.O_RDWR | constants.O_CREAT | constants.O_EXCL | NOFOLLOW | NONBLOCK, 0o600); protectNew(lockPath, lockFd, 0o600, checkAcl); } catch (error) { if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error; const existing = inspect(lockPath, 0o600, checkAcl); if (!existing) throw unsafe(); lockFd = openSync(lockPath, constants.O_RDONLY | NOFOLLOW | NONBLOCK); const opened = fstatSync(lockFd, { bigint: true }); owned(opened); if (opened.dev !== existing.dev || opened.ino !== existing.ino) throw unsafe(); } const lock = fstatSync(lockFd, { bigint: true }); assertEntries(); same(lockPath, lock); return withClientLifecycleSync(() => { same(lockPath, lock); assertEntries(); const files: LocalCaFiles = { readPair() { assertEntries(); const cert = inspect(join(dir, CERT), 0o644, checkAcl); const key = inspect(join(dir, KEY), 0o600, checkAcl); if (!cert || !key) return null; return { certPem: readPinned(join(dir, CERT), cert, 0o644, assertDirectory, checkAcl), keyPem: readPinned(join(dir, KEY), key, 0o600, assertDirectory, checkAcl) }; }, writePair(pair) { assertEntries(); const key = stage(join(dir, KEY), pair.keyPem, 0o600, assertDirectory, checkAcl); let cert: ReturnType<typeof stage> | undefined; try { cert = stage(join(dir, CERT), pair.certPem, 0o644, assertDirectory, checkAcl); assertEntries(); key.publish(); cert.publish(); } finally { try { key.dispose(); } finally { cert?.dispose(); } } }, }; const value = work(files); same(lockPath, lock); assertEntries(); return value; }, { lockPath }); } finally { try { if (lockFd !== undefined) closeSync(lockFd); } finally { if (dirFd !== null) closeSync(dirFd); } } }