@jshookmcp/jshook 0.2.6 → 0.2.8

package/dist/src/modules/process/memory/types.d.ts

@@ -1,66 +0,0 @@
-import { exec, execFile } from 'child_process';
-export declare const execAsync: typeof exec.__promisify__;
-export declare const execFileAsync: typeof execFile.__promisify__;
-export type Platform = 'win32' | 'linux' | 'darwin' | 'unknown';
-export type PatternType = 'hex' | 'int32' | 'int64' | 'float' | 'double' | 'string';
-export interface MemoryReadResult {
-    success: boolean;
-    data?: string;
-    error?: string;
-}
-export interface MemoryWriteResult {
-    success: boolean;
-    bytesWritten?: number;
-    error?: string;
-}
-export interface MemoryScanResult {
-    success: boolean;
-    addresses: string[];
-    error?: string;
-    stats?: {
-        patternLength: number;
-        resultsFound: number;
-    };
-}
-export interface MemoryRegion {
-    baseAddress: string;
-    size: number;
-    state: string;
-    protection: string;
-    isReadable: boolean;
-    type: string;
-}
-export interface MemoryProtectionInfo {
-    success: boolean;
-    protection?: string;
-    isWritable?: boolean;
-    isReadable?: boolean;
-    isExecutable?: boolean;
-    regionStart?: string;
-    regionSize?: number;
-    error?: string;
-}
-export interface ModuleInfo {
-    name: string;
-    baseAddress: string;
-    size: number;
-}
-export interface MemoryPatch {
-    address: string;
-    data: string;
-    encoding?: 'hex' | 'base64';
-}
-export interface MemoryMonitorEntry {
-    pid: number;
-    address: string;
-    interval: number;
-    lastValue: string;
-    timer: NodeJS.Timeout;
-}
-export declare function executePowerShellScript(script: string, options?: {
-    maxBuffer?: number;
-    timeout?: number;
-}): Promise<{
-    stdout: string;
-    stderr: string;
-}>;

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

@@ -1,20 +0,0 @@
-import { exec, execFile } from 'child_process';
-import { promisify } from 'util';
-export const execAsync = promisify(exec);
-export const execFileAsync = promisify(execFile);
-function getPowerShellExecutable() {
-    return process.platform === 'win32' ? 'powershell.exe' : 'powershell';
-}
-export async function executePowerShellScript(script, options = {}) {
-    const encodedCommand = Buffer.from(script, 'utf16le').toString('base64');
-    const args = ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encodedCommand];
-    const { stdout, stderr } = await execFileAsync(getPowerShellExecutable(), args, {
-        maxBuffer: options.maxBuffer ?? 1024 * 1024,
-        timeout: options.timeout,
-        windowsHide: true,
-    });
-    return {
-        stdout: String(stdout ?? ''),
-        stderr: String(stderr ?? ''),
-    };
-}

package/dist/src/modules/process/memory/writer.d.ts

@@ -1,11 +0,0 @@
-import { type Platform, type MemoryWriteResult, type MemoryProtectionInfo, type MemoryPatch } from '../../process/memory/types.js';
-export declare function writeMemory(platform: Platform, pid: number, address: string, data: string, encoding: "hex" | "base64" | undefined, checkProtectionFn: (pid: number, address: string) => Promise<MemoryProtectionInfo>): Promise<MemoryWriteResult>;
-export declare function batchMemoryWrite(pid: number, patches: MemoryPatch[], writeFn: (pid: number, address: string, data: string, encoding: 'hex' | 'base64') => Promise<MemoryWriteResult>): Promise<{
-    success: boolean;
-    results: {
-        address: string;
-        success: boolean;
-        error?: string;
-    }[];
-    error?: string;
-}>;

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

@@ -1,250 +0,0 @@
-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 { stdout } = await executePowerShellScript(psScript, { maxBuffer: 1024 * 1024 });
-        const _trimmed = stdout.trim();
-        if (!_trimmed)
-            throw new Error('PowerShell returned empty output');
-        const result = JSON.parse(_trimmed);
-        return {
-            success: result.success,
-            bytesWritten: result.bytesWritten,
-            error: result.error,
-        };
-    }
-    catch (error) {
-        logger.error('Windows memory write failed:', error);
-        return {
-            success: false,
-            error: error instanceof Error
-                ? error.message
-                : 'PowerShell execution failed. Run as Administrator.',
-        };
-    }
-}
-async function writeMemoryLinux(pid, address, data) {
-    try {
-        const hexData = data.toString('hex');
-        const { stderr } = await execAsync(`sudo sh -c 'printf "${hexData}" | xxd -r -p | dd of=/proc/${pid}/mem bs=1 seek=${address} conv=notrunc 2>&1' || echo ""`, { maxBuffer: 1024 * 1024, timeout: 10000 });
-        if (stderr && stderr.includes('error')) {
-            return {
-                success: false,
-                error: 'Memory write failed. Requires root privileges.',
-            };
-        }
-        return {
-            success: true,
-            bytesWritten: data.length,
-        };
-    }
-    catch (error) {
-        logger.error('Linux memory write failed:', error);
-        return {
-            success: false,
-            error: 'Memory write failed. Run as root.',
-        };
-    }
-}
-async function writeMemoryMac(pid, address, data, checkProtectionFn) {
-    if (address === 0) {
-        return { success: false, error: 'Invalid address: null pointer (0x0)' };
-    }
-    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}` };
-    }
-    if (!prot.isWritable) {
-        return {
-            success: false,
-            error: `Address ${addrHex} is not writable (protection: ${prot.protection ?? 'unknown'})`,
-        };
-    }
-    try {
-        const hexBytes = Array.from(data)
-            .map((b) => `0x${b.toString(16).padStart(2, '0')}`)
-            .join(' ');
-        const { stdout } = await execAsync(`lldb --batch -p ${pid} -o "memory write ${addrHex} ${hexBytes}" -o "process detach"`, { timeout: 10000, maxBuffer: 1024 * 1024 });
-        if (stdout.includes('error:')) {
-            const errLine = stdout.split('\n').find((l) => l.includes('error:')) ?? stdout;
-            return { success: false, error: `lldb memory write failed: ${errLine.trim()}` };
-        }
-        return { success: true, bytesWritten: data.length };
-    }
-    catch (error) {
-        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' };
-        }
-        let buffer;
-        try {
-            if (encoding === 'base64') {
-                buffer = Buffer.from(data, 'base64');
-            }
-            else {
-                const cleanHex = data.replace(/\s/g, '');
-                buffer = Buffer.from(cleanHex, 'hex');
-            }
-        }
-        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);
-                if (result.success) {
-                    logger.debug('Native memory write succeeded');
-                    return result;
-                }
-                logger.warn('Native memory write failed, falling back to PowerShell:', result.error);
-            }
-            catch (nativeError) {
-                logger.warn('Native memory write error, falling back to PowerShell:', nativeError);
-            }
-        }
-        switch (platform) {
-            case 'win32':
-                return writeMemoryWindows(pid, addrNum, buffer);
-            case 'linux':
-                return writeMemoryLinux(pid, addrNum, buffer);
-            case 'darwin':
-                return writeMemoryMac(pid, addrNum, buffer, checkProtectionFn);
-            default:
-                return {
-                    success: false,
-                    error: `Memory operations not supported on platform: ${platform}`,
-                };
-        }
-    }
-    catch (error) {
-        logger.error('Memory write failed:', error);
-        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');
-        results.push({
-            address: patch.address,
-            success: result.success,
-            error: result.error,
-        });
-    }
-    const allSuccess = results.every((r) => r.success);
-    return {
-        success: allSuccess,
-        results,
-        error: allSuccess
-            ? undefined
-            : `Failed to write ${results.filter((r) => !r.success).length} of ${results.length} patches`,
-    };
-}

package/dist/src/modules/process/memoryUtils.d.ts

@@ -1,51 +0,0 @@
-export declare function scanMemory(pid: number, pattern: string, patternType?: 'hex' | 'int32' | 'int64' | 'float' | 'double' | 'string'): Promise<import("../process/MemoryManager.js").MemoryScanResult>;
-export declare function dumpMemory(pid: number, address: string, size: number, outputPath: string): Promise<{
-    success: boolean;
-    error?: string;
-}>;
-export declare function listMemoryRegions(pid: number): Promise<{
-    success: boolean;
-    regions?: import("./memory/regions.enumerate.js").EnumeratedRegion[];
-    error?: string;
-}>;
-export declare function checkProtection(pid: number, address: string): Promise<import("./memory/index.js").MemoryProtectionInfo>;
-export declare function scanFiltered(pid: number, pattern: string, addresses: string[], patternType?: 'hex' | 'int32' | 'int64' | 'float' | 'double' | 'string'): Promise<import("../process/MemoryManager.js").MemoryScanResult>;
-export declare function batchWrite(pid: number, patches: {
-    address: string;
-    data: string;
-    encoding?: 'hex' | 'base64';
-}[]): Promise<{
-    success: boolean;
-    results: {
-        address: string;
-        success: boolean;
-        error?: string;
-    }[];
-    error?: string;
-}>;
-export declare function startMonitor(pid: number, address: string, size?: number, intervalMs?: number, onChange?: (oldValue: string, newValue: string) => void): string;
-export declare function stopMonitor(monitorId: string): boolean;
-export declare function injectDll(pid: number, dllPath: string): Promise<{
-    success: boolean;
-    remoteThreadId?: number;
-    error?: string;
-}>;
-export declare function injectShellcode(pid: number, shellcode: string, encoding?: 'hex' | 'base64'): Promise<{
-    success: boolean;
-    remoteThreadId?: number;
-    error?: string;
-}>;
-export declare function checkDebugPort(pid: number): Promise<{
-    success: boolean;
-    isDebugged?: boolean;
-    error?: string;
-}>;
-export declare function enumerateModules(pid: number): Promise<{
-    success: boolean;
-    modules?: {
-        name: string;
-        baseAddress: string;
-        size: number;
-    }[];
-    error?: string;
-}>;

package/dist/src/modules/process/memoryUtils.js

@@ -1,49 +0,0 @@
-import { MemoryManager } from '../process/MemoryManager.js';
-export async function scanMemory(pid, pattern, patternType = 'hex') {
-    const manager = new MemoryManager();
-    return manager.scanMemory(pid, pattern, patternType);
-}
-export async function dumpMemory(pid, address, size, outputPath) {
-    const manager = new MemoryManager();
-    return manager.dumpMemoryRegion(pid, address, size, outputPath);
-}
-export async function listMemoryRegions(pid) {
-    const manager = new MemoryManager();
-    return manager.enumerateRegions(pid);
-}
-export async function checkProtection(pid, address) {
-    const manager = new MemoryManager();
-    return manager.checkMemoryProtection(pid, address);
-}
-export async function scanFiltered(pid, pattern, addresses, patternType = 'hex') {
-    const manager = new MemoryManager();
-    return manager.scanMemoryFiltered(pid, pattern, addresses, patternType);
-}
-export async function batchWrite(pid, patches) {
-    const manager = new MemoryManager();
-    return manager.batchMemoryWrite(pid, patches);
-}
-export function startMonitor(pid, address, size = 4, intervalMs = 1000, onChange) {
-    const manager = new MemoryManager();
-    return manager.startMemoryMonitor(pid, address, size, intervalMs, onChange);
-}
-export function stopMonitor(monitorId) {
-    const manager = new MemoryManager();
-    return manager.stopMemoryMonitor(monitorId);
-}
-export async function injectDll(pid, dllPath) {
-    const manager = new MemoryManager();
-    return manager.injectDll(pid, dllPath);
-}
-export async function injectShellcode(pid, shellcode, encoding = 'hex') {
-    const manager = new MemoryManager();
-    return manager.injectShellcode(pid, shellcode, encoding);
-}
-export async function checkDebugPort(pid) {
-    const manager = new MemoryManager();
-    return manager.checkDebugPort(pid);
-}
-export async function enumerateModules(pid) {
-    const manager = new MemoryManager();
-    return manager.enumerateModules(pid);
-}

package/dist/src/modules/process/types.d.ts

@@ -1,56 +0,0 @@
-export interface MemoryReadResult {
-    success: boolean;
-    data?: string;
-    error?: string;
-}
-export interface MemoryWriteResult {
-    success: boolean;
-    bytesWritten?: number;
-    error?: string;
-}
-export interface MemoryScanResult {
-    success: boolean;
-    addresses: string[];
-    error?: string;
-    stats?: {
-        patternLength: number;
-        resultsFound: number;
-    };
-}
-export interface MemoryRegion {
-    baseAddress: string;
-    size: number;
-    state: string;
-    protection: string;
-    isReadable: boolean;
-    type: string;
-}
-export interface MemoryProtectionInfo {
-    success: boolean;
-    protection?: string;
-    isWritable?: boolean;
-    isReadable?: boolean;
-    isExecutable?: boolean;
-    regionStart?: string;
-    regionSize?: number;
-    error?: string;
-}
-export interface ModuleInfo {
-    name: string;
-    baseAddress: string;
-    size: number;
-}
-export type Platform = 'win32' | 'linux' | 'darwin' | 'unknown';
-export type PatternType = 'hex' | 'int32' | 'int64' | 'float' | 'double' | 'string';
-export interface MemoryPatch {
-    address: string;
-    data: string;
-    encoding?: 'hex' | 'base64';
-}
-export interface MemoryMonitor {
-    pid: number;
-    address: string;
-    interval: number;
-    lastValue: string;
-    timer: NodeJS.Timeout;
-}

package/dist/src/modules/process/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/modules/security/ExecutionSandbox.d.ts

@@ -1,16 +0,0 @@
-export interface SandboxExecuteRequest {
-    code: string;
-    timeoutMs?: number;
-    memoryLimitMB?: number;
-}
-export interface SandboxExecuteResult {
-    ok: boolean;
-    output?: unknown;
-    error?: string;
-    timedOut: boolean;
-    durationMs: number;
-}
-export declare class ExecutionSandbox {
-    execute(request: SandboxExecuteRequest): Promise<SandboxExecuteResult>;
-    private _execute;
-}

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

@@ -1,116 +0,0 @@
-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',
-  });
-}
-`;
-export class ExecutionSandbox {
-    async execute(request) {
-        return cpuLimit(() => this._execute(request));
-    }
-    _execute(request) {
-        const timeoutMs = request.timeoutMs ?? SANDBOX_EXEC_TIMEOUT_MS;
-        const memoryLimitMB = request.memoryLimitMB ?? SANDBOX_MEMORY_LIMIT_MB;
-        const startTime = Date.now();
-        return new Promise((resolve) => {
-            let settled = false;
-            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: {
-                    code: request.code,
-                    timeoutMs,
-                },
-                resourceLimits: {
-                    maxOldGenerationSizeMb: memoryLimitMB,
-                    maxYoungGenerationSizeMb: Math.ceil(memoryLimitMB / 4),
-                    stackSizeMb: SANDBOX_STACK_SIZE_MB,
-                },
-            };
-            workerOptions.type = 'module';
-            const worker = new Worker(WORKER_SCRIPT, workerOptions);
-            const finish = (result) => {
-                if (settled)
-                    return;
-                settled = true;
-                if (terminationTimeout)
-                    clearTimeout(terminationTimeout);
-                resolve({ ...result, durationMs: Date.now() - startTime });
-            };
-            worker.on('message', (msg) => {
-                finish({
-                    ok: msg.ok,
-                    output: msg.output,
-                    error: msg.error,
-                    timedOut: msg.timedOut || false,
-                });
-                void worker.terminate();
-            });
-            worker.on('error', (err) => {
-                finish({
-                    ok: false,
-                    error: `Worker error: ${err.message}`,
-                    timedOut: false,
-                });
-            });
-            worker.on('exit', (code) => {
-                if (!settled) {
-                    finish({
-                        ok: false,
-                        error: `Worker exited unexpectedly with code ${code}`,
-                        timedOut: false,
-                    });
-                }
-            });
-        });
-    }
-}

package/dist/src/modules/security/RedactionService.d.ts

@@ -1,15 +0,0 @@
-export type RedactionLevel = 'standard' | 'strict' | 'none';
-export declare class RedactionService {
-    private level;
-    private activePatterns;
-    constructor(level?: RedactionLevel);
-    redactString(input: string): string;
-    redactObject<T>(obj: T): T;
-    setLevel(level: RedactionLevel): void;
-    getLevel(): RedactionLevel;
-    getStats(): {
-        level: RedactionLevel;
-        activePatterns: number;
-        patternNames: string[];
-    };
-}