OpenAI's Codex Security CLI and TypeScript SDK for finding, validating, and fixing security vulnerabilities. npm: https://www.npmjs.com/package/@openai/codex-security
TypeScript ai-securityapplication-securityclicode-scanningcodexcodex-securitycybersecuritydevsecopsnodejsnpmopenaisdksecuritytypescriptvulnerability-scanning
fix(runtime): reclaim credential-home locks held by a reused PID (#611)
Rohan Poudel79734fd92c9d
diff --git a/sdk/typescript/src/runtime.ts b/sdk/typescript/src/runtime.tsindex 15063adf6..2ce27a75b 100644--- a/sdk/typescript/src/runtime.ts+++ b/sdk/typescript/src/runtime.ts@@ -24,6 +24,7 @@ import {rm,rmdir,stat,+ utimes,writeFile,} from "node:fs/promises";import { homedir, tmpdir } from "node:os";@@ -74,6 +75,7 @@ const MAX_ZIP_EXPANDED_SIZE = 512 * 1024 * 1024;const MODEL_UNSAFE_PATH = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/u;const CREDENTIAL_LOCK_NAME = ".codex-security-scan.lock";const CREDENTIAL_LOGOUT_MARKER = ".codex-security-logged-out";+const CREDENTIAL_LOCK_HEARTBEAT_MILLISECONDS = 5_000;const CREDENTIAL_LOCK_POLL_MILLISECONDS = 25;const INCOMPLETE_CREDENTIAL_LOCK_MILLISECONDS = 30_000;const MAX_PROCESS_ID = 2_147_483_647;@@ -1065,7 +1067,7 @@ export async function acquireCodexSecurityCredentialHomeLock(throw error;});if (existingLock !== null) {- if (await recoverStaleCredentialHomeLock(lock)) continue;+ if (await recoverStaleCredentialHomeLock(lock, signal)) continue;await delay(CREDENTIAL_LOCK_POLL_MILLISECONDS, undefined, { signal });continue;}@@ -1078,7 +1080,7 @@ export async function acquireCodexSecurityCredentialHomeLock(await mkdir(lock, { mode: 0o700 });} catch (error) {if (nodeErrorCode(error) !== "EEXIST") throw error;- if (await recoverStaleCredentialHomeLock(lock)) continue;+ if (await recoverStaleCredentialHomeLock(lock, signal)) continue;await delay(CREDENTIAL_LOCK_POLL_MILLISECONDS, undefined, { signal });continue;}@@ -1094,9 +1096,18 @@ export async function acquireCodexSecurityCredentialHomeLock(throw error;}+ const heartbeat = setInterval(async () => {+ try {+ const now = new Date();+ await utimes(lock, now, now);+ } catch {}+ }, CREDENTIAL_LOCK_HEARTBEAT_MILLISECONDS);+ heartbeat.unref();+let released = false;return async () => {if (released) return;+ clearInterval(heartbeat);await requireSecureCredentialHome(codexHome, {...securityOptions,expectedDevice,@@ -1116,7 +1127,10 @@ export async function acquireCodexSecurityCredentialHomeLock(}}-async function recoverStaleCredentialHomeLock(lock: string): Promise<boolean> {+async function recoverStaleCredentialHomeLock(+ lock: string,+ signal?: AbortSignal,+): Promise<boolean> {const metadata = await lstat(lock).catch((error: unknown) => {if (nodeErrorCode(error) === "ENOENT") return null;throw error;@@ -1135,17 +1149,13 @@ async function recoverStaleCredentialHomeLock(lock: string): Promise<boolean> {if (nodeErrorCode(error) !== "ENOENT" && !(error instanceof SyntaxError)) {throw error;}- if (- Date.now() - metadata.mtimeMs <- INCOMPLETE_CREDENTIAL_LOCK_MILLISECONDS- ) {- return false;- }}// Only positive signed-32-bit PIDs identify an owner. Other values can name// process groups or fail argument validation, so use the stale-age check.const ownerPid = isRecord(owner) ? owner["pid"] : undefined;+ let ownerExited = false;+ let ownerIsAlive = false;if (typeof ownerPid === "number" &&Number.isInteger(ownerPid) &&@@ -1154,20 +1164,38 @@ async function recoverStaleCredentialHomeLock(lock: string): Promise<boolean> {) {try {process.kill(ownerPid, 0);- return false;+ ownerIsAlive = true;} catch (error) {- if (nodeErrorCode(error) !== "ESRCH") {- if (nodeErrorCode(error) === "EPERM") return false;- throw error;- }+ if (nodeErrorCode(error) === "ESRCH") ownerExited = true;+ else if (nodeErrorCode(error) === "EPERM") ownerIsAlive = true;+ else throw error;}- } else if (- Date.now() - metadata.mtimeMs <- INCOMPLETE_CREDENTIAL_LOCK_MILLISECONDS+ }+ if (+ !ownerExited &&+ Date.now() - metadata.mtimeMs < INCOMPLETE_CREDENTIAL_LOCK_MILLISECONDS) {return false;}+ if (ownerIsAlive) {+ await delay(CREDENTIAL_LOCK_HEARTBEAT_MILLISECONDS, undefined, { signal });+ const refreshedMetadata = await lstat(lock).catch((error: unknown) => {+ if (nodeErrorCode(error) === "ENOENT") return null;+ throw error;+ });+ if (refreshedMetadata === null) return true;+ if (+ !refreshedMetadata.isDirectory() ||+ refreshedMetadata.isSymbolicLink()+ ) {+ throw new OutputDirectoryError(+ `Codex Security credential-home lock is not a directory: ${lock}`,+ );+ }+ if (refreshedMetadata.mtimeMs > metadata.mtimeMs) return false;+ }+const quarantine = `${lock}.stale-${randomUUID()}`;try {await rename(lock, quarantine);diff --git a/sdk/typescript/tests-ts/runtime.test.ts b/sdk/typescript/tests-ts/runtime.test.tsindex 7dbf80c8f..179db5b5c 100644--- a/sdk/typescript/tests-ts/runtime.test.ts+++ b/sdk/typescript/tests-ts/runtime.test.ts@@ -29,6 +29,7 @@ import {sep,} from "node:path";import { promisify } from "node:util";+import * as timersPromises from "node:timers/promises";import { brotliDecompressSync } from "node:zlib";import { afterEach, describe, expect, mock, spyOn, test } from "bun:test";import { strToU8, zipSync } from "fflate";@@ -97,6 +98,104 @@ async function temporaryDirectory(return path;}+async function plantCredentialHomeLock(+ home: string,+ pid: number,+ modifiedAt?: Date,+): Promise<string> {+ const lock = join(home, ".codex-security-scan.lock");+ await mkdir(lock, { mode: 0o700 });+ await writeFile(+ join(lock, "owner.json"),+ `${JSON.stringify({ pid, token: "planted-owner" })}\n`,+ { mode: 0o600 },+ );+ if (modifiedAt !== undefined) await utimes(lock, modifiedAt, modifiedAt);+ return lock;+}++async function acquireCredentialHomeLockWithTimeout(+ home: string,+): Promise<() => Promise<void>> {+ const controller = new AbortController();+ const timeout = setTimeout(+ () => controller.abort(new DOMException("timed out", "AbortError")),+ 10_000,+ );+ timeout.unref();+ try {+ return await acquireCodexSecurityCredentialHomeLock(+ home,+ controller.signal,+ );+ } finally {+ clearTimeout(timeout);+ }+}++function abortCredentialLockWaitWhenOwnerIsInspected(+ controller: AbortController,+): ReturnType<typeof spyOn> {+ const killProcess = process.kill.bind(process);+ return spyOn(process, "kill").mockImplementation(((+ pid: number,+ signal: number,+ ) => {+ const result = killProcess(pid, signal);+ controller.abort(new DOMException("canceled", "AbortError"));+ return result;+ }) as typeof process.kill);+}++function captureCredentialLockHeartbeatTimer() {+ const realSetInterval = globalThis.setInterval.bind(globalThis);+ const realClearInterval = globalThis.clearInterval.bind(globalThis);+ const unref = mock(() => undefined);+ const interval = { unref } as unknown as NodeJS.Timeout;+ let callback: (() => Promise<void>) | undefined;+ let milliseconds: number | undefined;+ let cleared = false;+ const setIntervalSpy = spyOn(globalThis, "setInterval").mockImplementation(((+ candidate: (...args: unknown[]) => void,+ delay?: number,+ ...args: unknown[]+ ) => {+ if (delay === 5_000 && callback === undefined) {+ callback = candidate as () => Promise<void>;+ milliseconds = delay;+ return interval;+ }+ return realSetInterval(candidate, delay, ...args);+ }) as typeof setInterval);+ const clearIntervalSpy = spyOn(+ globalThis,+ "clearInterval",+ ).mockImplementation(((timer: NodeJS.Timeout) => {+ if (timer === interval) {+ cleared = true;+ return;+ }+ realClearInterval(timer);+ }) as typeof clearInterval);++ return {+ get callback() {+ return callback;+ },+ get cleared() {+ return cleared;+ },+ get milliseconds() {+ return milliseconds;+ },+ restore() {+ clearIntervalSpy.mockRestore();+ setIntervalSpy.mockRestore();+ },+ unref,+ };+}+async function plugin(root: string, version = "1.2.3"): Promise<string> {const path = join(root, "plugin");await mkdir(join(path, ".codex-plugin"), { recursive: true });@@ -2281,24 +2380,70 @@ describe("runtime directories and plugin Python boundary", () => {expect(existsSync(join(home, ".codex-security-scan.lock"))).toBe(false);});- test("cancels a scan waiting for the persistent credential-home lock", async () => {+ test("keeps a fresh live credential-home lock and cancels the waiter", async () => {const root = await temporaryDirectory();const home = await prepareCodexSecurityCredentialHome({CODEX_SECURITY_STATE_DIR: join(root, "state"),});const release = await acquireCodexSecurityCredentialHomeLock(home);const controller = new AbortController();- const waiting = acquireCodexSecurityCredentialHomeLock(- home,- controller.signal,- );- controller.abort(new DOMException("canceled", "AbortError"));+ const inspectOwner =+ abortCredentialLockWaitWhenOwnerIsInspected(controller);try {+ const waiting = acquireCodexSecurityCredentialHomeLock(+ home,+ controller.signal,+ );await expect(waiting).rejects.toMatchObject({ name: "AbortError" });+ expect(inspectOwner).toHaveBeenCalledWith(process.pid, 0);+ expect(existsSync(join(home, ".codex-security-scan.lock"))).toBe(true);} finally {+ inspectOwner.mockRestore();await release();}+ expect(existsSync(join(home, ".codex-security-scan.lock"))).toBe(false);+ });++ test("heartbeats a held credential-home lock across the stale horizon", async () => {+ const root = await temporaryDirectory();+ const home = await prepareCodexSecurityCredentialHome({+ CODEX_SECURITY_STATE_DIR: join(root, "state"),+ });+ const lock = join(home, ".codex-security-scan.lock");+ const heartbeatTimer = captureCredentialLockHeartbeatTimer();+ let release: (() => Promise<void>) | undefined;+ let inspectOwner: ReturnType<typeof spyOn> | undefined;++ try {+ release = await acquireCodexSecurityCredentialHomeLock(home);+ expect(heartbeatTimer.milliseconds).toBe(5_000);+ expect(heartbeatTimer.unref).toHaveBeenCalledTimes(1);+ expect(heartbeatTimer.callback).toBeDefined();++ const stale = new Date(Date.now() - 60_000);+ await utimes(lock, stale, stale);+ await heartbeatTimer.callback!();+ expect(Date.now() - (await stat(lock)).mtimeMs).toBeLessThan(30_000);++ const controller = new AbortController();+ inspectOwner = abortCredentialLockWaitWhenOwnerIsInspected(controller);+ const waiting = acquireCodexSecurityCredentialHomeLock(+ home,+ controller.signal,+ );+ await expect(waiting).rejects.toMatchObject({ name: "AbortError" });+ expect(existsSync(lock)).toBe(true);+ } finally {+ inspectOwner?.mockRestore();+ try {+ if (release !== undefined) await release();+ } finally {+ heartbeatTimer.restore();+ }+ }+ expect(heartbeatTimer.cleared).toBe(true);+ expect(existsSync(lock)).toBe(false);});test("does not rewrite Windows credential ACLs while polling a held lock", async () => {@@ -2363,6 +2508,118 @@ describe("runtime directories and plugin Python boundary", () => {expect(existsSync(lock)).toBe(false);});+ test("recovers a stale credential-home lock naming a live process", async () => {+ const root = await temporaryDirectory();+ const home = await prepareCodexSecurityCredentialHome({+ CODEX_SECURITY_STATE_DIR: join(root, "state"),+ });+ const stale = new Date(Date.now() - 10 * 60_000);+ const lock = await plantCredentialHomeLock(home, process.pid, stale);+ let release: (() => Promise<void>) | undefined;++ try {+ release = await acquireCredentialHomeLockWithTimeout(home);+ expect(existsSync(lock)).toBe(true);+ } finally {+ if (release !== undefined) await release();+ }+ expect(existsSync(lock)).toBe(false);+ });++ test("recovers a stale credential-home lock when PID inspection is denied", async () => {+ const root = await temporaryDirectory();+ const home = await prepareCodexSecurityCredentialHome({+ CODEX_SECURITY_STATE_DIR: join(root, "state"),+ });+ const stale = new Date(Date.now() - 10 * 60_000);+ const lock = await plantCredentialHomeLock(home, process.pid, stale);+ const inspectOwner = spyOn(process, "kill").mockImplementation((() => {+ const error = new Error(+ "operation not permitted",+ ) as NodeJS.ErrnoException;+ error.code = "EPERM";+ throw error;+ }) as typeof process.kill);+ let release: (() => Promise<void>) | undefined;++ try {+ release = await acquireCredentialHomeLockWithTimeout(home);+ expect(existsSync(lock)).toBe(true);+ } finally {+ inspectOwner.mockRestore();+ if (release !== undefined) await release();+ }+ expect(existsSync(lock)).toBe(false);+ });++ test("abandons stale recovery when the owner heartbeat advances", async () => {+ if (+ runTestInSubprocess(+ import.meta.path,+ "abandons stale recovery when the owner heartbeat advances",+ )+ ) {+ return;+ }+ const root = await temporaryDirectory();+ const home = await prepareCodexSecurityCredentialHome({+ CODEX_SECURITY_STATE_DIR: join(root, "state"),+ });+ const lock = join(home, ".codex-security-scan.lock");+ const controller = new AbortController();+ const heartbeatTimer = captureCredentialLockHeartbeatTimer();+ const realDelay = timersPromises.setTimeout;+ let waitedForHeartbeat = false;+ let observedDelaySignal: AbortSignal | undefined;+ mock.module("node:timers/promises", () => ({+ ...timersPromises,+ setTimeout: (async (+ milliseconds: number,+ value?: unknown,+ options?: { signal?: AbortSignal },+ ) => {+ observedDelaySignal = options?.signal;+ if (milliseconds === 5_000) {+ waitedForHeartbeat = true;+ await heartbeatTimer.callback!();+ return value;+ }+ controller.abort(new DOMException("canceled", "AbortError"));+ return await realDelay(0, value, { signal: controller.signal });+ }) as typeof timersPromises.setTimeout,+ }));+ let release: (() => Promise<void>) | undefined;++ try {+ release = await acquireCodexSecurityCredentialHomeLock(home);+ expect(heartbeatTimer.milliseconds).toBe(5_000);+ expect(heartbeatTimer.unref).toHaveBeenCalledTimes(1);+ expect(heartbeatTimer.callback).toBeDefined();+ const stale = new Date(Date.now() - 10 * 60_000);+ await utimes(lock, stale, stale);++ const waiting = acquireCodexSecurityCredentialHomeLock(+ home,+ controller.signal,+ );+ await expect(waiting).rejects.toMatchObject({ name: "AbortError" });+ expect(waitedForHeartbeat).toBe(true);+ expect(observedDelaySignal).toBe(controller.signal);+ expect(Date.now() - (await stat(lock)).mtimeMs).toBeLessThan(30_000);+ expect(existsSync(lock)).toBe(true);+ } finally {+ mock.module("node:timers/promises", () => ({+ ...timersPromises,+ setTimeout: realDelay,+ }));+ try {+ if (release !== undefined) await release();+ } finally {+ heartbeatTimer.restore();+ }+ }+ });+test("recovers credential-home locks whose owner names no process", async () => {const root = await temporaryDirectory();const home = await prepareCodexSecurityCredentialHome({@@ -2379,19 +2636,9 @@ describe("runtime directories and plugin Python boundary", () => {const aged = new Date(Date.now() - 10 * 60_000);await utimes(lock, aged, aged);- // Bound acquisition so a false live-owner result cannot hang the test.- const abort = new AbortController();- const timer = setTimeout(() => abort.abort(), 5_000);- try {- const release = await acquireCodexSecurityCredentialHomeLock(- home,- abort.signal,- );- expect(existsSync(lock)).toBe(true);- await release();- } finally {- clearTimeout(timer);- }+ const release = await acquireCredentialHomeLockWithTimeout(home);+ expect(existsSync(lock)).toBe(true);+ await release();expect(existsSync(lock)).toBe(false);}});