@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/native/PointerChainEngine.js

@@ -0,0 +1,319 @@
+import { randomUUID } from 'node:crypto';
+import { POINTER_CHAIN_MAX_DEPTH, POINTER_CHAIN_MAX_OFFSET, POINTER_CHAIN_MAX_RESULTS, POINTER_CHAIN_SCAN_CHUNK_SIZE, } from '../constants.js';
+import { createPlatformProvider } from './platform/factory.js';
+import { nativeMemoryManager } from './NativeMemoryManager.impl.js';
+import { formatAddress, parseAddress } from './formatAddress.js';
+export class PointerChainEngine {
+    _provider = null;
+    get provider() {
+        if (!this._provider) {
+            this._provider = createPlatformProvider();
+        }
+        return this._provider;
+    }
+    async scan(pid, targetAddress, options) {
+        const start = performance.now();
+        const maxDepth = Math.min(options?.maxDepth ?? 4, POINTER_CHAIN_MAX_DEPTH);
+        const maxOffset = options?.maxOffset ?? POINTER_CHAIN_MAX_OFFSET;
+        const maxResults = options?.maxResults ?? POINTER_CHAIN_MAX_RESULTS;
+        const alignment = options?.alignment ?? 8;
+        const staticOnly = options?.staticOnly ?? false;
+        const targetAddr = parseAddress(targetAddress);
+        const handle = this.provider.openProcess(pid, false);
+        try {
+            const modules = await this.getModuleMap(pid);
+            const levelResults = [];
+            let currentTargets = new Set([targetAddr]);
+            for (let depth = 0; depth < maxDepth; depth++) {
+                if (currentTargets.size === 0)
+                    break;
+                const matches = this.scanLevel(handle, currentTargets, maxOffset, alignment, options?.modules ? { modules: options.modules } : undefined);
+                if (matches.length === 0)
+                    break;
+                levelResults.push(matches);
+                currentTargets = new Set();
+                for (const m of matches) {
+                    currentTargets.add(m.pointerAddress);
+                    if (currentTargets.size > 50_000)
+                        break;
+                }
+            }
+            const chains = this.buildChains(levelResults, targetAddr, modules, maxResults, staticOnly);
+            const elapsed = `${(performance.now() - start).toFixed(1)}ms`;
+            return {
+                pid,
+                targetAddress: formatAddress(targetAddr),
+                chains,
+                totalFound: chains.length,
+                maxDepth,
+                elapsed,
+            };
+        }
+        finally {
+            this.provider.closeProcess(handle);
+        }
+    }
+    async validateChain(pid, chain) {
+        const handle = this.provider.openProcess(pid, false);
+        try {
+            let currentAddr = parseAddress(chain.baseAddress);
+            for (let i = 0; i < chain.links.length; i++) {
+                const link = chain.links[i];
+                let ptrValue;
+                try {
+                    const buf = this.provider.readMemory(handle, currentAddr, 8).data;
+                    ptrValue = buf.readBigUInt64LE(0);
+                }
+                catch {
+                    return {
+                        chainId: chain.id,
+                        isValid: false,
+                        resolvedAddress: null,
+                        expectedAddress: chain.targetAddress,
+                        brokenAt: i,
+                    };
+                }
+                currentAddr = ptrValue + BigInt(link.offset);
+            }
+            const resolvedStr = formatAddress(currentAddr);
+            const expectedAddr = parseAddress(chain.targetAddress);
+            const isValid = currentAddr === expectedAddr;
+            return {
+                chainId: chain.id,
+                isValid,
+                resolvedAddress: resolvedStr,
+                expectedAddress: chain.targetAddress,
+                brokenAt: isValid ? undefined : chain.links.length - 1,
+            };
+        }
+        finally {
+            this.provider.closeProcess(handle);
+        }
+    }
+    async validateChains(pid, chains) {
+        const results = [];
+        for (const chain of chains) {
+            results.push(await this.validateChain(pid, chain));
+        }
+        return results;
+    }
+    async resolveChain(pid, chain) {
+        const handle = this.provider.openProcess(pid, false);
+        try {
+            let currentAddr = parseAddress(chain.baseAddress);
+            for (const link of chain.links) {
+                let ptrValue;
+                try {
+                    const buf = this.provider.readMemory(handle, currentAddr, 8).data;
+                    ptrValue = buf.readBigUInt64LE(0);
+                }
+                catch {
+                    return null;
+                }
+                currentAddr = ptrValue + BigInt(link.offset);
+            }
+            return formatAddress(currentAddr);
+        }
+        finally {
+            this.provider.closeProcess(handle);
+        }
+    }
+    exportChains(chains) {
+        return JSON.stringify(chains, null, 2);
+    }
+    importChains(data) {
+        const parsed = JSON.parse(data);
+        if (!Array.isArray(parsed))
+            throw new Error('Invalid chain data: expected array');
+        return parsed;
+    }
+    async getModuleMap(pid) {
+        const modules = new Map();
+        try {
+            const result = await nativeMemoryManager.enumerateModules(pid);
+            if (result.success && result.modules) {
+                for (const mod of result.modules) {
+                    const base = parseAddress(mod.baseAddress);
+                    modules.set(mod.name.toLowerCase(), { name: mod.name, base, size: mod.size });
+                }
+            }
+        }
+        catch {
+        }
+        return modules;
+    }
+    resolveToModule(address, moduleMap) {
+        for (const entry of moduleMap.values()) {
+            if (address >= entry.base && address < entry.base + BigInt(entry.size)) {
+                return {
+                    module: entry.name,
+                    offset: Number(address - entry.base),
+                };
+            }
+        }
+        return null;
+    }
+    scanLevel(handle, targetAddresses, maxOffset, alignment, _filter) {
+        const matches = [];
+        const chunkSize = POINTER_CHAIN_SCAN_CHUNK_SIZE;
+        const targets = Array.from(targetAddresses).sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+        if (targets.length === 0)
+            return matches;
+        const maxOffsetBig = BigInt(maxOffset);
+        const globalMin = targets[0] - maxOffsetBig;
+        const globalMax = targets[targets.length - 1] + maxOffsetBig;
+        let address = 0n;
+        const maxAddress = BigInt('0x7FFFFFFF0000');
+        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) {
+                const regionBase = regionInfo.baseAddress;
+                for (let offset = 0; offset < regionSize && matches.length < 100_000; 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 += alignment) {
+                        const ptrValue = chunk.readBigUInt64LE(i);
+                        if (ptrValue < globalMin || ptrValue > globalMax)
+                            continue;
+                        const searchMin = ptrValue - maxOffsetBig;
+                        const searchMax = ptrValue + maxOffsetBig;
+                        let lo = 0;
+                        let hi = targets.length;
+                        while (lo < hi) {
+                            const mid = (lo + hi) >>> 1;
+                            if (targets[mid] < searchMin)
+                                lo = mid + 1;
+                            else
+                                hi = mid;
+                        }
+                        for (let t = lo; t < targets.length && targets[t] <= searchMax; t++) {
+                            const target = targets[t];
+                            const diff = ptrValue > target
+                                ? Number(ptrValue - target)
+                                : Number(target - ptrValue);
+                            if (diff <= maxOffset) {
+                                const pointerAddr = chunkAddr + BigInt(i);
+                                const matchOffset = Number(target - ptrValue);
+                                matches.push({
+                                    pointerAddress: pointerAddr,
+                                    pointsTo: ptrValue,
+                                    offset: matchOffset,
+                                });
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            address = regionInfo.baseAddress + BigInt(regionInfo.size);
+        }
+        return matches;
+    }
+    buildChains(levelResults, targetAddr, modules, maxResults, staticOnly) {
+        if (levelResults.length === 0)
+            return [];
+        const chains = [];
+        const targetAddrStr = formatAddress(targetAddr);
+        for (let depth = 0; depth < levelResults.length && chains.length < maxResults; depth++) {
+            const level = levelResults[depth];
+            if (depth === 0) {
+                for (const match of level) {
+                    if (chains.length >= maxResults)
+                        break;
+                    const baseAddrStr = formatAddress(match.pointerAddress);
+                    const modInfo = this.resolveToModule(match.pointerAddress, modules);
+                    const isStatic = modInfo !== null;
+                    if (staticOnly && !isStatic)
+                        continue;
+                    const link = {
+                        address: baseAddrStr,
+                        module: modInfo?.module,
+                        moduleOffset: modInfo?.offset,
+                        offset: match.offset,
+                    };
+                    chains.push({
+                        id: randomUUID(),
+                        links: [link],
+                        targetAddress: targetAddrStr,
+                        baseAddress: baseAddrStr,
+                        isStatic,
+                        depth: 1,
+                        lastValidated: Date.now(),
+                        isValid: true,
+                    });
+                }
+            }
+            else {
+                const prevLevel = levelResults[depth - 1];
+                const prevByAddr = new Map();
+                for (const pm of prevLevel) {
+                    prevByAddr.set(pm.pointerAddress, pm);
+                }
+                const maxOff = BigInt(POINTER_CHAIN_MAX_OFFSET);
+                for (const match of level) {
+                    if (chains.length >= maxResults)
+                        break;
+                    let prevMatch;
+                    prevMatch = prevByAddr.get(match.pointsTo);
+                    if (!prevMatch) {
+                        for (const pm of prevLevel) {
+                            const diff = match.pointsTo > pm.pointerAddress
+                                ? match.pointsTo - pm.pointerAddress
+                                : pm.pointerAddress - match.pointsTo;
+                            if (diff <= maxOff) {
+                                prevMatch = pm;
+                                break;
+                            }
+                        }
+                    }
+                    if (!prevMatch)
+                        continue;
+                    const baseAddrStr = formatAddress(match.pointerAddress);
+                    const modInfo = this.resolveToModule(match.pointerAddress, modules);
+                    const isStatic = modInfo !== null;
+                    if (staticOnly && !isStatic)
+                        continue;
+                    const links = [
+                        {
+                            address: baseAddrStr,
+                            module: modInfo?.module,
+                            moduleOffset: modInfo?.offset,
+                            offset: Number(prevMatch.pointerAddress - match.pointsTo),
+                        },
+                        {
+                            address: formatAddress(prevMatch.pointerAddress),
+                            offset: prevMatch.offset,
+                        },
+                    ];
+                    chains.push({
+                        id: randomUUID(),
+                        links,
+                        targetAddress: targetAddrStr,
+                        baseAddress: baseAddrStr,
+                        isStatic,
+                        depth: links.length,
+                        lastValidated: Date.now(),
+                        isValid: true,
+                    });
+                }
+            }
+        }
+        chains.sort((a, b) => {
+            if (a.isStatic !== b.isStatic)
+                return a.isStatic ? -1 : 1;
+            return a.depth - b.depth;
+        });
+        return chains.slice(0, maxResults);
+    }
+}
+export const pointerChainEngine = new PointerChainEngine();

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

@@ -0,0 +1,39 @@
+export interface PointerChainLink {
+    address: string;
+    module?: string;
+    moduleOffset?: number;
+    offset: number;
+}
+export interface PointerChain {
+    id: string;
+    links: PointerChainLink[];
+    targetAddress: string;
+    baseAddress: string;
+    isStatic: boolean;
+    depth: number;
+    lastValidated: number;
+    isValid: boolean;
+}
+export interface PointerScanOptions {
+    maxDepth?: number;
+    maxOffset?: number;
+    staticOnly?: boolean;
+    maxResults?: number;
+    modules?: string[];
+    alignment?: number;
+}
+export interface PointerScanResult {
+    pid: number;
+    targetAddress: string;
+    chains: PointerChain[];
+    totalFound: number;
+    maxDepth: number;
+    elapsed: string;
+}
+export interface ChainValidationResult {
+    chainId: string;
+    isValid: boolean;
+    resolvedAddress: string | null;
+    expectedAddress: string;
+    brokenAt?: number;
+}

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

@@ -0,0 +1,5 @@
+import type { ScanCompareMode, ScanValueType } from './NativeMemoryManager.types.js';
+export declare function getValueSize(type: ScanValueType): number;
+export declare function getDefaultAlignment(type: ScanValueType): number;
+export declare function readTypedValue(buf: Buffer, type: ScanValueType): number | bigint;
+export declare function compareScanValues(current: Buffer, previous: Buffer | null, target: Buffer | null, target2: Buffer | null, mode: ScanCompareMode, valueType: ScanValueType): boolean;

package/dist/src/native/ScanComparators.js

@@ -0,0 +1,162 @@
+const FLOAT_EPSILON = 1e-6;
+const DOUBLE_EPSILON = 1e-12;
+export function getValueSize(type) {
+    switch (type) {
+        case 'byte':
+        case 'int8':
+            return 1;
+        case 'int16':
+        case 'uint16':
+            return 2;
+        case 'int32':
+        case 'uint32':
+        case 'float':
+            return 4;
+        case 'int64':
+        case 'uint64':
+        case 'double':
+        case 'pointer':
+            return 8;
+        case 'hex':
+        case 'string':
+            return 0;
+        default:
+            return 4;
+    }
+}
+export function getDefaultAlignment(type) {
+    switch (type) {
+        case 'byte':
+        case 'int8':
+            return 1;
+        case 'int16':
+        case 'uint16':
+            return 2;
+        case 'int32':
+        case 'uint32':
+        case 'float':
+            return 4;
+        case 'int64':
+        case 'uint64':
+        case 'double':
+        case 'pointer':
+            return 8;
+        default:
+            return 1;
+    }
+}
+export function readTypedValue(buf, type) {
+    switch (type) {
+        case 'byte':
+            return buf.readUInt8(0);
+        case 'int8':
+            return buf.readInt8(0);
+        case 'int16':
+            return buf.readInt16LE(0);
+        case 'uint16':
+            return buf.readUInt16LE(0);
+        case 'int32':
+            return buf.readInt32LE(0);
+        case 'uint32':
+            return buf.readUInt32LE(0);
+        case 'int64':
+            return buf.readBigInt64LE(0);
+        case 'uint64':
+        case 'pointer':
+            return buf.readBigUInt64LE(0);
+        case 'float':
+            return buf.readFloatLE(0);
+        case 'double':
+            return buf.readDoubleLE(0);
+        default:
+            return buf.readInt32LE(0);
+    }
+}
+function approxEqual(a, b, type) {
+    if (typeof a === 'bigint' && typeof b === 'bigint') {
+        return a === b;
+    }
+    const na = Number(a);
+    const nb = Number(b);
+    if (type === 'float') {
+        return Math.abs(na - nb) < FLOAT_EPSILON;
+    }
+    if (type === 'double') {
+        return Math.abs(na - nb) < DOUBLE_EPSILON;
+    }
+    return na === nb;
+}
+function compareValues(a, b) {
+    if (typeof a === 'bigint' && typeof b === 'bigint') {
+        if (a < b)
+            return -1;
+        if (a > b)
+            return 1;
+        return 0;
+    }
+    return Number(a) - Number(b);
+}
+export function compareScanValues(current, previous, target, target2, mode, valueType) {
+    const cur = readTypedValue(current, valueType);
+    switch (mode) {
+        case 'exact': {
+            if (!target)
+                return false;
+            const tgt = readTypedValue(target, valueType);
+            return approxEqual(cur, tgt, valueType);
+        }
+        case 'unknown_initial':
+            return true;
+        case 'changed': {
+            if (!previous)
+                return false;
+            const prev = readTypedValue(previous, valueType);
+            return !approxEqual(cur, prev, valueType);
+        }
+        case 'unchanged': {
+            if (!previous)
+                return true;
+            const prev = readTypedValue(previous, valueType);
+            return approxEqual(cur, prev, valueType);
+        }
+        case 'increased': {
+            if (!previous)
+                return false;
+            const prev = readTypedValue(previous, valueType);
+            return compareValues(cur, prev) > 0;
+        }
+        case 'decreased': {
+            if (!previous)
+                return false;
+            const prev = readTypedValue(previous, valueType);
+            return compareValues(cur, prev) < 0;
+        }
+        case 'greater_than': {
+            if (!target)
+                return false;
+            const tgt = readTypedValue(target, valueType);
+            return compareValues(cur, tgt) > 0;
+        }
+        case 'less_than': {
+            if (!target)
+                return false;
+            const tgt = readTypedValue(target, valueType);
+            return compareValues(cur, tgt) < 0;
+        }
+        case 'between': {
+            if (!target || !target2)
+                return false;
+            const lo = readTypedValue(target, valueType);
+            const hi = readTypedValue(target2, valueType);
+            return compareValues(cur, lo) >= 0 && compareValues(cur, hi) <= 0;
+        }
+        case 'not_equal': {
+            if (!target)
+                return false;
+            const tgt = readTypedValue(target, valueType);
+            return !approxEqual(cur, tgt, valueType);
+        }
+        default:
+            return false;
+    }
+}

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

@@ -0,0 +1,16 @@
+import type { SpeedhackState } from './Speedhack.types.js';
+export declare class Speedhack {
+    private states;
+    apply(pid: number, speed: number): Promise<{
+        success: boolean;
+        hookedApis: string[];
+    }>;
+    setSpeed(pid: number, speed: number): Promise<boolean>;
+    getSpeed(pid: number): number | null;
+    remove(pid: number): Promise<boolean>;
+    isActive(pid: number): boolean;
+    listActive(): SpeedhackState[];
+    private hookTimeFunction;
+    private buildAbsoluteJump;
+}
+export declare const speedhack: Speedhack;