@jshookmcp/jshook 0.2.6 → 0.2.8

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

@@ -1,384 +0,0 @@
-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)) {
-            logger.info('Stealth scripts already injected on this page, skipping');
-            return;
-        }
-        logger.info('Injecting modern stealth scripts...');
-        await Promise.all([
-            this.hideWebDriver(page),
-            this.mockChrome(page),
-            this.mockPlugins(page),
-            this.fixPermissions(page),
-            this.mockCanvas(page),
-            this.mockWebGL(page),
-            this.fixLanguages(page),
-            this.mockBattery(page),
-            this.fixMediaDevices(page),
-            this.mockNotifications(page),
-        ]);
-        await this.injectTimingDefense(page);
-        this.injectedPages.add(page);
-        logger.info(' ');
-    }
-    static async injectTimingDefense(page) {
-        await page.evaluateOnNewDocument(() => {
-            const _originalPerfNow = performance.now.bind(performance);
-            const _originalDateNow = Date.now;
-            let _cdpOffset = 0;
-            performance.now = function () {
-                const win = window;
-                if (typeof win.__cdpTimingOffset === 'number') {
-                    _cdpOffset = win.__cdpTimingOffset;
-                }
-                return _originalPerfNow() - _cdpOffset;
-            };
-            Date.now = function () {
-                const win = window;
-                if (typeof win.__cdpTimingOffset === 'number') {
-                    _cdpOffset = win.__cdpTimingOffset;
-                }
-                return _originalDateNow.call(Date) - Math.floor(_cdpOffset);
-            };
-            const _OriginalDate = Date;
-            const _ProxiedDate = function (...args) {
-                if (args.length === 0) {
-                    return new _OriginalDate(_OriginalDate.now());
-                }
-                return new _OriginalDate(...args);
-            };
-            _ProxiedDate.now = _OriginalDate.now;
-            _ProxiedDate.parse = _OriginalDate.parse.bind(_OriginalDate);
-            _ProxiedDate.UTC = _OriginalDate.UTC.bind(_OriginalDate);
-            Object.defineProperty(_ProxiedDate, 'prototype', { value: _OriginalDate.prototype });
-            globalThis.Date = _ProxiedDate;
-        });
-    }
-    static async hideWebDriver(page) {
-        await page.evaluateOnNewDocument(() => {
-            const originalNavigator = navigator;
-            const navigatorPrototype = Object.getPrototypeOf(originalNavigator);
-            delete navigatorPrototype.webdriver;
-            Object.defineProperty(navigator, 'webdriver', {
-                get: () => undefined,
-                configurable: true,
-            });
-            const originalGetOwnPropertyNames = Object.getOwnPropertyNames;
-            Object.getOwnPropertyNames = function (obj) {
-                const props = originalGetOwnPropertyNames(obj);
-                return props.filter((prop) => prop !== 'webdriver');
-            };
-            if (typeof document !== 'undefined') {
-                const doc = document;
-                for (const key of Object.keys(doc)) {
-                    if (key.startsWith('cdc_') || key.startsWith('$cdc_')) {
-                        delete doc[key];
-                    }
-                }
-            }
-        });
-    }
-    static async mockChrome(page) {
-        await page.evaluateOnNewDocument(() => {
-            const win = window;
-            win.chrome = {
-                runtime: {
-                    connect: () => { },
-                    sendMessage: () => { },
-                    onMessage: {
-                        addListener: () => { },
-                        removeListener: () => { },
-                    },
-                },
-                loadTimes: function () {
-                    return {
-                        commitLoadTime: Date.now() / 1000,
-                        connectionInfo: 'http/1.1',
-                        finishDocumentLoadTime: Date.now() / 1000,
-                        finishLoadTime: Date.now() / 1000,
-                        firstPaintAfterLoadTime: 0,
-                        firstPaintTime: Date.now() / 1000,
-                        navigationType: 'Other',
-                        npnNegotiatedProtocol: 'unknown',
-                        requestTime: 0,
-                        startLoadTime: Date.now() / 1000,
-                        wasAlternateProtocolAvailable: false,
-                        wasFetchedViaSpdy: false,
-                        wasNpnNegotiated: false,
-                    };
-                },
-                csi: function () {
-                    return {
-                        onloadT: Date.now(),
-                        pageT: Date.now(),
-                        startE: Date.now(),
-                        tran: 15,
-                    };
-                },
-                app: {
-                    isInstalled: false,
-                    InstallState: {
-                        DISABLED: 'disabled',
-                        INSTALLED: 'installed',
-                        NOT_INSTALLED: 'not_installed',
-                    },
-                    RunningState: {
-                        CANNOT_RUN: 'cannot_run',
-                        READY_TO_RUN: 'ready_to_run',
-                        RUNNING: 'running',
-                    },
-                },
-            };
-        });
-    }
-    static async mockPlugins(page) {
-        await page.evaluateOnNewDocument(() => {
-            Object.defineProperty(navigator, 'plugins', {
-                configurable: true,
-                get: () => [
-                    {
-                        0: {
-                            type: 'application/pdf',
-                            suffixes: 'pdf',
-                            description: 'Portable Document Format',
-                        },
-                        description: 'Portable Document Format',
-                        filename: 'internal-pdf-viewer',
-                        length: 1,
-                        name: 'Chrome PDF Plugin',
-                    },
-                    {
-                        0: { type: 'application/x-google-chrome-pdf', suffixes: 'pdf', description: '' },
-                        description: '',
-                        filename: 'internal-pdf-viewer',
-                        length: 1,
-                        name: 'Chrome PDF Viewer',
-                    },
-                    {
-                        0: {
-                            type: 'application/x-nacl',
-                            suffixes: '',
-                            description: 'Native Client Executable',
-                        },
-                        1: {
-                            type: 'application/x-pnacl',
-                            suffixes: '',
-                            description: 'Portable Native Client Executable',
-                        },
-                        description: '',
-                        filename: 'internal-nacl-plugin',
-                        length: 2,
-                        name: 'Native Client',
-                    },
-                ],
-            });
-        });
-    }
-    static async fixPermissions(page) {
-        await page.evaluateOnNewDocument(() => {
-            const originalQuery = window.navigator.permissions.query.bind(window.navigator.permissions);
-            const notification = Notification;
-            window.navigator.permissions.query = (parameters) => parameters.name === 'notifications'
-                ? Promise.resolve({ state: notification.permission })
-                : originalQuery(parameters);
-        });
-    }
-    static async mockCanvas(page) {
-        await page.evaluateOnNewDocument(() => {
-            const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
-            const originalGetImageData = CanvasRenderingContext2D.prototype.getImageData;
-            HTMLCanvasElement.prototype.toDataURL = function (...args) {
-                const context = this.getContext('2d');
-                if (context) {
-                    const imageData = context.getImageData(0, 0, this.width, this.height);
-                    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);
-                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;
-            };
-        });
-    }
-    static async mockWebGL(page) {
-        await page.evaluateOnNewDocument(() => {
-            const getParameter = WebGLRenderingContext.prototype.getParameter;
-            WebGLRenderingContext.prototype.getParameter = function (parameter) {
-                if (parameter === 37445) {
-                    return 'Intel Inc.';
-                }
-                if (parameter === 37446) {
-                    return 'Intel Iris OpenGL Engine';
-                }
-                return getParameter.apply(this, [parameter]);
-            };
-        });
-    }
-    static async fixLanguages(page) {
-        await page.evaluateOnNewDocument(() => {
-            Object.defineProperty(navigator, 'language', {
-                configurable: true,
-                get: () => 'en-US',
-            });
-            Object.defineProperty(navigator, 'languages', {
-                configurable: true,
-                get: () => ['en-US', 'en'],
-            });
-        });
-    }
-    static async mockBattery(page) {
-        await page.evaluateOnNewDocument(() => {
-            const navigatorWithBattery = navigator;
-            if (typeof navigatorWithBattery.getBattery === 'function') {
-                const originalGetBattery = navigatorWithBattery.getBattery;
-                navigatorWithBattery.getBattery = function () {
-                    return originalGetBattery.call(navigator).then((battery) => {
-                        Object.defineProperty(battery, 'charging', { configurable: true, get: () => true });
-                        Object.defineProperty(battery, 'chargingTime', { configurable: true, get: () => 0 });
-                        Object.defineProperty(battery, 'dischargingTime', {
-                            configurable: true,
-                            get: () => Infinity,
-                        });
-                        Object.defineProperty(battery, 'level', { configurable: true, get: () => 1 });
-                        return battery;
-                    });
-                };
-            }
-        });
-    }
-    static async fixMediaDevices(page) {
-        await page.evaluateOnNewDocument(() => {
-            if (navigator.mediaDevices && navigator.mediaDevices.enumerateDevices) {
-                const originalEnumerateDevices = navigator.mediaDevices.enumerateDevices;
-                navigator.mediaDevices.enumerateDevices = function () {
-                    return originalEnumerateDevices.call(navigator.mediaDevices).then((devices) => {
-                        if (devices.length === 0) {
-                            return [
-                                {
-                                    deviceId: 'default',
-                                    kind: 'audioinput',
-                                    label: 'Default - Microphone',
-                                    groupId: 'default',
-                                    toJSON: () => ({}),
-                                },
-                                {
-                                    deviceId: 'default',
-                                    kind: 'videoinput',
-                                    label: 'Default - Camera',
-                                    groupId: 'default',
-                                    toJSON: () => ({}),
-                                },
-                            ];
-                        }
-                        return devices;
-                    });
-                };
-            }
-        });
-    }
-    static async mockNotifications(page) {
-        await page.evaluateOnNewDocument(() => {
-            if ('Notification' in window) {
-                Object.defineProperty(Notification, 'permission', {
-                    configurable: true,
-                    get: () => 'default',
-                });
-            }
-        });
-    }
-    static async setRealisticUserAgent(page, platform = 'windows') {
-        const userAgents = {
-            windows: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
-            mac: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
-            linux: 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
-        };
-        const platformMap = {
-            windows: 'Win32',
-            mac: 'MacIntel',
-            linux: 'Linux x86_64',
-        };
-        const concurrencyMap = {
-            windows: 16,
-            mac: 12,
-            linux: 8,
-        };
-        await page.setUserAgent(userAgents[platform]);
-        const cores = concurrencyMap[platform];
-        await page.evaluateOnNewDocument((platformValue, hwConcurrency) => {
-            Object.defineProperty(navigator, 'platform', {
-                configurable: true,
-                get: () => platformValue,
-            });
-            Object.defineProperty(navigator, 'vendor', {
-                configurable: true,
-                get: () => 'Google Inc.',
-            });
-            Object.defineProperty(navigator, 'hardwareConcurrency', {
-                configurable: true,
-                get: () => hwConcurrency,
-            });
-            Object.defineProperty(navigator, 'deviceMemory', {
-                configurable: true,
-                get: () => 8,
-            });
-        }, platformMap[platform], cores);
-    }
-    static getRecommendedLaunchArgs() {
-        return [
-            '--no-sandbox',
-            '--disable-setuid-sandbox',
-            '--disable-blink-features=AutomationControlled',
-            '--disable-dev-shm-usage',
-            '--disable-accelerated-2d-canvas',
-            '--no-first-run',
-            '--no-zygote',
-            '--disable-gpu',
-            '--disable-web-security',
-            '--disable-features=IsolateOrigins,site-per-process',
-            '--window-size=1920,1080',
-            '--disable-infobars',
-            '--disable-extensions',
-            '--disable-default-apps',
-            '--disable-sync',
-            '--metrics-recording-only',
-            '--mute-audio',
-            '--no-default-browser-check',
-            '--disable-background-timer-throttling',
-            '--disable-backgrounding-occluded-windows',
-            '--disable-renderer-backgrounding',
-            ...StealthScripts.getPatchrightLaunchArgs(),
-        ];
-    }
-    static getPatchrightLaunchArgs() {
-        return [
-            '--remote-allow-origins=*',
-            '--disable-component-update',
-            '--disable-features=OptimizationGuideModelDownloading,OptimizationHintsFetching,OptimizationHints',
-            '--disable-hang-monitor',
-            '--disable-domain-reliability',
-            '--disable-client-side-phishing-detection',
-            '--disable-popup-blocking',
-        ];
-    }
-}

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

@@ -1,18 +0,0 @@
-import { type Page } from 'rebrowser-puppeteer-core';
-export interface StealthCheck {
-    name: string;
-    passed: boolean;
-    expected: string;
-    actual: string;
-}
-export interface StealthCheckResult {
-    passed: boolean;
-    checks: StealthCheck[];
-    score: number;
-    passedCount: number;
-    totalCount: number;
-    recommendations: string[];
-}
-export declare class StealthVerifier {
-    verify(page: Page): Promise<StealthCheckResult>;
-}

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

@@ -1,143 +0,0 @@
-import {} from 'rebrowser-puppeteer-core';
-export class StealthVerifier {
-    async verify(page) {
-        const checks = await page.evaluate(() => {
-            const results = [];
-            const wd = navigator.webdriver;
-            results.push({
-                name: 'navigator.webdriver',
-                passed: wd === undefined || 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 canvas = document.createElement('canvas');
-                const gl = 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 docKeys = Object.keys(document);
-            const cdcKeys = docKeys.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 !== undefined && 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,
-        };
-    }
-}

package/dist/src/modules/symbolic/JSVMPSymbolicExecutor.d.ts

@@ -1,84 +0,0 @@
-import { SymbolicExecutor, type SymbolicState, type Constraint } from '../symbolic/SymbolicExecutor.js';
-import type { VMType } from '../../types/index.js';
-export declare enum JSVMPOpcode {
-    PUSH = 1,
-    POP = 2,
-    DUP = 3,
-    ADD = 16,
-    SUB = 17,
-    MUL = 18,
-    DIV = 19,
-    MOD = 20,
-    AND = 32,
-    OR = 33,
-    NOT = 34,
-    XOR = 35,
-    EQ = 48,
-    NE = 49,
-    LT = 50,
-    LE = 51,
-    GT = 52,
-    GE = 53,
-    JMP = 64,
-    JZ = 65,
-    JNZ = 66,
-    CALL = 67,
-    RET = 68,
-    LOAD = 80,
-    STORE = 81,
-    LOAD_CONST = 82,
-    NOP = 0,
-    HALT = 255
-}
-export interface JSVMPInstruction {
-    opcode: JSVMPOpcode;
-    operands: unknown[];
-    location: number;
-}
-export interface JSVMPSymbolicExecutorOptions {
-    instructions: JSVMPInstruction[];
-    vmType?: VMType;
-    maxSteps?: number;
-    timeout?: number;
-}
-export interface JSVMPSymbolicExecutorResult {
-    finalState: SymbolicState;
-    executionTrace: SymbolicState[];
-    inferredLogic: string;
-    constraints: Constraint[];
-    confidence: number;
-    warnings: string[];
-}
-export declare class JSVMPSymbolicExecutor extends SymbolicExecutor {
-    executeJSVMP(options: JSVMPSymbolicExecutorOptions): Promise<JSVMPSymbolicExecutorResult>;
-    private executeInstruction;
-    private executePush;
-    private asNumberOperand;
-    private asStringOperand;
-    private executePop;
-    private executeAdd;
-    private executeSub;
-    private executeMul;
-    private executeDiv;
-    private executeMod;
-    private executeAnd;
-    private executeOr;
-    private executeNot;
-    private executeXor;
-    private executeEq;
-    private executeNe;
-    private executeLt;
-    private executeLe;
-    private executeGt;
-    private executeGe;
-    private executeJnz;
-    private executeDup;
-    private executeLoad;
-    private executeStore;
-    private executeJZ;
-    private executeCall;
-    private inferLogic;
-    private collectAllConstraints;
-    private calculateConfidence;
-    private cloneStateInternal;
-}