@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/VersionDetector-CNXcvD46.mjs

@@ -0,0 +1,104 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+//#region src/modules/v8-inspector/VersionDetector.ts
+var VersionDetector_exports = /* @__PURE__ */ __exportAll({ VersionDetector: () => VersionDetector });
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function isCDPPageLike(value) {
+	return isRecord(value) && typeof value["createCDPSession"] === "function";
+}
+function readString(record, key) {
+	const value = record[key];
+	return typeof value === "string" ? value : null;
+}
+function readBooleanResult(value) {
+	if (typeof value === "boolean") return value;
+	if (isRecord(value)) {
+		const nested = value["value"];
+		return typeof nested === "boolean" ? nested : false;
+	}
+	return false;
+}
+var VersionDetector = class {
+	constructor(getPage) {
+		this.getPage = getPage;
+	}
+	async detectV8Version() {
+		const browserVersion = await this.detectBrowserVersion();
+		if (browserVersion) return browserVersion;
+		if (typeof process.versions.v8 === "string" && process.versions.v8.length > 0) return this.parseV8Version(process.versions.v8);
+		return null;
+	}
+	parseV8Version(versionString) {
+		const match = /(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:\.(?<commit>[A-Za-z0-9._-]+))?/u.exec(versionString.trim());
+		if (!match?.groups) return {
+			major: 0,
+			minor: 0,
+			patch: 0,
+			commit: ""
+		};
+		const major = Number(match.groups["major"] ?? 0);
+		const minor = Number(match.groups["minor"] ?? 0);
+		const patch = Number(match.groups["patch"] ?? 0);
+		return {
+			major: Number.isFinite(major) ? major : 0,
+			minor: Number.isFinite(minor) ? minor : 0,
+			patch: Number.isFinite(patch) ? patch : 0,
+			commit: match.groups["commit"] ?? ""
+		};
+	}
+	async supportsNativesSyntax() {
+		if (process.execArgv.includes("--allow-natives-syntax")) return true;
+		const session = await this.createSession();
+		if (!session) return false;
+		try {
+			const response = await session.send("Runtime.evaluate", {
+				expression: `
+          (() => {
+            try {
+              return Boolean(new Function("return %HaveSameMap({}, {})")());
+            } catch (error) {
+              return false;
+            }
+          })()
+        `,
+				returnByValue: true,
+				awaitPromise: false
+			});
+			if (!isRecord(response)) return false;
+			return readBooleanResult(response["result"]);
+		} catch {
+			return false;
+		} finally {
+			await session.detach().catch(() => void 0);
+		}
+	}
+	async detectBrowserVersion() {
+		const session = await this.createSession();
+		if (!session) return null;
+		try {
+			const response = await session.send("Browser.getVersion");
+			if (!isRecord(response)) return null;
+			const jsVersion = readString(response, "jsVersion");
+			if (jsVersion) return this.parseV8Version(jsVersion);
+			const product = readString(response, "product");
+			return product ? this.parseV8Version(product) : null;
+		} catch {
+			return null;
+		} finally {
+			await session.detach().catch(() => void 0);
+		}
+	}
+	async createSession() {
+		if (!this.getPage) return null;
+		try {
+			const page = await this.getPage();
+			if (!isCDPPageLike(page)) return null;
+			return await page.createCDPSession();
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
+export { VersionDetector_exports as n, VersionDetector as t };

package/dist/Win32API-Bc0QnQsN.mjs

@@ -0,0 +1,340 @@
+import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
+import { t as logger } from "./logger-BmWzC2lM.mjs";
+import koffi from "koffi";
+//#region src/native/Win32API.ts
+/**
+* Win32 API Bindings using koffi FFI
+* Direct native calls to Windows kernel32.dll, ntdll.dll, psapi.dll
+*
+* This replaces PowerShell-based P/Invoke with direct FFI calls,
+* providing 10-100x performance improvement for memory operations.
+*
+* Note: We use inline types in function signatures to avoid
+* "Duplicate type name" errors in test environments where modules
+* may be loaded multiple times.
+*
+* @module Win32API
+*/
+var Win32API_exports = /* @__PURE__ */ __exportAll({
+	CloseHandle: () => CloseHandle,
+	CreateRemoteThread: () => CreateRemoteThread,
+	EnumProcessModules: () => EnumProcessModules,
+	GetLastError: () => GetLastError,
+	GetModuleBaseName: () => GetModuleBaseName,
+	GetModuleFileNameEx: () => GetModuleFileNameEx,
+	GetModuleHandle: () => GetModuleHandle,
+	GetModuleInformation: () => GetModuleInformation,
+	GetProcAddress: () => GetProcAddress,
+	MEM: () => MEM,
+	NtQueryInformationProcess: () => NtQueryInformationProcess,
+	OpenProcess: () => OpenProcess,
+	PAGE: () => PAGE,
+	PROCESS_ACCESS: () => PROCESS_ACCESS,
+	ReadProcessMemory: () => ReadProcessMemory,
+	VirtualAllocEx: () => VirtualAllocEx,
+	VirtualFreeEx: () => VirtualFreeEx,
+	VirtualProtectEx: () => VirtualProtectEx,
+	VirtualQueryEx: () => VirtualQueryEx,
+	WriteProcessMemory: () => WriteProcessMemory,
+	isKoffiAvailable: () => isKoffiAvailable,
+	isWindows: () => isWindows,
+	openProcessForMemory: () => openProcessForMemory
+});
+const PROCESS_ACCESS = {
+	TERMINATE: 1,
+	CREATE_THREAD: 2,
+	SET_SESSIONID: 4,
+	VM_OPERATION: 8,
+	VM_READ: 16,
+	VM_WRITE: 32,
+	DUP_HANDLE: 64,
+	CREATE_PROCESS: 128,
+	SET_QUOTA: 256,
+	SET_INFORMATION: 512,
+	QUERY_INFORMATION: 1024,
+	SUSPEND_RESUME: 2048,
+	QUERY_LIMITED_INFORMATION: 4096,
+	ALL_ACCESS: 2035711
+};
+const MEM = {
+	COMMIT: 4096,
+	RESERVE: 8192,
+	DECOMMIT: 16384,
+	RELEASE: 32768,
+	FREE: 65536,
+	PRIVATE: 131072,
+	MAPPED: 262144,
+	RESET: 524288,
+	TOP_DOWN: 1048576,
+	WRITE_WATCH: 2097152,
+	PHYSICAL: 4194304,
+	LARGE_PAGES: 536870912
+};
+const PAGE = {
+	NOACCESS: 1,
+	READONLY: 2,
+	READWRITE: 4,
+	WRITECOPY: 8,
+	EXECUTE: 16,
+	EXECUTE_READ: 32,
+	EXECUTE_READWRITE: 64,
+	EXECUTE_WRITECOPY: 128,
+	GUARD: 256,
+	NOCACHE: 512,
+	WRITECOMBINE: 1024
+};
+let kernel32 = null;
+let ntdll = null;
+let psapi = null;
+let koffiAvailable = null;
+/**
+* Check if koffi is available
+*/
+function isKoffiAvailable() {
+	if (koffiAvailable !== null) return koffiAvailable;
+	try {
+		koffi.load("kernel32.dll").unload();
+		koffiAvailable = true;
+		return true;
+	} catch {
+		/* istanbul ignore next */
+		koffiAvailable = false;
+		/* istanbul ignore next */
+		return false;
+	}
+}
+/**
+* Check if running on Windows
+*/
+function isWindows() {
+	return process.platform === "win32";
+}
+/**
+* Get or load kernel32.dll
+*/
+function getKernel32() {
+	if (!kernel32) {
+		kernel32 = koffi.load("kernel32.dll");
+		logger.debug("Loaded kernel32.dll via koffi");
+	}
+	return kernel32;
+}
+/**
+* Get or load ntdll.dll
+*/
+function getNtdll() {
+	if (!ntdll) {
+		ntdll = koffi.load("ntdll.dll");
+		logger.debug("Loaded ntdll.dll via koffi");
+	}
+	return ntdll;
+}
+/**
+* Get or load psapi.dll
+*/
+function getPsapi() {
+	if (!psapi) {
+		psapi = koffi.load("psapi.dll");
+		logger.debug("Loaded psapi.dll via koffi");
+	}
+	return psapi;
+}
+/**
+* Open a process handle
+*/
+function OpenProcess(dwDesiredAccess, bInheritHandle, dwProcessId) {
+	return getKernel32().func("void * OpenProcess(uint32, int, uint32)")(dwDesiredAccess, bInheritHandle ? 1 : 0, dwProcessId);
+}
+/**
+* Close a handle
+*/
+function CloseHandle(hObject) {
+	return getKernel32().func("int CloseHandle(void *)")(hObject) !== 0;
+}
+/**
+* Read process memory - returns buffer directly
+*/
+function ReadProcessMemory(hProcess, lpBaseAddress, size) {
+	const fn = getKernel32().func("int ReadProcessMemory(void *, void *, _Out_ uint8_t[len], size_t len, _Out_ size_t *bytesRead)");
+	const buffer = Buffer.alloc(size);
+	const bytesReadBuf = Buffer.alloc(8);
+	if (fn(hProcess, lpBaseAddress, buffer, BigInt(size), bytesReadBuf) === 0) {
+		const error = GetLastError();
+		throw new Error(`ReadProcessMemory failed. Error: 0x${error.toString(16)}`);
+	}
+	return buffer;
+}
+/**
+* Write process memory
+*/
+function WriteProcessMemory(hProcess, lpBaseAddress, data) {
+	const fn = getKernel32().func("int WriteProcessMemory(void *, void *, uint8_t[len], size_t len, _Out_ size_t *bytesWritten)");
+	const bytesWrittenBuf = Buffer.alloc(8);
+	if (fn(hProcess, lpBaseAddress, data, BigInt(data.length), bytesWrittenBuf) === 0) {
+		const error = GetLastError();
+		throw new Error(`WriteProcessMemory failed. Error: 0x${error.toString(16)}`);
+	}
+	return Number(bytesWrittenBuf.readBigUInt64LE());
+}
+/**
+* Query memory region information
+* Uses Buffer parsing to avoid koffi struct registration issues
+*/
+function VirtualQueryEx(hProcess, lpAddress) {
+	const fn = getKernel32().func("size_t VirtualQueryEx(void *, void *, _Out_ uint8_t[48], size_t)");
+	const structSize = 48;
+	const buffer = Buffer.alloc(structSize);
+	const result = fn(hProcess, lpAddress, buffer, BigInt(structSize));
+	if (Number(result) !== structSize) return {
+		success: false,
+		info: {}
+	};
+	return {
+		success: true,
+		info: {
+			BaseAddress: buffer.readBigUInt64LE(0),
+			AllocationBase: buffer.readBigUInt64LE(8),
+			AllocationProtect: buffer.readUInt32LE(16),
+			RegionSize: buffer.readBigUInt64LE(24),
+			State: buffer.readUInt32LE(32),
+			Protect: buffer.readUInt32LE(36),
+			Type: buffer.readUInt32LE(40)
+		}
+	};
+}
+/**
+* Change memory protection
+*/
+function VirtualProtectEx(hProcess, lpAddress, dwSize, flNewProtect) {
+	const fn = getKernel32().func("int VirtualProtectEx(void *, void *, size_t, uint32, _Out_ uint32 *)");
+	const oldProtectBuf = Buffer.alloc(4);
+	return {
+		success: fn(hProcess, lpAddress, BigInt(dwSize), flNewProtect, oldProtectBuf) !== 0,
+		oldProtect: oldProtectBuf.readUInt32LE(0)
+	};
+}
+/**
+* Allocate memory in another process
+*/
+function VirtualAllocEx(hProcess, lpAddress, dwSize, flAllocationType, flProtect) {
+	return getKernel32().func("void * VirtualAllocEx(void *, void *, size_t, uint32, uint32)")(hProcess, lpAddress, BigInt(dwSize), flAllocationType, flProtect);
+}
+/**
+* Free memory in another process
+*/
+function VirtualFreeEx(hProcess, lpAddress, dwSize, dwFreeType) {
+	return getKernel32().func("int VirtualFreeEx(void *, void *, size_t, uint32)")(hProcess, lpAddress, BigInt(dwSize), dwFreeType) !== 0;
+}
+/**
+* Create a remote thread in another process
+*/
+function CreateRemoteThread(hProcess, lpStartAddress, lpParameter) {
+	const fn = getKernel32().func("void * CreateRemoteThread(void *, void *, size_t, void *, void *, uint32, _Out_ uint32 *)");
+	const threadIdBuf = Buffer.alloc(4);
+	return {
+		handle: fn(hProcess, null, 0n, lpStartAddress, lpParameter, 0, threadIdBuf),
+		threadId: threadIdBuf.readUInt32LE(0)
+	};
+}
+/**
+* Get module handle by name
+*/
+function GetModuleHandle(lpModuleName) {
+	return getKernel32().func("void * GetModuleHandleA(char *)")(lpModuleName);
+}
+/**
+* Get function address from module
+*/
+function GetProcAddress(hModule, lpProcName) {
+	return getKernel32().func("void * GetProcAddress(void *, char *)")(hModule, lpProcName);
+}
+/**
+* Get last error code
+*/
+function GetLastError() {
+	return getKernel32().func("uint32 GetLastError()")();
+}
+/**
+* NtQueryInformationProcess for anti-debug detection
+*/
+function NtQueryInformationProcess(hProcess, processInformationClass) {
+	const fn = getNtdll().func("int32 NtQueryInformationProcess(void *, uint32, _Out_ void *, uint32, void *)");
+	const debugPortBuf = Buffer.alloc(8);
+	return {
+		status: fn(hProcess, processInformationClass, debugPortBuf, 8, null),
+		debugPort: Number(debugPortBuf.readBigUInt64LE())
+	};
+}
+/**
+* Enumerate process modules
+*/
+function EnumProcessModules(hProcess, maxModules = 1024) {
+	const fn = getPsapi().func("int EnumProcessModules(void *, _Out_ void *[], uint32, _Out_ uint32 *)");
+	const moduleBuf = Buffer.alloc(maxModules * 8);
+	const neededBuf = Buffer.alloc(4);
+	const result = fn(hProcess, moduleBuf, maxModules * 8, neededBuf);
+	const needed = neededBuf.readUInt32LE(0);
+	const count = Math.floor(needed / 8);
+	const modules = [];
+	for (let i = 0; i < count; i++) modules.push(moduleBuf.readBigUInt64LE(i * 8));
+	return {
+		success: result !== 0,
+		modules,
+		count
+	};
+}
+/**
+* Get module base name
+*/
+function GetModuleBaseName(hProcess, hModule, maxSize = 260) {
+	const fn = getPsapi().func("uint32 GetModuleBaseNameA(void *, void *, _Out_ char[], uint32)");
+	const buffer = Buffer.alloc(maxSize);
+	fn(hProcess, hModule, buffer, maxSize);
+	let len = 0;
+	while (len < maxSize && buffer[len] !== 0) len++;
+	return buffer.toString("utf8", 0, len);
+}
+/**
+* Get full module path from a remote process.
+* Returns null when the API is unavailable or the module path cannot be resolved.
+*/
+function GetModuleFileNameEx(hProcess, hModule, maxSize = 32768) {
+	const fn = getPsapi().func("uint32 GetModuleFileNameExA(void *, void *, _Out_ char[], uint32)");
+	const buffer = Buffer.alloc(maxSize);
+	const result = fn(hProcess, hModule, buffer, maxSize);
+	if (typeof result !== "number" || result <= 0) return null;
+	let len = 0;
+	while (len < maxSize && buffer[len] !== 0) len++;
+	return len > 0 ? buffer.toString("utf8", 0, len) : null;
+}
+/**
+* Get module information
+* Uses Buffer parsing to avoid koffi struct registration issues
+*/
+function GetModuleInformation(hProcess, hModule) {
+	const fn = getPsapi().func("int GetModuleInformation(void *, void *, _Out_ uint8_t[24], uint32)");
+	const buffer = Buffer.alloc(24);
+	const result = fn(hProcess, hModule, buffer, 24);
+	const info = {
+		lpBaseOfDll: buffer.readBigUInt64LE(0),
+		SizeOfImage: buffer.readUInt32LE(8),
+		EntryPoint: buffer.readBigUInt64LE(16)
+	};
+	return {
+		success: result !== 0,
+		info
+	};
+}
+/**
+* Open a process with standard memory access rights
+*/
+function openProcessForMemory(pid, writeAccess = false) {
+	const handle = OpenProcess(writeAccess ? PROCESS_ACCESS.VM_READ | PROCESS_ACCESS.VM_WRITE | PROCESS_ACCESS.VM_OPERATION | PROCESS_ACCESS.QUERY_INFORMATION : PROCESS_ACCESS.VM_READ | PROCESS_ACCESS.QUERY_INFORMATION, false, pid);
+	if (handle === 0n) {
+		const error = GetLastError();
+		throw new Error(`Failed to open process ${pid}. Error: 0x${error.toString(16)}. Run as Administrator.`);
+	}
+	return handle;
+}
+//#endregion
+export { WriteProcessMemory as _, GetModuleFileNameEx as a, openProcessForMemory as b, GetProcAddress as c, ReadProcessMemory as d, VirtualAllocEx as f, Win32API_exports as g, VirtualQueryEx as h, GetModuleBaseName as i, MEM as l, VirtualProtectEx as m, EnumProcessModules as n, GetModuleHandle as o, VirtualFreeEx as p, GetLastError as r, GetModuleInformation as s, CloseHandle as t, PAGE as u, isKoffiAvailable as v, isWindows as y };