@jshookmcp/jshook 0.2.3 → 0.2.6

package/dist/src/modules/process/memory/scanner.windows.js

@@ -7,130 +7,130 @@ function buildMemoryScanScript(pid, pattern, patternType) {
     const { patternBytes, mask } = buildPatternBytesAndMask(pattern, patternType);
     const patternArray = patternBytes.join(',');
     const maskArray = mask.join(',');
-    return `
-Add-Type @"
-using System;
-using System.Runtime.InteropServices;
-using System.Collections.Generic;
-using System.ComponentModel;
-
-public class MemoryScanner {
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int read);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern int VirtualQueryEx(IntPtr hProcess, IntPtr addr, out MEMORY_BASIC_INFORMATION info, int size);
-
-    [DllImport("kernel32.dll", SetLastError = true)]
-    public static extern bool CloseHandle(IntPtr handle);
-
-    const int PROCESS_VM_READ = 0x0010;
-    const int PROCESS_QUERY_INFORMATION = 0x0400;
-
-    [StructLayout(LayoutKind.Sequential)]
-    public struct MEMORY_BASIC_INFORMATION {
-        public IntPtr BaseAddress;
-        public IntPtr AllocationBase;
-        public uint AllocationProtect;
-        public IntPtr RegionSize;
-        public uint State;
-        public uint Protect;
-        public uint Type;
-    }
-
-    const uint MEM_COMMIT = 0x1000;
-    const uint PAGE_READONLY = 0x02;
-    const uint PAGE_READWRITE = 0x04;
-    const uint PAGE_WRITECOPY = 0x08;
-    const uint PAGE_EXECUTE_READ = 0x20;
-    const uint PAGE_EXECUTE_READWRITE = 0x40;
-
-    public static List<string> ScanMemory(int pid, byte[] pattern, byte[] mask, int maxResults = 10000) {
-        var results = new List<string>();
-        IntPtr hProcess = OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, false, pid);
-        if (hProcess == IntPtr.Zero) {
-            int error = Marshal.GetLastWin32Error();
-            throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
-        }
-
-        try {
-            IntPtr addr = IntPtr.Zero;
-            MEMORY_BASIC_INFORMATION info;
-            int infoSize = Marshal.SizeOf(typeof(MEMORY_BASIC_INFORMATION));
-            int scannedRegions = 0;
-
-            while (VirtualQueryEx(hProcess, addr, out info, infoSize) == infoSize) {
-                scannedRegions++;
-                bool isReadable = (info.State == MEM_COMMIT) &&
-                    ((info.Protect & PAGE_READONLY) != 0 ||
-                     (info.Protect & PAGE_READWRITE) != 0 ||
-                     (info.Protect & PAGE_WRITECOPY) != 0 ||
-                     (info.Protect & PAGE_EXECUTE_READ) != 0 ||
-                     (info.Protect & PAGE_EXECUTE_READWRITE) != 0);
-
-                if (isReadable && info.RegionSize.ToInt64() > 0 && info.RegionSize.ToInt64() < 1073741824) {
-                    long regionSize = info.RegionSize.ToInt64();
-                    if (regionSize > 16777216) regionSize = 16777216; // bound scan window per region (16MB)
-                    byte[] buffer = new byte[(int)regionSize];
-                    int bytesRead;
-
-                    if (ReadProcessMemory(hProcess, info.BaseAddress, buffer, buffer.Length, out bytesRead)) {
-                        for (int i = 0; i <= bytesRead - pattern.Length; i++) {
-                            if (PatternMatch(buffer, i, pattern, mask)) {
-                                long foundAddr = info.BaseAddress.ToInt64() + i;
-                                results.Add("0x" + foundAddr.ToString("X"));
-                                if (results.Count >= maxResults) break;
-                            }
-                        }
-                    }
-                }
-
-                if (results.Count >= maxResults) break;
-                if (scannedRegions >= 50000) break;
-                long baseAddr = info.BaseAddress.ToInt64();
-                long regionSizeRaw = info.RegionSize.ToInt64();
-                if (regionSizeRaw <= 0) break;
-                long nextAddr = baseAddr + regionSizeRaw;
-                if (nextAddr <= baseAddr) break;
-                addr = new IntPtr(nextAddr);
-                if (addr.ToInt64() >= 0x7FFFFFFF0000) break;
-            }
-
-            return results;
-        } finally {
-            CloseHandle(hProcess);
-        }
-    }
-
-    private static bool PatternMatch(byte[] buffer, int offset, byte[] pattern, byte[] mask) {
-        for (int i = 0; i < pattern.Length; i++) {
-            if (mask[i] == 1 && buffer[offset + i] != pattern[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-}
-"@
-
-try {
-    $patternBytes = @(${patternArray})
-    $maskBytes = @(${maskArray})
-    $results = [MemoryScanner]::ScanMemory(${pid}, $patternBytes, $maskBytes, 1000)
-    @{
-        success = $true;
-        addresses = $results;
-        stats = @{
-            patternLength = $patternBytes.Length;
-            resultsFound = $results.Count
-        }
-    } | ConvertTo-Json -Compress
-} catch {
-    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-}
+    return `
+Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+public class MemoryScanner {
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int read);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern int VirtualQueryEx(IntPtr hProcess, IntPtr addr, out MEMORY_BASIC_INFORMATION info, int size);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    public static extern bool CloseHandle(IntPtr handle);
+
+    const int PROCESS_VM_READ = 0x0010;
+    const int PROCESS_QUERY_INFORMATION = 0x0400;
+
+    [StructLayout(LayoutKind.Sequential)]
+    public struct MEMORY_BASIC_INFORMATION {
+        public IntPtr BaseAddress;
+        public IntPtr AllocationBase;
+        public uint AllocationProtect;
+        public IntPtr RegionSize;
+        public uint State;
+        public uint Protect;
+        public uint Type;
+    }
+
+    const uint MEM_COMMIT = 0x1000;
+    const uint PAGE_READONLY = 0x02;
+    const uint PAGE_READWRITE = 0x04;
+    const uint PAGE_WRITECOPY = 0x08;
+    const uint PAGE_EXECUTE_READ = 0x20;
+    const uint PAGE_EXECUTE_READWRITE = 0x40;
+
+    public static List<string> ScanMemory(int pid, byte[] pattern, byte[] mask, int maxResults = 10000) {
+        var results = new List<string>();
+        IntPtr hProcess = OpenProcess(PROCESS_VM_READ | PROCESS_QUERY_INFORMATION, false, pid);
+        if (hProcess == IntPtr.Zero) {
+            int error = Marshal.GetLastWin32Error();
+            throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
+        }
+
+        try {
+            IntPtr addr = IntPtr.Zero;
+            MEMORY_BASIC_INFORMATION info;
+            int infoSize = Marshal.SizeOf(typeof(MEMORY_BASIC_INFORMATION));
+            int scannedRegions = 0;
+
+            while (VirtualQueryEx(hProcess, addr, out info, infoSize) == infoSize) {
+                scannedRegions++;
+                bool isReadable = (info.State == MEM_COMMIT) &&
+                    ((info.Protect & PAGE_READONLY) != 0 ||
+                     (info.Protect & PAGE_READWRITE) != 0 ||
+                     (info.Protect & PAGE_WRITECOPY) != 0 ||
+                     (info.Protect & PAGE_EXECUTE_READ) != 0 ||
+                     (info.Protect & PAGE_EXECUTE_READWRITE) != 0);
+
+                if (isReadable && info.RegionSize.ToInt64() > 0 && info.RegionSize.ToInt64() < 1073741824) {
+                    long regionSize = info.RegionSize.ToInt64();
+                    if (regionSize > 16777216) regionSize = 16777216; // bound scan window per region (16MB)
+                    byte[] buffer = new byte[(int)regionSize];
+                    int bytesRead;
+
+                    if (ReadProcessMemory(hProcess, info.BaseAddress, buffer, buffer.Length, out bytesRead)) {
+                        for (int i = 0; i <= bytesRead - pattern.Length; i++) {
+                            if (PatternMatch(buffer, i, pattern, mask)) {
+                                long foundAddr = info.BaseAddress.ToInt64() + i;
+                                results.Add("0x" + foundAddr.ToString("X"));
+                                if (results.Count >= maxResults) break;
+                            }
+                        }
+                    }
+                }
+
+                if (results.Count >= maxResults) break;
+                if (scannedRegions >= 50000) break;
+                long baseAddr = info.BaseAddress.ToInt64();
+                long regionSizeRaw = info.RegionSize.ToInt64();
+                if (regionSizeRaw <= 0) break;
+                long nextAddr = baseAddr + regionSizeRaw;
+                if (nextAddr <= baseAddr) break;
+                addr = new IntPtr(nextAddr);
+                if (addr.ToInt64() >= 0x7FFFFFFF0000) break;
+            }
+
+            return results;
+        } finally {
+            CloseHandle(hProcess);
+        }
+    }
+
+    private static bool PatternMatch(byte[] buffer, int offset, byte[] pattern, byte[] mask) {
+        for (int i = 0; i < pattern.Length; i++) {
+            if (mask[i] == 1 && buffer[offset + i] != pattern[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+"@
+
+try {
+    $patternBytes = @(${patternArray})
+    $maskBytes = @(${maskArray})
+    $results = [MemoryScanner]::ScanMemory(${pid}, $patternBytes, $maskBytes, 1000)
+    @{
+        success = $true;
+        addresses = $results;
+        stats = @{
+            patternLength = $patternBytes.Length;
+            resultsFound = $results.Count
+        }
+    } | ConvertTo-Json -Compress
+} catch {
+    @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
+}
   `.trim();
 }
 export async function scanMemoryWindows(pid, pattern, patternType) {

package/dist/src/modules/process/memory/writer.js

@@ -1,64 +1,65 @@
 import { logger } from '../../../utils/logger.js';
 import { nativeMemoryManager } from '../../../native/NativeMemoryManager.js';
 import { isKoffiAvailable } from '../../../native/Win32API.js';
+import { MEMORY_MAX_WRITE_BYTES } from '../../../constants.js';
 import { execAsync, executePowerShellScript, } from '../../process/memory/types.js';
 async function writeMemoryWindows(pid, address, data) {
     try {
         const hexData = data.toString('hex').toUpperCase();
-        const psScript = `
-        Add-Type @"
-          using System;
-          using System.Runtime.InteropServices;
-          using System.ComponentModel;
-
-          public class MemoryWriter {
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
-
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
-
-            [DllImport("kernel32.dll", SetLastError = true)]
-            public static extern bool CloseHandle(IntPtr handle);
-
-            const int PROCESS_VM_WRITE = 0x0020;
-            const int PROCESS_VM_OPERATION = 0x0008;
-
-            public static int WriteMemory(int pid, long address, string hexData) {
-              IntPtr hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, pid);
-              if (hProcess == IntPtr.Zero) {
-                int error = Marshal.GetLastWin32Error();
-                throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
-              }
-
-              try {
-                byte[] buffer = new byte[hexData.Length / 2];
-                for (int i = 0; i < hexData.Length; i += 2) {
-                  buffer[i / 2] = Convert.ToByte(hexData.Substring(i, 2), 16);
-                }
-
-                int bytesWritten;
-                bool success = WriteProcessMemory(hProcess, (IntPtr)address, buffer, buffer.Length, out bytesWritten);
-
-                if (!success) {
-                  int error = Marshal.GetLastWin32Error();
-                  throw new Win32Exception(error, "Failed to write memory");
-                }
-
-                return bytesWritten;
-              } finally {
-                CloseHandle(hProcess);
-              }
-            }
-          }
-"@
-
-        try {
-          $bytesWritten = [MemoryWriter]::WriteMemory(${pid}, ${address}, "${hexData}")
-          @{ success = $true; bytesWritten = $bytesWritten } | ConvertTo-Json -Compress
-        } catch {
-          @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
-        }
+        const psScript = `
+        Add-Type @"
+          using System;
+          using System.Runtime.InteropServices;
+          using System.ComponentModel;
+
+          public class MemoryWriter {
+            [DllImport("kernel32.dll", SetLastError = true)]
+            public static extern IntPtr OpenProcess(int access, bool inherit, int pid);
+
+            [DllImport("kernel32.dll", SetLastError = true)]
+            public static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr addr, byte[] buffer, int size, out int written);
+
+            [DllImport("kernel32.dll", SetLastError = true)]
+            public static extern bool CloseHandle(IntPtr handle);
+
+            const int PROCESS_VM_WRITE = 0x0020;
+            const int PROCESS_VM_OPERATION = 0x0008;
+
+            public static int WriteMemory(int pid, long address, string hexData) {
+              IntPtr hProcess = OpenProcess(PROCESS_VM_WRITE | PROCESS_VM_OPERATION, false, pid);
+              if (hProcess == IntPtr.Zero) {
+                int error = Marshal.GetLastWin32Error();
+                throw new Win32Exception(error, "Failed to open process. Run as Administrator.");
+              }
+
+              try {
+                byte[] buffer = new byte[hexData.Length / 2];
+                for (int i = 0; i < hexData.Length; i += 2) {
+                  buffer[i / 2] = Convert.ToByte(hexData.Substring(i, 2), 16);
+                }
+
+                int bytesWritten;
+                bool success = WriteProcessMemory(hProcess, (IntPtr)address, buffer, buffer.Length, out bytesWritten);
+
+                if (!success) {
+                  int error = Marshal.GetLastWin32Error();
+                  throw new Win32Exception(error, "Failed to write memory");
+                }
+
+                return bytesWritten;
+              } finally {
+                CloseHandle(hProcess);
+              }
+            }
+          }
+"@
+
+        try {
+          $bytesWritten = [MemoryWriter]::WriteMemory(${pid}, ${address}, "${hexData}")
+          @{ success = $true; bytesWritten = $bytesWritten } | ConvertTo-Json -Compress
+        } catch {
+          @{ success = $false; error = $_.Exception.Message } | ConvertTo-Json -Compress
+        }
       `;
         const { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024 });
         const _trimmed = stdout.trim();
@@ -108,11 +109,32 @@ async function writeMemoryMac(pid, address, data, checkProtectionFn) {
     if (address === 0) {
         return { success: false, error: 'Invalid address: null pointer (0x0)' };
     }
-    const MAX_WRITE_SIZE = 16 * 1024;
-    if (data.length === 0 || data.length > MAX_WRITE_SIZE) {
-        return { success: false, error: `Invalid write size: must be 1–${MAX_WRITE_SIZE} bytes` };
+    if (data.length === 0 || data.length > MEMORY_MAX_WRITE_BYTES) {
+        return {
+            success: false,
+            error: `Invalid write size: must be 1–${MEMORY_MAX_WRITE_BYTES} bytes`,
+        };
     }
     const addrHex = `0x${address.toString(16)}`;
+    try {
+        const { createPlatformProvider } = await import('../../../native/platform/factory.js');
+        const provider = createPlatformProvider();
+        const avail = await provider.checkAvailability();
+        if (avail.available) {
+            const handle = provider.openProcess(pid, true);
+            try {
+                const result = provider.writeMemory(handle, BigInt(address), data);
+                logger.debug('Native Mach memory write succeeded (zero-pause)');
+                return { success: true, bytesWritten: result.bytesWritten };
+            }
+            finally {
+                provider.closeProcess(handle);
+            }
+        }
+    }
+    catch (nativeErr) {
+        logger.debug('Native Mach write failed, falling back to lldb:', nativeErr);
+    }
     const prot = await checkProtectionFn(pid, addrHex);
     if (!prot.success) {
         return { success: false, error: `Cannot verify memory region: ${prot.error}` };
@@ -138,8 +160,12 @@ async function writeMemoryMac(pid, address, data, checkProtectionFn) {
         return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
+const HEX_ADDR = /^(?:0x)?[0-9a-fA-F]{1,16}$/;
 export async function writeMemory(platform, pid, address, data, encoding = 'hex', checkProtectionFn) {
     try {
+        if (!HEX_ADDR.test(address)) {
+            return { success: false, error: 'Invalid address format. Use hex like "0x12345678"' };
+        }
         const addrNum = parseInt(address, 16);
         if (isNaN(addrNum)) {
             return { success: false, error: 'Invalid address format' };
@@ -154,9 +180,15 @@ export async function writeMemory(platform, pid, address, data, encoding = 'hex'
                 buffer = Buffer.from(cleanHex, 'hex');
             }
         }
-        catch (_e) {
+        catch {
             return { success: false, error: `Invalid ${encoding} data` };
         }
+        if (buffer.length === 0 || buffer.length > MEMORY_MAX_WRITE_BYTES) {
+            return {
+                success: false,
+                error: `Write size must be 1–${MEMORY_MAX_WRITE_BYTES} bytes (${(MEMORY_MAX_WRITE_BYTES / 1024).toFixed(0)} KB)`,
+            };
+        }
         if (platform === 'win32' && isKoffiAvailable()) {
             try {
                 const result = await nativeMemoryManager.writeMemory(pid, address, data, encoding);
@@ -189,7 +221,15 @@ export async function writeMemory(platform, pid, address, data, encoding = 'hex'
         return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
+const MAX_BATCH_PATCHES = 1000;
 export async function batchMemoryWrite(pid, patches, writeFn) {
+    if (patches.length > MAX_BATCH_PATCHES) {
+        return {
+            success: false,
+            results: [],
+            error: `Too many patches (${patches.length}), max ${MAX_BATCH_PATCHES}`,
+        };
+    }
     const results = [];
     for (const patch of patches) {
         const result = await writeFn(pid, patch.address, patch.data, patch.encoding || 'hex');

package/dist/src/modules/security/ExecutionSandbox.js

@@ -2,50 +2,50 @@ import { Worker } from 'node:worker_threads';
 import { logger } from '../../utils/logger.js';
 import { cpuLimit } from '../../utils/concurrency.js';
 import { SANDBOX_EXEC_TIMEOUT_MS, SANDBOX_MEMORY_LIMIT_MB, SANDBOX_STACK_SIZE_MB, SANDBOX_TERMINATE_GRACE_MS, } from '../../constants.js';
-const WORKER_SCRIPT = `
-import { workerData, parentPort } from 'node:worker_threads';
-import * as vm from 'node:vm';
-
-const { code, timeoutMs } = workerData;
-
-try {
-  // Create an isolated context with minimal globals
-  const sandbox = {
-    // Safe built-ins only
-    parseInt, parseFloat, isNaN, isFinite,
-    encodeURIComponent, decodeURIComponent,
-    encodeURI, decodeURI,
-    JSON: { parse: JSON.parse, stringify: JSON.stringify },
-    Math,
-    String, Number, Boolean, Array, Object, Map, Set,
-    Date, RegExp, Error, TypeError, RangeError,
-    Promise,
-    Symbol,
-    undefined,
-    NaN,
-    Infinity,
-    // Explicitly denied: require, process, __filename, __dirname, Buffer, setTimeout, setInterval, fetch
-  };
-
-  const context = vm.createContext(sandbox, {
-    name: 'jshook-sandbox',
-    codeGeneration: { strings: false, wasm: false },
-  });
-
-  const script = new vm.Script(code, {
-    filename: 'sandbox-eval.js',
-    timeout: timeoutMs,
-  });
-
-  const result = script.runInContext(context, { timeout: timeoutMs });
-  parentPort.postMessage({ ok: true, output: result });
-} catch (err) {
-  parentPort.postMessage({
-    ok: false,
-    error: err.message || String(err),
-    timedOut: err.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT',
-  });
-}
+const WORKER_SCRIPT = `
+import { workerData, parentPort } from 'node:worker_threads';
+import * as vm from 'node:vm';
+
+const { code, timeoutMs } = workerData;
+
+try {
+  // Create an isolated context with minimal globals
+  const sandbox = {
+    // Safe built-ins only
+    parseInt, parseFloat, isNaN, isFinite,
+    encodeURIComponent, decodeURIComponent,
+    encodeURI, decodeURI,
+    JSON: { parse: JSON.parse, stringify: JSON.stringify },
+    Math,
+    String, Number, Boolean, Array, Object, Map, Set,
+    Date, RegExp, Error, TypeError, RangeError,
+    Promise,
+    Symbol,
+    undefined,
+    NaN,
+    Infinity,
+    // Explicitly denied: require, process, __filename, __dirname, Buffer, setTimeout, setInterval, fetch
+  };
+
+  const context = vm.createContext(sandbox, {
+    name: 'jshook-sandbox',
+    codeGeneration: { strings: false, wasm: false },
+  });
+
+  const script = new vm.Script(code, {
+    filename: 'sandbox-eval.js',
+    timeout: timeoutMs,
+  });
+
+  const result = script.runInContext(context, { timeout: timeoutMs });
+  parentPort.postMessage({ ok: true, output: result });
+} catch (err) {
+  parentPort.postMessage({
+    ok: false,
+    error: err.message || String(err),
+    timedOut: err.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT',
+  });
+}
 `;
 export class ExecutionSandbox {
     async execute(request) {
@@ -57,7 +57,13 @@ export class ExecutionSandbox {
         const startTime = Date.now();
         return new Promise((resolve) => {
             let settled = false;
-            let terminationTimeout;
+            const terminationTimeout = setTimeout(() => {
+                if (!settled) {
+                    void worker.terminate();
+                    logger.warn(`[ExecutionSandbox] Worker terminated after ${timeoutMs + SANDBOX_TERMINATE_GRACE_MS}ms`);
+                    finish({ ok: false, error: 'Execution timed out (worker terminated)', timedOut: true });
+                }
+            }, timeoutMs + SANDBOX_TERMINATE_GRACE_MS);
             const workerOptions = {
                 eval: true,
                 workerData: {
@@ -80,13 +86,6 @@ export class ExecutionSandbox {
                     clearTimeout(terminationTimeout);
                 resolve({ ...result, durationMs: Date.now() - startTime });
             };
-            terminationTimeout = setTimeout(() => {
-                if (!settled) {
-                    void worker.terminate();
-                    logger.warn(`[ExecutionSandbox] Worker terminated after ${timeoutMs + SANDBOX_TERMINATE_GRACE_MS}ms`);
-                    finish({ ok: false, error: 'Execution timed out (worker terminated)', timedOut: true });
-                }
-            }, timeoutMs + SANDBOX_TERMINATE_GRACE_MS);
             worker.on('message', (msg) => {
                 finish({
                     ok: msg.ok,

package/dist/src/modules/stealth/FingerprintManager.js

@@ -70,7 +70,7 @@ export class FingerprintManager {
             throw new Error('fingerprint-injector not installed');
         }
         try {
-            const { newInjectedPage } = await import('fingerprint-injector');
+            const { newInjectedPage } = (await import('fingerprint-injector'));
             const fp = 'fingerprint' in profile ? profile.fingerprint : profile;
             await newInjectedPage(page, { fingerprint: fp });
             logger.info('Fingerprint injected into page');

package/dist/src/modules/stealth/StealthScripts.d.ts

@@ -1,5 +1,6 @@
 import { type Page } from 'rebrowser-puppeteer-core';
 export declare class StealthScripts {
+    protected constructor();
     protected static injectedPages: WeakSet<object>;
     static injectAll(page: Page): Promise<void>;
     static injectTimingDefense(page: Page): Promise<void>;

package/dist/src/modules/stealth/StealthScripts.js

@@ -1,6 +1,7 @@
 import {} from 'rebrowser-puppeteer-core';
 import { logger } from '../../utils/logger.js';
 export class StealthScripts {
+    constructor() { }
     static injectedPages = new WeakSet();
     static async injectAll(page) {
         if (this.injectedPages.has(page)) {
@@ -190,29 +191,33 @@ export class StealthScripts {
         await page.evaluateOnNewDocument(() => {
             const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
             const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
-            const addNoise = (imageData) => {
-                const data = imageData.data;
-                if (data) {
-                    for (let i = 0; i < data.length; i += 4) {
-                        data[i] = data[i] ^ 1;
-                        data[i + 1] = data[i + 1] ^ 1;
-                        data[i + 2] = data[i + 2] ^ 1;
-                    }
-                }
-                return imageData;
-            };
             HTMLCanvasElement.prototype.toDataURL = function (...args) {
                 const context = this.getContext('2d');
                 if (context) {
                     const imageData = context.getImageData(0, 0, this.width, this.height);
-                    addNoise(imageData);
+                    const data = imageData.data;
+                    if (data) {
+                        for (let i = 0; i < data.length; i += 4) {
+                            data[i] = data[i] ^ 1;
+                            data[i + 1] = data[i + 1] ^ 1;
+                            data[i + 2] = data[i + 2] ^ 1;
+                        }
+                    }
                     context.putImageData(imageData, 0, 0);
                 }
                 return originalToDataURL.apply(this, args);
             };
             CanvasRenderingContext2D.prototype.getImageData = function (...args) {
                 const imageData = originalGetImageData.apply(this, args);
-                return addNoise(imageData);
+                const data = imageData.data;
+                if (data) {
+                    for (let i = 0; i < data.length; i += 4) {
+                        data[i] = data[i] ^ 1;
+                        data[i + 1] = data[i + 1] ^ 1;
+                        data[i + 2] = data[i + 2] ^ 1;
+                    }
+                }
+                return imageData;
             };
         });
     }

package/dist/src/modules/stealth/StealthVerifier.js

@@ -18,9 +18,7 @@ export class StealthVerifier {
                 expected: 'object',
                 actual: typeof win.chrome,
             });
-            const chromeApp = hasChrome
-                ? win.chrome.app
-                : null;
+            const chromeApp = hasChrome ? win.chrome.app : null;
             const hasAppIsInstalled = chromeApp && typeof chromeApp === 'object' && 'isInstalled' in chromeApp;
             results.push({
                 name: 'chrome.app.isInstalled',