@jshookmcp/jshook 0.2.1 → 0.2.2

package/dist/tests/native/NativeMemoryManager.impl.extended.test.js

@@ -1,307 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const state = vi.hoisted(() => ({
-    PAGE: {
-        NOACCESS: 0x01,
-        READONLY: 0x02,
-        READWRITE: 0x04,
-        WRITECOPY: 0x08,
-        EXECUTE: 0x10,
-        EXECUTE_READ: 0x20,
-        EXECUTE_READWRITE: 0x40,
-        GUARD: 0x100,
-    },
-    MEM: {
-        COMMIT: 0x1000,
-        RESERVE: 0x2000,
-        FREE: 0x10000,
-    },
-    MEM_TYPE: {
-        IMAGE: 0x1000000,
-        MAPPED: 0x40000,
-        PRIVATE: 0x20000,
-    },
-    exec: vi.fn(),
-    execAsync: vi.fn(),
-    openProcessForMemory: vi.fn(),
-    CloseHandle: vi.fn(),
-    ReadProcessMemory: vi.fn(),
-    WriteProcessMemory: vi.fn(),
-    VirtualQueryEx: vi.fn(),
-    VirtualProtectEx: vi.fn(),
-    VirtualAllocEx: vi.fn(),
-    CreateRemoteThread: vi.fn(),
-    GetModuleHandle: vi.fn(),
-    GetProcAddress: vi.fn(),
-    NtQueryInformationProcess: vi.fn(),
-    EnumProcessModules: vi.fn(),
-    GetModuleBaseName: vi.fn(),
-    GetModuleInformation: vi.fn(),
-    checkNativeMemoryAvailability: vi.fn(),
-    findPatternInBuffer: vi.fn(),
-    logger: {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        debug: vi.fn(),
-    },
-}));
-vi.mock('node:child_process', () => ({
-    exec: state.exec,
-}));
-vi.mock('node:util', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        promisify: vi.fn(() => state.execAsync),
-    };
-});
-vi.mock('@utils/logger', () => ({
-    logger: state.logger,
-}));
-vi.mock('@native/Win32API', () => ({
-    PAGE: state.PAGE,
-    MEM: state.MEM,
-    MEM_TYPE: state.MEM_TYPE,
-    openProcessForMemory: state.openProcessForMemory,
-    CloseHandle: state.CloseHandle,
-    ReadProcessMemory: state.ReadProcessMemory,
-    WriteProcessMemory: state.WriteProcessMemory,
-    VirtualQueryEx: state.VirtualQueryEx,
-    VirtualProtectEx: state.VirtualProtectEx,
-    VirtualAllocEx: state.VirtualAllocEx,
-    CreateRemoteThread: state.CreateRemoteThread,
-    GetModuleHandle: state.GetModuleHandle,
-    GetProcAddress: state.GetProcAddress,
-    NtQueryInformationProcess: state.NtQueryInformationProcess,
-    EnumProcessModules: state.EnumProcessModules,
-    GetModuleBaseName: state.GetModuleBaseName,
-    GetModuleInformation: state.GetModuleInformation,
-}));
-vi.mock('@native/NativeMemoryManager.availability', () => ({
-    checkNativeMemoryAvailability: state.checkNativeMemoryAvailability,
-}));
-import { scanRegionInChunks, NativeMemoryManager } from '../../src/native/NativeMemoryManager.impl.js';
-describe('scanRegionInChunks', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('returns empty when patternBytes is empty', () => {
-        const readChunk = vi.fn();
-        const result = scanRegionInChunks({ baseAddress: 0x1000n, regionSize: 1024 }, [], [], readChunk);
-        expect(result).toEqual([]);
-        expect(readChunk).not.toHaveBeenCalled();
-    });
-    it('returns empty when region is smaller than pattern', () => {
-        const readChunk = vi.fn();
-        const result = scanRegionInChunks({ baseAddress: 0x1000n, regionSize: 2 }, [0xaa, 0xbb, 0xcc], [1, 1, 1], readChunk);
-        expect(result).toEqual([]);
-    });
-    it('returns empty when chunkSize is zero or negative', () => {
-        const readChunk = vi.fn();
-        const result = scanRegionInChunks({ baseAddress: 0x1000n, regionSize: 1024 }, [0xaa], [1], readChunk, 0);
-        expect(result).toEqual([]);
-    });
-    it('finds a single match in a small region', () => {
-        const data = Buffer.from([0x00, 0xaa, 0xbb, 0x00]);
-        const readChunk = vi.fn().mockReturnValue(data);
-        const result = scanRegionInChunks({ baseAddress: 0x1000n, regionSize: 4 }, [0xaa, 0xbb], [1, 1], readChunk, 4096);
-        expect(result).toEqual([0x1001n]);
-    });
-    it('finds matches spanning multiple chunks with carry-over', () => {
-        const chunk1 = Buffer.from([0xaa, 0xbb, 0xcc]);
-        const chunk2 = Buffer.from([0xdd, 0xee]);
-        const readChunk = vi.fn()
-            .mockReturnValueOnce(chunk1)
-            .mockReturnValueOnce(chunk2);
-        const result = scanRegionInChunks({ baseAddress: 0x2000n, regionSize: 5 }, [0xcc, 0xdd], [1, 1], readChunk, 3);
-        expect(result).toEqual([0x2002n]);
-    });
-    it('finds multiple matches across the region', () => {
-        const data = Buffer.from([0xaa, 0xbb, 0x00, 0xaa, 0xbb]);
-        const readChunk = vi.fn().mockReturnValue(data);
-        const result = scanRegionInChunks({ baseAddress: 0x3000n, regionSize: 5 }, [0xaa, 0xbb], [1, 1], readChunk, 4096);
-        expect(result).toEqual([0x3000n, 0x3003n]);
-    });
-    it('supports wildcard mask matches', () => {
-        const data = Buffer.from([0xaa, 0xff, 0xcc]);
-        const readChunk = vi.fn().mockReturnValue(data);
-        const result = scanRegionInChunks({ baseAddress: 0x4000n, regionSize: 3 }, [0xaa, 0x00, 0xcc], [1, 0, 1], readChunk, 4096);
-        expect(result).toEqual([0x4000n]);
-    });
-});
-describe('NativeMemoryManager extended', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        state.openProcessForMemory.mockReturnValue(9999n);
-        state.CloseHandle.mockReturnValue(true);
-        state.checkNativeMemoryAvailability.mockResolvedValue({ available: true });
-    });
-    describe('writeMemory', () => {
-        it('returns error when openProcessForMemory throws', async () => {
-            state.openProcessForMemory.mockImplementation(() => {
-                throw new Error('access denied');
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.writeMemory(100, '0x1000', 'AABB');
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('access denied');
-        });
-    });
-    describe('enumerateRegions', () => {
-        it('returns error when openProcessForMemory throws', async () => {
-            state.openProcessForMemory.mockImplementation(() => {
-                throw new Error('no access');
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.enumerateRegions(100);
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('no access');
-        });
-    });
-    describe('enumerateModules', () => {
-        it('returns modules with name and base address', async () => {
-            state.EnumProcessModules.mockReturnValue({
-                success: true,
-                modules: [0x10000n, 0x20000n],
-                count: 2,
-            });
-            state.GetModuleBaseName
-                .mockReturnValueOnce('kernel32.dll')
-                .mockReturnValueOnce('ntdll.dll');
-            state.GetModuleInformation
-                .mockReturnValueOnce({
-                success: true,
-                info: { lpBaseOfDll: 0x10000n, SizeOfImage: 4096, EntryPoint: 0x10100n },
-            })
-                .mockReturnValueOnce({
-                success: true,
-                info: { lpBaseOfDll: 0x20000n, SizeOfImage: 8192, EntryPoint: 0x20100n },
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.enumerateModules(50);
-            expect(result.success).toBe(true);
-            expect(result.modules).toHaveLength(2);
-            expect(result.modules[0]).toEqual({
-                name: 'kernel32.dll',
-                baseAddress: '0x10000',
-                size: 4096,
-            });
-            expect(result.modules[1]).toEqual({
-                name: 'ntdll.dll',
-                baseAddress: '0x20000',
-                size: 8192,
-            });
-        });
-        it('returns failure when EnumProcessModules fails', async () => {
-            state.EnumProcessModules.mockReturnValue({
-                success: false,
-                modules: [],
-                count: 0,
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.enumerateModules(50);
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('EnumProcessModules failed');
-        });
-        it('skips modules where GetModuleInformation fails', async () => {
-            state.EnumProcessModules.mockReturnValue({
-                success: true,
-                modules: [0x10000n, 0x20000n],
-                count: 2,
-            });
-            state.GetModuleBaseName.mockReturnValue('test.dll');
-            state.GetModuleInformation
-                .mockReturnValueOnce({ success: false, info: {} })
-                .mockReturnValueOnce({
-                success: true,
-                info: { lpBaseOfDll: 0x20000n, SizeOfImage: 2048, EntryPoint: 0n },
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.enumerateModules(50);
-            const onlyModule = result.modules?.[0];
-            expect(result.modules).toHaveLength(1);
-            expect(onlyModule?.baseAddress).toBe('0x20000');
-        });
-    });
-    describe('injectShellcode', () => {
-        it('injects hex-encoded shellcode successfully', async () => {
-            state.VirtualAllocEx.mockReturnValue(0x8000n);
-            state.WriteProcessMemory.mockReturnValue(2);
-            state.VirtualProtectEx.mockReturnValue({ success: true, oldProtect: 4 });
-            state.CreateRemoteThread.mockReturnValue({ handle: 5555n, threadId: 99 });
-            const manager = new NativeMemoryManager();
-            const result = await manager.injectShellcode(200, 'CC DD');
-            expect(result.success).toBe(true);
-            expect(result.remoteThreadId).toBe(99);
-        });
-        it('injects base64-encoded shellcode', async () => {
-            state.VirtualAllocEx.mockReturnValue(0x9000n);
-            state.WriteProcessMemory.mockReturnValue(3);
-            state.VirtualProtectEx.mockReturnValue({ success: true, oldProtect: 4 });
-            state.CreateRemoteThread.mockReturnValue({ handle: 6666n, threadId: 88 });
-            const manager = new NativeMemoryManager();
-            const result = await manager.injectShellcode(200, 'zM0=', 'base64');
-            expect(result.success).toBe(true);
-            expect(result.remoteThreadId).toBe(88);
-        });
-        it('returns failure when VirtualAllocEx returns null', async () => {
-            state.VirtualAllocEx.mockReturnValue(0n);
-            const manager = new NativeMemoryManager();
-            const result = await manager.injectShellcode(200, 'CC DD');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('allocate remote memory');
-        });
-        it('returns failure when VirtualProtectEx fails', async () => {
-            state.VirtualAllocEx.mockReturnValue(0x8000n);
-            state.WriteProcessMemory.mockReturnValue(2);
-            state.VirtualProtectEx.mockReturnValue({ success: false, oldProtect: 0 });
-            const manager = new NativeMemoryManager();
-            const result = await manager.injectShellcode(200, 'CC DD');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('memory protection');
-        });
-        it('returns failure when CreateRemoteThread returns null handle', async () => {
-            state.VirtualAllocEx.mockReturnValue(0x8000n);
-            state.WriteProcessMemory.mockReturnValue(2);
-            state.VirtualProtectEx.mockReturnValue({ success: true, oldProtect: 4 });
-            state.CreateRemoteThread.mockReturnValue({ handle: 0n, threadId: 0 });
-            const manager = new NativeMemoryManager();
-            const result = await manager.injectShellcode(200, 'CC DD');
-            expect(result.success).toBe(false);
-            expect(result.error).toContain('remote thread');
-        });
-    });
-    describe('checkMemoryProtection', () => {
-        it('returns protection details on success', async () => {
-            state.VirtualQueryEx.mockReturnValue({
-                success: true,
-                info: {
-                    BaseAddress: 0x1000n,
-                    AllocationBase: 0x1000n,
-                    AllocationProtect: state.PAGE.READWRITE,
-                    RegionSize: 0x2000n,
-                    State: state.MEM.COMMIT,
-                    Protect: state.PAGE.EXECUTE_READ,
-                    Type: state.MEM_TYPE.IMAGE,
-                },
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.checkMemoryProtection(42, '0x1000');
-            expect(result.success).toBe(true);
-            expect(result.protection).toBe('RX');
-            expect(result.isReadable).toBe(true);
-            expect(result.isExecutable).toBe(true);
-            expect(result.regionStart).toBe('0x1000');
-            expect(result.regionSize).toBe(8192);
-        });
-        it('returns error when the outer openProcess throws', async () => {
-            state.openProcessForMemory.mockImplementation(() => {
-                throw new Error('permission denied');
-            });
-            const manager = new NativeMemoryManager();
-            const result = await manager.checkMemoryProtection(42, '0x1000');
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('permission denied');
-        });
-    });
-});

package/dist/tests/native/NativeMemoryManager.impl.test.d.ts

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

package/dist/tests/native/NativeMemoryManager.impl.test.js

@@ -1,218 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-const state = vi.hoisted(() => ({
-    PAGE: {
-        NOACCESS: 0x01,
-        READONLY: 0x02,
-        READWRITE: 0x04,
-        WRITECOPY: 0x08,
-        EXECUTE: 0x10,
-        EXECUTE_READ: 0x20,
-        EXECUTE_READWRITE: 0x40,
-        GUARD: 0x100,
-    },
-    MEM: {
-        COMMIT: 0x1000,
-        RESERVE: 0x2000,
-        FREE: 0x10000,
-    },
-    MEM_TYPE: {
-        IMAGE: 0x1000000,
-        MAPPED: 0x40000,
-        PRIVATE: 0x20000,
-    },
-    exec: vi.fn(),
-    execAsync: vi.fn(),
-    openProcessForMemory: vi.fn(),
-    CloseHandle: vi.fn(),
-    ReadProcessMemory: vi.fn(),
-    WriteProcessMemory: vi.fn(),
-    VirtualQueryEx: vi.fn(),
-    VirtualProtectEx: vi.fn(),
-    VirtualAllocEx: vi.fn(),
-    CreateRemoteThread: vi.fn(),
-    GetModuleHandle: vi.fn(),
-    GetProcAddress: vi.fn(),
-    NtQueryInformationProcess: vi.fn(),
-    EnumProcessModules: vi.fn(),
-    GetModuleBaseName: vi.fn(),
-    GetModuleInformation: vi.fn(),
-    checkNativeMemoryAvailability: vi.fn(),
-    logger: {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        debug: vi.fn(),
-    },
-}));
-vi.mock('node:child_process', () => ({
-    exec: state.exec,
-}));
-vi.mock('node:util', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        promisify: vi.fn(() => state.execAsync),
-    };
-});
-vi.mock('@utils/logger', () => ({
-    logger: state.logger,
-}));
-vi.mock('@native/Win32API', () => ({
-    PAGE: state.PAGE,
-    MEM: state.MEM,
-    MEM_TYPE: state.MEM_TYPE,
-    openProcessForMemory: state.openProcessForMemory,
-    CloseHandle: state.CloseHandle,
-    ReadProcessMemory: state.ReadProcessMemory,
-    WriteProcessMemory: state.WriteProcessMemory,
-    VirtualQueryEx: state.VirtualQueryEx,
-    VirtualProtectEx: state.VirtualProtectEx,
-    VirtualAllocEx: state.VirtualAllocEx,
-    CreateRemoteThread: state.CreateRemoteThread,
-    GetModuleHandle: state.GetModuleHandle,
-    GetProcAddress: state.GetProcAddress,
-    NtQueryInformationProcess: state.NtQueryInformationProcess,
-    EnumProcessModules: state.EnumProcessModules,
-    GetModuleBaseName: state.GetModuleBaseName,
-    GetModuleInformation: state.GetModuleInformation,
-}));
-vi.mock('@native/NativeMemoryManager.availability', () => ({
-    checkNativeMemoryAvailability: state.checkNativeMemoryAvailability,
-}));
-import { NativeMemoryManager } from '../../src/native/NativeMemoryManager.impl.js';
-function makeMemoryInfo(overrides) {
-    return {
-        BaseAddress: 0x1000n,
-        AllocationBase: 0x1000n,
-        AllocationProtect: state.PAGE.READWRITE,
-        RegionSize: 0x200n,
-        State: state.MEM.COMMIT,
-        Protect: state.PAGE.READWRITE,
-        Type: state.MEM_TYPE.PRIVATE,
-        ...overrides,
-    };
-}
-describe('NativeMemoryManager.impl', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        state.openProcessForMemory.mockReturnValue(1234);
-        state.ReadProcessMemory.mockReturnValue(Buffer.from([0xaa, 0xbb]));
-        state.WriteProcessMemory.mockReturnValue(2);
-        state.checkNativeMemoryAvailability.mockResolvedValue({ available: true });
-        state.GetModuleHandle.mockReturnValue(0x5000n);
-        state.GetProcAddress.mockReturnValue(0x6000n);
-        state.VirtualAllocEx.mockReturnValue(0x7000n);
-        state.CreateRemoteThread.mockReturnValue({ handle: 4321, threadId: 77 });
-    });
-    it('delegates availability checks to the availability helper with the promisified exec function', async () => {
-        const manager = new NativeMemoryManager();
-        await expect(manager.checkAvailability()).resolves.toEqual({ available: true });
-        expect(state.checkNativeMemoryAvailability).toHaveBeenCalledWith(state.execAsync);
-    });
-    it('reads memory, normalizes the address, and returns uppercase spaced hex', async () => {
-        const manager = new NativeMemoryManager();
-        await expect(manager.readMemory(99, '1000', 2)).resolves.toEqual({
-            success: true,
-            data: 'AA BB',
-        });
-        expect(state.openProcessForMemory).toHaveBeenCalledWith(99, false);
-        expect(state.ReadProcessMemory).toHaveBeenCalledWith(1234, 0x1000n, 2);
-        expect(state.CloseHandle).toHaveBeenCalledWith(1234);
-    });
-    it('returns a structured error when reading memory fails', async () => {
-        state.ReadProcessMemory.mockImplementation(() => {
-            throw new Error('boom');
-        });
-        const manager = new NativeMemoryManager();
-        const result = await manager.readMemory(99, '0x2000', 4);
-        expect(result).toEqual({
-            success: false,
-            error: 'boom',
-        });
-        expect(state.logger.error).toHaveBeenCalledWith('Native memory read failed', expect.objectContaining({
-            pid: 99,
-            address: '0x2000',
-            size: 4,
-            error: 'boom',
-        }));
-    });
-    it('writes normalized hex and base64 payloads through WriteProcessMemory', async () => {
-        const manager = new NativeMemoryManager();
-        await expect(manager.writeMemory(7, 'ABC', 'DE AD')).resolves.toEqual({
-            success: true,
-            bytesWritten: 2,
-        });
-        expect(state.WriteProcessMemory).toHaveBeenNthCalledWith(1, 1234, 0xabcn, Buffer.from([0xde, 0xad]));
-        await expect(manager.writeMemory(7, '0xABC', '3q0=', 'base64')).resolves.toEqual({
-            success: true,
-            bytesWritten: 2,
-        });
-        expect(state.WriteProcessMemory).toHaveBeenNthCalledWith(2, 1234, 0xabcn, Buffer.from([0xde, 0xad]));
-    });
-    it('enumerates memory regions and maps them into response objects', async () => {
-        state.VirtualQueryEx
-            .mockReturnValueOnce({ success: true, info: makeMemoryInfo() })
-            .mockReturnValueOnce({ success: false, info: makeMemoryInfo({ BaseAddress: 0x1200n, RegionSize: 0n }) });
-        const manager = new NativeMemoryManager();
-        const result = await manager.enumerateRegions(123);
-        expect(result).toEqual({
-            success: true,
-            regions: [
-                {
-                    baseAddress: '0x1000',
-                    size: 512,
-                    state: 'COMMIT',
-                    protection: 'RW',
-                    isReadable: true,
-                    isWritable: true,
-                    isExecutable: false,
-                    type: 'PRIVATE',
-                },
-            ],
-        });
-    });
-    it('returns a failure when memory protection lookup cannot query the region', async () => {
-        state.VirtualQueryEx.mockReturnValue({
-            success: false,
-            info: makeMemoryInfo(),
-        });
-        const manager = new NativeMemoryManager();
-        await expect(manager.checkMemoryProtection(55, '0x1000')).resolves.toEqual({
-            success: false,
-            error: 'Failed to query memory region',
-        });
-    });
-    it('injectDll reports a missing LoadLibraryA address as a structured failure', async () => {
-        state.GetProcAddress.mockReturnValue(0n);
-        const manager = new NativeMemoryManager();
-        await expect(manager.injectDll(17, 'C:\\temp\\demo.dll')).resolves.toEqual({
-            success: false,
-            error: 'Failed to get LoadLibraryA address',
-        });
-        expect(state.CloseHandle).toHaveBeenCalledWith(1234);
-    });
-    it('injectDll writes the DLL path into remote memory and returns the thread id', async () => {
-        const manager = new NativeMemoryManager();
-        const result = await manager.injectDll(17, 'C:\\temp\\demo.dll');
-        expect(result).toEqual({
-            success: true,
-            remoteThreadId: 77,
-        });
-        expect(state.VirtualAllocEx).toHaveBeenCalledWith(1234, 0n, 'C:\\temp\\demo.dll'.length + 1, state.MEM.COMMIT | state.MEM.RESERVE, state.PAGE.READWRITE);
-        expect(state.WriteProcessMemory).toHaveBeenCalledWith(1234, 0x7000n, expect.any(Buffer));
-        expect(state.CloseHandle).toHaveBeenCalledWith(4321);
-    });
-    it('reports debugger presence from NtQueryInformationProcess and returns status errors when needed', async () => {
-        state.NtQueryInformationProcess.mockReturnValueOnce({ status: 0, debugPort: 1 });
-        const manager = new NativeMemoryManager();
-        await expect(manager.checkDebugPort(42)).resolves.toEqual({
-            success: true,
-            isDebugged: true,
-        });
-        state.NtQueryInformationProcess.mockReturnValueOnce({ status: 5, debugPort: 0 });
-        await expect(manager.checkDebugPort(42)).resolves.toEqual({
-            success: false,
-            error: 'NtQueryInformationProcess failed with status 0x5',
-        });
-    });
-});

package/dist/tests/native/NativeMemoryManager.test.d.ts

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

package/dist/tests/native/NativeMemoryManager.test.js

@@ -1,12 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import * as entry from '../../src/native/NativeMemoryManager.js';
-import * as implementation from '../../src/native/NativeMemoryManager.impl.js';
-describe('NativeMemoryManager entrypoint', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    it('re-exports the implementation surface from NativeMemoryManager.impl', () => {
-        expect(entry.NativeMemoryManager).toBe(implementation.NativeMemoryManager);
-        expect(entry.scanRegionInChunks).toBe(implementation.scanRegionInChunks);
-    });
-});

package/dist/tests/native/NativeMemoryManager.utils.extended.test.d.ts

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