@memoryprocess/bindings 0.0.0-stage → 0.0.1

package/binding.gyp

@@ -0,0 +1,46 @@
+{
+  "targets": [
+    {
+      "target_name": "memoryprocess",
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "sources": [
+        "native/memoryprocess.cc",
+        "native/process.cc",
+        "native/memory.cc",
+        "native/module.cc",
+        "native/pattern.cc",
+        "native/hde/hde64.c"
+      ],
+      "defines": [
+        "NAPI_DISABLE_CPP_EXCEPTIONS",
+        "NAPI_VERSION=<(napi_build_version)"
+      ],
+      "conditions": [
+        ["OS==\"win\"", {
+          "msvs_settings": {
+            "VCCLCompilerTool": {
+              "ExceptionHandling": 1,
+              "AdditionalOptions!": [ "-flto=thin", "-flto=full", "-flto" ]
+            },
+            "VCLibrarianTool": {
+              "AdditionalOptions!": [ "-flto=thin", "-flto=full", "-flto" ]
+            },
+            "VCLinkerTool": {
+              "AdditionalOptions!": [ "-flto=thin", "-flto=full", "-flto", "/opt:lldltojobs=<(lto_jobs)" ]
+            }
+          }
+        }]
+      ],
+      # Node 26 official builds ship thin-LTO flags (-flto=thin, /opt:lldltojobs)
+      # that MSVC cannot link. The '%' lets these defaults be overridden but
+      # neutralises them when Node reports them enabled.
+      "variables": {
+        "enable_lto%": "false",
+        "enable_thin_lto%": "false",
+        "lto_jobs%": ""
+      }
+    }
+  ]
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @memoryprocess/bindings — the native N-API layer.
+ * Exposes the raw `.node` module plus its TypeScript interface.
+ * Most consumers want `@memoryprocess/core` (the Process class) instead.
+ */
+export * from './native.js';

package/dist/index.js

@@ -0,0 +1,27 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+// src/native.ts
+const require = createRequire(import.meta.url);
+const __dir = dirname(fileURLToPath(import.meta.url));
+const candidates = [
+	join(__dir, "memoryprocess.node"),
+	join(__dir, "..", "dist", "memoryprocess.node"),
+	join(__dir, "..", "build", "Release", "memoryprocess.node")
+];
+const native = (() => {
+	let lastErr;
+	for (const path of candidates) try {
+		return require(path);
+	} catch (e) {
+		lastErr = e;
+	}
+	try {
+		return require("node-gyp-build")(join(__dir, ".."));
+	} catch (e) {
+		lastErr = lastErr ?? e;
+	}
+	const detail = lastErr instanceof Error ? `: ${lastErr.message}` : "";
+	throw new Error(`memoryprocess native addon failed to load (run \`bun run build\`)${detail}`);
+})();
+export { native };

package/dist/native.d.ts

@@ -0,0 +1,128 @@
+interface Native {
+    openProcess(nameOrPid: string | number, access?: number): {
+        handle: number;
+        pid: number;
+    };
+    closeHandle(handle: number): boolean;
+    listProcesses(): {
+        pid: number;
+        name: string;
+    }[];
+    getModules(handle: number, pid: number): {
+        base: number;
+        size: number;
+        path: string;
+    }[];
+    getRegions(handle: number): {
+        baseAddress: number;
+        size: number;
+        protection: number;
+        type: number;
+    }[];
+    readValue(handle: number, address: number, type: string): number | bigint;
+    writeValue(handle: number, address: number, type: string, value: number | bigint): boolean;
+    readBuffer(handle: number, address: number, size: number): Buffer;
+    writeBuffer(handle: number, address: number, data: Buffer): boolean;
+    scan(pid: number, pattern: string, opts?: {
+        start?: number;
+        end?: number;
+        onlyReadable?: boolean;
+    }): Promise<bigint[]>;
+    scanValue(pid: number, needle: Uint8Array, opts?: {
+        start?: number;
+        end?: number;
+        onlyWritable?: boolean;
+        alignment?: number;
+    }): Promise<bigint[]>;
+    allocMemory(handle: number, size: number, protection: number, nearAddress?: number): bigint;
+    freeMemory(handle: number, address: number): boolean;
+    protectMemory(handle: number, address: number, size: number, protection: number): number;
+    isWow64(handle: number): boolean;
+    listThreads(pid: number): number[];
+    suspendThread(tid: number): boolean;
+    resumeThread(tid: number): boolean;
+    readSafe(handle: number, address: number, size: number): Buffer;
+    flushInstructions(handle: number, address: number, size: number): boolean;
+    injectDll(pid: number, dllPath: string, timeoutMs?: number): boolean;
+    ejectDll(pid: number, moduleBase: number): boolean;
+    queryAddress(handle: number, address: number): {
+        baseAddress: number;
+        allocationBase: number;
+        size: number;
+        protection: number;
+        state: number;
+        type: number;
+    } | null;
+    getThreadContext(tid: number): {
+        rip: bigint;
+        rsp: bigint;
+        rbp: bigint;
+        dr0: bigint;
+        dr1: bigint;
+        dr2: bigint;
+        dr3: bigint;
+        dr6: bigint;
+        dr7: bigint;
+        eflags: bigint;
+    } | null;
+    setThreadContext(tid: number, ctx: Partial<Record<'rip' | 'rsp' | 'rbp' | 'dr0' | 'dr1' | 'dr2' | 'dr3' | 'dr6' | 'dr7' | 'eflags', number | bigint>>): boolean;
+    callRemote(pid: number, fnAddress: number | bigint, param: number | bigint, timeoutMs?: number): number | null;
+    disasmInstructions(handle: number, address: number, count: number): {
+        offset: number;
+        length: number;
+        relative: boolean;
+    }[];
+    /**
+     * Walk instructions at `address` until `minBytes` are covered, then
+     * RELOCATE position-relative operands (rel32 branch/call immediates,
+     * RIP-relative disp32) so the stolen bytes are correct when executed from
+     * `stubAddr` (must be within rel32 range of `address`). External rel8/16
+     * branches (incl. LOOP/JECXZ) can't be widened — refused `HOOK_RELOCATE`,
+     * like MinHook; rel8/16 internal (target inside the stolen window) and
+     * all non-relative instructions copy verbatim. Without `stubAddr` any
+     * position-relative instruction is refused (inspection mode).
+     * Throws `HOOK_STEAL`/`HOOK_RELOCATE` — returns the relocated bytes.
+     */
+    hookSteal(handle: number, address: number, minBytesOrOpts?: number | {
+        minBytes?: number;
+        stubAddr?: number | bigint;
+    }, stubAddr?: number | bigint): {
+        length: number;
+        bytes: Buffer;
+        original: Buffer;
+    };
+    /**
+     * Per-region VirtualProtectEx→write→restore across the whole write span —
+     * records each region's real old protection before writing, restores each
+     * individually. `restored=false` means part of the span is left weakened.
+     */
+    writeProtectedMemory(handle: number, address: number, buffer: Buffer, protection?: number): {
+        ok: boolean;
+        restored: boolean;
+        protected: boolean;
+    };
+    /** Current thread id (TID) — used to refuse self-suspend. */
+    currentThreadId(): number;
+    suspendProcess(pid: number): boolean;
+    resumeProcess(pid: number): boolean;
+    enableDebugPrivilege(): boolean;
+    waitForExit(pid: number, timeoutMs?: number): Promise<number | null>;
+    findWhatWrites(pid: number, address: number | bigint, size: number, timeoutMs: number, maxHits: number): Promise<{
+        rip: bigint;
+        tid: number;
+        threadContext: {
+            rip: bigint;
+            rsp: bigint;
+            rbp: bigint;
+            dr0: bigint;
+            dr1: bigint;
+            dr2: bigint;
+            dr3: bigint;
+            dr6: bigint;
+            dr7: bigint;
+            eflags: bigint;
+        };
+    }[]>;
+}
+export declare const native: Native;
+export {};

package/native/hde/LICENSE-minhook.txt

@@ -0,0 +1,81 @@
+MinHook - The Minimalistic API Hooking Library for x64/x86
+Copyright (C) 2009-2017 Tsuda Kageyu.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER
+OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+================================================================================
+Portions of this software are Copyright (c) 2008-2009, Vyacheslav Patkov.
+================================================================================
+Hacker Disassembler Engine 32 C
+Copyright (c) 2008-2009, Vyacheslav Patkov.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------------------
+Hacker Disassembler Engine 64 C
+Copyright (c) 2008-2009, Vyacheslav Patkov.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+ 1. Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+ 2. Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.