@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/crypto/CryptoRules.js

@@ -1,303 +0,0 @@
-export class CryptoRulesManager {
-    keywordRules = new Map();
-    libraryRules = new Map();
-    constantRules = new Map();
-    patternRules = new Map();
-    securityRules = new Map();
-    constructor() {
-        this.loadDefaultRules();
-    }
-    loadDefaultRules() {
-        this.addKeywordRule({
-            category: 'symmetric',
-            keywords: [
-                'AES',
-                'DES',
-                '3DES',
-                'TripleDES',
-                'RC4',
-                'RC2',
-                'Blowfish',
-                'Twofish',
-                'ChaCha20',
-                'Camellia',
-                'SEED',
-                'ARIA',
-                'SM4',
-            ],
-            confidence: 0.6,
-            description: 'Symmetric encryption algorithms',
-        });
-        this.addKeywordRule({
-            category: 'asymmetric',
-            keywords: [
-                'RSA',
-                'ECC',
-                'ECDSA',
-                'ECDH',
-                'DSA',
-                'ElGamal',
-                'Ed25519',
-                'X25519',
-                'Curve25519',
-                'secp256k1',
-                'SM2',
-            ],
-            confidence: 0.6,
-            description: 'Asymmetric encryption algorithms',
-        });
-        this.addKeywordRule({
-            category: 'hash',
-            keywords: [
-                'MD5',
-                'SHA1',
-                'SHA-1',
-                'SHA256',
-                'SHA-256',
-                'SHA512',
-                'SHA-512',
-                'SHA3',
-                'BLAKE2',
-                'BLAKE3',
-                'RIPEMD',
-                'Whirlpool',
-                'SM3',
-                'Keccak',
-            ],
-            confidence: 0.6,
-            description: 'Hash algorithms',
-        });
-        this.addKeywordRule({
-            category: 'encoding',
-            keywords: ['Base64', 'Base32', 'Base58', 'Hex', 'UTF8', 'UTF-8', 'Latin1', 'ASCII'],
-            confidence: 0.5,
-            description: 'Encoding methods',
-        });
-        this.addKeywordRule({
-            category: 'mode',
-            keywords: ['CBC', 'ECB', 'CTR', 'GCM', 'CFB', 'OFB', 'XTS', 'CCM'],
-            confidence: 0.7,
-            description: 'Block cipher modes',
-        });
-        this.addKeywordRule({
-            category: 'padding',
-            keywords: ['PKCS7', 'PKCS5', 'PKCS1', 'ISO10126', 'ZeroPadding', 'NoPadding', 'OAEP', 'PSS'],
-            confidence: 0.7,
-            description: 'Padding schemes',
-        });
-        this.addLibraryRule({
-            name: 'CryptoJS',
-            patterns: ['CryptoJS', 'crypto-js'],
-            versionPattern: /CryptoJS\.version\s*=\s*['"]([^'"]+)['"]/,
-            confidence: 0.9,
-            features: [
-                'AES',
-                'DES',
-                'TripleDES',
-                'RC4',
-                'Rabbit',
-                'MD5',
-                'SHA1',
-                'SHA256',
-                'SHA512',
-                'HMAC',
-                'PBKDF2',
-            ],
-        });
-        this.addLibraryRule({
-            name: 'JSEncrypt',
-            patterns: ['JSEncrypt', 'jsencrypt'],
-            versionPattern: /version:\s*['"]([^'"]+)['"]/,
-            confidence: 0.9,
-            features: ['RSA'],
-        });
-        this.addLibraryRule({
-            name: 'forge',
-            patterns: ['forge.', 'node-forge'],
-            versionPattern: /forge\.version\s*=\s*['"]([^'"]+)['"]/,
-            confidence: 0.9,
-            features: ['RSA', 'AES', 'DES', '3DES', 'MD5', 'SHA1', 'SHA256', 'SHA512', 'HMAC', 'PBKDF2'],
-        });
-        this.addLibraryRule({
-            name: 'sjcl',
-            patterns: ['sjcl.'],
-            versionPattern: /sjcl\.version\s*=\s*['"]([^'"]+)['"]/,
-            confidence: 0.9,
-            features: ['AES', 'SHA256', 'HMAC', 'PBKDF2', 'CCM', 'GCM'],
-        });
-        this.addLibraryRule({
-            name: 'Web Crypto API',
-            patterns: ['crypto.subtle', 'window.crypto.subtle', 'self.crypto.subtle'],
-            confidence: 0.95,
-            features: [
-                'AES-CBC',
-                'AES-CTR',
-                'AES-GCM',
-                'RSA-OAEP',
-                'RSA-PSS',
-                'ECDSA',
-                'ECDH',
-                'SHA-1',
-                'SHA-256',
-                'SHA-384',
-                'SHA-512',
-                'HMAC',
-                'PBKDF2',
-            ],
-        });
-        this.addLibraryRule({
-            name: 'asmCrypto',
-            patterns: ['asmCrypto'],
-            confidence: 0.9,
-            features: ['AES', 'RSA', 'SHA256', 'HMAC', 'PBKDF2'],
-        });
-        this.addLibraryRule({
-            name: 'TweetNaCl',
-            patterns: ['nacl.', 'tweetnacl'],
-            confidence: 0.9,
-            features: ['Curve25519', 'Ed25519', 'Salsa20', 'Poly1305'],
-        });
-        this.addLibraryRule({
-            name: 'elliptic',
-            patterns: ['elliptic', 'ec.keyFromPrivate', 'ec.keyFromPublic'],
-            confidence: 0.9,
-            features: ['ECDSA', 'ECDH', 'secp256k1'],
-        });
-        this.addConstantRule({
-            name: 'MD5',
-            type: 'hash',
-            values: [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476],
-            confidence: 0.95,
-            description: 'MD5 initialization vector',
-        });
-        this.addConstantRule({
-            name: 'SHA1',
-            type: 'hash',
-            values: [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0],
-            confidence: 0.95,
-            description: 'SHA-1 initialization vector',
-        });
-        this.addConstantRule({
-            name: 'SHA256',
-            type: 'hash',
-            values: [
-                0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab,
-                0x5be0cd19,
-            ],
-            confidence: 0.95,
-            description: 'SHA-256 initialization vector',
-        });
-        this.addConstantRule({
-            name: 'AES S-box',
-            type: 'symmetric',
-            values: [0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5],
-            confidence: 0.9,
-            description: 'AES S-box first 8 values',
-        });
-        this.addSecurityRule({
-            name: 'weak-md5',
-            severity: 'high',
-            check: (ctx) => ctx.algorithm === 'MD5',
-            message: 'MD5 is cryptographically broken and should not be used',
-            recommendation: 'Use SHA-256 or SHA-3 instead',
-        });
-        this.addSecurityRule({
-            name: 'weak-sha1',
-            severity: 'high',
-            check: (ctx) => ctx.algorithm === 'SHA1' || ctx.algorithm === 'SHA-1',
-            message: 'SHA-1 is deprecated and vulnerable to collision attacks',
-            recommendation: 'Use SHA-256 or SHA-3 instead',
-        });
-        this.addSecurityRule({
-            name: 'weak-des',
-            severity: 'critical',
-            check: (ctx) => ctx.algorithm === 'DES',
-            message: 'DES has a very small key size (56 bits) and is easily broken',
-            recommendation: 'Use AES-256 instead',
-        });
-        this.addSecurityRule({
-            name: 'weak-rc4',
-            severity: 'critical',
-            check: (ctx) => ctx.algorithm === 'RC4',
-            message: 'RC4 has known vulnerabilities and should not be used',
-            recommendation: 'Use AES-GCM or ChaCha20-Poly1305 instead',
-        });
-        this.addSecurityRule({
-            name: 'ecb-mode',
-            severity: 'high',
-            check: (ctx) => ctx.mode === 'ECB',
-            message: 'ECB mode is insecure as it does not provide semantic security',
-            recommendation: 'Use CBC, CTR, or GCM mode instead',
-        });
-        this.addSecurityRule({
-            name: 'no-padding',
-            severity: 'medium',
-            check: (ctx) => ctx.padding === 'NoPadding' && ctx.mode !== 'CTR' && ctx.mode !== 'GCM',
-            message: 'Using no padding with non-streaming modes can be insecure',
-            recommendation: 'Use PKCS7 padding or switch to CTR/GCM mode',
-        });
-        this.addSecurityRule({
-            name: 'short-key',
-            severity: 'high',
-            check: (ctx) => Boolean(ctx.keySize && ctx.keySize < 128),
-            message: 'Key size is too short and vulnerable to brute force attacks',
-            recommendation: 'Use at least 128-bit keys, preferably 256-bit',
-        });
-    }
-    addKeywordRule(rule) {
-        this.keywordRules.set(rule.category, rule);
-    }
-    addLibraryRule(rule) {
-        this.libraryRules.set(rule.name, rule);
-    }
-    addConstantRule(rule) {
-        this.constantRules.set(rule.name, rule);
-    }
-    addPatternRule(rule) {
-        this.patternRules.set(rule.name, rule);
-    }
-    addSecurityRule(rule) {
-        this.securityRules.set(rule.name, rule);
-    }
-    getKeywordRules() {
-        return Array.from(this.keywordRules.values());
-    }
-    getLibraryRules() {
-        return Array.from(this.libraryRules.values());
-    }
-    getConstantRules() {
-        return Array.from(this.constantRules.values());
-    }
-    getPatternRules() {
-        return Array.from(this.patternRules.values());
-    }
-    getSecurityRules() {
-        return Array.from(this.securityRules.values());
-    }
-    loadFromJSON(json) {
-        try {
-            const rules = JSON.parse(json);
-            if (rules.keywords) {
-                rules.keywords.forEach((rule) => this.addKeywordRule(rule));
-            }
-            if (rules.libraries) {
-                rules.libraries.forEach((rule) => this.addLibraryRule(rule));
-            }
-            if (rules.constants) {
-                rules.constants.forEach((rule) => this.addConstantRule(rule));
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to load rules from JSON: ${error}`, { cause: error });
-        }
-    }
-    exportToJSON() {
-        return JSON.stringify({
-            keywords: this.getKeywordRules(),
-            libraries: this.getLibraryRules(),
-            constants: this.getConstantRules(),
-            patterns: this.getPatternRules(),
-            security: this.getSecurityRules(),
-        }, null, 2);
-    }
-}

package/dist/src/modules/debugger/BlackboxManager.d.ts

@@ -1,14 +0,0 @@
-import type { CDPSession } from 'rebrowser-puppeteer-core';
-export declare class BlackboxManager {
-    private cdpSession;
-    private blackboxedPatterns;
-    static readonly COMMON_LIBRARY_PATTERNS: string[];
-    constructor(cdpSession: CDPSession);
-    private normalizePattern;
-    blackboxByPattern(urlPattern: string): Promise<void>;
-    unblackboxByPattern(urlPattern: string): Promise<boolean>;
-    blackboxCommonLibraries(): Promise<void>;
-    getAllBlackboxedPatterns(): string[];
-    clearAllBlackboxedPatterns(): Promise<void>;
-    close(): Promise<void>;
-}

package/dist/src/modules/debugger/BlackboxManager.js

@@ -1,116 +0,0 @@
-import { logger } from '../../utils/logger.js';
-export class BlackboxManager {
-    cdpSession;
-    blackboxedPatterns = new Set();
-    static COMMON_LIBRARY_PATTERNS = [
-        '*jquery*.js',
-        '*react*.js',
-        '*react-dom*.js',
-        '*vue*.js',
-        '*angular*.js',
-        '*lodash*.js',
-        '*underscore*.js',
-        '*moment*.js',
-        '*axios*.js',
-        '*node_modules/*',
-        '*webpack*',
-        '*bundle*.js',
-        '*vendor*.js',
-    ];
-    constructor(cdpSession) {
-        this.cdpSession = cdpSession;
-        logger.info('BlackboxManager initialized with shared CDP session');
-    }
-    normalizePattern(pattern) {
-        const input = String(pattern || '').trim();
-        if (!input) {
-            throw new Error('Pattern cannot be empty');
-        }
-        if (input.includes('*') || input.includes('?')) {
-            const escaped = input.replace(/[.+^${}()|[\]\\]/g, '\\$&');
-            return escaped.replace(/\*/g, '.*').replace(/\?/g, '.');
-        }
-        try {
-            void new RegExp(input);
-            return input;
-        }
-        catch {
-            return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        }
-    }
-    async blackboxByPattern(urlPattern) {
-        const normalized = this.normalizePattern(urlPattern);
-        this.blackboxedPatterns.add(normalized);
-        try {
-            await this.cdpSession.send('Debugger.setBlackboxPatterns', {
-                patterns: Array.from(this.blackboxedPatterns),
-            });
-            logger.info(`Blackboxed pattern: ${urlPattern} -> ${normalized}`);
-        }
-        catch (error) {
-            logger.error('Failed to set blackbox pattern:', error);
-            this.blackboxedPatterns.delete(normalized);
-            throw error;
-        }
-    }
-    async unblackboxByPattern(urlPattern) {
-        const normalized = this.normalizePattern(urlPattern);
-        const deleted = this.blackboxedPatterns.delete(normalized);
-        if (!deleted) {
-            return false;
-        }
-        try {
-            await this.cdpSession.send('Debugger.setBlackboxPatterns', {
-                patterns: Array.from(this.blackboxedPatterns),
-            });
-            logger.info(`Unblackboxed pattern: ${urlPattern} -> ${normalized}`);
-            return true;
-        }
-        catch (error) {
-            logger.error('Failed to remove blackbox pattern:', error);
-            this.blackboxedPatterns.add(normalized);
-            throw error;
-        }
-    }
-    async blackboxCommonLibraries() {
-        for (const pattern of BlackboxManager.COMMON_LIBRARY_PATTERNS) {
-            this.blackboxedPatterns.add(this.normalizePattern(pattern));
-        }
-        try {
-            await this.cdpSession.send('Debugger.setBlackboxPatterns', {
-                patterns: Array.from(this.blackboxedPatterns),
-            });
-            logger.info(`Blackboxed ${BlackboxManager.COMMON_LIBRARY_PATTERNS.length} common library patterns`);
-        }
-        catch (error) {
-            logger.error('Failed to blackbox common libraries:', error);
-            throw error;
-        }
-    }
-    getAllBlackboxedPatterns() {
-        return Array.from(this.blackboxedPatterns);
-    }
-    async clearAllBlackboxedPatterns() {
-        this.blackboxedPatterns.clear();
-        try {
-            await this.cdpSession.send('Debugger.setBlackboxPatterns', {
-                patterns: [],
-            });
-            logger.info('All blackbox patterns cleared');
-        }
-        catch (error) {
-            logger.error('Failed to clear blackbox patterns:', error);
-            throw error;
-        }
-    }
-    async close() {
-        try {
-            await this.clearAllBlackboxedPatterns();
-            logger.info('BlackboxManager closed');
-        }
-        catch (error) {
-            logger.error('Failed to close BlackboxManager:', error);
-            throw error;
-        }
-    }
-}

package/dist/src/modules/debugger/DebuggerManager.d.ts

@@ -1,2 +0,0 @@
-export { DebuggerManager } from '../debugger/DebuggerManager.impl.js';
-export type { BreakpointInfo, PausedState, CallFrame, Scope, ObjectPropertyInfo, } from '../debugger/DebuggerManager.impl.js';

package/dist/src/modules/debugger/DebuggerManager.impl.core.breakpoints.d.ts

@@ -1,17 +0,0 @@
-import type { BreakpointInfo } from '../debugger/DebuggerManager.impl.core.class.js';
-export declare function setBreakpointByUrlCore(ctx: unknown, params: {
-    url: string;
-    lineNumber: number;
-    columnNumber?: number;
-    condition?: string;
-}): Promise<BreakpointInfo>;
-export declare function setBreakpointCore(ctx: unknown, params: {
-    scriptId: string;
-    lineNumber: number;
-    columnNumber?: number;
-    condition?: string;
-}): Promise<BreakpointInfo>;
-export declare function removeBreakpointCore(ctx: unknown, breakpointId: string): Promise<void>;
-export declare function listBreakpointsCore(ctx: unknown): BreakpointInfo[];
-export declare function getBreakpointCore(ctx: unknown, breakpointId: string): BreakpointInfo | undefined;
-export declare function clearAllBreakpointsCore(ctx: unknown): Promise<void>;

package/dist/src/modules/debugger/DebuggerManager.impl.core.breakpoints.js

@@ -1,145 +0,0 @@
-import { logger } from '../../utils/logger.js';
-import { PrerequisiteError } from '../../errors/PrerequisiteError.js';
-function asBreakpointsCoreContext(ctx) {
-    return ctx;
-}
-export async function setBreakpointByUrlCore(ctx, params) {
-    const coreCtx = asBreakpointsCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        try {
-            await coreCtx.ensureSession();
-        }
-        catch (err) {
-            logger.warn(`Debugger auto-reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
-            throw new PrerequisiteError('Debugger is not enabled and auto-reconnect failed. Call init() or enable() first.');
-        }
-    }
-    if (!params.url) {
-        throw new Error('url parameter is required');
-    }
-    if (params.lineNumber < 0) {
-        throw new Error('lineNumber must be a non-negative number');
-    }
-    if (params.columnNumber !== undefined && params.columnNumber < 0) {
-        throw new Error('columnNumber must be a non-negative number');
-    }
-    try {
-        const result = await coreCtx.cdpSession.send('Debugger.setBreakpointByUrl', {
-            url: params.url,
-            lineNumber: params.lineNumber,
-            columnNumber: params.columnNumber,
-            condition: params.condition,
-        });
-        const breakpointInfo = {
-            breakpointId: result.breakpointId,
-            location: {
-                url: params.url,
-                lineNumber: params.lineNumber,
-                columnNumber: params.columnNumber,
-            },
-            condition: params.condition,
-            enabled: true,
-            hitCount: 0,
-            createdAt: Date.now(),
-        };
-        coreCtx.breakpoints.set(result.breakpointId, breakpointInfo);
-        logger.info(`Breakpoint set: ${params.url}:${params.lineNumber}`, {
-            breakpointId: result.breakpointId,
-            condition: params.condition,
-        });
-        return breakpointInfo;
-    }
-    catch (error) {
-        logger.error('Failed to set breakpoint:', error);
-        throw error;
-    }
-}
-export async function setBreakpointCore(ctx, params) {
-    const coreCtx = asBreakpointsCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        try {
-            await coreCtx.ensureSession();
-        }
-        catch (err) {
-            logger.warn(`Debugger auto-reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
-            throw new PrerequisiteError('Debugger is not enabled and auto-reconnect failed. Call init() or enable() first.');
-        }
-    }
-    if (!params.scriptId) {
-        throw new Error('scriptId parameter is required');
-    }
-    if (params.lineNumber < 0) {
-        throw new Error('lineNumber must be a non-negative number');
-    }
-    if (params.columnNumber !== undefined && params.columnNumber < 0) {
-        throw new Error('columnNumber must be a non-negative number');
-    }
-    try {
-        const result = await coreCtx.cdpSession.send('Debugger.setBreakpoint', {
-            location: {
-                scriptId: params.scriptId,
-                lineNumber: params.lineNumber,
-                columnNumber: params.columnNumber,
-            },
-            condition: params.condition,
-        });
-        const breakpointInfo = {
-            breakpointId: result.breakpointId,
-            location: {
-                scriptId: params.scriptId,
-                lineNumber: params.lineNumber,
-                columnNumber: params.columnNumber,
-            },
-            condition: params.condition,
-            enabled: true,
-            hitCount: 0,
-            createdAt: Date.now(),
-        };
-        coreCtx.breakpoints.set(result.breakpointId, breakpointInfo);
-        logger.info(`Breakpoint set: scriptId=${params.scriptId}:${params.lineNumber}`, {
-            breakpointId: result.breakpointId,
-        });
-        return breakpointInfo;
-    }
-    catch (error) {
-        logger.error('Failed to set breakpoint:', error);
-        throw error;
-    }
-}
-export async function removeBreakpointCore(ctx, breakpointId) {
-    const coreCtx = asBreakpointsCoreContext(ctx);
-    if (!coreCtx.enabled || !coreCtx.cdpSession) {
-        throw new PrerequisiteError('Debugger is not enabled. Call init() or enable() first.');
-    }
-    if (!breakpointId) {
-        throw new Error('breakpointId parameter is required');
-    }
-    if (!coreCtx.breakpoints.has(breakpointId)) {
-        throw new Error(`Breakpoint not found: ${breakpointId}. Use listBreakpoints() to see active breakpoints.`);
-    }
-    try {
-        await coreCtx.cdpSession.send('Debugger.removeBreakpoint', { breakpointId });
-        coreCtx.breakpoints.delete(breakpointId);
-        logger.info(`Breakpoint removed: ${breakpointId}`);
-    }
-    catch (error) {
-        logger.error(`Failed to remove breakpoint ${breakpointId}:`, error);
-        throw error;
-    }
-}
-export function listBreakpointsCore(ctx) {
-    const coreCtx = asBreakpointsCoreContext(ctx);
-    return Array.from(coreCtx.breakpoints.values());
-}
-export function getBreakpointCore(ctx, breakpointId) {
-    const coreCtx = asBreakpointsCoreContext(ctx);
-    return coreCtx.breakpoints.get(breakpointId);
-}
-export async function clearAllBreakpointsCore(ctx) {
-    const coreCtx = asBreakpointsCoreContext(ctx);
-    const breakpointIds = Array.from(coreCtx.breakpoints.keys());
-    for (const id of breakpointIds) {
-        await coreCtx.removeBreakpoint(id);
-    }
-    logger.info(`Cleared ${breakpointIds.length} breakpoints`);
-}