@jshookmcp/jshook 0.1.8 → 0.1.9

package/dist/server/domains/process/handlers.impl.core.runtime.inject.js

@@ -1,410 +0,0 @@
-import { logger } from '../../../utils/logger.js';
-import { ENABLE_INJECTION_TOOLS } from '../../../constants.js';
-import { ProcessToolHandlersMemory } from '../../domains/process/handlers.impl.core.runtime.memory.js';
-import { requireString, validatePid } from '../../domains/process/handlers.impl.core.runtime.base.js';
-const INJECTION_TOOLS_DISABLED_ERROR = 'Injection tools are disabled by default for safety. Set ENABLE_INJECTION_TOOLS=true before starting the server to enable DLL and shellcode injection.';
-const INJECTION_TOOLS_ENABLE_GUIDANCE = 'Set ENABLE_INJECTION_TOOLS=true before starting the server.';
-const INJECTION_TOOLS_SECURITY_NOTICE = 'Only enable injection tools in an authorized debugging, lab, or CTF environment.';
-function buildInjectionDisabledPayload() {
-    return {
-        success: false,
-        error: INJECTION_TOOLS_DISABLED_ERROR,
-        howToEnable: INJECTION_TOOLS_ENABLE_GUIDANCE,
-        securityNotice: INJECTION_TOOLS_SECURITY_NOTICE,
-    };
-}
-function getOptionalPid(value) {
-    const pid = Number(value);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-}
-function getOptionalString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : null;
-}
-function getShellcodeSize(shellcode, encoding) {
-    if (encoding === 'hex') {
-        const normalized = shellcode.replace(/\s+/g, '');
-        return Math.ceil(normalized.length / 2);
-    }
-    return Buffer.from(shellcode, 'base64').length;
-}
-export class ProcessToolHandlersRuntime extends ProcessToolHandlersMemory {
-    async handleInjectDll(args) {
-        const startedAt = Date.now();
-        if (!ENABLE_INJECTION_TOOLS) {
-            this.recordMemoryAudit({
-                operation: 'inject_dll',
-                pid: getOptionalPid(args.pid),
-                address: getOptionalString(args.dllPath),
-                size: null,
-                result: 'failure',
-                error: INJECTION_TOOLS_DISABLED_ERROR,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(buildInjectionDisabledPayload(), null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const pid = validatePid(args.pid);
-            const dllPath = requireString(args.dllPath, 'dllPath');
-            const result = await this.memoryManager.injectDll(pid, dllPath);
-            this.recordMemoryAudit({
-                operation: 'inject_dll',
-                pid,
-                address: dllPath,
-                size: null,
-                result: result.success ? 'success' : 'failure',
-                error: result.error,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('DLL injection failed:', error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            this.recordMemoryAudit({
-                operation: 'inject_dll',
-                pid: getOptionalPid(args.pid),
-                address: getOptionalString(args.dllPath),
-                size: null,
-                result: 'failure',
-                error: errorMessage,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: errorMessage }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleInjectShellcode(args) {
-        const startedAt = Date.now();
-        if (!ENABLE_INJECTION_TOOLS) {
-            const shellcode = getOptionalString(args.shellcode);
-            const encoding = args.encoding || 'hex';
-            this.recordMemoryAudit({
-                operation: 'inject_shellcode',
-                pid: getOptionalPid(args.pid),
-                address: null,
-                size: shellcode ? getShellcodeSize(shellcode, encoding) : null,
-                result: 'failure',
-                error: INJECTION_TOOLS_DISABLED_ERROR,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(buildInjectionDisabledPayload(), null, 2),
-                    },
-                ],
-            };
-        }
-        try {
-            const pid = validatePid(args.pid);
-            const shellcode = requireString(args.shellcode, 'shellcode');
-            const encoding = args.encoding || 'hex';
-            const size = getShellcodeSize(shellcode, encoding);
-            const result = await this.memoryManager.injectShellcode(pid, shellcode, encoding);
-            this.recordMemoryAudit({
-                operation: 'inject_shellcode',
-                pid,
-                address: null,
-                size,
-                result: result.success ? 'success' : 'failure',
-                error: result.error,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Shellcode injection failed:', error);
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const shellcode = getOptionalString(args.shellcode);
-            const encoding = args.encoding || 'hex';
-            this.recordMemoryAudit({
-                operation: 'inject_shellcode',
-                pid: getOptionalPid(args.pid),
-                address: null,
-                size: shellcode ? getShellcodeSize(shellcode, encoding) : null,
-                result: 'failure',
-                error: errorMessage,
-                durationMs: Date.now() - startedAt,
-            });
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: errorMessage }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleCheckDebugPort(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const result = await this.memoryManager.checkDebugPort(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Debug port check failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error) }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleEnumerateModules(args) {
-        try {
-            const pid = validatePid(args.pid);
-            const result = await this.memoryManager.enumerateModules(pid);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('Module enumeration failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error) }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-    async handleElectronAttach(args) {
-        const rawPort = args.port ?? 9229;
-        const port = Number(rawPort);
-        if (!Number.isInteger(port) || port < 1 || port > 65535) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ success: false, error: `Invalid port: ${JSON.stringify(rawPort)}. Must be integer 1-65535.` }) }],
-            };
-        }
-        const wsEndpointArg = args.wsEndpoint ?? '';
-        const evaluateExpr = args.evaluate ?? '';
-        const pageUrl = args.pageUrl ?? '';
-        const formatUnknownError = (error) => {
-            if (error instanceof Error) {
-                return error.message;
-            }
-            if (typeof error === 'object' && error !== null) {
-                try {
-                    return JSON.stringify(error, null, 2);
-                }
-                catch {
-                    return String(error);
-                }
-            }
-            return String(error);
-        };
-        try {
-            const baseUrl = `http://127.0.0.1:${port}`;
-            const listUrl = `${baseUrl}/json/list`;
-            let targets;
-            try {
-                const resp = await fetch(listUrl);
-                if (!resp.ok) {
-                    throw new Error(`CDP list endpoint returned HTTP ${resp.status}`);
-                }
-                targets = (await resp.json());
-            }
-            catch (listError) {
-                try {
-                    const resp = await fetch(`${baseUrl}/json`);
-                    if (!resp.ok) {
-                        throw new Error(`CDP fallback endpoint returned HTTP ${resp.status}`);
-                    }
-                    targets = (await resp.json());
-                }
-                catch (fallbackError) {
-                    const original = formatUnknownError(fallbackError || listError);
-                    throw new Error(`Cannot connect to Electron CDP at ${baseUrl}. ` +
-                        `Ensure the target app is running with a remote debugging port (for example: process_launch_debug with debugPort=${port}), ` +
-                        `then retry electron_attach. Original error: ${original}`);
-                }
-            }
-            if (!Array.isArray(targets)) {
-                throw new Error('CDP target list is not an array');
-            }
-            const filtered = pageUrl ? targets.filter((t) => t.url.includes(pageUrl)) : targets;
-            if (!evaluateExpr) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                total: targets.length,
-                                filtered: filtered.length,
-                                pages: filtered.map((t) => ({
-                                    id: t.id,
-                                    title: t.title,
-                                    url: t.url,
-                                    type: t.type,
-                                    wsUrl: t.webSocketDebuggerUrl,
-                                })),
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const target = filtered[0];
-            if (!target || !target.webSocketDebuggerUrl) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `No matching page found (pageUrl filter: "${pageUrl}"). Available targets:\n` +
-                                targets.map((t) => `  [${t.type}] ${t.title} — ${t.url}`).join('\n'),
-                        },
-                    ],
-                };
-            }
-            const { default: puppeteer } = await import('rebrowser-puppeteer-core');
-            let browserWsEndpoint = wsEndpointArg;
-            if (!browserWsEndpoint) {
-                try {
-                    const versionResp = await fetch(`${baseUrl}/json/version`);
-                    if (versionResp.ok) {
-                        const versionData = (await versionResp.json());
-                        if (versionData.webSocketDebuggerUrl) {
-                            browserWsEndpoint = versionData.webSocketDebuggerUrl;
-                        }
-                    }
-                }
-                catch {
-                }
-            }
-            if (!browserWsEndpoint) {
-                browserWsEndpoint = target.webSocketDebuggerUrl
-                    .replace(/\/devtools\/page\/[^/]+$/, '')
-                    .replace('/devtools/page', '/devtools/browser');
-            }
-            if (!browserWsEndpoint) {
-                throw new Error('Could not determine browser WebSocket endpoint');
-            }
-            const browser = await puppeteer.connect({
-                browserWSEndpoint: browserWsEndpoint,
-                defaultViewport: null,
-            });
-            let evalResult;
-            let evalError;
-            try {
-                const pages = await browser.pages();
-                const matchedPage = pages.find((p) => p.url().includes(target.url)) ?? pages[0];
-                if (!matchedPage)
-                    throw new Error('Could not get page from connected browser');
-                const evaluated = await matchedPage.evaluate((expression) => {
-                    try {
-                        const fn = new Function('return (' + expression + ')');
-                        return { ok: true, result: fn() };
-                    }
-                    catch (e) {
-                        const errorLike = typeof e === 'object' && e !== null
-                            ? e
-                            : {};
-                        return {
-                            ok: false,
-                            error: {
-                                name: errorLike.name || 'Error',
-                                message: String(errorLike.message || e),
-                                stack: errorLike.stack ? String(errorLike.stack) : undefined,
-                            },
-                        };
-                    }
-                }, evaluateExpr);
-                if (!evaluated?.ok) {
-                    evalError = `Evaluation failed: ${evaluated?.error?.name || 'Error'}: ${evaluated?.error?.message || 'Unknown error'}`;
-                }
-                else {
-                    evalResult = evaluated.result;
-                }
-            }
-            finally {
-                await browser.disconnect();
-            }
-            if (evalError) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({
-                                success: false,
-                                error: evalError,
-                                target: { title: target.title, url: target.url },
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            logger.info(`electron_attach: evaluated in ${target.title}`);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: true,
-                            target: { title: target.title, url: target.url },
-                            result: evalResult,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error('electron_attach failed:', error);
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify({
-                            success: false,
-                            error: formatUnknownError(error),
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-    }
-}