@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/Speedhack-CeF0XmEz.mjs

@@ -0,0 +1,156 @@
+import { _ as WriteProcessMemory, b as openProcessForMemory, c as GetProcAddress, d as ReadProcessMemory, f as VirtualAllocEx, l as MEM, m as VirtualProtectEx, o as GetModuleHandle, p as VirtualFreeEx, t as CloseHandle, u as PAGE } from "./Win32API-Bc0QnQsN.mjs";
+import { l as FlushInstructionCache } from "./Win32Debug-DUHt9XUn.mjs";
+//#region src/native/Speedhack.ts
+var Speedhack = class {
+	states = /* @__PURE__ */ new Map();
+	/** Apply speedhack to process with multiplier (1.0 = normal) */
+	async apply(pid, speed) {
+		if (this.states.has(pid)) await this.remove(pid);
+		const handle = openProcessForMemory(pid, true);
+		const hookedApis = [];
+		const patchIds = [];
+		try {
+			const kernel32Base = GetModuleHandle("kernel32.dll");
+			if (kernel32Base === 0n) throw new Error("Cannot find kernel32.dll");
+			const sharedMem = VirtualAllocEx(handle, 0n, 4096, MEM.COMMIT | MEM.RESERVE, PAGE.EXECUTE_READWRITE);
+			if (sharedMem === 0n) throw new Error("VirtualAllocEx failed for speedhack shared memory");
+			const speedBuf = Buffer.alloc(8);
+			speedBuf.writeDoubleLE(speed, 0);
+			WriteProcessMemory(handle, sharedMem, speedBuf);
+			const zeroBuf = Buffer.alloc(8, 0);
+			WriteProcessMemory(handle, sharedMem + 8n, zeroBuf);
+			WriteProcessMemory(handle, sharedMem + 16n, zeroBuf);
+			const gettickAddr = GetProcAddress(kernel32Base, "GetTickCount64");
+			if (gettickAddr !== 0n) {
+				if (await this.hookTimeFunction(handle, gettickAddr, sharedMem, 256n, "gettick64")) {
+					hookedApis.push("GetTickCount64");
+					patchIds.push("gettick64");
+				}
+			}
+			const qpcAddr = GetProcAddress(kernel32Base, "QueryPerformanceCounter");
+			if (qpcAddr !== 0n) {
+				if (await this.hookTimeFunction(handle, qpcAddr, sharedMem, 512n, "qpc")) {
+					hookedApis.push("QueryPerformanceCounter");
+					patchIds.push("qpc");
+				}
+			}
+			this.states.set(pid, {
+				pid,
+				speed,
+				hookedApis,
+				isActive: true,
+				allocatedMemory: `0x${sharedMem.toString(16).toUpperCase()}`,
+				patchIds
+			});
+			return {
+				success: hookedApis.length > 0,
+				hookedApis
+			};
+		} catch (error) {
+			CloseHandle(handle);
+			throw error;
+		} finally {
+			CloseHandle(handle);
+		}
+	}
+	/** Update speed multiplier (without re-hooking) */
+	async setSpeed(pid, speed) {
+		const state = this.states.get(pid);
+		if (!state || !state.isActive || !state.allocatedMemory) return false;
+		const addr = BigInt(state.allocatedMemory);
+		const handle = openProcessForMemory(pid, true);
+		try {
+			const buf = Buffer.alloc(8);
+			buf.writeDoubleLE(speed, 0);
+			WriteProcessMemory(handle, addr, buf);
+			state.speed = speed;
+			return true;
+		} finally {
+			CloseHandle(handle);
+		}
+	}
+	/** Get current speed multiplier */
+	getSpeed(pid) {
+		const state = this.states.get(pid);
+		return state?.isActive ? state.speed : null;
+	}
+	/** Remove speedhack, restore original functions */
+	async remove(pid) {
+		const state = this.states.get(pid);
+		if (!state) return false;
+		const handle = openProcessForMemory(pid, true);
+		try {
+			if (state.allocatedMemory) {
+				const allocAddr = BigInt(state.allocatedMemory);
+				for (let i = 0; i < state.patchIds.length; i++) try {
+					const metaBuf = ReadProcessMemory(handle, allocAddr + (3072n + BigInt(i * 32)), 32);
+					const origAddr = metaBuf.readBigUInt64LE(0);
+					const origSize = metaBuf.readUInt32LE(8);
+					if (origAddr !== 0n && origSize > 0 && origSize <= 16) {
+						const origBytes = metaBuf.subarray(12, 12 + origSize);
+						const { oldProtect } = VirtualProtectEx(handle, origAddr, origSize, PAGE.EXECUTE_READWRITE);
+						WriteProcessMemory(handle, origAddr, origBytes);
+						FlushInstructionCache(handle, origAddr, origSize);
+						VirtualProtectEx(handle, origAddr, origSize, oldProtect);
+					}
+				} catch {}
+				VirtualFreeEx(handle, allocAddr, 0, MEM.RELEASE);
+			}
+		} finally {
+			CloseHandle(handle);
+		}
+		state.isActive = false;
+		this.states.delete(pid);
+		return true;
+	}
+	/** Check if speedhack is active for a process */
+	isActive(pid) {
+		return this.states.get(pid)?.isActive ?? false;
+	}
+	/** List all active speedhacks */
+	listActive() {
+		return Array.from(this.states.values()).filter((s) => s.isActive);
+	}
+	/**
+	* Hook a time function with a JMP trampoline.
+	* Saves original bytes in shared memory for restoration.
+	*/
+	async hookTimeFunction(handle, funcAddr, sharedMem, trampolineOffset, _hookId) {
+		try {
+			const origBytes = ReadProcessMemory(handle, funcAddr, 14);
+			const trampolineAddr = sharedMem + trampolineOffset;
+			WriteProcessMemory(handle, trampolineAddr, origBytes);
+			const jumpBackAddr = funcAddr + 14n;
+			const jumpBack = this.buildAbsoluteJump(jumpBackAddr);
+			WriteProcessMemory(handle, trampolineAddr + 14n, Buffer.from(jumpBack));
+			const jumpToTrampoline = this.buildAbsoluteJump(trampolineAddr);
+			const { oldProtect } = VirtualProtectEx(handle, funcAddr, 14, PAGE.EXECUTE_READWRITE);
+			WriteProcessMemory(handle, funcAddr, Buffer.from(jumpToTrampoline));
+			FlushInstructionCache(handle, funcAddr, 14);
+			VirtualProtectEx(handle, funcAddr, 14, oldProtect);
+			const patchIndex = this.states.size;
+			const metaOffset = 3072n + BigInt(patchIndex * 32);
+			const metaBuf = Buffer.alloc(32);
+			metaBuf.writeBigUInt64LE(funcAddr, 0);
+			metaBuf.writeUInt32LE(14, 8);
+			origBytes.copy(metaBuf, 12);
+			WriteProcessMemory(handle, sharedMem + metaOffset, metaBuf);
+			FlushInstructionCache(handle, trampolineAddr, 32);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/** Build a 14-byte absolute JMP for x64: FF 25 00 00 00 00 [8-byte addr] */
+	buildAbsoluteJump(target) {
+		const buf = Buffer.alloc(14);
+		buf[0] = 255;
+		buf[1] = 37;
+		buf.writeUInt32LE(0, 2);
+		buf.writeBigUInt64LE(target, 6);
+		return Array.from(buf);
+	}
+};
+const speedhack = new Speedhack();
+//#endregion
+export { Speedhack, speedhack };

package/dist/StealthVerifier-BzBCFiwx.mjs

@@ -0,0 +1,135 @@
+import "rebrowser-puppeteer-core";
+//#region src/modules/stealth/StealthVerifier.ts
+var StealthVerifier = class {
+	/**
+	* Run all anti-detection checks on the given page.
+	* Should be called AFTER stealth_inject for meaningful results.
+	*/
+	async verify(page) {
+		const checks = await page.evaluate(() => {
+			const results = [];
+			const wd = navigator.webdriver;
+			results.push({
+				name: "navigator.webdriver",
+				passed: wd === void 0 || wd === false,
+				expected: "undefined",
+				actual: String(wd)
+			});
+			const win = window;
+			const hasChrome = typeof win.chrome === "object" && win.chrome !== null;
+			results.push({
+				name: "window.chrome",
+				passed: hasChrome,
+				expected: "object",
+				actual: typeof win.chrome
+			});
+			const chromeApp = hasChrome ? win.chrome.app : null;
+			const hasAppIsInstalled = chromeApp && typeof chromeApp === "object" && "isInstalled" in chromeApp;
+			results.push({
+				name: "chrome.app.isInstalled",
+				passed: Boolean(hasAppIsInstalled),
+				expected: "exists (false)",
+				actual: hasAppIsInstalled ? String(chromeApp.isInstalled) : "missing"
+			});
+			const pluginCount = navigator.plugins?.length ?? 0;
+			results.push({
+				name: "navigator.plugins",
+				passed: pluginCount >= 3,
+				expected: ">= 3",
+				actual: String(pluginCount)
+			});
+			const langs = navigator.languages;
+			results.push({
+				name: "navigator.languages",
+				passed: langs.length > 0,
+				expected: "non-empty",
+				actual: JSON.stringify(langs)
+			});
+			const ua = navigator.userAgent;
+			const platform = navigator.platform;
+			let platformConsistent = true;
+			if (ua.includes("Windows") && !platform.includes("Win")) platformConsistent = false;
+			if (ua.includes("Macintosh") && !platform.includes("Mac")) platformConsistent = false;
+			if (ua.includes("Linux") && !platform.includes("Linux")) platformConsistent = false;
+			results.push({
+				name: "platform/UA consistency",
+				passed: platformConsistent,
+				expected: "consistent",
+				actual: `UA=${ua.substring(0, 50)}... platform=${platform}`
+			});
+			let webglVendor = "unavailable";
+			try {
+				const gl = document.createElement("canvas").getContext("webgl");
+				if (gl) {
+					const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+					if (debugInfo) webglVendor = gl.getParameter(debugInfo.UNMASKED_VENDOR_WEBGL) || "empty";
+				}
+			} catch {
+				webglVendor = "error";
+			}
+			results.push({
+				name: "WebGL vendor",
+				passed: webglVendor !== "empty" && webglVendor !== "error",
+				expected: "non-empty vendor string",
+				actual: webglVendor
+			});
+			const cdcKeys = Object.keys(document).filter((k) => k.startsWith("cdc_") || k.startsWith("$cdc_"));
+			results.push({
+				name: "cdc_ variables",
+				passed: cdcKeys.length === 0,
+				expected: "none",
+				actual: cdcKeys.length === 0 ? "none" : cdcKeys.join(", ")
+			});
+			const hwc = navigator.hardwareConcurrency ?? 0;
+			results.push({
+				name: "hardwareConcurrency",
+				passed: hwc >= 4,
+				expected: ">= 4",
+				actual: String(hwc)
+			});
+			const dm = navigator.deviceMemory;
+			results.push({
+				name: "deviceMemory",
+				passed: dm !== void 0 && dm >= 4,
+				expected: ">= 4",
+				actual: String(dm ?? "undefined")
+			});
+			return results;
+		});
+		const passedCount = checks.filter((c) => c.passed).length;
+		const totalCount = checks.length;
+		const score = Math.round(passedCount / totalCount * 100);
+		const recommendations = [];
+		for (const check of checks) if (!check.passed) switch (check.name) {
+			case "navigator.webdriver":
+				recommendations.push("Run stealth_inject to hide navigator.webdriver");
+				break;
+			case "window.chrome":
+				recommendations.push("Run stealth_inject to inject window.chrome object");
+				break;
+			case "chrome.app.isInstalled":
+				recommendations.push("Update stealth scripts to include chrome.app structure");
+				break;
+			case "navigator.plugins":
+				recommendations.push("Run stealth_inject to restore navigator.plugins");
+				break;
+			case "platform/UA consistency":
+				recommendations.push("Run stealth_set_user_agent with matching platform before stealth_inject");
+				break;
+			case "cdc_ variables":
+				recommendations.push("Run stealth_inject to clean up ChromeDriver cdc_ variables");
+				break;
+			default: recommendations.push(`Fix: ${check.name} — expected ${check.expected}, got ${check.actual}`);
+		}
+		return {
+			passed: passedCount === totalCount,
+			checks,
+			score,
+			passedCount,
+			totalCount,
+			recommendations
+		};
+	}
+};
+//#endregion
+export { StealthVerifier };