UNPKG

@bitkyc08/opencodex

Version:

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

448 lines (411 loc) • 18.2 kB
/** * Resolve the effective Windows token to the locale-independent SID form that * icacls accepts ("*S-1-..."). Environment values such as USERDOMAIN are not * an authority for the current token: on workgroup machines USERDOMAIN may be * the literal WORKGROUP even though the account belongs to the local computer. * * There is deliberately NO name-shaped fallback. A `DOMAIN\User` string has a * valid shape, but shape is not evidence that the account is the current * token's subject, and both environment variables are writable by whatever * launched us. A wrong principal here is not cosmetic: `runIcacls` grants it * Full Control and then removes inheritance, so a wrong grant either leaves a * different account holding the secret or strands the file with no usable ACE. * When the SID cannot be resolved, the caller declines to touch the ACL at all. * * Windows x64 reads SID and account name natively. The async path owns one * Worker through closure, with a separate monotonic deadline per caller. A late * result cannot enter the successful identity cache. The sync path checks elapsed * time after its native call; synchronous FFI cannot be interrupted. Unsupported * architectures retain the trusted, bounded PowerShell helper. */ import { existsSync } from "node:fs"; import { win32 as windowsPath } from "node:path"; import { waitForSubprocessExit } from "./bounded-subprocess"; import { decodeWindowsTextBytes } from "./windows-text"; import { resolveWindowsNativePrincipal, resolveWindowsNativePrincipalAsync, type NativeWindowsPrincipal, } from "./windows-native-principal"; import { resolveTrustedWindowsPowerShellExe, WindowsSystemDirectoryFfiUnavailableError, } from "./windows-elevation"; /** * Shared ceiling for a full effective-token identity lookup. Fallback PowerShell startup can * legitimately take several seconds on loaded desktops as well as CI, so every caller * that is not spending a smaller pre-existing deadline uses the same #2914-tested budget. */ export const WINDOWS_PRINCIPAL_LOOKUP_TIMEOUT_MS = 30_000; const SID_PATTERN = /^S-1-(?:\d+-)+\d+$/i; const IDENTITY_EXPRESSION = "$identity=[System.Security.Principal.WindowsIdentity]::GetCurrent();$identity.User.Value;$identity.Name"; const DEFAULT_WINDOWS_ARM64_POWERSHELL = windowsPath.join( "C:\\Windows\\System32", "WindowsPowerShell", "v1.0", "powershell.exe", ); type PrincipalExecutableResolution = Readonly<{ platform: NodeJS.Platform; arch: string; resolveTrusted: () => string; pathExists: (path: string) => boolean; }>; /** * Bun's Windows ARM64 build cannot currently execute the `bun:ffi` call used * by the general System32 resolver. The ACL identity lookup has a narrower * authority than the elevation helpers: it starts one non-elevated PowerShell * command and accepts only a SID-shaped result. Keep its fallback equally * narrow by using the fixed, OS-protected default installation path only. * * Environment and PATH lookup are deliberately absent. A Windows installation * outside C:\\Windows keeps failing closed rather than executing a binary chosen * by caller-controlled `SystemRoot`, `WINDIR`, or `PATH` values. */ function resolveWindowsPrincipalPowerShellExecutable( resolution: PrincipalExecutableResolution = { platform: process.platform, arch: process.arch, resolveTrusted: resolveTrustedWindowsPowerShellExe, pathExists: existsSync, }, ): string { try { return resolution.resolveTrusted(); } catch (error) { if ( !(error instanceof WindowsSystemDirectoryFfiUnavailableError) || resolution.platform !== "win32" || resolution.arch !== "arm64" || !resolution.pathExists(DEFAULT_WINDOWS_ARM64_POWERSHELL) ) { throw error; } return DEFAULT_WINDOWS_ARM64_POWERSHELL; } } /** Test-only dependency-injected view of the Windows ARM64 executable boundary. */ export function resolveWindowsPrincipalPowerShellExecutableForTests( resolution: PrincipalExecutableResolution, ): string { return resolveWindowsPrincipalPowerShellExecutable(resolution); } export interface WindowsPrincipalLookupResult { success: boolean; exitCode: number | null; timedOut: boolean; /** * Raw child stdout. Bytes are allowed because `powershell.exe` writes the console * output code page, not UTF-8, and the decode below is the thing under test: a seam * that only carried a decoded string could never exercise it. */ stdout: string | Uint8Array; } export type WindowsPrincipalRunner = ( timeoutMs: number, ) => WindowsPrincipalLookupResult; export type AsyncWindowsPrincipalRunner = ( timeoutMs: number, ) => Promise<WindowsPrincipalLookupResult>; const POWERSHELL_ARGS = [ "-NoLogo", "-NoProfile", "-NonInteractive", "-Command", IDENTITY_EXPRESSION, ] as const; function windowsPrincipalPowerShellCommand(): string[] { return [resolveWindowsPrincipalPowerShellExecutable(), ...POWERSHELL_ARGS]; } /** Test-only readback of the exact trusted executable and static arguments. */ export function windowsPrincipalPowerShellCommandForTests(): string[] { return windowsPrincipalPowerShellCommand(); } function defaultWindowsPrincipalRunner(timeoutMs: number): WindowsPrincipalLookupResult { const started = performance.now(); const native = nativeLookups.sync(); const remaining = timeoutMs - (performance.now() - started); if (remaining <= 0) return { success: false, exitCode: null, timedOut: true, stdout: "" }; if (native) return nativeResult(native); const result = Bun.spawnSync(windowsPrincipalPowerShellCommand(), { stdin: "ignore", stdout: "pipe", stderr: "ignore", timeout: Math.max(1, remaining), windowsHide: true, }); return { success: result.success, exitCode: result.exitCode, timedOut: result.exitedDueToTimeout ?? false, // Bytes, NOT .toString(): that is UTF-8, and Windows PowerShell 5.1 emits the // console output code page. A non-ASCII account name decoded as UTF-8 becomes // U+FFFD and is then frozen into the identity cache. stdout: result.stdout ?? new Uint8Array(), }; } async function defaultAsyncWindowsPrincipalRunner( timeoutMs: number, ): Promise<WindowsPrincipalLookupResult> { const started = performance.now(); const native = await nativeLookups.async(timeoutMs); const remaining = timeoutMs - (performance.now() - started); if (remaining <= 0) return { success: false, exitCode: null, timedOut: true, stdout: "" }; if (native) return nativeResult(native); const proc = Bun.spawn(windowsPrincipalPowerShellCommand(), { stdin: "ignore", stdout: "pipe", stderr: "ignore", windowsHide: true, }); // No kill grace. The grace exists so a dying child releases a path someone is about to // remove; this lookup holds no such path, and it runs during `ocx start`, where the composed // acceptance cases already measure real startups at up to 38.8s against a bounded watchdog. // Paying two extra seconds per timed-out resolution there buys nothing and costs margin. const { exitCode, timedOut } = await waitForSubprocessExit(proc, remaining, 0); // `.bytes()` rather than `.text()`, for the same reason as the sync runner above. const stdout: string | Uint8Array = !timedOut && proc.stdout ? await new Response(proc.stdout).bytes().catch(() => new Uint8Array()) : ""; return { success: !timedOut && exitCode === 0, exitCode: timedOut ? null : exitCode, timedOut, stdout, }; } let principalRunner: WindowsPrincipalRunner = defaultWindowsPrincipalRunner; let asyncPrincipalRunner: AsyncWindowsPrincipalRunner = defaultAsyncWindowsPrincipalRunner; let principalLocaleForTests: string | undefined; const defaultNativeLookups = { sync: resolveWindowsNativePrincipal, async: resolveWindowsNativePrincipalAsync }; let nativeLookups = defaultNativeLookups; let defaultAsyncCallers = 0; function nativeResult(identity: NativeWindowsPrincipal): WindowsPrincipalLookupResult { return { success: true, exitCode: 0, timedOut: false, stdout: `${identity.sid}\n${identity.name}` }; } /** Boundary injection; undefined restores production. Existing runner overrides still win. */ export function setNativeWindowsPrincipalLookupsForTests(next: typeof defaultNativeLookups | null): void { if (asyncLookupInFlight || defaultAsyncCallers) throw new Error("Cannot replace a native lookup in flight."); nativeLookups = next ?? defaultNativeLookups; cachedIdentity = null; } /** * Decode child stdout the way the rest of this repository already decodes Windows * console output: UTF-16 with or without a BOM, then STRICT UTF-8, then the locale's * legacy code page. Strict-UTF-8-first is what keeps an ordinary UTF-8 host unaffected. * * The SID on the first line is ASCII by construction and survives either way, which is * why this corruption stayed silent: only the account name on the second line breaks. */ function decodePrincipalStdout(stdout: string | Uint8Array): string { if (typeof stdout === "string") return stdout; return decodeWindowsTextBytes( stdout, principalLocaleForTests ? { locale: principalLocaleForTests } : {}, ); } export interface WindowsPrincipalIdentity { readonly sid: string; readonly name: string; } let cachedIdentity: WindowsPrincipalIdentity | null = null; let asyncLookupInFlight: Promise<string> | null = null; /** * POSIX CI drives the Windows ACL branch through `setPlatformForTests("win32")`, * on hosts that have neither System32 nor PowerShell. Those runs need SOME * principal, so this seam supplies a synthetic one. * * It lives here rather than in `windows-secret-acl.ts` for one reason that is * not cosmetic: an explicitly injected runner must be able to beat it. When the * synthetic value was chosen first, in the ACL module, a test could not inject a * lookup FAILURE on POSIX at all — so the fail-closed and memo-isolation cases * were guarded with `if (process.platform !== "win32") return;` and never ran * outside Windows. Resolution order below is what makes those cases executable * on every runner. */ let syntheticPrincipalForTests: string | null = null; /** * Test seam: supply the principal used when no runner was injected and the host * is not really Windows. Pass null to disable. */ export function setSyntheticWindowsPrincipalForTests(principal: string | null): void { syntheticPrincipalForTests = principal; cachedIdentity = null; } /** True when an explicit runner override is installed and must take precedence. */ function hasSyncRunnerOverride(): boolean { return principalRunner !== defaultWindowsPrincipalRunner; } function hasAsyncRunnerOverride(): boolean { return asyncPrincipalRunner !== defaultAsyncWindowsPrincipalRunner; } function identityError(reason: string): NodeJS.ErrnoException { const error = new Error(`Windows effective-account SID lookup ${reason}`) as NodeJS.ErrnoException; // Keep identity lookup failures distinct from icacls timeouts. In particular, // they must not populate windows-secret-acl's destination timeout memo. error.code = "EACLIDENTITY"; return error; } function identityFromResult(result: WindowsPrincipalLookupResult): WindowsPrincipalIdentity { if (!result.success) { throw identityError(result.timedOut ? "timed out" : `exited ${result.exitCode ?? "null"}`); } const lines = decodePrincipalStdout(result.stdout).trim().split(/\r?\n/); const sid = lines[0]?.trim() ?? ""; const name = lines[1]?.trim() ?? ""; if (!SID_PATTERN.test(sid)) { throw identityError(sid ? "returned an invalid SID" : "returned an empty SID"); } if (!name || lines.length !== 2) { throw identityError(name ? "returned an ambiguous account name" : "returned an empty account name"); } return Object.freeze({ sid: sid.toUpperCase(), name }); } /** Read the effective-token identity only when an earlier lookup already cached it. */ export function cachedCurrentWindowsIdentity(): WindowsPrincipalIdentity | null { return cachedIdentity; } /** Resolve and process-cache the effective token SID for synchronous ACL paths. */ export function resolveCurrentWindowsPrincipal(timeoutMs: number): string { // Order matters: an explicitly injected runner outranks the synthetic value, // so a test can inject a FAILURE on a POSIX host. See the seam comment above. if (hasSyncRunnerOverride()) { if (cachedIdentity) return `*${cachedIdentity.sid}`; if (timeoutMs <= 0) throw identityError("had no remaining deadline"); let overridden: WindowsPrincipalLookupResult; try { overridden = principalRunner(timeoutMs); } catch { throw identityError("could not start"); } cachedIdentity = identityFromResult(overridden); return `*${cachedIdentity.sid}`; } if (cachedIdentity) return `*${cachedIdentity.sid}`; if (syntheticPrincipalForTests) return syntheticPrincipalForTests; if (timeoutMs <= 0) throw identityError("had no remaining deadline"); const deadline = performance.now() + timeoutMs; let result: WindowsPrincipalLookupResult; try { result = principalRunner(timeoutMs); } catch { throw identityError("could not start"); } const identity = identityFromResult(result); if (performance.now() >= deadline) throw identityError("timed out"); cachedIdentity = identity; return `*${cachedIdentity.sid}`; } async function waitForExistingLookup( lookup: Promise<string>, timeoutMs: number, ): Promise<string> { if (timeoutMs <= 0) throw identityError("had no remaining deadline"); let timer: ReturnType<typeof setTimeout> | undefined; try { return await Promise.race([ lookup, new Promise<never>((_, reject) => { timer = setTimeout( () => reject(identityError("timed out while awaiting the shared lookup")), Math.max(1, timeoutMs), ); }), ]); } finally { if (timer) clearTimeout(timer); } } /** * Native callers share one Worker with independent waits. Fallback/injected * child runners retain the first caller's owned process timeout; later callers * may exhaust their own wait without extending or cancelling that child. */ export async function resolveCurrentWindowsPrincipalAsync(timeoutMs: number): Promise<string> { const overridden = hasAsyncRunnerOverride(); if (cachedIdentity) return `*${cachedIdentity.sid}`; if (asyncLookupInFlight) return waitForExistingLookup(asyncLookupInFlight, timeoutMs); // Same precedence rule as the sync path: an injected runner beats the synthetic. if (!overridden && syntheticPrincipalForTests) return syntheticPrincipalForTests; if (timeoutMs <= 0) throw identityError("had no remaining deadline"); // Native jobs own their Worker through close; each caller owns its own wait/cache admission. // Keep the old first-owner child timeout contract for explicit runners and ARM64 fallback. if (!overridden && process.platform === "win32" && process.arch === "x64") { defaultAsyncCallers += 1; try { const deadline = performance.now() + timeoutMs; let result: WindowsPrincipalLookupResult; try { result = await defaultAsyncWindowsPrincipalRunner(timeoutMs); } catch { throw identityError("could not complete the native lookup"); } const identity = identityFromResult(result); if (performance.now() >= deadline) throw identityError("timed out"); cachedIdentity = identity; return `*${cachedIdentity.sid}`; } finally { defaultAsyncCallers -= 1; } } const lookup = (async (): Promise<string> => { let result: WindowsPrincipalLookupResult; try { result = await asyncPrincipalRunner(timeoutMs); } catch { throw identityError("could not start"); } cachedIdentity = identityFromResult(result); return `*${cachedIdentity.sid}`; })(); asyncLookupInFlight = lookup; void lookup.then( () => { if (asyncLookupInFlight === lookup) asyncLookupInFlight = null; }, () => { if (asyncLookupInFlight === lookup) asyncLookupInFlight = null; }, ); return waitForExistingLookup(lookup, timeoutMs); } /** Test seam: replace the sync resolver process and clear its successful cache. */ export function setWindowsPrincipalRunnerForTests( runner: WindowsPrincipalRunner | null, ): void { if (asyncLookupInFlight || defaultAsyncCallers) { throw new Error("Cannot replace the Windows principal runner while a lookup is in flight."); } principalRunner = runner ?? defaultWindowsPrincipalRunner; cachedIdentity = null; } /** Test seam: replace the async resolver process and clear its successful cache. */ export function setAsyncWindowsPrincipalRunnerForTests( runner: AsyncWindowsPrincipalRunner | null, ): void { if (asyncLookupInFlight || defaultAsyncCallers) { throw new Error("Cannot replace the Windows principal runner while a lookup is in flight."); } asyncPrincipalRunner = runner ?? defaultAsyncWindowsPrincipalRunner; cachedIdentity = null; } /** * Test seam: pin the locale that selects the legacy code page. * * Required rather than convenient. `decodeWindowsTextBytes` picks ONE legacy encoding * from the ambient locale, so CP949, CP932 and CP936 fixtures cannot all decode * correctly in a single process without being told which to expect. Production passes * nothing and keeps the ambient locale. * * Clears the cache and refuses mid-flight for the same reasons the runner setters do: * a successful identity is returned from cache BEFORE any decode, and the async path * decodes after its runner resolves. */ export function setWindowsPrincipalLocaleForTests(locale: string | null): void { if (asyncLookupInFlight || defaultAsyncCallers) { throw new Error("Cannot change the Windows principal locale while a lookup is in flight."); } principalLocaleForTests = locale ?? undefined; cachedIdentity = null; } /** Test seam: clear only process-local principal state. */ export function resetWindowsPrincipalForTests(): void { if (asyncLookupInFlight || defaultAsyncCallers) { throw new Error("Cannot reset the Windows principal while a lookup is in flight."); } cachedIdentity = null; syntheticPrincipalForTests = null; }