@jshookmcp/jshook 0.1.7 → 0.1.9

package/dist/src/modules/collector/PageController.js

@@ -0,0 +1,306 @@
+import { logger } from '../../utils/logger.js';
+export class PageController {
+    collector;
+    constructor(collector) {
+        this.collector = collector;
+    }
+    async navigate(url, options) {
+        const page = await this.collector.getActivePage();
+        const startTime = Date.now();
+        await page.goto(url, {
+            waitUntil: options?.waitUntil || 'networkidle2',
+            timeout: options?.timeout || 30000,
+        });
+        const loadTime = Date.now() - startTime;
+        const title = await page.title();
+        const currentUrl = page.url();
+        logger.info(`Navigated to: ${url}`);
+        return {
+            url: currentUrl,
+            title,
+            loadTime,
+        };
+    }
+    async reload(options) {
+        const page = await this.collector.getActivePage();
+        await page.reload({
+            waitUntil: options?.waitUntil || 'networkidle2',
+            timeout: options?.timeout || 30000,
+        });
+        logger.info('Page reloaded');
+    }
+    async goBack() {
+        const page = await this.collector.getActivePage();
+        await page.goBack();
+        logger.info('Navigated back');
+    }
+    async goForward() {
+        const page = await this.collector.getActivePage();
+        await page.goForward();
+        logger.info('Navigated forward');
+    }
+    async click(selector, options) {
+        const page = await this.collector.getActivePage();
+        await page.click(selector, {
+            button: options?.button || 'left',
+            clickCount: options?.clickCount || 1,
+            delay: options?.delay,
+        });
+        logger.info(`Clicked: ${selector}`);
+    }
+    async type(selector, text, options) {
+        const page = await this.collector.getActivePage();
+        await page.type(selector, text, {
+            delay: options?.delay,
+        });
+        logger.info(`Typed into ${selector}: ${text.substring(0, 20)}...`);
+    }
+    async select(selector, ...values) {
+        const page = await this.collector.getActivePage();
+        await page.select(selector, ...values);
+        logger.info(`Selected in ${selector}: ${values.join(', ')}`);
+    }
+    async hover(selector) {
+        const page = await this.collector.getActivePage();
+        await page.hover(selector);
+        logger.info(`Hovered: ${selector}`);
+    }
+    async scroll(options) {
+        const page = await this.collector.getActivePage();
+        await page.evaluate((opts) => {
+            window.scrollTo(opts.x || 0, opts.y || 0);
+        }, options);
+        logger.info(`Scrolled to: x=${options.x || 0}, y=${options.y || 0}`);
+    }
+    async waitForSelector(selector, timeout) {
+        try {
+            const page = await this.collector.getActivePage();
+            await page.waitForSelector(selector, {
+                timeout: timeout || 30000,
+            });
+            const element = await page.evaluate((sel) => {
+                const el = document.querySelector(sel);
+                if (!el)
+                    return null;
+                return {
+                    tagName: el.tagName.toLowerCase(),
+                    id: el.id || undefined,
+                    className: el.className || undefined,
+                    textContent: el.textContent?.trim().substring(0, 100) || undefined,
+                    attributes: Array.from(el.attributes).reduce((acc, attr) => {
+                        acc[attr.name] = attr.value;
+                        return acc;
+                    }, {}),
+                };
+            }, selector);
+            logger.info(`Selector appeared: ${selector}`);
+            return {
+                success: true,
+                element,
+                message: `Selector appeared: ${selector}`,
+            };
+        }
+        catch (error) {
+            logger.error(`waitForSelector timeout for ${selector}:`, error);
+            return {
+                success: false,
+                message: `Timeout waiting for selector: ${selector}`,
+            };
+        }
+    }
+    async waitForNavigation(timeout) {
+        const page = await this.collector.getActivePage();
+        await page.waitForNavigation({
+            waitUntil: 'networkidle2',
+            timeout: timeout || 30000,
+        });
+        logger.info('Navigation completed');
+    }
+    async evaluate(code) {
+        const page = await this.collector.getActivePage();
+        const result = await page.evaluate(code);
+        logger.info('JavaScript executed');
+        return result;
+    }
+    async getURL() {
+        const page = await this.collector.getActivePage();
+        return page.url();
+    }
+    async getTitle() {
+        const page = await this.collector.getActivePage();
+        return await page.title();
+    }
+    async getContent() {
+        const page = await this.collector.getActivePage();
+        return await page.content();
+    }
+    async screenshot(options) {
+        const page = await this.collector.getActivePage();
+        const screenshotOpts = {
+            path: options?.path,
+            type: options?.type || 'png',
+            quality: options?.quality,
+            fullPage: options?.fullPage || false,
+        };
+        if (options?.clip) {
+            screenshotOpts.clip = options.clip;
+            screenshotOpts.fullPage = false;
+        }
+        const buffer = await page.screenshot(screenshotOpts);
+        logger.info(`Screenshot taken${options?.path ? `: ${options.path}` : ''}`);
+        return buffer;
+    }
+    async getPerformanceMetrics() {
+        const page = await this.collector.getActivePage();
+        const metrics = await page.evaluate(() => {
+            const perf = performance.getEntriesByType('navigation')[0];
+            return {
+                domContentLoaded: perf.domContentLoadedEventEnd - perf.domContentLoadedEventStart,
+                loadComplete: perf.loadEventEnd - perf.loadEventStart,
+                dns: perf.domainLookupEnd - perf.domainLookupStart,
+                tcp: perf.connectEnd - perf.connectStart,
+                request: perf.responseStart - perf.requestStart,
+                response: perf.responseEnd - perf.responseStart,
+                total: perf.loadEventEnd - perf.fetchStart,
+                resources: performance.getEntriesByType('resource').length,
+            };
+        });
+        logger.info('Performance metrics retrieved');
+        return metrics;
+    }
+    async injectScript(scriptContent) {
+        const page = await this.collector.getActivePage();
+        await page.evaluate((script) => {
+            const scriptElement = document.createElement('script');
+            scriptElement.textContent = script;
+            document.head.appendChild(scriptElement);
+        }, scriptContent);
+        logger.info('Script injected into page');
+    }
+    async setCookies(cookies) {
+        const page = await this.collector.getActivePage();
+        await page.setCookie(...cookies);
+        logger.info(`Set ${cookies.length} cookies`);
+    }
+    async getCookies() {
+        const page = await this.collector.getActivePage();
+        const cookies = await page.cookies();
+        logger.info(`Retrieved ${cookies.length} cookies`);
+        return cookies;
+    }
+    async clearCookies() {
+        const page = await this.collector.getActivePage();
+        const cookies = await page.cookies();
+        await page.deleteCookie(...cookies);
+        logger.info('All cookies cleared');
+    }
+    async setViewport(width, height) {
+        const page = await this.collector.getActivePage();
+        await page.setViewport({ width, height });
+        logger.info(`Viewport set to ${width}x${height}`);
+    }
+    async emulateDevice(deviceName) {
+        const page = await this.collector.getActivePage();
+        const devices = {
+            iPhone: {
+                viewport: { width: 375, height: 812, isMobile: true },
+                userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15',
+            },
+            iPad: {
+                viewport: { width: 768, height: 1024, isMobile: true },
+                userAgent: 'Mozilla/5.0 (iPad; CPU OS 14_0 like Mac OS X) AppleWebKit/605.1.15',
+            },
+            Android: {
+                viewport: { width: 360, height: 640, isMobile: true },
+                userAgent: 'Mozilla/5.0 (Linux; Android 10) AppleWebKit/537.36 Chrome/91.0.4472.120',
+            },
+        };
+        const normalized = String(deviceName || '').trim().toLowerCase();
+        let resolvedDevice = null;
+        if (normalized.includes('iphone')) {
+            resolvedDevice = 'iPhone';
+        }
+        else if (normalized.includes('ipad')) {
+            resolvedDevice = 'iPad';
+        }
+        else if (normalized.includes('android') || normalized.includes('pixel')) {
+            resolvedDevice = 'Android';
+        }
+        if (!resolvedDevice) {
+            throw new Error(`Unsupported device "${deviceName}". Supported values include: iPhone, iPad, Android (aliases like "iPhone 13" are accepted).`);
+        }
+        const device = devices[resolvedDevice];
+        await page.setViewport(device.viewport);
+        await page.setUserAgent(device.userAgent);
+        logger.info(`Emulating ${resolvedDevice} (input: ${deviceName})`);
+        return resolvedDevice;
+    }
+    async waitForNetworkIdle(timeout = 30000) {
+        const page = await this.collector.getActivePage();
+        await page.waitForNetworkIdle({ timeout });
+        logger.info('Network is idle');
+    }
+    async getLocalStorage() {
+        const page = await this.collector.getActivePage();
+        const storage = await page.evaluate(() => {
+            const items = {};
+            for (let i = 0; i < localStorage.length; i++) {
+                const key = localStorage.key(i);
+                if (key) {
+                    items[key] = localStorage.getItem(key) || '';
+                }
+            }
+            return items;
+        });
+        logger.info(`Retrieved ${Object.keys(storage).length} localStorage items`);
+        return storage;
+    }
+    async setLocalStorage(key, value) {
+        const page = await this.collector.getActivePage();
+        await page.evaluate((k, v) => {
+            localStorage.setItem(k, v);
+        }, key, value);
+        logger.info(`Set localStorage: ${key}`);
+    }
+    async clearLocalStorage() {
+        const page = await this.collector.getActivePage();
+        await page.evaluate(() => {
+            localStorage.clear();
+        });
+        logger.info('LocalStorage cleared');
+    }
+    async pressKey(key) {
+        const page = await this.collector.getActivePage();
+        await page.keyboard.press(key);
+        logger.info(`Pressed key: ${key}`);
+    }
+    async uploadFile(selector, filePath) {
+        const page = await this.collector.getActivePage();
+        const input = await page.$(selector);
+        if (!input) {
+            throw new Error(`File input not found: ${selector}`);
+        }
+        await input.uploadFile(filePath);
+        logger.info(`File uploaded: ${filePath}`);
+    }
+    async getAllLinks() {
+        const page = await this.collector.getActivePage();
+        const links = await page.evaluate(() => {
+            const anchors = document.querySelectorAll('a[href]');
+            const result = [];
+            for (let i = 0; i < anchors.length; i++) {
+                const anchor = anchors[i];
+                result.push({
+                    text: anchor.textContent?.trim() || '',
+                    href: anchor.href,
+                });
+            }
+            return result;
+        });
+        logger.info(`Found ${links.length} links`);
+        return links;
+    }
+    async getPage() {
+        return await this.collector.getActivePage();
+    }
+}

package/dist/src/modules/deobfuscator/AdvancedDeobfuscator.d.ts

@@ -0,0 +1,38 @@
+import type { DeobfuscateBundleSummary, DeobfuscateMappingRule, DeobfuscateSavedArtifact } from '../../types/deobfuscator.js';
+export interface AdvancedDeobfuscateOptions {
+    code: string;
+    detectOnly?: boolean;
+    aggressiveVM?: boolean;
+    useASTOptimization?: boolean;
+    timeout?: number;
+    unpack?: boolean;
+    unminify?: boolean;
+    jsx?: boolean;
+    mangle?: boolean;
+    outputDir?: string;
+    forceOutput?: boolean;
+    includeModuleCode?: boolean;
+    maxBundleModules?: number;
+    mappings?: DeobfuscateMappingRule[];
+}
+export interface AdvancedDeobfuscateResult {
+    code: string;
+    detectedTechniques: string[];
+    confidence: number;
+    warnings: string[];
+    astOptimized?: boolean;
+    bundle?: DeobfuscateBundleSummary;
+    savedTo?: string;
+    savedArtifacts?: DeobfuscateSavedArtifact[];
+    engine?: 'webcrack';
+    webcrackApplied?: boolean;
+    vmDetected?: {
+        type: string;
+        instructions: number;
+        deobfuscated: boolean;
+    };
+}
+export declare class AdvancedDeobfuscator {
+    deobfuscate(options: AdvancedDeobfuscateOptions): Promise<AdvancedDeobfuscateResult>;
+    private calculateConfidence;
+}

package/dist/src/modules/deobfuscator/AdvancedDeobfuscator.js

@@ -0,0 +1,84 @@
+import { logger } from '../../utils/logger.js';
+import { runWebcrack } from '../deobfuscator/webcrack.js';
+import { detectObfuscationType as detectObfuscationTypeUtil } from '../deobfuscator/Deobfuscator.utils.js';
+export class AdvancedDeobfuscator {
+    async deobfuscate(options) {
+        logger.info('Starting advanced webcrack deobfuscation...');
+        const detectedTechniques = detectObfuscationTypeUtil(options.code);
+        const warnings = [];
+        if (options.aggressiveVM !== undefined) {
+            warnings.push('aggressiveVM is deprecated and ignored; VM-specific legacy logic has been removed.');
+        }
+        if (options.useASTOptimization !== undefined) {
+            warnings.push('useASTOptimization is deprecated and ignored; legacy AST post-processing has been removed.');
+        }
+        if (options.timeout !== undefined) {
+            warnings.push('timeout is currently ignored; webcrack controls its own execution flow.');
+        }
+        if (options.detectOnly) {
+            return {
+                code: options.code,
+                detectedTechniques,
+                confidence: Math.min(0.6 + detectedTechniques.length * 0.05, 0.9),
+                warnings: [
+                    ...warnings,
+                    'detectOnly does not invoke a separate legacy detector anymore; techniques are inferred from the current static signature pass.',
+                ],
+                astOptimized: false,
+                engine: 'webcrack',
+                webcrackApplied: false,
+            };
+        }
+        const webcrackResult = await runWebcrack(options.code, {
+            unpack: options.unpack,
+            unminify: options.unminify,
+            jsx: options.jsx,
+            mangle: options.mangle,
+            mappings: options.mappings,
+            includeModuleCode: options.includeModuleCode,
+            maxBundleModules: options.maxBundleModules,
+            outputDir: options.outputDir,
+            forceOutput: options.forceOutput,
+        });
+        if (!webcrackResult.applied) {
+            const reason = webcrackResult.reason ?? 'webcrack did not return a result';
+            logger.error(`advanced webcrack deobfuscation failed: ${reason}`);
+            throw new Error(reason);
+        }
+        if (webcrackResult.bundle) {
+            detectedTechniques.push('bundle-unpack');
+        }
+        if (webcrackResult.optionsUsed.unminify) {
+            detectedTechniques.push('unminify');
+        }
+        if (webcrackResult.optionsUsed.jsx) {
+            detectedTechniques.push('jsx-decompile');
+        }
+        if (webcrackResult.optionsUsed.mangle) {
+            detectedTechniques.push('mangle');
+        }
+        detectedTechniques.push('webcrack');
+        return {
+            code: webcrackResult.code,
+            detectedTechniques: Array.from(new Set(detectedTechniques)),
+            confidence: this.calculateConfidence(webcrackResult, detectedTechniques),
+            warnings,
+            astOptimized: false,
+            bundle: webcrackResult.bundle,
+            savedTo: webcrackResult.savedTo,
+            savedArtifacts: webcrackResult.savedArtifacts,
+            engine: 'webcrack',
+            webcrackApplied: true,
+        };
+    }
+    calculateConfidence(webcrackResult, detectedTechniques) {
+        let confidence = 0.72 + detectedTechniques.length * 0.03;
+        if (webcrackResult.bundle) {
+            confidence += 0.08;
+        }
+        if (webcrackResult.savedTo) {
+            confidence += 0.04;
+        }
+        return Math.min(confidence, 0.99);
+    }
+}

package/dist/src/modules/deobfuscator/Deobfuscator.d.ts

@@ -0,0 +1,15 @@
+import type { DeobfuscateOptions, DeobfuscateResult } from '../../types/index.js';
+import { LLMService } from '../../services/LLMService.js';
+export declare class Deobfuscator {
+    private llm?;
+    private resultCache;
+    private maxCacheSize;
+    constructor(llm?: LLMService);
+    private generateCacheKey;
+    deobfuscate(options: DeobfuscateOptions): Promise<DeobfuscateResult>;
+    private detectObfuscationType;
+    private calculateReadabilityScore;
+    private calculateConfidence;
+    private buildAnalysis;
+    private llmAnalysis;
+}

package/dist/src/modules/deobfuscator/Deobfuscator.js

@@ -0,0 +1,177 @@
+import crypto from 'crypto';
+import { logger } from '../../utils/logger.js';
+import { DEOBF_LLM_MAX_TOKENS } from '../../constants.js';
+import { generateDeobfuscationPrompt } from '../../services/prompts/deobfuscation.js';
+import { calculateReadabilityScore as calculateReadabilityScoreUtil, detectObfuscationType as detectObfuscationTypeUtil, } from '../deobfuscator/Deobfuscator.utils.js';
+import { runWebcrack } from '../deobfuscator/webcrack.js';
+export class Deobfuscator {
+    llm;
+    resultCache = new Map();
+    maxCacheSize = 100;
+    constructor(llm) {
+        this.llm = llm;
+    }
+    generateCacheKey(options) {
+        const key = JSON.stringify({
+            code: options.code.substring(0, 2000),
+            forceOutput: options.forceOutput,
+            includeModuleCode: options.includeModuleCode,
+            jsx: options.jsx,
+            llm: options.llm,
+            mangle: options.mangle ?? options.renameVariables,
+            mappings: options.mappings,
+            maxBundleModules: options.maxBundleModules,
+            outputDir: options.outputDir,
+            unpack: options.unpack,
+            unminify: options.unminify,
+        });
+        return crypto.createHash('md5').update(key).digest('hex');
+    }
+    async deobfuscate(options) {
+        const cacheKey = this.generateCacheKey(options);
+        const cached = this.resultCache.get(cacheKey);
+        if (cached) {
+            logger.debug('Deobfuscation result from cache');
+            return cached;
+        }
+        logger.info('Starting webcrack deobfuscation...');
+        const startTime = Date.now();
+        const obfuscationType = this.detectObfuscationType(options.code);
+        const warnings = [];
+        if (options.aggressive !== undefined) {
+            warnings.push('aggressive is deprecated and ignored; webcrack is now the only deobfuscation engine.');
+        }
+        if (options.preserveLogic !== undefined) {
+            warnings.push('preserveLogic is deprecated and ignored.');
+        }
+        if (options.inlineFunctions !== undefined) {
+            warnings.push('inlineFunctions is deprecated and ignored.');
+        }
+        const webcrackResult = await runWebcrack(options.code, {
+            unpack: options.unpack,
+            unminify: options.unminify,
+            jsx: options.jsx,
+            mangle: options.mangle ?? options.renameVariables,
+            mappings: options.mappings,
+            includeModuleCode: options.includeModuleCode,
+            maxBundleModules: options.maxBundleModules,
+            outputDir: options.outputDir,
+            forceOutput: options.forceOutput,
+        });
+        if (!webcrackResult.applied) {
+            const reason = webcrackResult.reason ?? 'webcrack did not return a result';
+            logger.error(`webcrack deobfuscation failed: ${reason}`);
+            throw new Error(reason);
+        }
+        let analysis = this.buildAnalysis(webcrackResult, obfuscationType);
+        if (this.llm && options.llm) {
+            const llmResult = await this.llmAnalysis(webcrackResult.code);
+            if (llmResult) {
+                analysis = llmResult;
+            }
+        }
+        const transformations = [
+            {
+                type: 'webcrack',
+                description: `Ran webcrack (unminify=${webcrackResult.optionsUsed.unminify}, unpack=${webcrackResult.optionsUsed.unpack}, jsx=${webcrackResult.optionsUsed.jsx}, mangle=${webcrackResult.optionsUsed.mangle})`,
+                success: true,
+            },
+            ...(webcrackResult.bundle
+                ? [
+                    {
+                        type: 'webcrack-unpack',
+                        description: `Recovered ${webcrackResult.bundle.moduleCount} bundled modules`,
+                        success: true,
+                    },
+                ]
+                : []),
+            ...(webcrackResult.savedTo
+                ? [
+                    {
+                        type: 'webcrack-save',
+                        description: `Saved webcrack artifacts to ${webcrackResult.savedTo}`,
+                        success: true,
+                    },
+                ]
+                : []),
+            ...(this.llm && options.llm
+                ? [
+                    {
+                        type: 'llm-analysis',
+                        description: 'AI-assisted analysis completed after webcrack deobfuscation',
+                        success: true,
+                    },
+                ]
+                : []),
+        ];
+        const readabilityScore = this.calculateReadabilityScore(webcrackResult.code);
+        const confidence = this.calculateConfidence(webcrackResult, readabilityScore);
+        const duration = Date.now() - startTime;
+        logger.success(`webcrack deobfuscation completed in ${duration}ms (confidence: ${(confidence * 100).toFixed(1)}%)`);
+        const result = {
+            code: webcrackResult.code,
+            readabilityScore,
+            confidence,
+            obfuscationType,
+            transformations,
+            analysis,
+            bundle: webcrackResult.bundle,
+            savedTo: webcrackResult.savedTo,
+            savedArtifacts: webcrackResult.savedArtifacts,
+            warnings: warnings.length > 0 ? warnings : undefined,
+            engine: 'webcrack',
+            webcrackApplied: true,
+        };
+        if (this.resultCache.size >= this.maxCacheSize) {
+            const firstKey = this.resultCache.keys().next().value;
+            if (firstKey) {
+                this.resultCache.delete(firstKey);
+            }
+        }
+        this.resultCache.set(cacheKey, result);
+        return result;
+    }
+    detectObfuscationType(code) {
+        return detectObfuscationTypeUtil(code);
+    }
+    calculateReadabilityScore(code) {
+        return calculateReadabilityScoreUtil(code);
+    }
+    calculateConfidence(webcrackResult, readabilityScore) {
+        let confidence = 0.7;
+        confidence += readabilityScore / 500;
+        if (webcrackResult.bundle) {
+            confidence += 0.1;
+        }
+        if (webcrackResult.savedTo) {
+            confidence += 0.05;
+        }
+        return Math.min(confidence, 0.99);
+    }
+    buildAnalysis(webcrackResult, obfuscationType) {
+        const parts = [`webcrack completed deobfuscation for detected types: ${obfuscationType.join(', ')}.`];
+        if (webcrackResult.bundle) {
+            parts.push(`Recovered a ${webcrackResult.bundle.type} bundle with ${webcrackResult.bundle.moduleCount} modules.`);
+        }
+        if (webcrackResult.savedTo) {
+            parts.push(`Artifacts saved to ${webcrackResult.savedTo}.`);
+        }
+        return parts.join(' ');
+    }
+    async llmAnalysis(code) {
+        if (!this.llm)
+            return null;
+        try {
+            const messages = generateDeobfuscationPrompt(code);
+            const response = await this.llm.chat(messages, {
+                temperature: 0.3,
+                maxTokens: DEOBF_LLM_MAX_TOKENS,
+            });
+            return response.content;
+        }
+        catch (error) {
+            logger.warn('LLM analysis failed after webcrack deobfuscation', error);
+            return null;
+        }
+    }
+}

package/dist/src/modules/deobfuscator/webcrack.d.ts

@@ -0,0 +1,13 @@
+import type { DeobfuscateBundleSummary, DeobfuscateOptions, DeobfuscateSavedArtifact } from '../../types/deobfuscator.js';
+type WebcrackInvocationOptions = Pick<DeobfuscateOptions, 'forceOutput' | 'includeModuleCode' | 'jsx' | 'mangle' | 'mappings' | 'maxBundleModules' | 'outputDir' | 'unminify' | 'unpack'>;
+export interface WebcrackExecutionResult {
+    applied: boolean;
+    code: string;
+    bundle?: DeobfuscateBundleSummary;
+    savedTo?: string;
+    savedArtifacts?: DeobfuscateSavedArtifact[];
+    optionsUsed: Required<Pick<DeobfuscateOptions, 'jsx' | 'mangle' | 'unminify' | 'unpack'>>;
+    reason?: string;
+}
+export declare function runWebcrack(code: string, options: WebcrackInvocationOptions): Promise<WebcrackExecutionResult>;
+export {};