@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/{HeapAnalyzer-CEbo10xU.mjs → HeapAnalyzer-DruMgsgj.mjs}

@@ -1,7 +1,7 @@
-import { t as logger } from "./logger-BmWzC2lM.mjs";
-import { at as HEAP_SUSPICIOUS_BLOCK_SIZE, it as HEAP_SPRAY_THRESHOLD, nt as HEAP_ENUMERATE_MAX_BLOCKS, rt as HEAP_SPRAY_SIZE_TOLERANCE } from "./constants-CCvsN80K.mjs";
-import { b as openProcessForMemory, d as ReadProcessMemory, t as CloseHandle } from "./Win32API-Bc0QnQsN.mjs";
-import { m as TH32CS } from "./Win32Debug-DUHt9XUn.mjs";
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { ct as HEAP_SPRAY_THRESHOLD, lt as HEAP_SUSPICIOUS_BLOCK_SIZE, ot as HEAP_ENUMERATE_MAX_BLOCKS, st as HEAP_SPRAY_SIZE_TOLERANCE } from "./constants-CDZLOoVv.mjs";
+import { b as openProcessForMemory, d as ReadProcessMemory, t as CloseHandle } from "./Win32API-C2kjj0ze.mjs";
+import { m as TH32CS } from "./Win32Debug-CKrGOTpo.mjs";
 import koffi from "koffi";
 //#region src/native/HeapAnalyzer.types.ts
 /** Heap block flags */
@@ -25,7 +25,7 @@ const HF32 = {
 *
 * @module HeapAnalyzer
 */
-let _heapApis = null;
+let heapApisCache = null;
 function loadHeapApis() {
 	const k32 = koffi.load("kernel32.dll");
 	return {
@@ -44,8 +44,8 @@ function loadHeapApis() {
 	};
 }
 function getHeapApis() {
-	if (!_heapApis) _heapApis = loadHeapApis();
-	return _heapApis;
+	if (!heapApisCache) heapApisCache = loadHeapApis();
+	return heapApisCache;
 }
 const SIZE_RANGES = [
 	[
@@ -113,7 +113,7 @@ var HeapAnalyzer = class {
 				const processId = hlBuf.readUInt32LE(8);
 				const heapId = hlBuf.readBigUInt64LE(12);
 				const flags = hlBuf.readUInt32LE(20);
-				const blocks = await this._enumerateBlocksInternal(pid, heapId, HEAP_ENUMERATE_MAX_BLOCKS);
+				const blocks = await this.enumerateBlocksInternal(pid, heapId, HEAP_ENUMERATE_MAX_BLOCKS);
 				heaps.push({
 					heapId: `0x${heapId.toString(16)}`,
 					processId,
@@ -130,7 +130,7 @@ var HeapAnalyzer = class {
 		}
 		return {
 			heaps,
-			stats: this._computeStats(heaps, [])
+			stats: this.computeStats(heaps, [])
 		};
 	}
 	/**
@@ -139,7 +139,7 @@ var HeapAnalyzer = class {
 	async enumerateBlocks(pid, heapId, options) {
 		const id = BigInt(heapId);
 		const max = options?.maxBlocks ?? HEAP_ENUMERATE_MAX_BLOCKS;
-		return this._enumerateBlocksInternal(pid, id, max);
+		return this.enumerateBlocksInternal(pid, id, max);
 	}
 	/**
 	* Get full statistical breakdown for all heaps.
@@ -148,10 +148,10 @@ var HeapAnalyzer = class {
 		const { heaps } = await this.enumerateHeaps(pid);
 		const allBlocks = [];
 		for (const heap of heaps) {
-			const blocks = await this._enumerateBlocksInternal(pid, BigInt(heap.heapId), HEAP_ENUMERATE_MAX_BLOCKS);
+			const blocks = await this.enumerateBlocksInternal(pid, BigInt(heap.heapId), HEAP_ENUMERATE_MAX_BLOCKS);
 			allBlocks.push(...blocks);
 		}
-		return this._computeStats(heaps, allBlocks);
+		return this.computeStats(heaps, allBlocks);
 	}
 	/**
 	* Detect heap anomalies: spray, UAF heuristic, suspicious sizes.
@@ -160,14 +160,14 @@ var HeapAnalyzer = class {
 		const anomalies = [];
 		const { heaps } = await this.enumerateHeaps(pid);
 		for (const heap of heaps) {
-			const blocks = await this._enumerateBlocksInternal(pid, BigInt(heap.heapId), HEAP_ENUMERATE_MAX_BLOCKS);
-			this._detectSpray(blocks, heap.heapId, anomalies);
-			this._detectSuspiciousSizes(blocks, heap.heapId, anomalies);
-			await this._detectPossibleUAF(pid, blocks, heap.heapId, anomalies);
+			const blocks = await this.enumerateBlocksInternal(pid, BigInt(heap.heapId), HEAP_ENUMERATE_MAX_BLOCKS);
+			this.detectSpray(blocks, heap.heapId, anomalies);
+			this.detectSuspiciousSizes(blocks, heap.heapId, anomalies);
+			await this.detectPossibleUaf(pid, blocks, heap.heapId, anomalies);
 		}
 		return anomalies;
 	}
-	async _enumerateBlocksInternal(pid, heapId, maxBlocks) {
+	async enumerateBlocksInternal(pid, heapId, maxBlocks) {
 		const apis = getHeapApis();
 		const blocks = [];
 		const heBuf = Buffer.alloc(apis.HEAPENTRY32_SIZE);
@@ -189,7 +189,7 @@ var HeapAnalyzer = class {
 		}
 		return blocks;
 	}
-	_computeStats(heaps, blocks) {
+	computeStats(heaps, blocks) {
 		const buckets = SIZE_RANGES.map(([range]) => ({
 			range,
 			count: 0,
@@ -223,7 +223,7 @@ var HeapAnalyzer = class {
 			fragmentationRatio: totalSize > 0 ? freeSize / totalSize : 0
 		};
 	}
-	_detectSpray(blocks, heapId, anomalies) {
+	detectSpray(blocks, heapId, anomalies) {
 		const sizeGroups = /* @__PURE__ */ new Map();
 		for (const block of blocks) {
 			if (block.isFree) continue;
@@ -240,7 +240,7 @@ var HeapAnalyzer = class {
 			heapId
 		});
 	}
-	_detectSuspiciousSizes(blocks, heapId, anomalies) {
+	detectSuspiciousSizes(blocks, heapId, anomalies) {
 		for (const block of blocks) if (block.size === 0) anomalies.push({
 			type: "suspicious_size",
 			severity: "medium",
@@ -256,7 +256,7 @@ var HeapAnalyzer = class {
 			heapId
 		});
 	}
-	async _detectPossibleUAF(pid, blocks, heapId, anomalies) {
+	async detectPossibleUaf(pid, blocks, heapId, anomalies) {
 		const sampled = blocks.filter((b) => b.isFree && b.size >= 8).slice(0, 100);
 		let hProcess = null;
 		try {

package/dist/HookGeneratorBuilders.core.generators.storage-CTbB4Lcx.mjs

@@ -0,0 +1,566 @@
+//#region src/modules/hook/HookGeneratorBuilders.core.generators.runtime.ts
+function generateFunctionHook(target, action, customCode, condition, performance = false) {
+	return `
+(function() {
+'use strict';
+${condition ? `
+  let callCount = 0;
+  let lastCallTime = 0;
+  const maxCalls = ${condition.maxCalls || "Infinity"};
+  const minInterval = ${condition.minInterval || 0};
+  ` : ""}
+
+const originalFunction = ${target};
+
+if (typeof originalFunction !== 'function') {
+  console.error('[Hook] Target is not a function: ${target}');
+  return;
+}
+
+${target} = function(...args) {
+  ${condition ? `
+  const now = Date.now();
+  if (callCount >= maxCalls) {
+    console.log('[Hook] Max calls reached, skipping');
+    return originalFunction.apply(this, args);
+  }
+  if (now - lastCallTime < minInterval) {
+    console.log('[Hook] Min interval not met, skipping');
+    return originalFunction.apply(this, args);
+  }
+  callCount++;
+  lastCallTime = now;
+  ` : ""}
+
+  ${performance ? `
+  const startTime = performance.now();
+  ` : ""}
+
+  const hookContext = {
+    target: '${target}',
+    type: 'function',
+    timestamp: Date.now(),
+    arguments: args,
+    stackTrace: new Error().stack
+  };
+
+  console.log('[Hook] Function called:', hookContext);
+
+  ${action === "block" ? "return undefined;" : ""}
+  ${action === "modify" && customCode ? customCode : ""}
+
+  const result = originalFunction.apply(this, args);
+
+  ${performance ? `
+  const endTime = performance.now();
+  console.log('[Hook] Execution time:', (endTime - startTime).toFixed(2), 'ms');
+  ` : ""}
+
+  console.log('[Hook] Function result:', result);
+
+  return result;
+};
+
+console.log('[Hook] Successfully hooked: ${target}');
+})();
+`.trim();
+}
+function generateEvalHook(action, customCode, _condition, _performance = false) {
+	return `
+(function() {
+'use strict';
+
+const originalEval = window.eval;
+const originalFunction = window.Function;
+const originalSetTimeout = window.setTimeout;
+const originalSetInterval = window.setInterval;
+
+let evalCounter = 0;
+
+window.eval = function(code) {
+  const evalId = ++evalCounter;
+  const stackTrace = new Error().stack.split('\\n').slice(2, 5).join('\\n');
+
+  console.log(\`[Eval Hook #\${evalId}] eval:\`, {
+    code: typeof code === 'string' ? (code.length > 200 ? code.substring(0, 200) + '...' : code) : code,
+    codeType: typeof code,
+    codeLength: code?.length || 0,
+    stackTrace: stackTrace,
+    timestamp: new Date().toISOString()
+  });
+
+  ${action === "block" ? "return undefined;" : ""}
+  ${customCode || ""}
+
+  try {
+    const result = originalEval.call(this, code);
+    console.log(\`[Eval Hook #\${evalId}] result:\`, typeof result);
+    return result;
+  } catch (error) {
+    console.error(\`[Eval Hook #\${evalId}] error:\`, error.message);
+    throw error;
+  }
+};
+
+window.Function = function(...args) {
+  const evalId = ++evalCounter;
+  const stackTrace = new Error().stack.split('\\n').slice(2, 5).join('\\n');
+
+  const functionBody = args[args.length - 1];
+  const functionParams = args.slice(0, -1);
+
+  console.log(\`[Eval Hook #\${evalId}] Function constructor:\`, {
+    params: functionParams,
+    body: typeof functionBody === 'string' ?
+      (functionBody.length > 200 ? functionBody.substring(0, 200) + '...' : functionBody) :
+      functionBody,
+    bodyLength: functionBody?.length || 0,
+    stackTrace: stackTrace,
+    timestamp: new Date().toISOString()
+  });
+
+  ${action === "block" ? "return function() {};" : ""}
+  ${customCode || ""}
+
+  try {
+    const result = originalFunction.apply(this, args);
+    console.log(\`[Eval Hook #\${evalId}] Function created\`);
+    return result;
+  } catch (error) {
+    console.error(\`[Eval Hook #\${evalId}] error:\`, error.message);
+    throw error;
+  }
+};
+
+window.setTimeout = function(handler, timeout, ...args) {
+  if (typeof handler === 'string') {
+    const evalId = ++evalCounter;
+    console.log(\`[Eval Hook #\${evalId}] setTimeout with code:\`, {
+      code: handler.length > 200 ? handler.substring(0, 200) + '...' : handler,
+      timeout: timeout,
+      timestamp: new Date().toISOString()
+    });
+
+    ${action === "block" ? "return 0;" : ""}
+  }
+
+  return originalSetTimeout.apply(this, [handler, timeout, ...args]);
+};
+
+window.setInterval = function(handler, timeout, ...args) {
+  if (typeof handler === 'string') {
+    const evalId = ++evalCounter;
+    console.log(\`[Eval Hook #\${evalId}] setInterval with code:\`, {
+      code: handler.length > 200 ? handler.substring(0, 200) + '...' : handler,
+      timeout: timeout,
+      timestamp: new Date().toISOString()
+    });
+
+    ${action === "block" ? "return 0;" : ""}
+  }
+
+  return originalSetInterval.apply(this, [handler, timeout, ...args]);
+};
+
+console.log('[Eval Hook] Successfully hooked eval, Function, setTimeout, setInterval');
+})();
+`.trim();
+}
+function generateObjectMethodHook(target, action, customCode, _condition, _performance = false) {
+	const parts = target.split(".");
+	const methodName = parts.pop();
+	const objectPath = parts.join(".");
+	return `
+(function() {
+'use strict';
+
+function getObjectByPath(path) {
+  const parts = path.split('.');
+  let obj = window;
+
+  for (const part of parts) {
+    if (part === 'window') continue;
+    if (!obj || !(part in obj)) {
+      return null;
+    }
+    obj = obj[part];
+  }
+
+  return obj;
+}
+
+const targetObject = getObjectByPath('${objectPath}');
+const methodName = '${methodName}';
+
+if (!targetObject) {
+  console.error('[Object Hook] Target object not found: ${objectPath}');
+  return;
+}
+
+const descriptor = Object.getOwnPropertyDescriptor(targetObject, methodName) ||
+                   Object.getOwnPropertyDescriptor(Object.getPrototypeOf(targetObject), methodName);
+
+if (!descriptor) {
+  console.error('[Object Hook] Property not found: ${target}');
+  return;
+}
+
+let callCounter = 0;
+
+if (typeof targetObject[methodName] === 'function') {
+  const originalMethod = targetObject[methodName];
+
+  targetObject[methodName] = function(...args) {
+    const callId = ++callCounter;
+    const startTime = performance.now();
+    const stackTrace = new Error().stack.split('\\n').slice(2, 5).join('\\n');
+
+    console.log(\`[Object Hook #\${callId}] ${target}:\`, {
+      arguments: args,
+      this: this,
+      thisType: this?.constructor?.name,
+      stackTrace: stackTrace,
+      timestamp: new Date().toISOString()
+    });
+
+    ${action === "block" ? "return undefined;" : ""}
+    ${customCode || ""}
+
+    try {
+      const result = originalMethod.apply(this, args);
+      const endTime = performance.now();
+      const duration = (endTime - startTime).toFixed(2);
+
+      console.log(\`[Object Hook #\${callId}] ${target} result:\`, {
+        result: result,
+        resultType: typeof result,
+        duration: duration + 'ms'
+      });
+
+      return result;
+    } catch (error) {
+      console.error(\`[Object Hook #\${callId}] ${target} error:\`, error);
+      throw error;
+    }
+  };
+
+  Object.setPrototypeOf(targetObject[methodName], originalMethod);
+
+  console.log('[Object Hook] Successfully hooked method: ${target}');
+}
+else if (descriptor.get || descriptor.set) {
+  const originalGet = descriptor.get;
+  const originalSet = descriptor.set;
+
+  Object.defineProperty(targetObject, methodName, {
+    get: function() {
+      console.log('[Object Hook] getter called: ${target}');
+      return originalGet ? originalGet.call(this) : undefined;
+    },
+    set: function(value) {
+      console.log('[Object Hook] setter called: ${target}', { value });
+      ${action === "block" ? "return;" : ""}
+      if (originalSet) {
+        originalSet.call(this, value);
+      }
+    },
+    configurable: true,
+    enumerable: descriptor.enumerable
+  });
+
+  console.log('[Object Hook] Successfully hooked property: ${target}');
+}
+})();
+`.trim();
+}
+function generateAntiDebugBypass() {
+	return `
+(function() {
+'use strict';
+
+console.log('[Anti-Debug Bypass] Initializing...');
+
+const originalEval = window.eval;
+window.eval = function(code) {
+  if (typeof code === 'string') {
+    code = code.replace(/debugger\\s*;?/g, '');
+  }
+  return originalEval.call(this, code);
+};
+
+const originalFunction = window.Function;
+window.Function = function(...args) {
+  if (args.length > 0) {
+    const lastArg = args[args.length - 1];
+    if (typeof lastArg === 'string') {
+      args[args.length - 1] = lastArg.replace(/debugger\\s*;?/g, '');
+    }
+  }
+  return originalFunction.apply(this, args);
+};
+
+Object.defineProperty(window, 'outerHeight', {
+  get: function() {
+    return window.innerHeight;
+  }
+});
+
+Object.defineProperty(window, 'outerWidth', {
+  get: function() {
+    return window.innerWidth;
+  }
+});
+
+let lastTime = Date.now();
+const originalDateNow = Date.now;
+Date.now = function() {
+  const currentTime = originalDateNow();
+  if (currentTime - lastTime > 100) {
+    lastTime += 16;
+    return lastTime;
+  }
+  lastTime = currentTime;
+  return currentTime;
+};
+
+const originalToString = Function.prototype.toString;
+Function.prototype.toString = function() {
+  if (this === window.eval || this === window.Function) {
+    return 'function () { [native code] }';
+  }
+  return originalToString.call(this);
+};
+
+const devtools = { open: false };
+const threshold = 160;
+
+setInterval(function() {
+  if (window.outerWidth - window.innerWidth > threshold ||
+      window.outerHeight - window.innerHeight > threshold) {
+    devtools.open = true;
+  } else {
+    devtools.open = false;
+  }
+}, 500);
+
+Object.defineProperty(window, 'devtools', {
+  get: function() {
+    return { open: false };
+  }
+});
+
+console.log('[Anti-Debug Bypass] Successfully bypassed anti-debugging protections');
+})();
+`.trim();
+}
+function generateHookTemplate(targetName, targetType) {
+	if (targetType === "function") return `
+(function() {
+'use strict';
+
+const original = ${targetName};
+
+${targetName} = function(...args) {
+  console.log('[Hook] ${targetName} called:', args);
+
+
+  const result = original.apply(this, args);
+  console.log('[Hook] ${targetName} result:', result);
+
+  return result;
+};
+
+console.log('[Hook] Successfully hooked: ${targetName}');
+})();
+`.trim();
+	else if (targetType === "property") return `
+(function() {
+'use strict';
+
+const descriptor = Object.getOwnPropertyDescriptor(${targetName.split(".").slice(0, -1).join(".")}, '${targetName.split(".").pop()}');
+const originalGet = descriptor?.get;
+const originalSet = descriptor?.set;
+
+Object.defineProperty(${targetName.split(".").slice(0, -1).join(".")}, '${targetName.split(".").pop()}', {
+  get: function() {
+    console.log('[Hook] ${targetName} get');
+    return originalGet ? originalGet.call(this) : undefined;
+  },
+  set: function(value) {
+    console.log('[Hook] ${targetName} set:', value);
+    if (originalSet) {
+      originalSet.call(this, value);
+    }
+  },
+  configurable: true
+});
+
+console.log('[Hook] Successfully hooked property: ${targetName}');
+})();
+`.trim();
+	else return `
+(function() {
+'use strict';
+
+const original = ${targetName};
+
+${targetName} = function(...args) {
+  console.log('[Hook] ${targetName} constructor called:', args);
+
+  const instance = new original(...args);
+
+  const methodNames = Object.getOwnPropertyNames(original.prototype);
+  methodNames.forEach(name => {
+    if (name !== 'constructor' && typeof instance[name] === 'function') {
+      const originalMethod = instance[name];
+      instance[name] = function(...methodArgs) {
+        console.log(\`[Hook] \${name} called:\`, methodArgs);
+        return originalMethod.apply(this, methodArgs);
+      };
+    }
+  });
+
+  return instance;
+};
+
+${targetName}.prototype = original.prototype;
+
+console.log('[Hook] Successfully hooked prototype: ${targetName}');
+})();
+`.trim();
+}
+//#endregion
+//#region src/modules/hook/HookGeneratorBuilders.core.generators.storage.ts
+function generateLocalStorageHook(action, customCode, _condition, _performance = false) {
+	return `
+(function() {
+'use strict';
+
+const originalSetItem = Storage.prototype.setItem;
+const originalGetItem = Storage.prototype.getItem;
+const originalRemoveItem = Storage.prototype.removeItem;
+const originalClear = Storage.prototype.clear;
+
+Storage.prototype.setItem = function(key, value) {
+  const storageType = this === window.localStorage ? 'localStorage' : 'sessionStorage';
+  const stackTrace = new Error().stack.split('\\n').slice(2, 4).join('\\n');
+
+  console.log(\`[Storage Hook] \${storageType}.setItem:\`, {
+    key: key,
+    value: value,
+    valueType: typeof value,
+    valueLength: value?.length || 0,
+    stackTrace: stackTrace
+  });
+
+  ${action === "block" ? "return;" : ""}
+  ${customCode || ""}
+
+  return originalSetItem.apply(this, arguments);
+};
+
+Storage.prototype.getItem = function(key) {
+  const value = originalGetItem.apply(this, arguments);
+  const storageType = this === window.localStorage ? 'localStorage' : 'sessionStorage';
+
+  console.log(\`[Storage Hook] \${storageType}.getItem:\`, {
+    key: key,
+    value: value,
+    found: value !== null
+  });
+
+  return value;
+};
+
+Storage.prototype.removeItem = function(key) {
+  const storageType = this === window.localStorage ? 'localStorage' : 'sessionStorage';
+  const oldValue = this.getItem(key);
+
+  console.log(\`[Storage Hook] \${storageType}.removeItem:\`, {
+    key: key,
+    oldValue: oldValue
+  });
+
+  return originalRemoveItem.apply(this, arguments);
+};
+
+Storage.prototype.clear = function() {
+  const storageType = this === window.localStorage ? 'localStorage' : 'sessionStorage';
+  const itemCount = this.length;
+
+  console.log(\`[Storage Hook] \${storageType}.clear:\`, {
+    itemCount: itemCount,
+    items: Object.keys(this)
+  });
+
+  return originalClear.apply(this, arguments);
+};
+
+console.log('[Storage Hook] Successfully hooked localStorage and sessionStorage');
+})();
+`.trim();
+}
+function generateCookieHook(action, customCode, _condition, _performance = false) {
+	return `
+(function() {
+'use strict';
+
+const cookieDescriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie') ||
+                         Object.getOwnPropertyDescriptor(HTMLDocument.prototype, 'cookie');
+
+if (!cookieDescriptor) {
+  console.error('[Cookie Hook] Failed to get cookie descriptor');
+  return;
+}
+
+const originalGet = cookieDescriptor.get;
+const originalSet = cookieDescriptor.set;
+
+function parseCookie(cookieString) {
+  const parts = cookieString.split(';')[0].split('=');
+  return {
+    name: parts[0]?.trim(),
+    value: parts[1]?.trim(),
+    raw: cookieString
+  };
+}
+
+Object.defineProperty(document, 'cookie', {
+  get: function() {
+    const value = originalGet.call(this);
+
+    console.log('[Cookie Hook] get:', {
+      value: value,
+      cookieCount: value ? value.split(';').length : 0
+    });
+
+    return value;
+  },
+  set: function(value) {
+    const cookieInfo = parseCookie(value);
+    const stackTrace = new Error().stack.split('\\n').slice(2, 4).join('\\n');
+
+    console.log('[Cookie Hook] set:', {
+      name: cookieInfo.name,
+      value: cookieInfo.value,
+      raw: cookieInfo.raw,
+      stackTrace: stackTrace
+    });
+
+    ${action === "block" ? "return;" : ""}
+    ${customCode || ""}
+
+    return originalSet.call(this, value);
+  },
+  configurable: true
+});
+
+console.log('[Cookie Hook] Successfully hooked document.cookie');
+})();
+`.trim();
+}
+function getInjectionInstructions(type) {
+	return `This hook script monitors ${type} operations. Inject it into the target page via page_evaluate or console_execute to activate.`;
+}
+//#endregion
+export { generateEvalHook as a, generateObjectMethodHook as c, generateAntiDebugBypass as i, generateLocalStorageHook as n, generateFunctionHook as o, getInjectionInstructions as r, generateHookTemplate as s, generateCookieHook as t };