@jshookmcp/jshook 0.1.5 → 0.1.6

package/dist/server/domains/process/handlers.impl.core.runtime.memory.js

@@ -14,14 +14,67 @@ function normalizePatternType(value) {
     }
     return 'hex';
 }
+function getOptionalPid(value) {
+    const pid = Number(value);
+    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+function getOptionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function getOptionalPositiveNumber(value) {
+    const size = Number(value);
+    return Number.isFinite(size) && size > 0 ? size : undefined;
+}
+function getWriteSize(data, encoding) {
+    if (encoding === 'hex') {
+        const normalized = data.replace(/\s+/g, '');
+        return Math.ceil(normalized.length / 2);
+    }
+    return Buffer.from(data, 'base64').length;
+}
 export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
+    async safeBuildMemoryDiagnostics(input) {
+        try {
+            return await this.buildMemoryDiagnostics(input);
+        }
+        catch (diagnosticError) {
+            logger.warn('Memory diagnostics generation failed:', diagnosticError);
+            return undefined;
+        }
+    }
+    recordMemoryAudit(entry) {
+        try {
+            this.auditTrail.record(entry);
+        }
+        catch (auditError) {
+            logger.warn('Memory audit trail recording failed:', auditError);
+        }
+    }
     async handleMemoryRead(args) {
+        const startedAt = Date.now();
         try {
             const pid = validatePid(args.pid);
             const address = requireString(args.address, 'address');
             const size = requirePositiveNumber(args.size, 'size');
             const availability = await this.memoryManager.checkAvailability();
             if (!availability.available) {
+                const errorMessage = availability.reason ?? 'Memory operations not available';
+                const diagnostics = await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_read',
+                    error: errorMessage,
+                });
+                this.recordMemoryAudit({
+                    operation: 'memory_read',
+                    pid,
+                    address,
+                    size,
+                    result: 'failure',
+                    error: errorMessage,
+                    durationMs: Date.now() - startedAt,
+                });
                 return {
                     content: [
                         {
@@ -34,38 +87,82 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
                                 requestedAddress: address,
                                 requestedSize: size,
                                 pid,
+                                diagnostics,
                             }, null, 2),
                         },
                     ],
                 };
             }
             const result = await this.memoryManager.readMemory(pid, address, size);
+            const diagnostics = !result.success
+                ? await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_read',
+                    error: result.error,
+                })
+                : undefined;
+            this.recordMemoryAudit({
+                operation: 'memory_read',
+                pid,
+                address,
+                size,
+                result: result.success ? 'success' : 'failure',
+                error: result.error,
+                durationMs: Date.now() - startedAt,
+            });
+            const payload = {
+                success: result.success,
+                data: result.data,
+                error: result.error,
+                pid,
+                address,
+                size,
+                platform: this.platform,
+            };
+            if (!result.success) {
+                payload.diagnostics = diagnostics;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({
-                            success: result.success,
-                            data: result.data,
-                            error: result.error,
-                            pid,
-                            address,
-                            size,
-                            platform: this.platform,
-                        }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             logger.error('Memory read failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const pid = getOptionalPid(args.pid);
+            const address = getOptionalString(args.address);
+            const size = getOptionalPositiveNumber(args.size);
+            const diagnostics = await this.safeBuildMemoryDiagnostics({
+                pid,
+                address,
+                size,
+                operation: 'memory_read',
+                error: errorMessage,
+            });
+            this.recordMemoryAudit({
+                operation: 'memory_read',
+                pid: pid ?? null,
+                address: address ?? null,
+                size: size ?? null,
+                result: 'failure',
+                error: errorMessage,
+                durationMs: Date.now() - startedAt,
+            });
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: errorMessage,
+                            diagnostics,
                         }, null, 2),
                     },
                 ],
@@ -73,13 +170,32 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
         }
     }
     async handleMemoryWrite(args) {
+        const startedAt = Date.now();
         try {
             const pid = validatePid(args.pid);
             const address = requireString(args.address, 'address');
             const data = requireString(args.data, 'data');
             const encoding = args.encoding || 'hex';
+            const size = getWriteSize(data, encoding);
             const availability = await this.memoryManager.checkAvailability();
             if (!availability.available) {
+                const errorMessage = availability.reason ?? 'Memory operations not available';
+                const diagnostics = await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_write',
+                    error: errorMessage,
+                });
+                this.recordMemoryAudit({
+                    operation: 'memory_write',
+                    pid,
+                    address,
+                    size,
+                    result: 'failure',
+                    error: errorMessage,
+                    durationMs: Date.now() - startedAt,
+                });
                 return {
                     content: [
                         {
@@ -93,39 +209,85 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
                                 dataLength: data != null ? data.length : 0,
                                 encoding,
                                 pid,
+                                diagnostics,
                             }, null, 2),
                         },
                     ],
                 };
             }
             const result = await this.memoryManager.writeMemory(pid, address, data, encoding);
+            const diagnostics = !result.success
+                ? await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    address,
+                    size,
+                    operation: 'memory_write',
+                    error: result.error,
+                })
+                : undefined;
+            this.recordMemoryAudit({
+                operation: 'memory_write',
+                pid,
+                address,
+                size,
+                result: result.success ? 'success' : 'failure',
+                error: result.error,
+                durationMs: Date.now() - startedAt,
+            });
+            const payload = {
+                success: result.success,
+                bytesWritten: result.bytesWritten,
+                error: result.error,
+                pid,
+                address,
+                dataLength: data.length,
+                encoding,
+                platform: this.platform,
+            };
+            if (!result.success) {
+                payload.diagnostics = diagnostics;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({
-                            success: result.success,
-                            bytesWritten: result.bytesWritten,
-                            error: result.error,
-                            pid,
-                            address,
-                            dataLength: data.length,
-                            encoding,
-                            platform: this.platform,
-                        }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             logger.error('Memory write failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const pid = getOptionalPid(args.pid);
+            const address = getOptionalString(args.address);
+            const data = getOptionalString(args.data);
+            const encoding = args.encoding || 'hex';
+            const size = data ? getWriteSize(data, encoding) : undefined;
+            const diagnostics = await this.safeBuildMemoryDiagnostics({
+                pid,
+                address,
+                size,
+                operation: 'memory_write',
+                error: errorMessage,
+            });
+            this.recordMemoryAudit({
+                operation: 'memory_write',
+                pid: pid ?? null,
+                address: address ?? null,
+                size: size ?? null,
+                result: 'failure',
+                error: errorMessage,
+                durationMs: Date.now() - startedAt,
+            });
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: errorMessage,
+                            diagnostics,
                         }, null, 2),
                     },
                 ],
@@ -133,12 +295,28 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
         }
     }
     async handleMemoryScan(args) {
+        const startedAt = Date.now();
         try {
             const pid = validatePid(args.pid);
             const pattern = requireString(args.pattern, 'pattern');
             const patternType = normalizePatternType(args.patternType);
             const availability = await this.memoryManager.checkAvailability();
             if (!availability.available) {
+                const errorMessage = availability.reason ?? 'Memory operations not available';
+                const diagnostics = await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    operation: 'memory_scan',
+                    error: errorMessage,
+                });
+                this.recordMemoryAudit({
+                    operation: 'memory_scan',
+                    pid,
+                    address: null,
+                    size: null,
+                    result: 'failure',
+                    error: errorMessage,
+                    durationMs: Date.now() - startedAt,
+                });
                 return {
                     content: [
                         {
@@ -151,43 +329,116 @@ export class ProcessToolHandlersMemory extends ProcessToolHandlersBase {
                                 requestedPattern: pattern,
                                 patternType,
                                 pid,
+                                diagnostics,
                             }, null, 2),
                         },
                     ],
                 };
             }
             const result = await this.memoryManager.scanMemory(pid, pattern, patternType);
+            const diagnostics = !result.success
+                ? await this.safeBuildMemoryDiagnostics({
+                    pid,
+                    operation: 'memory_scan',
+                    error: result.error,
+                })
+                : undefined;
+            this.recordMemoryAudit({
+                operation: 'memory_scan',
+                pid,
+                address: null,
+                size: null,
+                result: result.success ? 'success' : 'failure',
+                error: result.error,
+                durationMs: Date.now() - startedAt,
+            });
+            const payload = {
+                success: result.success,
+                addresses: result.addresses,
+                error: result.error,
+                pid,
+                pattern,
+                patternType,
+                platform: this.platform,
+            };
+            if (!result.success) {
+                payload.diagnostics = diagnostics;
+            }
             return {
                 content: [
                     {
                         type: 'text',
-                        text: JSON.stringify({
-                            success: result.success,
-                            addresses: result.addresses,
-                            error: result.error,
-                            pid,
-                            pattern,
-                            patternType,
-                            platform: this.platform,
-                        }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         }
         catch (error) {
             logger.error('Memory scan failed:', error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const pid = getOptionalPid(args.pid);
+            const diagnostics = await this.safeBuildMemoryDiagnostics({
+                pid,
+                operation: 'memory_scan',
+                error: errorMessage,
+            });
+            this.recordMemoryAudit({
+                operation: 'memory_scan',
+                pid: pid ?? null,
+                address: null,
+                size: null,
+                result: 'failure',
+                error: errorMessage,
+                durationMs: Date.now() - startedAt,
+            });
             return {
                 content: [
                     {
                         type: 'text',
                         text: JSON.stringify({
                             success: false,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: errorMessage,
+                            diagnostics,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+    }
+    async handleMemoryAuditExport(args) {
+        try {
+            const exportedJson = this.auditTrail.exportJson();
+            const entries = JSON.parse(exportedJson);
+            const clear = args.clear === true;
+            const count = this.auditTrail.size();
+            if (clear) {
+                this.auditTrail.clear();
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            count,
+                            cleared: clear,
+                            entries,
                         }, null, 2),
                     },
                 ],
             };
         }
+        catch (error) {
+            logger.error('Memory audit export failed:', error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ success: false, error: error instanceof Error ? error.message : String(error) }, null, 2),
+                    },
+                ],
+            };
+        }
     }
     async handleMemoryCheckProtection(args) {
         try {

package/dist/server/domains/process/manifest.js

@@ -36,6 +36,7 @@ const manifest = {
         { tool: t('memory_batch_write'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryBatchWrite(a)) },
         { tool: t('memory_dump_region'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryDumpRegion(a)) },
         { tool: t('memory_list_regions'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryListRegions(a)) },
+        { tool: t('memory_audit_export'), domain: DOMAIN, bind: b((h, a) => h.handleMemoryAuditExport(a)) },
         { tool: t('inject_dll'), domain: DOMAIN, bind: b((h, a) => h.handleInjectDll(a)) },
         { tool: t('module_inject_dll'), domain: DOMAIN, bind: b((h, a) => h.handleInjectDll(a)) },
         { tool: t('inject_shellcode'), domain: DOMAIN, bind: b((h, a) => h.handleInjectShellcode(a)) },

package/dist/server/domains/transform/handlers.impl.transform-base.js

@@ -28,98 +28,98 @@ export const CRYPTO_KEYWORDS = [
     'aes',
     'rsa',
 ];
-const CRYPTO_TEST_WORKER_SCRIPT = `
-const __bootstrap = async () => {
-  const [workerThreads, vm, perfHooks] = await Promise.all([
-    import('node:worker_threads'),
-    import('node:vm'),
-    import('node:perf_hooks'),
-  ]);
-
-  const parentPort = workerThreads.parentPort;
-  const performance = perfHooks.performance;
-
-  if (!parentPort) {
-    throw new Error('worker parentPort is unavailable');
-  }
-
-  function normalizeOutput(value) {
-    if (value === undefined) return '__undefined__';
-    if (value === null) return 'null';
-    if (typeof value === 'string') return value;
-    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
-    try { return JSON.stringify(value); } catch { return String(value); }
-  }
-
-  parentPort.on('message', async (msg) => {
-    const { jobId, payload } = msg;
-    try {
-      const { code, functionName, testInputs } = payload;
-      const sandbox = {
-        console: { log() {}, warn() {}, error() {} },
-        Buffer,
-        TextEncoder,
-        TextDecoder,
-        atob: (v) => Buffer.from(String(v), 'base64').toString('binary'),
-        btoa: (v) => Buffer.from(String(v), 'binary').toString('base64'),
-      };
-      sandbox.globalThis = sandbox;
-      const context = vm.createContext(sandbox);
-
-      const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(functionName);
-      const bindCode = isValidIdentifier
-        ? "\\n;globalThis.__targetFn = (typeof " + functionName + " !== 'undefined' ? " + functionName + " : globalThis[" + JSON.stringify(functionName) + "]);"
-        : "\\n;globalThis.__targetFn = globalThis[" + JSON.stringify(functionName) + "];";
-
-      const script = new vm.Script(code + bindCode, { timeout: 5000 });
-      script.runInContext(context, { timeout: 5000 });
-
-      const targetFn = context.__targetFn;
-      if (typeof targetFn !== 'function') {
-        throw new Error("Function not found or not callable: " + functionName);
-      }
-
-      const rows = [];
-      for (const input of testInputs) {
-        const started = performance.now();
-        try {
-          const raw = targetFn(input);
-          const resolved = raw && typeof raw.then === 'function' ? await raw : raw;
-          rows.push({
-            input,
-            output: normalizeOutput(resolved),
-            duration: Number((performance.now() - started).toFixed(3)),
-          });
-        } catch (err) {
-          rows.push({
-            input,
-            output: '',
-            error: err && err.message ? err.message : String(err),
-            duration: Number((performance.now() - started).toFixed(3)),
-          });
-        }
-      }
-
-      parentPort.postMessage({ jobId, ok: true, result: { ok: true, results: rows } });
-    } catch (error) {
-      parentPort.postMessage({
-        jobId,
-        ok: true,
-        result: {
-          ok: false,
-          error: error && error.message ? error.message : String(error),
-          results: [],
-        },
-      });
-    }
-  });
-};
-
-__bootstrap().catch((error) => {
-  if (typeof console !== 'undefined' && typeof console.error === 'function') {
-    console.error('crypto harness worker bootstrap failed:', error && error.message ? error.message : String(error));
-  }
-});
+const CRYPTO_TEST_WORKER_SCRIPT = `
+const __bootstrap = async () => {
+  const [workerThreads, vm, perfHooks] = await Promise.all([
+    import('node:worker_threads'),
+    import('node:vm'),
+    import('node:perf_hooks'),
+  ]);
+
+  const parentPort = workerThreads.parentPort;
+  const performance = perfHooks.performance;
+
+  if (!parentPort) {
+    throw new Error('worker parentPort is unavailable');
+  }
+
+  function normalizeOutput(value) {
+    if (value === undefined) return '__undefined__';
+    if (value === null) return 'null';
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+    try { return JSON.stringify(value); } catch { return String(value); }
+  }
+
+  parentPort.on('message', async (msg) => {
+    const { jobId, payload } = msg;
+    try {
+      const { code, functionName, testInputs } = payload;
+      const sandbox = {
+        console: { log() {}, warn() {}, error() {} },
+        Buffer,
+        TextEncoder,
+        TextDecoder,
+        atob: (v) => Buffer.from(String(v), 'base64').toString('binary'),
+        btoa: (v) => Buffer.from(String(v), 'binary').toString('base64'),
+      };
+      sandbox.globalThis = sandbox;
+      const context = vm.createContext(sandbox);
+
+      const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(functionName);
+      const bindCode = isValidIdentifier
+        ? "\\n;globalThis.__targetFn = (typeof " + functionName + " !== 'undefined' ? " + functionName + " : globalThis[" + JSON.stringify(functionName) + "]);"
+        : "\\n;globalThis.__targetFn = globalThis[" + JSON.stringify(functionName) + "];";
+
+      const script = new vm.Script(code + bindCode, { timeout: 5000 });
+      script.runInContext(context, { timeout: 5000 });
+
+      const targetFn = context.__targetFn;
+      if (typeof targetFn !== 'function') {
+        throw new Error("Function not found or not callable: " + functionName);
+      }
+
+      const rows = [];
+      for (const input of testInputs) {
+        const started = performance.now();
+        try {
+          const raw = targetFn(input);
+          const resolved = raw && typeof raw.then === 'function' ? await raw : raw;
+          rows.push({
+            input,
+            output: normalizeOutput(resolved),
+            duration: Number((performance.now() - started).toFixed(3)),
+          });
+        } catch (err) {
+          rows.push({
+            input,
+            output: '',
+            error: err && err.message ? err.message : String(err),
+            duration: Number((performance.now() - started).toFixed(3)),
+          });
+        }
+      }
+
+      parentPort.postMessage({ jobId, ok: true, result: { ok: true, results: rows } });
+    } catch (error) {
+      parentPort.postMessage({
+        jobId,
+        ok: true,
+        result: {
+          ok: false,
+          error: error && error.message ? error.message : String(error),
+          results: [],
+        },
+      });
+    }
+  });
+};
+
+__bootstrap().catch((error) => {
+  if (typeof console !== 'undefined' && typeof console.error === 'function') {
+    console.error('crypto harness worker bootstrap failed:', error && error.message ? error.message : String(error));
+  }
+});
 `;
 export class TransformToolHandlersBase {
     collector;
@@ -333,16 +333,16 @@ export class TransformToolHandlersBase {
         return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
     }
     buildCryptoPolyfills() {
-        return `
-const __textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
-const __textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
-
-if (typeof globalThis.atob === 'undefined') {
-  globalThis.atob = (value) => Buffer.from(String(value), 'base64').toString('binary');
-}
-if (typeof globalThis.btoa === 'undefined') {
-  globalThis.btoa = (value) => Buffer.from(String(value), 'binary').toString('base64');
-}
+        return `
+const __textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const __textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
+
+if (typeof globalThis.atob === 'undefined') {
+  globalThis.atob = (value) => Buffer.from(String(value), 'base64').toString('binary');
+}
+if (typeof globalThis.btoa === 'undefined') {
+  globalThis.btoa = (value) => Buffer.from(String(value), 'binary').toString('base64');
+}
 `.trim();
     }
     async runCryptoHarness(code, functionName, testInputs) {