@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
119 lines (109 loc) • 5.75 kB
text/typescript
/**
* Where `ocx update --desktop` stages the verified MSI and the installer log (#8246).
*
* msiexec opens the package by path after this process has verified it. When the command runs
* elevated, a directory in the user's TEMP would let any non-elevated process of the same user
* swap the package, plant a link at the log path, or move the directory away between that
* verification and msiexec opening the file, and the elevated installer would act on the
* substitute. So an elevated run stages under the Windows directory's Temp, in a fresh directory
* created with a protected security descriptor that lets only SYSTEM and Administrators write.
* Non-elevated processes may create entries in that Temp but cannot delete or rename another
* account's, and cannot write inside this one. A run that is not elevated keeps its own TEMP: its
* msiexec has no more rights than a process that could change the file there.
*/
import { mkdtempSync } from "node:fs";
import { randomBytes } from "node:crypto";
import { tmpdir } from "node:os";
import { join, win32 } from "node:path";
import { dlopen, ptr } from "bun:ffi";
import { trustedWindowsSystemDirectory } from "../service/desktop-supervision.mjs";
/**
* Protected (no inherited entries); full access for SYSTEM and Administrators, inherited by the
* files inside; the owner's implicit right to rewrite the descriptor reduced to reading it.
*/
export const PROTECTED_STAGING_SDDL = "D:P(A;OICI;FA;;;SY)(A;OICI;FA;;;BA)(A;OICI;RC;;;OW)";
export const STAGING_PREFIX = "ocx-desktop-update-";
export interface StagingDirectoryDeps {
/** Whether this process runs with an elevated token; a throw counts as elevated. */
elevated(): boolean;
windowsDirectory(): string;
/** Create a new directory with this descriptor; throws when the path already exists. */
createProtectedDirectory(path: string, sddl: string): void;
createPrivateTempDirectory(): string;
randomSuffix(): string;
}
export function createStagingDirectory(deps: StagingDirectoryDeps): string {
let elevated = true;
try { elevated = deps.elevated(); } catch { /* unknown: stage as if elevated */ }
if (!elevated) return deps.createPrivateTempDirectory();
const path = win32.join(deps.windowsDirectory(), "Temp", `${STAGING_PREFIX}${deps.randomSuffix()}`);
deps.createProtectedDirectory(path, PROTECTED_STAGING_SDDL);
return path;
}
const TOKEN_QUERY = 0x0008;
const TOKEN_ELEVATION_CLASS = 20;
const SDDL_REVISION_1 = 1;
function loadSystemLibraries<A extends Parameters<typeof dlopen>[1], K extends Parameters<typeof dlopen>[1]>(advapiSymbols: A, kernelSymbols: K) {
const directory = trustedWindowsSystemDirectory();
const advapi = dlopen(win32.join(directory, "advapi32.dll"), advapiSymbols);
try {
const kernel = dlopen(win32.join(directory, "kernel32.dll"), kernelSymbols);
return { advapi, kernel, close: () => { kernel.close(); advapi.close(); } };
} catch (error) {
advapi.close();
throw error;
}
}
function processIsElevated(): boolean {
const lib = loadSystemLibraries({
OpenProcessToken: { args: ["u64", "u32", "ptr"], returns: "i32" },
GetTokenInformation: { args: ["u64", "u32", "ptr", "u32", "ptr"], returns: "i32" },
}, {
GetCurrentProcess: { args: [], returns: "u64" },
CloseHandle: { args: ["u64"], returns: "i32" },
});
try {
const token = new BigUint64Array(1);
if (!lib.advapi.symbols.OpenProcessToken(lib.kernel.symbols.GetCurrentProcess(), TOKEN_QUERY, ptr(token))) throw new Error("OpenProcessToken failed");
try {
const elevation = new Uint32Array(1);
const length = new Uint32Array(1);
if (!lib.advapi.symbols.GetTokenInformation(token[0]!, TOKEN_ELEVATION_CLASS, ptr(elevation), 4, ptr(length))) throw new Error("GetTokenInformation failed");
return elevation[0] !== 0;
} finally { lib.kernel.symbols.CloseHandle(token[0]!); }
} finally { lib.close(); }
}
function createProtectedDirectoryWin32(path: string, sddl: string): void {
const lib = loadSystemLibraries({
ConvertStringSecurityDescriptorToSecurityDescriptorW: { args: ["ptr", "u32", "ptr", "ptr"], returns: "i32" },
}, {
CreateDirectoryW: { args: ["ptr", "ptr"], returns: "i32" },
LocalFree: { args: ["u64"], returns: "u64" },
GetLastError: { args: [], returns: "u32" },
});
try {
const descriptor = new BigUint64Array(1);
const text = Buffer.from(`${sddl}\0`, "utf16le");
if (!lib.advapi.symbols.ConvertStringSecurityDescriptorToSecurityDescriptorW(ptr(text), SDDL_REVISION_1, ptr(descriptor), null)) {
throw new Error(`the staging security descriptor was rejected (Windows error ${lib.kernel.symbols.GetLastError()})`);
}
try {
// SECURITY_ATTRIBUTES on x64: DWORD nLength, (pad), LPVOID lpSecurityDescriptor, BOOL bInheritHandle, (pad).
const attributes = Buffer.alloc(24);
attributes.writeUInt32LE(24, 0);
attributes.writeBigUInt64LE(descriptor[0]!, 8);
attributes.writeInt32LE(0, 16);
const wide = Buffer.from(`${path}\0`, "utf16le");
if (!lib.kernel.symbols.CreateDirectoryW(ptr(wide), ptr(attributes))) {
throw new Error(`could not create the protected staging directory ${path} (Windows error ${lib.kernel.symbols.GetLastError()})`);
}
} finally { lib.kernel.symbols.LocalFree(descriptor[0]!); }
} finally { lib.close(); }
}
export const windowsStagingDeps: StagingDirectoryDeps = {
elevated: processIsElevated,
windowsDirectory: () => win32.dirname(trustedWindowsSystemDirectory()),
createProtectedDirectory: createProtectedDirectoryWin32,
createPrivateTempDirectory: () => mkdtempSync(join(tmpdir(), STAGING_PREFIX)),
randomSuffix: () => randomBytes(16).toString("hex"),
};