@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
163 lines (154 loc) • 7.05 kB
text/typescript
/**
* The effective process token's SID, read in-process on Windows x64.
*
* The PowerShell helper this replaces is correct but slow to start: a cold
* `powershell.exe` on a loaded runner spent more than the 30s lookup budget
* before evaluating one constant of the process token, and `ocx service install`
* refused (#7544). Widening that budget again would only move the line. The SID
* itself costs three advapi32 calls, so the x64 path asks the OS directly and the
* helper keeps running only where `bun:ffi` cannot (Windows ARM64).
*
* The answer is the PROCESS token's user. `WindowsIdentity.GetCurrent()` would
* prefer a thread impersonation token, but nothing in this process impersonates,
* so the two agree; the process token is also what Task Scheduler and the ACL
* code grant to.
*
* Fail-closed is preserved: when the native API is available and fails, the
* lookup throws and the caller refuses. It never falls back to the helper, whose
* environment the native path exists to avoid depending on.
*/
import { dlopen, ptr, read, type Pointer } from "bun:ffi";
import { win32 } from "node:path";
import { resolveTrustedWindowsSystemDirectory } from "../lib/windows-elevation";
const TOKEN_QUERY = 0x0008;
const TOKEN_USER_INFORMATION_CLASS = 1;
/**
* TOKEN_USER is one SID_AND_ATTRIBUTES (an 8-byte SID pointer and a 4-byte
* attribute word, padded to 16) followed by the SID it points at. A SID is at
* most SECURITY_MAX_SID_SIZE (68) bytes, so 256 bytes always suffices and a
* larger reported length is treated as a malformed answer.
*/
const TOKEN_USER_BUFFER_BYTES = 256;
const TOKEN_USER_HEADER_BYTES = 16;
/** "S-1-" plus at most 15 sub-authorities of up to 10 digits each, with room to spare. */
const MAX_SID_STRING_CODE_UNITS = 256;
const SID_PATTERN = /^S-1-(?:\d+-)+\d+$/i;
export interface WindowsTokenSidApi {
/** OpenProcessToken(GetCurrentProcess(), access, &token). Non-zero BOOL is success. */
openProcessToken(desiredAccess: number, token: BigUint64Array): number;
/** GetTokenInformation(token, class, buffer, buffer.length, &returnLength). */
getTokenInformation(
token: bigint,
informationClass: number,
buffer: Uint8Array,
returnLength: Uint32Array,
): number;
/** ConvertSidToStringSidW(sid, &string). The string is LocalAlloc'd on success. */
convertSidToStringSid(sidAddress: number, output: BigUint64Array): number;
readCodeUnit(address: number, byteOffset: number): number;
localFree(address: number): void;
closeHandle(token: bigint): void;
}
function lookupError(detail: string): Error {
return new Error(`Windows effective-account token lookup ${detail}.`);
}
function readSidString(api: WindowsTokenSidApi, address: number): string {
const units: number[] = [];
for (let index = 0; index < MAX_SID_STRING_CODE_UNITS; index += 1) {
const unit = api.readCodeUnit(address, index * 2);
if (unit === 0) return String.fromCharCode(...units);
units.push(unit);
}
throw lookupError("returned an unterminated SID");
}
/** Same token user the PowerShell helper reports, without starting a process. */
export function readWindowsCurrentSid(api: WindowsTokenSidApi): string {
const tokenOutput = new BigUint64Array(1);
if (api.openProcessToken(TOKEN_QUERY, tokenOutput) === 0 || tokenOutput[0] === 0n) {
throw lookupError("could not open the process token");
}
const token = tokenOutput[0]!;
let stringAddress = 0;
try {
// Keep `buffer` referenced until the conversion returns: the SID pointer
// inside it points back into this same allocation.
const buffer = new Uint8Array(TOKEN_USER_BUFFER_BYTES);
const returnLength = new Uint32Array(1);
if (api.getTokenInformation(token, TOKEN_USER_INFORMATION_CLASS, buffer, returnLength) === 0) {
throw lookupError("could not read the token user");
}
const length = returnLength[0]!;
if (length <= TOKEN_USER_HEADER_BYTES || length > buffer.byteLength) {
throw lookupError("returned a malformed token user");
}
const sidAddress = Number(
new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getBigUint64(0, true),
);
if (!Number.isSafeInteger(sidAddress) || sidAddress <= 0) {
throw lookupError("returned a null SID");
}
const stringOutput = new BigUint64Array(1);
const converted = api.convertSidToStringSid(sidAddress, stringOutput);
const candidate = Number(stringOutput[0]);
if (converted === 0 || !Number.isSafeInteger(candidate) || candidate <= 0) {
throw lookupError("could not format the SID");
}
stringAddress = candidate;
const sid = readSidString(api, stringAddress);
if (!SID_PATTERN.test(sid)) throw lookupError("returned an invalid SID");
return sid.toUpperCase();
} finally {
if (stringAddress > 0) api.localFree(stringAddress);
api.closeHandle(token);
}
}
let nativeLookup: (() => string) | null | undefined;
function loadNativeLookup(): (() => string) | null {
if (nativeLookup !== undefined) return nativeLookup;
if (process.platform !== "win32" || process.arch !== "x64") return null;
try {
const systemDirectory = resolveTrustedWindowsSystemDirectory();
const advapi = dlopen(win32.join(systemDirectory, "advapi32.dll"), {
OpenProcessToken: { args: ["u64", "u32", "ptr"], returns: "i32" },
GetTokenInformation: { args: ["u64", "u32", "ptr", "u32", "ptr"], returns: "i32" },
ConvertSidToStringSidW: { args: ["ptr", "ptr"], returns: "i32" },
});
let kernel;
try {
kernel = dlopen(win32.join(systemDirectory, "kernel32.dll"), {
GetCurrentProcess: { args: [], returns: "u64" },
CloseHandle: { args: ["u64"], returns: "i32" },
LocalFree: { args: ["ptr"], returns: "ptr" },
});
} catch (error) {
advapi.close();
throw error;
}
const api: WindowsTokenSidApi = {
openProcessToken: (access, token) => advapi.symbols.OpenProcessToken(
kernel.symbols.GetCurrentProcess(), access, ptr(token),
),
getTokenInformation: (token, informationClass, buffer, returnLength) =>
advapi.symbols.GetTokenInformation(
token, informationClass, ptr(buffer), buffer.byteLength, ptr(returnLength),
),
convertSidToStringSid: (sidAddress, output) => advapi.symbols.ConvertSidToStringSidW(
sidAddress as Pointer, ptr(output),
),
readCodeUnit: (address, offset) => read.u16(address as Pointer, offset),
localFree: address => { kernel.symbols.LocalFree(address as Pointer); },
closeHandle: token => { kernel.symbols.CloseHandle(token); },
};
nativeLookup = () => readWindowsCurrentSid(api);
} catch {
nativeLookup = null;
}
return nativeLookup;
}
/** Unsupported FFI keeps the bounded trusted helper; an OS API failure still refuses. */
export function resolveWindowsCurrentSid(
powershellLookup: () => string,
lookup: (() => string) | null = loadNativeLookup(),
): string {
return lookup ? lookup() : powershellLookup();
}