@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/native/MemoryScanner.d.ts

@@ -1,45 +0,0 @@
-import type { NativeMemoryManager } from './NativeMemoryManager.impl.js';
-import type { ScanOptions, ScanCompareMode, ScanValueType } from './NativeMemoryManager.types.js';
-export interface ScanResult {
-    sessionId: string;
-    matchCount: number;
-    scanNumber: number;
-    addresses: string[];
-    totalMatches: number;
-    truncated: boolean;
-    elapsed: string;
-}
-export declare class MemoryScanner {
-    private readonly nmm;
-    private _provider;
-    private get provider();
-    constructor(nmm: NativeMemoryManager);
-    firstScan(pid: number, value: string, options: ScanOptions): Promise<ScanResult>;
-    nextScan(sessionId: string, mode: ScanCompareMode, value?: string, value2?: string): Promise<ScanResult>;
-    unknownInitialScan(pid: number, options: ScanOptions): Promise<ScanResult>;
-    pointerScan(pid: number, targetAddress: string, options?: {
-        maxDepth?: number;
-        maxResults?: number;
-        moduleOnly?: boolean;
-    }): Promise<{
-        sessionId: string;
-        pointers: Array<{
-            address: string;
-            value: string;
-            offsetFromTarget: number;
-        }>;
-        totalFound: number;
-        elapsed: string;
-    }>;
-    groupScan(pid: number, pattern: Array<{
-        offset: number;
-        value: string;
-        type: ScanValueType;
-    }>, options?: {
-        alignment?: number;
-        maxResults?: number;
-    }): Promise<ScanResult>;
-    private patternFirstScan;
-    private getFilteredRegions;
-}
-export declare const memoryScanner: MemoryScanner;

package/dist/src/native/MemoryScanner.js

@@ -1,393 +0,0 @@
-import { SCAN_MAX_RESULTS_PER_SCAN, SCAN_DISPLAY_RESULTS_LIMIT, SCAN_UNKNOWN_INITIAL_MAX_ADDRESSES, SCAN_POINTER_MAX_RESULTS, SCAN_GROUP_MAX_PATTERN_SIZE, } from '../constants.js';
-import { nativeMemoryManager } from './NativeMemoryManager.impl.js';
-import { scanSessionManager } from './MemoryScanSession.js';
-import { compareScanValues, getValueSize, getDefaultAlignment } from './ScanComparators.js';
-import { parsePattern } from './NativeMemoryManager.utils.js';
-import { createPlatformProvider } from './platform/factory.js';
-import { formatAddress, parseAddress } from './formatAddress.js';
-export class MemoryScanner {
-    nmm;
-    _provider = null;
-    get provider() {
-        if (!this._provider) {
-            this._provider = createPlatformProvider();
-        }
-        return this._provider;
-    }
-    constructor(nmm) {
-        this.nmm = nmm;
-    }
-    async firstScan(pid, value, options) {
-        const start = performance.now();
-        const valueType = options.valueType;
-        const valueSize = getValueSize(valueType);
-        const alignment = options.alignment ?? getDefaultAlignment(valueType);
-        const maxResults = options.maxResults ?? SCAN_MAX_RESULTS_PER_SCAN;
-        if (valueSize === 0) {
-            return this.patternFirstScan(pid, value, valueType, options);
-        }
-        const { patternBytes } = parsePattern(value, valueType === 'pointer' ? 'uint64' : valueType);
-        if (patternBytes.length === 0) {
-            throw new Error(`Invalid pattern for type ${valueType}: "${value}"`);
-        }
-        const targetBuf = Buffer.from(patternBytes);
-        const sessionId = scanSessionManager.createSession(pid, options);
-        const addresses = [];
-        const values = new Map();
-        const handle = this.provider.openProcess(pid, false);
-        try {
-            const regions = this.getFilteredRegions(handle, options);
-            for (const region of regions) {
-                if (addresses.length >= maxResults)
-                    break;
-                const regionBase = region.baseAddress;
-                const regionSize = region.size;
-                const chunkSize = 16 * 1024 * 1024;
-                for (let offset = 0; offset < regionSize && addresses.length < maxResults; offset += chunkSize) {
-                    const readSize = Math.min(chunkSize, regionSize - offset);
-                    const chunkAddr = regionBase + BigInt(offset);
-                    let chunk;
-                    try {
-                        chunk = this.provider.readMemory(handle, chunkAddr, readSize).data;
-                    }
-                    catch {
-                        break;
-                    }
-                    const alignStep = alignment > 0 ? alignment : 1;
-                    const startOffset = alignment > 0 ? (alignStep - (offset % alignStep)) % alignStep : 0;
-                    for (let i = startOffset; i <= chunk.length - valueSize; i += alignStep) {
-                        const currentBuf = chunk.subarray(i, i + valueSize);
-                        if (compareScanValues(currentBuf, null, targetBuf, null, 'exact', valueType)) {
-                            const addr = chunkAddr + BigInt(i);
-                            addresses.push(addr);
-                            values.set(addr, Buffer.from(currentBuf));
-                            if (addresses.length >= maxResults)
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            this.provider.closeProcess(handle);
-        }
-        scanSessionManager.updateSession(sessionId, addresses, values);
-        const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-        const displayAddresses = addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress);
-        return {
-            sessionId,
-            matchCount: addresses.length,
-            scanNumber: 1,
-            addresses: displayAddresses,
-            totalMatches: addresses.length,
-            truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-            elapsed,
-        };
-    }
-    async nextScan(sessionId, mode, value, value2) {
-        const start = performance.now();
-        const session = scanSessionManager.getSession(sessionId);
-        const { pid, valueType, addresses: prevAddresses, previousValues } = session;
-        const valueSize = getValueSize(valueType);
-        if (valueSize === 0) {
-            throw new Error('Next-scan is not supported for variable-length types (hex/string)');
-        }
-        let targetBuf = null;
-        let target2Buf = null;
-        if (value !== undefined) {
-            const effectiveType = valueType === 'pointer' ? 'uint64' : valueType;
-            const { patternBytes } = parsePattern(value, effectiveType);
-            targetBuf = Buffer.from(patternBytes);
-        }
-        if (value2 !== undefined) {
-            const effectiveType = valueType === 'pointer' ? 'uint64' : valueType;
-            const { patternBytes } = parsePattern(value2, effectiveType);
-            target2Buf = Buffer.from(patternBytes);
-        }
-        const newAddresses = [];
-        const newValues = new Map();
-        const handle = this.provider.openProcess(pid, false);
-        try {
-            for (const addr of prevAddresses) {
-                let currentBuf;
-                try {
-                    currentBuf = this.provider.readMemory(handle, addr, valueSize).data;
-                }
-                catch {
-                    continue;
-                }
-                const prevBuf = previousValues.get(addr) ?? null;
-                if (compareScanValues(currentBuf, prevBuf, targetBuf, target2Buf, mode, valueType)) {
-                    newAddresses.push(addr);
-                    newValues.set(addr, Buffer.from(currentBuf));
-                }
-            }
-        }
-        finally {
-            this.provider.closeProcess(handle);
-        }
-        scanSessionManager.updateSession(sessionId, newAddresses, newValues);
-        const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-        const displayAddresses = newAddresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress);
-        return {
-            sessionId,
-            matchCount: newAddresses.length,
-            scanNumber: session.scanCount,
-            addresses: displayAddresses,
-            totalMatches: newAddresses.length,
-            truncated: newAddresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-            elapsed,
-        };
-    }
-    async unknownInitialScan(pid, options) {
-        const start = performance.now();
-        const valueType = options.valueType;
-        const valueSize = getValueSize(valueType);
-        const alignment = options.alignment ?? getDefaultAlignment(valueType);
-        const maxAddresses = options.maxResults ?? SCAN_UNKNOWN_INITIAL_MAX_ADDRESSES;
-        if (valueSize === 0) {
-            throw new Error('Unknown initial scan is not supported for variable-length types');
-        }
-        const sessionId = scanSessionManager.createSession(pid, options);
-        const addresses = [];
-        const values = new Map();
-        const handle = this.provider.openProcess(pid, false);
-        try {
-            const regions = this.getFilteredRegions(handle, options);
-            for (const region of regions) {
-                if (addresses.length >= maxAddresses)
-                    break;
-                const regionBase = region.baseAddress;
-                const regionSize = region.size;
-                const chunkSize = 16 * 1024 * 1024;
-                for (let offset = 0; offset < regionSize && addresses.length < maxAddresses; offset += chunkSize) {
-                    const readSize = Math.min(chunkSize, regionSize - offset);
-                    const chunkAddr = regionBase + BigInt(offset);
-                    let chunk;
-                    try {
-                        chunk = this.provider.readMemory(handle, chunkAddr, readSize).data;
-                    }
-                    catch {
-                        break;
-                    }
-                    const alignStep = alignment > 0 ? alignment : 1;
-                    for (let i = 0; i <= chunk.length - valueSize; i += alignStep) {
-                        const addr = chunkAddr + BigInt(i);
-                        const currentBuf = chunk.subarray(i, i + valueSize);
-                        addresses.push(addr);
-                        values.set(addr, Buffer.from(currentBuf));
-                        if (addresses.length >= maxAddresses)
-                            break;
-                    }
-                }
-            }
-        }
-        finally {
-            this.provider.closeProcess(handle);
-        }
-        scanSessionManager.updateSession(sessionId, addresses, values);
-        const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-        return {
-            sessionId,
-            matchCount: addresses.length,
-            scanNumber: 1,
-            addresses: addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress),
-            totalMatches: addresses.length,
-            truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-            elapsed,
-        };
-    }
-    async pointerScan(pid, targetAddress, options = {}) {
-        const start = performance.now();
-        const maxResults = options.maxResults ?? SCAN_POINTER_MAX_RESULTS;
-        const targetAddr = parseAddress(targetAddress);
-        const scanOptions = {
-            valueType: 'pointer',
-            alignment: 8,
-            regionFilter: { moduleOnly: options.moduleOnly },
-        };
-        const sessionId = scanSessionManager.createSession(pid, scanOptions);
-        const pointers = [];
-        const handle = this.provider.openProcess(pid, false);
-        try {
-            const regions = this.getFilteredRegions(handle, scanOptions);
-            for (const region of regions) {
-                if (pointers.length >= maxResults)
-                    break;
-                const regionBase = region.baseAddress;
-                const regionSize = region.size;
-                const chunkSize = 16 * 1024 * 1024;
-                for (let offset = 0; offset < regionSize && pointers.length < maxResults; offset += chunkSize) {
-                    const readSize = Math.min(chunkSize, regionSize - offset);
-                    const chunkAddr = regionBase + BigInt(offset);
-                    let chunk;
-                    try {
-                        chunk = this.provider.readMemory(handle, chunkAddr, readSize).data;
-                    }
-                    catch {
-                        break;
-                    }
-                    for (let i = 0; i <= chunk.length - 8; i += 8) {
-                        const ptrValue = chunk.readBigUInt64LE(i);
-                        const diff = ptrValue > targetAddr ? Number(ptrValue - targetAddr) : Number(targetAddr - ptrValue);
-                        if (diff <= 4096) {
-                            const addr = chunkAddr + BigInt(i);
-                            const offsetFromTarget = ptrValue >= targetAddr
-                                ? Number(ptrValue - targetAddr)
-                                : -Number(targetAddr - ptrValue);
-                            pointers.push({
-                                address: formatAddress(addr),
-                                value: formatAddress(ptrValue),
-                                offsetFromTarget,
-                            });
-                            if (pointers.length >= maxResults)
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            this.provider.closeProcess(handle);
-        }
-        const addresses = pointers.map((p) => parseAddress(p.address));
-        scanSessionManager.updateSession(sessionId, addresses, new Map());
-        const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-        return {
-            sessionId,
-            pointers: pointers.slice(0, SCAN_DISPLAY_RESULTS_LIMIT),
-            totalFound: pointers.length,
-            elapsed,
-        };
-    }
-    async groupScan(pid, pattern, options) {
-        const start = performance.now();
-        if (pattern.length === 0) {
-            throw new Error('Group scan requires at least one value pattern');
-        }
-        const maxOffset = Math.max(...pattern.map((p) => p.offset + getValueSize(p.type)));
-        if (maxOffset > SCAN_GROUP_MAX_PATTERN_SIZE) {
-            throw new Error(`Group pattern too large: ${maxOffset} bytes (max ${SCAN_GROUP_MAX_PATTERN_SIZE})`);
-        }
-        const compositePattern = Array.from({ length: maxOffset }, () => 0);
-        const compositeMask = Array.from({ length: maxOffset }, () => 0);
-        for (const entry of pattern) {
-            const effectiveType = entry.type === 'pointer' ? 'uint64' : entry.type;
-            const { patternBytes, mask } = parsePattern(entry.value, effectiveType);
-            for (let i = 0; i < patternBytes.length; i++) {
-                compositePattern[entry.offset + i] = patternBytes[i];
-                compositeMask[entry.offset + i] = mask[i];
-            }
-        }
-        const alignment = options?.alignment ?? 4;
-        const maxResults = options?.maxResults ?? SCAN_MAX_RESULTS_PER_SCAN;
-        const scanOptions = { valueType: 'int32', alignment };
-        const sessionId = scanSessionManager.createSession(pid, scanOptions);
-        const addresses = [];
-        const handle = this.provider.openProcess(pid, false);
-        try {
-            const regions = this.getFilteredRegions(handle, scanOptions);
-            for (const region of regions) {
-                if (addresses.length >= maxResults)
-                    break;
-                const regionBase = region.baseAddress;
-                const regionSize = region.size;
-                const chunkSize = 16 * 1024 * 1024;
-                const overlap = maxOffset - 1;
-                for (let chunkOffset = 0; chunkOffset < regionSize && addresses.length < maxResults; chunkOffset += chunkSize) {
-                    const readSize = Math.min(chunkSize + overlap, regionSize - chunkOffset);
-                    const chunkAddr = regionBase + BigInt(chunkOffset);
-                    let chunk;
-                    try {
-                        chunk = this.provider.readMemory(handle, chunkAddr, readSize).data;
-                    }
-                    catch {
-                        break;
-                    }
-                    const alignStep = alignment > 0 ? alignment : 1;
-                    for (let i = 0; i <= chunk.length - maxOffset; i += alignStep) {
-                        let match = true;
-                        for (let j = 0; j < maxOffset; j++) {
-                            if (compositeMask[j] === 1 && chunk[i + j] !== compositePattern[j]) {
-                                match = false;
-                                break;
-                            }
-                        }
-                        if (match) {
-                            const addr = chunkAddr + BigInt(i);
-                            addresses.push(addr);
-                            if (addresses.length >= maxResults)
-                                break;
-                        }
-                    }
-                }
-            }
-        }
-        finally {
-            this.provider.closeProcess(handle);
-        }
-        scanSessionManager.updateSession(sessionId, addresses, new Map());
-        const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-        return {
-            sessionId,
-            matchCount: addresses.length,
-            scanNumber: 1,
-            addresses: addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress),
-            totalMatches: addresses.length,
-            truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-            elapsed,
-        };
-    }
-    async patternFirstScan(pid, value, valueType, options) {
-        const start = performance.now();
-        const patternType = (valueType === 'pointer' ? 'uint64' : valueType);
-        const result = await this.nmm.scanMemory(pid, value, patternType);
-        if (!result.success) {
-            throw new Error(result.error ?? 'Scan failed');
-        }
-        const sessionId = scanSessionManager.createSession(pid, options);
-        const maxResultCount = options.maxResults ?? SCAN_MAX_RESULTS_PER_SCAN;
-        const addresses = result.addresses.slice(0, maxResultCount).map(parseAddress);
-        scanSessionManager.updateSession(sessionId, addresses, new Map());
-        const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
-        return {
-            sessionId,
-            matchCount: addresses.length,
-            scanNumber: 1,
-            addresses: addresses.slice(0, SCAN_DISPLAY_RESULTS_LIMIT).map(formatAddress),
-            totalMatches: result.addresses.length,
-            truncated: addresses.length > SCAN_DISPLAY_RESULTS_LIMIT,
-            elapsed,
-        };
-    }
-    getFilteredRegions(handle, options) {
-        const regions = [];
-        let address = 0n;
-        const maxAddress = BigInt('0x7FFFFFFF0000');
-        const filter = options.regionFilter;
-        while (address < maxAddress) {
-            const regionInfo = this.provider.queryRegion(handle, address);
-            if (!regionInfo)
-                break;
-            const regionSize = regionInfo.size;
-            if (regionInfo.isReadable && regionSize > 0 && regionSize <= Number.MAX_SAFE_INTEGER) {
-                let include = true;
-                if (filter?.writable && !regionInfo.isWritable)
-                    include = false;
-                if (filter?.executable && !regionInfo.isExecutable)
-                    include = false;
-                if (filter?.moduleOnly && regionInfo.type !== 'image')
-                    include = false;
-                if (include) {
-                    regions.push({
-                        baseAddress: regionInfo.baseAddress,
-                        size: regionSize,
-                    });
-                }
-            }
-            address = regionInfo.baseAddress + BigInt(regionInfo.size);
-        }
-        return regions;
-    }
-}
-export const memoryScanner = new MemoryScanner(nativeMemoryManager);

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

@@ -1,9 +0,0 @@
-export declare function checkNativeMemoryAvailability(execAsync: (command: string, options?: {
-    timeout?: number;
-}) => Promise<{
-    stdout: string;
-    stderr: string;
-}>): Promise<{
-    available: boolean;
-    reason?: string;
-}>;

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

@@ -1,62 +0,0 @@
-import { isKoffiAvailable, isWindows } from './Win32API.js';
-export async function checkNativeMemoryAvailability(execAsync) {
-    if (process.platform === 'darwin') {
-        return checkDarwinAvailability(execAsync);
-    }
-    if (!isWindows()) {
-        return {
-            available: false,
-            reason: `Native memory operations require Windows or macOS. Current platform: ${process.platform}`,
-        };
-    }
-    if (!isKoffiAvailable()) {
-        return {
-            available: false,
-            reason: 'koffi library not available. Install with: pnpm add koffi',
-        };
-    }
-    try {
-        const { stdout } = await execAsync('powershell.exe -NoProfile -Command "([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)"', { timeout: 5000 });
-        if (stdout.trim().toLowerCase() !== 'true') {
-            return {
-                available: false,
-                reason: 'Native memory operations require Administrator privileges. Run as Administrator.',
-            };
-        }
-    }
-    catch {
-        return {
-            available: false,
-            reason: 'Failed to check Administrator privileges.',
-        };
-    }
-    return { available: true };
-}
-async function checkDarwinAvailability(execAsync) {
-    try {
-        const koffiMod = await import('koffi');
-        const testLib = koffiMod.default.load('/usr/lib/libSystem.B.dylib');
-        testLib.unload();
-    }
-    catch {
-        return {
-            available: false,
-            reason: 'koffi library cannot load libSystem.B.dylib. Install koffi with: pnpm add koffi',
-        };
-    }
-    let sipInfo = '';
-    try {
-        const { stdout } = await execAsync('csrutil status 2>&1 || true', { timeout: 5000 });
-        sipInfo = stdout.trim();
-    }
-    catch {
-    }
-    if (process.getuid && process.getuid() !== 0) {
-        const sipNote = sipInfo ? ` SIP status: ${sipInfo}` : '';
-        return {
-            available: false,
-            reason: `macOS memory operations require root privileges for task_for_pid. Run with: sudo node <your-script>.${sipNote}`,
-        };
-    }
-    return { available: true };
-}

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

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

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

@@ -1,53 +0,0 @@
-import type { MemoryRegion, ModuleInfo, NativeMemoryReadResult, NativeMemoryScanResult, NativeMemoryWriteResult } from './NativeMemoryManager.types.js';
-export type { MemoryRegion, ModuleInfo, NativeMemoryReadResult, NativeMemoryScanResult, NativeMemoryWriteResult, } from './NativeMemoryManager.types.js';
-export declare function scanRegionInChunks(region: {
-    baseAddress: bigint;
-    regionSize: number;
-}, patternBytes: number[], mask: number[], readChunk: (address: bigint, size: number) => Buffer<ArrayBufferLike>, chunkSize?: number): bigint[];
-export declare class NativeMemoryManager {
-    private _provider;
-    private get provider();
-    checkAvailability(): Promise<{
-        available: boolean;
-        reason?: string;
-    }>;
-    readMemory(pid: number, address: string, size: number): Promise<NativeMemoryReadResult>;
-    writeMemory(pid: number, address: string, data: string, encoding?: 'hex' | 'base64'): Promise<NativeMemoryWriteResult>;
-    enumerateRegions(pid: number): Promise<{
-        success: boolean;
-        regions?: MemoryRegion[];
-        error?: string;
-    }>;
-    checkMemoryProtection(pid: number, address: string): Promise<{
-        success: boolean;
-        protection?: string;
-        isWritable?: boolean;
-        isReadable?: boolean;
-        isExecutable?: boolean;
-        regionStart?: string;
-        regionSize?: number;
-        error?: string;
-    }>;
-    scanMemory(pid: number, pattern: string, patternType?: 'hex' | 'int32' | 'int64' | 'float' | 'double' | 'string'): Promise<NativeMemoryScanResult>;
-    enumerateModules(pid: number): Promise<{
-        success: boolean;
-        modules?: ModuleInfo[];
-        error?: string;
-    }>;
-    injectDll(pid: number, dllPath: string): Promise<{
-        success: boolean;
-        remoteThreadId?: number;
-        error?: string;
-    }>;
-    injectShellcode(pid: number, shellcode: string, encoding?: 'hex' | 'base64'): Promise<{
-        success: boolean;
-        remoteThreadId?: number;
-        error?: string;
-    }>;
-    checkDebugPort(pid: number): Promise<{
-        success: boolean;
-        isDebugged?: boolean;
-        error?: string;
-    }>;
-}
-export declare const nativeMemoryManager: NativeMemoryManager;