@jshookmcp/jshook 0.2.6 → 0.2.7

package/dist/src/native/NativeMemoryManager.impl.js

@@ -1,442 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { cpuLimit } from '../utils/concurrency.js';
-import { createPlatformProvider } from './platform/factory.js';
-import { MemoryProtection } from './platform/types.js';
-import { findPatternInBuffer, parsePattern } from './NativeMemoryManager.utils.js';
-import { checkNativeMemoryAvailability } from './NativeMemoryManager.availability.js';
-const execAsync = promisify(exec);
-const SCAN_CHUNK_SIZE = 16 * 1024 * 1024;
-export function scanRegionInChunks(region, patternBytes, mask, readChunk, chunkSize = SCAN_CHUNK_SIZE) {
-    if (patternBytes.length === 0 || region.regionSize < patternBytes.length || chunkSize <= 0) {
-        return [];
-    }
-    const overlap = Math.max(patternBytes.length - 1, 0);
-    let carryOver = Buffer.alloc(0);
-    const matches = [];
-    for (let chunkOffset = 0; chunkOffset < region.regionSize; chunkOffset += chunkSize) {
-        const readSize = Math.min(chunkSize, region.regionSize - chunkOffset);
-        const chunkAddress = region.baseAddress + BigInt(chunkOffset);
-        const chunk = readChunk(chunkAddress, readSize);
-        const scanBuffer = carryOver.length > 0 ? Buffer.concat([carryOver, chunk]) : chunk;
-        const chunkMatches = findPatternInBuffer(scanBuffer, patternBytes, mask);
-        for (const matchOffset of chunkMatches) {
-            const regionOffset = chunkOffset + matchOffset - carryOver.length;
-            matches.push(region.baseAddress + BigInt(regionOffset));
-        }
-        if (overlap === 0 || chunkOffset + readSize >= region.regionSize) {
-            carryOver = Buffer.alloc(0);
-            continue;
-        }
-        const carrySize = Math.min(overlap, scanBuffer.length);
-        carryOver = scanBuffer.subarray(scanBuffer.length - carrySize);
-    }
-    return matches;
-}
-export class NativeMemoryManager {
-    _provider = null;
-    get provider() {
-        if (!this._provider) {
-            this._provider = createPlatformProvider();
-        }
-        return this._provider;
-    }
-    async checkAvailability() {
-        return checkNativeMemoryAvailability(execAsync);
-    }
-    async readMemory(pid, address, size) {
-        try {
-            const addrNum = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-            const handle = this.provider.openProcess(pid, false);
-            try {
-                const { data: buffer } = this.provider.readMemory(handle, addrNum, size);
-                return {
-                    success: true,
-                    data: buffer.toString('hex').toUpperCase().match(/.{2}/g)?.join(' ') || '',
-                };
-            }
-            finally {
-                this.provider.closeProcess(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native memory read failed', {
-                pid,
-                address,
-                size,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async writeMemory(pid, address, data, encoding = 'hex') {
-        try {
-            const addrNum = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-            let buffer;
-            if (encoding === 'base64') {
-                buffer = Buffer.from(data, 'base64');
-            }
-            else {
-                buffer = Buffer.from(data.replace(/\s/g, ''), 'hex');
-            }
-            const handle = this.provider.openProcess(pid, true);
-            try {
-                const { bytesWritten } = this.provider.writeMemory(handle, addrNum, buffer);
-                return {
-                    success: true,
-                    bytesWritten,
-                };
-            }
-            finally {
-                this.provider.closeProcess(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native memory write failed', {
-                pid,
-                address,
-                encoding,
-                dataLength: data.length,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async enumerateRegions(pid) {
-        try {
-            const handle = this.provider.openProcess(pid, false);
-            const regions = [];
-            try {
-                let address = 0n;
-                const maxAddress = BigInt('0x7FFFFFFF0000');
-                while (address < maxAddress) {
-                    const regionInfo = this.provider.queryRegion(handle, address);
-                    if (!regionInfo) {
-                        break;
-                    }
-                    regions.push(regionInfoToMemoryRegion(regionInfo));
-                    address = regionInfo.baseAddress + BigInt(regionInfo.size);
-                }
-                return { success: true, regions };
-            }
-            finally {
-                this.provider.closeProcess(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native region enumeration failed', {
-                pid,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async checkMemoryProtection(pid, address) {
-        try {
-            const addrNum = BigInt(address.startsWith('0x') ? address : `0x${address}`);
-            const handle = this.provider.openProcess(pid, false);
-            try {
-                const regionInfo = this.provider.queryRegion(handle, addrNum);
-                if (!regionInfo) {
-                    return { success: false, error: 'Failed to query memory region' };
-                }
-                return {
-                    success: true,
-                    protection: protectionToString(regionInfo.protection),
-                    isWritable: regionInfo.isWritable,
-                    isReadable: regionInfo.isReadable,
-                    isExecutable: regionInfo.isExecutable,
-                    regionStart: `0x${regionInfo.baseAddress.toString(16).toUpperCase()}`,
-                    regionSize: regionInfo.size,
-                };
-            }
-            finally {
-                this.provider.closeProcess(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native protection check failed', {
-                pid,
-                address,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async scanMemory(pid, pattern, patternType = 'hex') {
-        try {
-            const { patternBytes, mask } = parsePattern(pattern, patternType);
-            if (patternBytes.length === 0) {
-                return { success: false, addresses: [], error: 'Invalid pattern' };
-            }
-            const maxResults = 10000;
-            const readableRegions = [];
-            const handle = this.provider.openProcess(pid, false);
-            let regionMatches = [];
-            try {
-                let address = 0n;
-                const maxAddress = BigInt('0x7FFFFFFF0000');
-                while (address < maxAddress) {
-                    const regionInfo = this.provider.queryRegion(handle, address);
-                    if (!regionInfo) {
-                        break;
-                    }
-                    if (regionInfo.isReadable &&
-                        regionInfo.size > 0 &&
-                        regionInfo.size <= Number.MAX_SAFE_INTEGER) {
-                        readableRegions.push({
-                            baseAddress: regionInfo.baseAddress,
-                            regionSize: regionInfo.size,
-                        });
-                    }
-                    address = regionInfo.baseAddress + BigInt(regionInfo.size);
-                }
-                const providerRef = this.provider;
-                regionMatches = await Promise.all(readableRegions.map((region) => cpuLimit(async () => {
-                    try {
-                        return scanRegionInChunks(region, patternBytes, mask, (addr, size) => providerRef.readMemory(handle, addr, size).data);
-                    }
-                    catch {
-                        return [];
-                    }
-                })));
-            }
-            finally {
-                this.provider.closeProcess(handle);
-            }
-            const addresses = [];
-            for (const matches of regionMatches) {
-                for (const foundAddr of matches) {
-                    addresses.push(`0x${foundAddr.toString(16).toUpperCase()}`);
-                    if (addresses.length >= maxResults) {
-                        break;
-                    }
-                }
-                if (addresses.length >= maxResults) {
-                    break;
-                }
-            }
-            return {
-                success: true,
-                addresses,
-                stats: {
-                    patternLength: patternBytes.length,
-                    resultsFound: addresses.length,
-                },
-            };
-        }
-        catch (error) {
-            logger.error('Native memory scan failed', {
-                pid,
-                patternType,
-                patternLength: pattern.length,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                addresses: [],
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async enumerateModules(pid) {
-        try {
-            const handle = this.provider.openProcess(pid, false);
-            try {
-                const platformModules = this.provider.enumerateModules(handle);
-                const modules = platformModules.map((m) => ({
-                    name: m.name,
-                    baseAddress: `0x${m.baseAddress.toString(16).toUpperCase()}`,
-                    size: m.size,
-                }));
-                return { success: true, modules };
-            }
-            finally {
-                this.provider.closeProcess(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native module enumeration failed', {
-                pid,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async injectDll(pid, dllPath) {
-        if (process.platform !== 'win32') {
-            return { success: false, error: 'DLL injection is only supported on Windows' };
-        }
-        try {
-            const { openProcessForMemory, CloseHandle, WriteProcessMemory, VirtualAllocEx, CreateRemoteThread, GetModuleHandle, GetProcAddress, PAGE, MEM, } = await import('./Win32API.js');
-            const handle = openProcessForMemory(pid, true);
-            try {
-                const kernel32Handle = GetModuleHandle('kernel32.dll');
-                const loadLibraryAddr = GetProcAddress(kernel32Handle, 'LoadLibraryA');
-                if (!loadLibraryAddr) {
-                    return { success: false, error: 'Failed to get LoadLibraryA address' };
-                }
-                const pathBuffer = Buffer.from(dllPath + '\0', 'ascii');
-                const remoteMem = VirtualAllocEx(handle, 0n, pathBuffer.length, MEM.COMMIT | MEM.RESERVE, PAGE.READWRITE);
-                if (!remoteMem) {
-                    return { success: false, error: 'Failed to allocate remote memory' };
-                }
-                WriteProcessMemory(handle, remoteMem, pathBuffer);
-                const { handle: threadHandle, threadId } = CreateRemoteThread(handle, loadLibraryAddr, remoteMem);
-                if (!threadHandle) {
-                    return { success: false, error: 'Failed to create remote thread' };
-                }
-                CloseHandle(threadHandle);
-                return { success: true, remoteThreadId: threadId };
-            }
-            finally {
-                CloseHandle(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native DLL injection failed', {
-                pid,
-                dllPath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async injectShellcode(pid, shellcode, encoding = 'hex') {
-        if (process.platform !== 'win32') {
-            return { success: false, error: 'Shellcode injection is only supported on Windows' };
-        }
-        try {
-            let buffer;
-            if (encoding === 'base64') {
-                buffer = Buffer.from(shellcode, 'base64');
-            }
-            else {
-                buffer = Buffer.from(shellcode.replace(/\s/g, ''), 'hex');
-            }
-            const { openProcessForMemory, CloseHandle, WriteProcessMemory, VirtualAllocEx, VirtualProtectEx, CreateRemoteThread, PAGE, MEM, } = await import('./Win32API.js');
-            const handle = openProcessForMemory(pid, true);
-            try {
-                const remoteMem = VirtualAllocEx(handle, 0n, buffer.length, MEM.COMMIT | MEM.RESERVE, PAGE.READWRITE);
-                if (!remoteMem) {
-                    return { success: false, error: 'Failed to allocate remote memory' };
-                }
-                WriteProcessMemory(handle, remoteMem, buffer);
-                const { success: protectSuccess } = VirtualProtectEx(handle, remoteMem, buffer.length, PAGE.EXECUTE_READWRITE);
-                if (!protectSuccess) {
-                    return { success: false, error: 'Failed to change memory protection' };
-                }
-                const { handle: threadHandle, threadId } = CreateRemoteThread(handle, remoteMem, 0n);
-                if (!threadHandle) {
-                    return { success: false, error: 'Failed to create remote thread' };
-                }
-                CloseHandle(threadHandle);
-                return { success: true, remoteThreadId: threadId };
-            }
-            finally {
-                CloseHandle(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native shellcode injection failed', {
-                pid,
-                encoding,
-                shellcodeLength: shellcode.length,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    async checkDebugPort(pid) {
-        if (process.platform !== 'win32') {
-            return { success: false, error: 'Debug port check is only supported on Windows' };
-        }
-        try {
-            const { openProcessForMemory, CloseHandle, NtQueryInformationProcess } = await import('./Win32API.js');
-            const handle = openProcessForMemory(pid, false);
-            try {
-                const { status, debugPort } = NtQueryInformationProcess(handle, 7);
-                if (status !== 0) {
-                    return {
-                        success: false,
-                        error: `NtQueryInformationProcess failed with status 0x${status.toString(16)}`,
-                    };
-                }
-                return {
-                    success: true,
-                    isDebugged: debugPort !== 0,
-                };
-            }
-            finally {
-                CloseHandle(handle);
-            }
-        }
-        catch (error) {
-            logger.error('Native debug port check failed', {
-                pid,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}
-function regionInfoToMemoryRegion(info) {
-    return {
-        baseAddress: `0x${info.baseAddress.toString(16).toUpperCase()}`,
-        size: info.size,
-        state: info.state.toUpperCase(),
-        protection: protectionToString(info.protection),
-        isReadable: info.isReadable,
-        isWritable: info.isWritable,
-        isExecutable: info.isExecutable,
-        type: info.type.toUpperCase(),
-    };
-}
-function protectionToString(prot) {
-    if (prot === MemoryProtection.NoAccess)
-        return 'NOACCESS';
-    const parts = [];
-    const hasRead = (prot & MemoryProtection.Read) !== 0;
-    const hasWrite = (prot & MemoryProtection.Write) !== 0;
-    const hasExec = (prot & MemoryProtection.Execute) !== 0;
-    const hasGuard = (prot & MemoryProtection.Guard) !== 0;
-    if (hasRead && hasWrite && hasExec)
-        parts.push('RWX');
-    else if (hasRead && hasExec)
-        parts.push('RX');
-    else if (hasRead && hasWrite)
-        parts.push('RW');
-    else if (hasRead)
-        parts.push('R');
-    else if (hasExec)
-        parts.push('X');
-    if (hasGuard)
-        parts.push('GUARD');
-    return parts.join(' ') || 'UNKNOWN';
-}
-export const nativeMemoryManager = new NativeMemoryManager();

package/dist/src/native/NativeMemoryManager.js

@@ -1 +0,0 @@
-export * from './NativeMemoryManager.impl.js';

package/dist/src/native/NativeMemoryManager.types.d.ts

@@ -1,58 +0,0 @@
-export interface NativeMemoryReadResult {
-    success: boolean;
-    data?: string;
-    error?: string;
-}
-export interface NativeMemoryWriteResult {
-    success: boolean;
-    bytesWritten?: number;
-    error?: string;
-}
-export interface NativeMemoryScanResult {
-    success: boolean;
-    addresses: string[];
-    error?: string;
-    stats?: {
-        patternLength: number;
-        resultsFound: number;
-    };
-}
-export interface MemoryRegion {
-    baseAddress: string;
-    size: number;
-    state: string;
-    protection: string;
-    isReadable: boolean;
-    isWritable: boolean;
-    isExecutable: boolean;
-    type: string;
-}
-export interface ModuleInfo {
-    name: string;
-    baseAddress: string;
-    size: number;
-}
-export type NativePatternType = 'hex' | 'string' | 'byte' | 'int8' | 'int16' | 'uint16' | 'int32' | 'uint32' | 'int64' | 'uint64' | 'float' | 'double' | 'pointer';
-export type ScanValueType = 'byte' | 'int8' | 'int16' | 'uint16' | 'int32' | 'uint32' | 'int64' | 'uint64' | 'float' | 'double' | 'pointer' | 'hex' | 'string';
-export type ScanCompareMode = 'exact' | 'unknown_initial' | 'changed' | 'unchanged' | 'increased' | 'decreased' | 'greater_than' | 'less_than' | 'between' | 'not_equal';
-export interface ScanOptions {
-    valueType: ScanValueType;
-    alignment?: number;
-    maxResults?: number;
-    regionFilter?: {
-        writable?: boolean;
-        executable?: boolean;
-        moduleOnly?: boolean;
-    };
-}
-export interface ScanSessionState {
-    id: string;
-    pid: number;
-    valueType: ScanValueType;
-    alignment: number;
-    createdAt: number;
-    lastScanAt: number;
-    scanCount: number;
-    addresses: bigint[];
-    previousValues: Map<bigint, Buffer>;
-}

package/dist/src/native/NativeMemoryManager.types.js

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

package/dist/src/native/NativeMemoryManager.utils.d.ts

@@ -1,14 +0,0 @@
-import { type MemoryBasicInfo } from './Win32API.js';
-import type { NativePatternType } from './NativeMemoryManager.types.js';
-export declare function isKoffiAvailable(): boolean;
-export declare function parsePattern(pattern: string, patternType: NativePatternType): {
-    patternBytes: number[];
-    mask: number[];
-};
-export declare function findPatternInBuffer(buffer: Buffer, pattern: number[], mask: number[]): number[];
-export declare function getStateString(state: number): string;
-export declare function getProtectionString(protect: number): string;
-export declare function getTypeString(type: number): string;
-export declare function isReadable(info: MemoryBasicInfo): boolean;
-export declare function isWritable(protect: number): boolean;
-export declare function isExecutable(protect: number): boolean;