Jshookmcp

Capture and filter Android logcat output in-process without shell grep pipelines.

Return structured Android package metadata: launcher, uid, versions, permissions, components, and native library dirs.

Manage ADB forward/reverse port mappings for device-host bridge workflows.

Read and parse /proc/PID/maps from a device, resolving PID from packageName when needed.

Pull native shared libraries (.so) for an installed app from a device.

Probe root indicators such as su, Magisk, test-keys, SELinux, and shell uid.

Record a short MP4 screen capture through adb shell screenrecord and pull it locally.

Capture a PNG screenshot through adb exec-out screencap -p.

Execute an ADB shell command on a specific device.

Capture Android UI hierarchy via uiautomator dump. Runs uiautomator dump on-device, pulls the XML, and returns parsed UI tree. Useful for UI automation verification, layout inspection, and accessibility tree analysis.

Uninstall a package from a device, optionally keeping app data.

Attach to a WebView via ADB; returns WebSocket debugger URL for CDP.

List debuggable WebView targets connected via ADB.

Manage AI hooks. Actions: inject (inject code into page), get_data (retrieve captured hook data), list (all active hooks), clear (remove hook data by id or all), toggle (enable/disable a hook), export (export data as JSON/CSV).

Use LLM to suggest exploit primitives and attack chains for a given vulnerability. Returns theoretical exploitation steps, references, and required conditions. IMPORTANT: Does NOT generate executable payloads or malicious code.

Match AST nodes by type and optional property filter.

Trace data flow through JavaScript: identify sources (user input, network, storage), sinks (XSS, eval, SQL injection, command execution), sanitizer pass-through points, and tainted variable propagation paths. Useful for finding injection vulnerabilities.

Decode literal string-array access back to strings.

Flatten switch-dispatch control flow back to straight-line code.

Static security scan of JavaScript: detect hardcoded secrets (API keys, tokens), dangerous functions (eval, Function constructor), XSS sinks (innerHTML, document.write), SQL injection patterns, and weak crypto (Math.random). Returns structured risks with severity and recommendations.

Create or inspect a managed Android runtime dump session from Frida/ADB dump artifacts, DEX files, and /proc/PID/maps snapshots.

Bypass one or more anti-debug protection types. Specify types to apply; omit or use ["all"] to apply all bypasses. Types: all, debugger_statement, timing, stack_trace, console_detect.

Detect anti-debug protections in current page with bypass recommendations.

Batch-probe API endpoints in browser context with auto token injection and HTML skip.

Build a cohesive APK/DEX intake evidence packet: ZIP entries, manifest summary, DEX headers, native libraries, generic surface hints, caller-supplied hint matches, and next actions.

Extract AndroidManifest.xml from an APK for quick inspection.

Return a compact structured AndroidManifest summary: package, launcher activity, app class, SDKs, permissions, components, providers, and SDK/surface hints.

List packaged native shared libraries (.so) inside an APK.

Detect Android APK packers by matching `lib/<abi>/lib*.so` filenames against user-supplied customSignatures (ReDoS-guarded regex compilation). The framework ships no built-in signature table — callers provide their own. **Does not unpack, execute, or otherwise interact with packed code.**

List the in-process signature table used by `apk_packer_detect`. Empty by default; reflects caller-managed state at request time. Optionally filter by case-insensitive category substring.

Sign an APK with apksigner using a caller-supplied keystore. Pairs with apktool_build for a full repack-and-sign workflow.

Read-only parser for the APK Signing Block (schemes v2/v3/v3.1/v4) plus key-rotation lineage detection and residue-block / dex-prefix / magic-offset anomaly flags. Never mutates the APK.

One-shot APK triage: ZIP metadata, manifest summary, native libs, asset hints, likely packers/protectors, and recommended next steps.

Rebuild an APK from a decoded apktool source directory (closes the patch-and-repack loop with apk_sign).

Decode an APK using apktool to inspect resources, manifest, and smali output.

Record a persisted insight for the current session.

Build a deterministic ARP payload for Ethernet/IPv4.

Scan every .js file inside an ASAR archive for obfuscation indicators (string-array arrays, webpack bundles, control-flow flattening, dynamic code, minification) and classify each file. Flagged files are optionally extracted to a directory for downstream deobfuscation.

Extract and list files from an Electron ASAR package.

Pack a directory tree into an Electron ASAR archive (inverse of asar_extract). Walks the input directory and writes a valid .asar (4xUInt32LE pickle prefix + JSON header + data segment) that parseAsarBuffer and Electron accept. Closes the unpack → patch → repack → retest loop without leaving jshookmcp.

Grep text patterns inside ASAR archive contents without extraction.

Apply transforms to input code or a live page scriptId.

Pretty-print minified or obfuscated JavaScript: re-emit the parsed source with standard 2-space indentation and normalised spacing. Formatting only — the AST is preserved, so program semantics do not change. Unparseable input is returned unchanged.

Create and store an in-memory transform chain.

Preview lightweight AST-like transforms (string/regex based) and return before/after diff.

Decode binary payloads, transport encodings, and compressed blobs into hex, utf8, or json output.

Detect binary payload format and encoding signals.

Encode utf8/hex/json input into transport encodings or compressed base64 blobs.

Compute entropy and byte frequency for a payload.

Compute Shannon entropy across fixed-size chunks of a binary file to locate encrypted / packed / compressed sections. High-entropy regions (>=7.0 bits/byte) are likely encrypted or compressed; low-entropy (<4.0) are typically code or text. Pure-compute, no external tools.

Report binary instrumentation backend availability.

Scan a binary for hardcoded key candidates (raw high-entropy, Base64, hex). Read-only — no decryption.

Send a command to a local Binary Ninja analysis bridge.

Extract printable ASCII/UTF-16LE strings from a binary file with regex filtering.

Blackbox scripts (skip during debugging) Usage: - Skip third-party library c...

Blackbox all common libraries (one-click) Includes: - jquery, react, vue, an...

List script blackbox patterns.

Manage breakpoints: code (line/script), function-name, XHR (URL pattern), event listener, event category, and exception breakpoints. Actions: - set: Create a breakpoint. Type determines required params. - remove: Remove a breakpoint by ID. - list: List active breakpoints of the given type. Types & params: - code: lineNumber (required), scriptId?, columnNumber?, condition?, logMessage? (logpoint: logs without pausing) - function: functionName (required for set) — resolves via globalThis lookup and breaks whenever that function is called - xhr: urlPattern (required for set) - event: eventName …

Browse the online extension registry for installable plugins and workflows.

Connect to a running browser.

Attach to a CDP target by targetId.

Atomic primitive: fetch browser runtime metrics via CDP Performance.getMetrics() on the active page. Returns raw CDP-level counters (LayoutCount, RecalcStyleCount, ScriptDuration, TaskDuration, JSHeapUsedSize, Nodes, Documents, Frames, ...) — not Web Vitals (use browser_get_metrics for those).

Close the browser and release all resources.

Start recording browser actions as replayable steps.

Stop recording browser actions and return cleaned replay steps.

Atomic primitive: begin CDP CPU profiling on the active page (Profiler.start). Pair with browser_cpu_profile_stop to save the .cpuprofile. Set samplingInterval to 30-100 µs for high-resolution profiles (default 1000 µs / 1 ms).

Atomic primitive: stop CDP CPU profiling, rank hot functions by sample count, and persist the raw profile to artifacts/profiles/ (or a custom path). The hot function list is derived from the samples array — modern Chrome profiles do not populate hitCount. Fails clearly if profiling was never started.

Detach the current CDP target session.

Evaluate JS in the attached CDP target.

Enumerate locally-installed fonts for fingerprint analysis. Primary path is the Local Font Access API (queryLocalFonts, Chromium 103+); when unavailable or denied, falls back to a small document.fonts.check probe set. Returns the detected font set, a stable hash for comparison, and optionally spoofs the font fingerprint.

Atomic primitive: collect page performance metrics via PerformanceMonitor — Web Vitals (FCP, LCP, CLS, TTFB), DOM timing (domContentLoaded, loadComplete), engine-level counters (scriptDuration, layoutDuration, recalcStyleDuration) and JS heap sizes (usedJSHeapSize / totalJSHeapSize / jsHeapSizeLimit). Optionally include the raw performance timeline entries. Replaces the legacy network-domain performance_get_metrics (still working as a backward-compat alias).

Manage cookies on a JSDOM session. Isolated from the attached browser.

Evaluate JS inside a JSDOM session. Requires explicit authorization — arbitrary code execution.

Parse HTML into an in-memory JSDOM session. No browser needed.

Query a JSDOM session with a CSS selector.

Serialize a JSDOM session to HTML.

Launch Chromium/Camoufox or connect to a running browser.

List CDP targets with optional type/URL/title filters.

List open browser tabs with URLs and titles.

Enumerate Service Worker / Shared Worker / dedicated Web Worker targets via Target.getTargets. Use browser_worker_scripts(targetId=...) afterwards to dump a worker's loaded scripts — essential for inspecting PWA / SW-backed auth code.

Seed a WebAuthn/Passkey credential into the browser for test automation.

Atomic primitive: subscribe to PerformanceObserver entry types in the active page and return both buffered and live entries observed during a collection window. Entry types are passed through to PerformanceObserver.observe({ type }) verbatim (e.g. largest-contentful-paint, layout-shift, longtask, event, long-animation-frame); unsupported entry types are skipped silently. One observer per type — the API does not accept multiple types in a single observe() call.

Atomic primitive: read Resource Timing API entries for the active page and decompose each resource into dns / connect / tls / ttfb / download phases plus transfer and body sizes. Optionally include Server-Timing headers and filter by URL substring. A read-only snapshot — no observers or listeners are installed.

Switch active tab by index, URL pattern, or title pattern.

Report browser status: running, tab count, version.

Atomic primitive: begin a Chrome performance trace on the active page via page.tracing.start(). Pair with browser_trace_stop to save the trace to disk. Use a sensible categories list when you have a specific hypothesis (e.g. ["devtools.timeline","v8.execute","blink.user_timing"]); the default set covers most profiling needs.

Atomic primitive: stop the Chrome performance trace started by browser_trace_start and persist it to artifacts/traces/ (or to a custom path). Returns event count, file size, and a Chrome DevTools hint. Fails clearly if tracing was never started or has already been stopped.

Attach a CDP session to a worker target and dump its parsed scripts (equivalent to get_all_scripts, but scoped to a worker). Debugger.scriptParsed is replayed on Debugger.enable, so already-loaded worker scripts are returned.

Analyze runtime function call graph from in-page traces.

Execute an already-active tool by name. Use this when activate_tools/activate_domain registered a tool but your client did not refresh its tool list. Does not auto-activate inactive tools.

Get geolocation for a locale.

Start, close, or check status of a Camoufox anti-detect server.

Dump the linked shader programs (vertex + fragment source, uniforms) running on the target canvas. Uses engine introspection where available (Three.js renderer.info.programs, BABYLON.Effect.ShadersStore, Laya.Shader registry) and the WEBGL_debug_shaders extension to recover source where the driver allows. Returns programs[] + an honest `reason` when the engine / driver refuses to expose source. Academic basis: WGPULens arXiv 2606.26412 + DarthShader arXiv 2409.01824.

Detect Canvas/WebGL game engines in the page.

Intercept Canvas 2D (drawImage/fillText/strokeText) and WebGL (drawArrays/drawElements) draw calls into a ring buffer on the page. Actions: install (wrap prototypes), read (dump captured calls), uninstall (restore). Set timing=true at install to also sample a requestAnimationFrame loop; then includeTiming=true at read to get frame-level stats (avg/p95 frame time, dropped frames, 60fps budget misses).

Assert runtime invariants about WebGL context lifetime, engine state consistency, and texture/program leaks. Reports checks[], violations[] (with severity + safe-cleanup fix), and a recommendations[] block. Honest scope: only JS-observable metrics (DOM canvas count vs live WebGL contexts, renderer.info.memory counts, contextLoss events). Full GC sweep / native-heap inspection is out of scope. Academic basis: JSidentify-V2 arXiv 2508.01655.

Pick / hit-test the topmost object at a given screen coordinate using the engine's hit-test system

Extract the full scene tree / display list from a detected canvas engine.

Search a previously-dumped scene tree (canvas_scene_dump output) for nodes by name regex and/or type. Pure-compute — no browser session required. Returns matching nodes with their path from root, depth, and engine-specific properties.

Trace a click event from DOM to JS call stack.

Configure CAPTCHA detection sensitivity and solver backend.

Detect CAPTCHAs on the current page.

Report CAPTCHA solving mode availability.

Solve a CAPTCHA with manual flow or a configured external service.

Block until the user manually solves the CAPTCHA.

Check if a process is being debugged using NtQueryInformationProcess (ProcessDebugPort).

Apply a deterministic 16-bit Internet checksum across a payload slice, optionally zeroing and writing the checksum field back into the packet.

Clean generated artifacts by age and size.

Clear all internal caches. Destructive — prefer smart_cache_cleanup.

Clear collected script data, caches, and in-memory indexes.

Collect JavaScript from a target website with configurable strategy.

Mark a task handoff as completed.

Manage injected interceptor state.

Evaluate a JS expression in the browser console context.

Get captured uncaught exceptions from the page

Retrieve captured console logs with type and time filters.

Inject an in-page script, XHR, fetch, or function monitor.

Inject a fetch interceptor.

Inject an XMLHttpRequest interceptor.

Toggle console log capture (log, warn, error, info, debug).

Restore a saved page snapshot including IndexedDB data. Navigates to the captured URL, re-injects cookies, localStorage, sessionStorage, and IndexedDB records from the snapshot.

Report which tools have been called in the current runtime and which known tools remain uncalled. Loads all domains first so the uncalled list reflects the full tool catalog, not just currently active tools.

Create a persisted task handoff for cross-tool coordination.

List all cross-domain capability categories and available workflows.

Run the built-in skia, mojo, syscall, and binary correlators and merge the results into the shared evidence graph.

Export the shared cross-domain evidence graph as JSON.

Query the shared evidence graph by URL, heap address, function, script, node type, metadata, or chain.

Get node and edge statistics for the shared cross-domain evidence graph.

Report health status of cross-domain bridges and correlators.

Recommend a multi-domain workflow to achieve a specific analysis goal.

Map natural-language queries to tool recommendations using a lightweight synonym graph. Pure TS — no LLM. Useful for discovering which tools implement a concept described in plain English (e.g. "find where the app signs requests" → deobfuscation, crypto, network).

Compare two crypto implementations against identical test vectors.

Extract crypto/sign/encrypt function from current page and generate standalone runnable code.

Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.

Execute a Dart function in the ARM64 emulator by address or name, with simplified runtime (mock built-ins, tagged pointers). Pass a sessionId to reuse the cached snapshot; the executor still initialises fresh CPU state per call (register state is never shared across calls).

Build a best-effort static call graph from a Dart AOT snapshot: nodes are Code objects, edges are ObjectPool entries whose value matches another Code entry point (caller to callee). Pass a sessionId to reuse a cached snapshot. Honest boundary: indirect/dynamic calls without a pool entry, and PcDescriptors-level mapping, require instruction decoding (deferred — cross-Dart-SDK version work).

Parse a Dart AOT snapshot once and cache it under a sessionId, so subsequent dart_load_snapshot / dart_list_functions / dart_call_graph / dart_inspect_object_pool / dart_call_function / dart_trace_execution calls can pass sessionId and skip re-parsing libapp.so (the dominant cost on a 10-40 MB Flutter snapshot). Destroy with dart_destroy_session when done; idle sessions auto-expire (TTL + sweep, see DART_SESSION_*).

Destroy a Dart snapshot session created by dart_create_session, releasing the cached parsed snapshot. Returns destroyed=true if the session existed, false if it was unknown or already swept by the idle TTL.

Dump an ObjectPool at a specific address, showing all entries with types and values. Pass a sessionId to reuse a cached snapshot.

List all Dart Code objects (compiled functions) from a loaded snapshot, with entry point address, size, and name (if available). Pass a sessionId to reuse a cached snapshot.

Load and parse a Dart AOT snapshot from libapp.so, extracting metadata and statistics (Code objects, ObjectPool entries, clusters). Pass a sessionId from dart_create_session to reuse an already-parsed snapshot (skips re-parsing libapp.so).

Read-only static dump of the Dart isolate ObjectPool in a libapp.so: classify each slot as smi/mint/double/string/classRef/functionRef/pool/null/unknown.

Parse PcDescriptors for one or all Dart functions in a loaded snapshot and resolve call targets by decoding ARM64 BL instructions at each call-site PC offset. Returns structured call-site entries with pcOffset, kind (1=icCall, 2=unoptStaticCall, 3=runtimeCall), and optionally resolved target addresses when code section bytes are available. Pass a sessionId or file path to load the snapshot.

Recover Dart Small Integer (Smi) constants from a libapp.so by reading aligned little-endian words and stripping the heap-pointer tag bit.

Parse the Dart isolate snapshot header in a libapp.so: magic, kind, 32-byte hash, features, target arch. Read-only.

Stream-extract ASCII/UTF-16LE strings from a Dart AOT libapp.so and classify them (urls, paths, classNames, packageRefs, cryptoKeywords, Dart identifiers, plus customRules). ReDoS-guarded.

Resolve obfuscated Dart identifiers using a developer-supplied Flutter --save-obfuscation-map JSON (flat, pairs, or object shape).

Trace Dart function execution step-by-step, emitting each instruction with register state (PC, x0-x30, PP, THR). Pass a sessionId to reuse the cached snapshot.

Identify Flutter/Dart SDK release from a libapp.so by combining header parse with a built-in (and optionally user-supplied) hash table.

Remove previously activated tools to free context. Only affects dynamically activated tools (added via activate_tools, activate_domain, or extension activation), not base profile tools.

Wait for the next debugger pause and capture call stack plus optional top-frame scope variables.

Disassemble V8 bytecode / instructions at the current paused location (or a given scriptId). Resolves the target scriptId automatically from the current paused call frame — useful when paused inside obfuscated/VM code to decide whether to step in. Native bytecode requires V8 natives syntax; set includeSourceFallback to derive a pseudo-bytecode from source when native extraction is unavailable.

Evaluate a JavaScript expression. context="frame" evaluates in the current call frame (requires paused state); context="global" evaluates in the global context (no pause required).

Get current paused state and reason.

Enable or disable the CDP debugger session.

Pause execution at the next statement.

Resume execution.

Run execution until a source location by setting a temporary code breakpoint, resuming, waiting for pause, and removing the breakpoint.

Manage debugger sessions. Actions: save (persist current session to file), load (restore session from file/JSON), export (export session as JSON string), list (list saved sessions in ./debugger-sessions/).

Step execution: into (enter next call), over (skip next call), out (exit current function).

Wait for debugger pause after setting breakpoints.

Run webcrack-powered JavaScript deobfuscation with bundle unpacking.

Get detailed information about a specific tool, including its input schema. Use this to see the exact parameters a tool expects before calling it.

Detect cryptographic algorithms and usage patterns in source code.

Detect obfuscation techniques in JavaScript source.

Scan a binary/memory-dump file for DEX or CompactDex magic and optionally extract hits.

Compare two heap snapshots from a trace.

Resolve many hostnames concurrently with per-host status.

Trace the full CNAME chain for a hostname.

Run a DNS query and return structured status instead of throwing.

Resolve a hostname to DNS records using the system resolver or an optional DNS server.

Reverse DNS lookup — find hostnames for an IP address.

Run environment doctor: dependencies, bridges, platform limits.

Attach to an Electron CDP port and optionally evaluate in a matching page.

Read Electron fuse states.

Check status of dual-CDP debug sessions launched by electron_launch_debug.

Analyze Electron app structure: main/renderer entry, preload, IPC.

Monitor Electron IPC messages.

Launch Electron with main and renderer CDP ports.

Patch Electron fuse states.

Scan a directory for Electron JSON userdata files.

Verify Electron ASAR integrity: parse the ElectronAsarIntegrity JSON embedded in the main binary, locate each referenced ASAR, and compare the on-disk SHA256/SHA512 hash against the embedded hash. A mismatch means the ASAR was tampered with after build.

Inspect a packaged Electron binary's own code signature (PE Authenticode on Windows, Mach-O embedded code signature on macOS). Pure-TS structural parse: locates the WIN_CERTIFICATE / SuperBlob, decodes the PKCS#7 SignedData, and surfaces the cert chain, signer, digest algorithm, and (macOS) the CodeDirectory ident + best-effort cdhash. No codesign/signtool dependency (runs in any CI). Cryptographic signature validity and timestamp counter-signatures are out of scope (verified:false).

List all loaded modules (DLLs) in a process with their base addresses.

Build a deterministic Ethernet II frame from source/destination MAC addresses, EtherType, and payload bytes.

Get full provenance chain from a node ID in specified direction.

Export the reverse evidence graph as JSON snapshot or Markdown report.

Query reverse evidence graph by URL, function name, or script ID to find associated nodes.

Execute JavaScript in an isolated sandbox.

Detect binary security mitigations (NX/DEP, PIE/ASLR, stack canary, RELRO, FORTIFY_SOURCE, CFG). Returns boolean flags for each protection. CFG (Control Flow Guard) is detected on Windows PE via IMAGE_DLLCHARACTERISTICS_GUARD_CF (0x4000).

Generate format string exploit payload for arbitrary write. Uses %hn (2-byte) writes for reliability. Returns hex payload and reliability assessment.

Generate heap spray payload for predictable heap layout. Supports V8 (ArrayBuffer), IE (BSTR), and generic (ArrayBuffer) spray targets. Returns spray code, allocation count, and predictability score.

Build a JOP (Jump-Oriented Programming) chain from binary gadgets. JOP bypasses CFI by chaining gadgets via an indirect-jump dispatcher (e.g. jmp [rax]) instead of ret. Discovers dispatcher candidates, groups functional gadgets by dispatch register, and assembles a chain that covers the specified goal constraints. Also supports COP (Call-Oriented) and COOP (Counter-Object Oriented) chains.

Build a ret2dlresolve payload that forges ELF dynamic-linker structures to resolve an arbitrary symbol (e.g. "system") without knowing libc addresses. Generates fake .rel.plt, .dynsym, and .dynstr entries. Supports x86 (Elf32_Rel) and x64 (Elf64_Rela). Returns hex payload, reloc_offset, and structural details. Pure-TS offline builder — no live process needed. Reference: phrack #58 article 4, pwntools Ret2dlresolvePayload.

Construct a ROP chain for a specified goal (execve, write_memory, call_function). Automatically searches for required gadgets and chains them. Returns hex chain and gadget list. User must provide command/address/function as needed.

Find and assemble stack pivot gadgets from a binary. Stack pivots redirect the stack pointer (ESP/RSP) to a controlled buffer, enabling ROP chains when limited stack space is available. Detects xchg(add/sub/mov,sp), push/pop(sp), leave, and add sp,N pivot patterns.

Clear all cached exploit-dev results. Use when binaries have been modified or to free memory.

Update exploit-dev cache configuration (TTLs, memory limits, enable/disable). Changes take effect immediately.

Invalidate cached exploit-dev results for a specific binary (by path). Computes the binary hash and removes all matching cache entries. Call without binaryPath to clear the entire cache. Use when binaries have been recompiled or modified.

Get exploit-dev cache statistics including hit rate, memory usage, and entry count. Used for performance monitoring and cache tuning.

Calculate buffer overflow offset from crash value and De Bruijn pattern. Used to determine exact EIP/RIP overwrite offset.

Discover one-gadget (single-address shell-spawning) offsets for common libc versions. First checks a built-in database (glibc 2.23/2.27/2.31/2.35/2.39 for x64/x86, musl 1.2), then falls back to heuristic binary scanning for custom libcs. Returns offsets with constraints (e.g. "[rsp+0x70] == NULL") that must be satisfied for the one-gadget to work. Also lists all known libc identities when called with listKnown=true.

Encode shellcode to avoid bad characters or detection. Supports alphanumeric, unicode, XOR, and fnstenv encodings. Returns encoded shellcode and decoder stub. User must provide raw shellcode.

Search for ROP/JOP/COP/COOP gadgets in a binary file. Returns addresses, instructions, and bytes for each gadget. Supports filtering by regex pattern and gadget type. User must provide target binary.

Find "jmp esp" / "call esp" style gadgets for stack pivoting. Searches for jump/call instructions targeting a specific register.

Generate egghunter shellcode for constrained buffer sizes. An egghunter searches process memory for a 4-byte "egg" tag (repeated twice) and jumps to the real shellcode following it. Supports Linux x86 access(2)-based and Windows SEH-based egghunters. Reference: skape, "Safely Searching Process Virtual Address Space" (2004).

Generate De Bruijn sequence for offset finding. Every 4-byte substring is unique, allowing precise offset calculation from crash dumps.

Generate a pwntools-compatible Python exploit script (exploit.py). Accepts ROP chain data, JOP chain data, shellcode payload, or one-gadget offset and emits a ready-to-run script with proper ELF loading, remote/local I/O setup, and payload assembly. Templates: io, rop, shellcode, ret2libc, format.

Solve a system of constraints using the Z3 SMT solver. Each constraint is a JavaScript-like boolean expression (e.g. "x > 10", "y <= 20", "x + y < 100"). Constraints are conjunctive (AND-ed together). Supports int, real, bool, and bitvec variable types. Returns sat/unsat/unknown plus an optional model with variable assignments when SAT. Use this for ROP gadget verification, opaque predicate inversion, and general constraint solving.

Verify a user-supplied ROP chain against an exploit goal using Z3. Decodes the hex chain into gadget addresses, matches each to a known gadget, simulates the register effects, and checks whether the final state satisfies the goal (e.g. execve syscall registers, write_memory address/value, call_function ABI args). Use this to audit hand-crafted or third-party ROP chains before use. Returns valid flag, decoded chain, final register state, violations, and warnings.

Export generated hook templates as a complete, runnable Frida script.

Export a trace database. format="chrome-trace" (default) emits Chrome Trace Event JSON with per-category thread tracks, thread_name metadata, and CPU-profile flame-graph X events. format="har" emits HTTP Archive 1.4 joining network_resources + response bodies — interchange format for Burp/ZAP/Postman.

Load an extension and execute a named exported context function.

Read installed extension manifest details without importing plugin code.

Install/register an extension from a manifest, local package directory, local module file, or remote module URL. Directory mode is zero-config: pass source=<plugin dir> after `pnpm build` and the tool reads id/name/version from package.json and discovers dist/manifest.js (or dist/index.js) automatically when no entry pointer exists.

List installed extensions from the local registry.

Reload an installed extension by unloading and loading it again.

Uninstall an extension from the local registry.

Extract a function and its dependency tree from collected scripts.

Export events captured by the fetch()-based stream monitor to artifacts/captures as JSON or NDJSON.

Get events captured by the fetch()-based stream monitor (text/event-stream consumed via fetch). Set fullData=true to include full event data.

Enable or disable capture of fetch()-based streams. Wraps window.fetch and, for responses with content-type text/event-stream, clones the body and parses the SSE frame stream into events. Covers the LLM / GraphQL-subscription streaming that the EventSource-based sse_monitor_enable misses (fetch + POST + custom headers). Use fetch_stream_get_events to read captured events.

Detect third-party Dart `package:` refs in a Flutter libapp.so, aggregated and SDK-stdlib-filtered.

Extract React/Vue/Svelte/Solid component state and meta-framework info.

Attach Frida to a target and open a session. Defaults to the local device; pass device+host for USB/remote devices. On Android the frida process name is the App Label (not the package name) — use frida_list_processes and attach by pid to avoid name mismatches.

Generate a real Frida Interceptor.attach block for a symbol and optionally install it in a session.

Detach from a Frida session and clean up resources.

Run frida-dexdump as a high-level Android DEX dump helper by package/process name or PID.

Enumerate exported functions for a specific module in a Frida session.

List loaded modules in an attached Frida session, with an isSystem tag and a summary (total/system/nonSystem). Use filter to focus on non-system modules for broker-vs-agent diffing.

Search for symbols matching a pattern in a Frida session.

Generate a Frida interceptor or hook script from built-in templates.

List frida-visible devices (local, USB, remote) via frida-ls-devices. Use the returned id with frida_attach device=id, or connect directly with device=remote + host.

List processes on a Frida device via frida-ps (defaults to the local device; pass device+host for USB/remote). On Android the process name is the App Label, not the package name — attach by the returned pid.

List all active Frida attach sessions with target info.

Read raw bytes from a Frida session via ptr(address).readByteArray. Returns hex; capped at 65536 bytes per call.

Scan process memory for a byte pattern via Frida Memory.scanSync. Searches a named module, an explicit address range, or all readable ranges by default. Pass async:true to scan in a background task (MCP 2.0 Tasks) and poll with tasks_get/tasks_result — broad scans survive past the default 15s CLI timeout.

Resume a target previously spawned for early Frida instrumentation.

Execute a Frida JavaScript snippet inside an attached Frida session. By default each call spawns a fresh frida CLI that tears down when the script returns, so hooks and timer callbacks do NOT survive — pass keepAliveMs (sync, clamped to 25s) or async:true + keepAlive:true (background task) to park the script with recv().wait() so hooks stay armed for the window. A frida 17 API compatibility shim (Module.findExportByName, Process.getCurrentPid) is injected automatically; scripts that need file writes on Windows must use send() instead of new File().

Spawn a target through Frida for early instrumentation before normal execution. Until frida_resume succeeds, every tool call on a spawn session re-spawns the target (restarts the app on remote Android).

Generate a Frida interceptor script for a list of symbols.

List all scripts loaded by the page with optional source.

List installed binary analysis plugins.

Get cache statistics: entries, sizes, hit rates, and cleanup recommendations.

Get the current call stack.

Get collection, cache, and compression statistics.

Retrieve large data by detailId. Supports slicing to prevent context window explosion.

Get properties of an object by objectId.

Retrieve the original bytes of a field that was offloaded to disk (see the `_offload.path` in a placeholder). Returns base64 by default for binary blobs (e.g. decoded data: URIs); use encoding="utf8" for text.

Enhanced scope variable inspection with deep object traversal.

Retrieve source code of a script by ID or URL pattern.

Read persisted task handoff context and session insights.

Get token budget usage stats, warnings, and optimization suggestions.

Analyze a binary and return metadata.

Send a command to a Ghidra bridge. Two backends: the pip ghidra_bridge server (TCP 127.0.0.1:4768 — pip install ghidra_bridge, then in Ghidra run ghidra_bridge_server.py) or a REST bridge (HTTP 18080). Auto mode prefers the pip TCP server when it answers.

Decompile a single named function via a stateless Ghidra headless run (no bridge server or plugin needed; ~5-10s per call). Run ghidra_analyze first to list function names — the name must match exactly.

Enumerate GraphQL fields from server suggestion errors with introspection fallback.

Extract GraphQL queries/mutations from captured network traces.

Run GraphQL introspection and optional Apollo Federation _service.sdl probing.

Replay a GraphQL operation with optional variables, batch array, or Apollo persisted-query (APQ) extensions.

Open a GraphQL subscription WebSocket, perform the graphql-transport-ws (or legacy graphql-ws) handshake, send a subscribe frame, and collect frames for collectMs. Runs in-page so the browser-session auth (cookies + connectionPayload) is preserved. Pairs with graphql_replay for targets that expose queries/mutations only via the authed WebSocket session.

Export captured gRPC / gRPC-Web calls to artifacts/captures as JSON or NDJSON.

Encode one or more messages into a gRPC / gRPC-Web length-prefixed body. Inverse of grpc_frame_parse — for constructing test or replay bodies. Each message takes payloadHex plus optional compressed / isTrailer flags.

Split a captured gRPC / gRPC-Web body into its length-prefixed messages. Each message is 1 compressed-flag byte + 4-byte big-endian length + payload. Detects gRPC-Web trailer frames (flag bit 7) and the compression flag (bit 0). Lenient: a truncated trailing message is still emitted with a warning. Each message exposes payloadHex and payloadBase64 — feed payloadBase64 directly to protobuf_decode_raw to complete the gRPC decode chain (capture body -> grpc_frame_parse -> protobuf_decode_raw).

Get captured gRPC / gRPC-Web calls with parsed message summaries. Set fullMessages=true to include the parsed message arrays (each carries payloadBase64 — feed to protobuf_decode_raw). Without fullMessages only per-call counts and flags are returned.

Enable or disable live capture of gRPC / gRPC-Web calls. gRPC calls are detected by content-type application/grpc(-web)?(+proto)? on the HTTP/2 response. On loadingFinished the response body is pulled (base64) and split into length-prefixed messages; feed each message payloadBase64 to protobuf_decode_raw to complete the decode chain. Must be enabled before navigating so requests are captured from the start.

Install a pre-built JavaScript hook from 20+ built-in presets (eval, atob/btoa, Proxy, Reflect, Object.defineProperty, etc.), or provide customTemplate/customTemplates to install your own reusable hook bodies. Use listPresets=true to see all available preset descriptions.

Send a raw HTTP request over plain TCP.

Build a raw HTTP/1.x request payload.

Build a raw HTTP/2 frame.

Decode a raw HTTP/2 frame (hex string) back into its header fields and type-specific payload (SETTINGS entries, PING opaque data, WINDOW_UPDATE increment, RST_STREAM/GOAWAY error codes, GOAWAY debug data). Inverse of http2_frame_build. Lenient: malformed payloads set decodeError but still return payloadHex.

Probe an HTTP/2 endpoint.

Move mouse along a Bezier curve with jitter.

Scroll with randomized speed and pauses to mimic human behavior.

Type text with human-like speed and occasional typos.

Build a deterministic ICMPv4 echo request or reply payload with an automatically computed checksum.

Send a command to an IDA Pro plugin bridge.

Decompile a function using IDA Pro.

Export IndexedDB databases and records. Supports keyRange queries (IDBKeyRange.bound/lower/upper), indexName (query a specific index), count (count-only mode), and cursor pagination (stream large stores in batches).

Inject a DLL into a target process. Requires elevated privileges. Target process and payload are validated before injection.

Allocate and execute raw shellcode in a target process. Requires elevated privileges. Target process and payload are validated before injection.

Install an extension from the remote registry.

Manage artifacts captured by instrumentation operations.

Apply hook presets inside an instrumentation session.

Replay a captured network request inside an instrumentation session.

Manage operations inside an instrumentation session.

Start, stop, or query status of an instrumentation recording session. Destroying a session archives it read-only (the last 8 destroyed sessions are retained, oldest evicted) so export/diff/merge/status can still inspect it.

Diff two instrumentation session snapshots: operations added/removed/common (by id) plus artifact fingerprints and per-type counts. Pure compare, mutates nothing.

Export an instrumentation session snapshot to an artifacts JSON file.

Merge two sessions into a new session: copies operations (with id remapping) and artifacts from both sources. Original sessions are untouched.

Decompile an APK class or method with JADX CLI.

High-level JADX APK decompile: decompile the whole APK to a stable output directory and return sourcesDir for jadx_search_code.

Ripgrep-backed search over jadx output. Pass decompileDir for read-only search, or apkPath to auto-decompile to a temporary directory first.

Analyze JSVMP/VM interpreter: dispatch type, handler table, opcode map.

Fetch a remote JS bundle and search it with named regex patterns, with caching and noise filtering.

Deobfuscate JSVMP/VM-protected JavaScript: extract VM bytecode and restore original logic.

Three-stage deobfuscation pipeline: preprocess → deobfuscate → humanize.

Search JS heap for strings matching a pattern.

Solve opaque predicates and constant expressions in obfuscated code.

Symbolic execution of JavaScript: explore all feasible execution paths, collect path constraints, and solve them. Best for control-flow-flattened code with complex branching.

Symbolic execution of JSVMP bytecode: step through instructions symbolically to infer original logic, constraints, and confidence score. Use after js_analyze_vm to get instructions.

List runtime-loaded extension workflows from plugins/ or workflows/ directories.

List all loaded plugins, workflows, and extension tools.

List all available macros.

List saved page snapshots.

Use LLM to suggest meaningful names for obfuscated identifiers.

Detect GPU family from WebGL/WebGPU renderer strings. Classifies into NVIDIA, AMD, Intel, Apple, Mali, Adreno, PowerVR, Vivante, Broadcom, Qualcomm, Microsoft. Pure-TS classifier — no browser needed. Provide at least one of webglRenderer, webgpuDescription, or deviceName.

Create, inspect, and clear JavaScript runtime hooks.

Clear stale entries and reset counters to free 10-30% of token budget.

Allocate executable memory in target process (VirtualAllocEx wrapper). Win32 only. Requires JSHOOK_INJECTION_ENABLE=1.

Scan process imports for anti-debug/anti-cheat mechanisms: IsDebuggerPresent, NtQueryInformationProcess, timing checks (QPC, GetTickCount), thread hiding, heap flag checks, and DR register inspection. Each detection includes a bypass suggestion.

Anti-detection hardening toolkit. Actions: check (run all detectors — kernel callbacks, instrumentation callback, AMSI/ETW status, chaos mode, platform info), harden (apply AMSI/ETW patches + process masquerade + self-defense — destructive), status (read-only current protection state). WARNING: harden action modifies process memory and mitigation policies. ProcessBreakOnTermination is PERMANENTLY DISABLED (stub — no BSOD risk). On non-Windows, returns platform info only.

Pre-flight anti-detection security audit. READ-ONLY — no patches or modifications. Checks: (1) ETW/AMSI patch status, (2) debugger attached to self via IsDebuggerPresent, (3) HVCI (Hypervisor-protected Code Integrity) and VBS (Virtualization-Based Security) status via registry, (4) known anti-cheat/EDR/AV/debugger processes via process enumeration. Returns a pass/warn/fail verdict with a 0-100 score, per-check results, and actionable recommendations. All checks are safe, user-mode, read-only operations. For actual hardening, use memory_antidetection action=harden.

Array-of-Bytes scan with wildcard and operator support (CE 7.6 parity). Search for byte patterns like "48 8B ?? ?? 00 00" across readable memory. Supports hex bytes (00-FF, optional 0x prefix), "??" wildcards, and operators: >XX (greater than), <XX (less than), XX-YY (range inclusive). Example: "48 8B >40 <80 00 00" matches bytes >0x40 at position 2 and <0x80 at position 3. Case insensitive. Use regionFilter to restrict to specific modules or skip system modules.

Assemble x64 assembly instructions to machine code bytes (x64dbg inline assembler parity). Uses Keystone assembler via koffi FFI (keystone.dll) if available on Windows, with a built-in fallback opcode table for common instructions (NOP, RET, INT3, PUSH/POP, MOV, XOR, ADD, SUB, INC, DEC). assemble: compile ASM string to hex bytes. assemble_at: assemble + write directly to target process memory at address (destructive, audit trail recorded). Separate multiple instructions with semicolons or newlines. Max 256 instructions, 4096 assembled bytes.

Export the in-memory audit trail for memory operations as JSON.

Execute a Cheat Engine-style Auto Assembler script. Parses [ENABLE]/[DISABLE] sections and executes ENABLE commands. Supported commands: ALLOC(name,size), DEALLOC(name), LABEL(name[,addr]), REGISTERSYMBOL(name), AOBSCAN(name,pattern), ASSERT(address,bytes), CREATETHREAD(address), DEFINE(name,value), FULLACCESS(address,size), READMEM(address,size), WRITEMEM(address,bytes). INCLUDE and LOADBINARY are rejected for security. Returns a disableScript for use with memory_auto_assemble_disable. Win32 only — requires native process access.

Execute the DISABLE section of a previously-run Auto Assembler script. Pass the disableScript returned by memory_auto_assemble. Executes DISABLE commands, running DEALLOC last (CE convention). Win32 only — requires native process access.

Write a value to ALL addresses in a scan session at once. Thin wrapper that iterates through the session address list and calls writeValue for each. Capped at 1000 addresses per call with a clear error when exceeded. Destructive — an audit trail entry is recorded for each write. Equivalent to GameGuardian's gg.editAll() or Cheat Engine's "Edit All".

Write multiple memory patches at once. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Manage address bookmarks for a process. Actions: add (bookmark an address with optional label and color), remove (delete a bookmark), list (show all bookmarks for the PID), clear (remove all bookmarks for the PID). Labels help categorize findings; colors use hex format (e.g. "#FF0000"). Bookmarks are scoped per PID. For long-term persistence, export via state_board_io with namespace "memory_bookmarks:<pid>".

Breakpoint via hardware debug registers (DR0-DR3) or software INT3 (0xCC). Actions: set, remove, list, trace. Hardware BPs (type='hardware'): use x64 DR0-DR3, max 4 concurrent, support read/write/readwrite/execute. Software BPs (type='software'): use INT3 (0xCC) patching, unlimited count, execute-only. Two debugger modes: "win32" (default, uses DebugActiveProcess — freezes entire process) and "veh" (Vectored Exception Handler — injects shellcode, only faulting thread pauses). VEH mode is less intrusive but requires code injection which may be detected by anti-cheat systems. Conditional breakpo…

Walk the call stack of a target process thread using the x64 RBP frame-pointer chain. Suspends the thread, reads the CONTEXT to get RBP/RSP/RIP, then follows the linked list of saved_RBP / return_address frames via ReadProcessMemory. Resolves module names using Toolhelp32 module snapshots. Returns an array of {frameIndex, returnAddress, moduleName, functionName}. Equivalent to x64dbg's "standard" call stack mode. Win32 (x64) only — requires Administrator privileges.

Import, export, sign, or verify Cheat Engine .CT files. Export: converts JSON entries to valid .CT XML. Import: parses .CT XML to JSON. Sign: HMAC-SHA256 sign the XML using a secret (from JSHOOK_TABLE_SECRET env var, state_board "memory_ct_sign" secret key, or explicit "secret" arg). Verify: validate a signed table's HMAC signature. Addresses can be hex or module+offset.

Check memory protection flags at a specific address. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Find code caves (runs of 0x00 or 0xCC) in executable sections of loaded modules. Returns largest caves first.

Dump memory region as hex with ASCII column. Outputs a formatted hex dump similar to xxd.

Dump a process memory region to a binary file for offline analysis. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Detect if a target process is a known console emulator (ArtMoney parity). Supports: PCSX2, Dolphin, RPCS3, Yuzu, Cemu, ePSXe, PPSSPP, xemu. Detection uses process name matching + optional module fingerprint confirmation. Returns emulator name, platform, and known memory region layout for emulator-mode scanning. Set list=true to enumerate all known emulators without a process check.

Find what writes to or accesses a memory address (Cheat Engine MWT workflow). Sets a hardware breakpoint on the target address, auto-rearms after each hit, captures the faulting instruction address + context + timestamp, and optionally disassembles the instruction. Returns aggregated hits with per-hit instruction details.

Find all references to an address in executable memory (x64dbg parity). Scans all executable regions for CALL rel32, JMP rel32, Jcc rel32, LEA [RIP+disp32], and MOV [RIP+disp32] instructions that reference the target address. Uses pure-TS byte-pattern heuristics — no Capstone dependency. Returns reference type, source address, disassembly, module name, and module offset. Optionally filter by module name.

Start a new memory scan session.

Free remote memory in target process (VirtualFreeEx wrapper). Win32 only. Requires JSHOOK_INJECTION_ENABLE=1.

Freeze or unfreeze a memory address. Freeze continuously writes a value to prevent changes; unfreeze stops it.

Export all active freeze entries as structured JSON. Returns an array of freeze entries with freezeId, pid, address, value, valueType, intervalMs, and active flag. Optional pid filter to scope the export to a single process. Pure data export — no workflow, no replay.

Generate an update-resistant AOB (Array-of-Bytes) signature from bytes at a memory address. Detects relative offsets in CALL/JMP/LEA/Jcc instructions and replaces the displacement bytes with wildcards (??), making the signature survive minor code changes between updates. Uses byte-pattern heuristics — no Capstone dependency required.

Search for multiple values at known offsets simultaneously.

Find all memory regions with PAGE_GUARD protection in a process. Guard pages are often used as anti-tampering mechanisms or stack overflow detection.

Enumerate all open handles in a target process via NtQuerySystemInformation. Returns handle value, object type, access mask, and object name for each handle. Filterable by type: File, Key, Process, Thread, Token, Section, etc. Useful for finding handles to protected resources and analyzing process security posture. Win32-only, admin required.

Detect heap anomalies: heap spray patterns (many same-size blocks), possible use-after-free (non-zero free blocks), and suspicious block sizes (0 or >100MB).

Enumerate all heaps and heap blocks in a process via Toolhelp32 snapshot. Returns heap list with block counts, sizes, and overall statistics.

Get detailed heap statistics with size distribution buckets (0-64B, 64B-1KB, 1-64KB, 64KB-1MB, >1MB), fragmentation ratio, and aggregate metrics.

EPT Hypervisor Phase 1: VMXON, VMCS setup, basic VM-exit handler design, CPUID spoofing. Intel VT-x only. Requires BYOVD kernel driver for MSR reads and VMXON region preparation. Gate: JSHOOK_HYPERVISOR_ENABLE=1 + admin. Actions: capabilities (detect VT-x/EPT/VPID, MSR values, Hyper-V conflicts), load (validate readiness + build VMCS config), unload (reset state), status (runtime state). NOTE: Actual VMXON/VMLAUNCH execution requires a kernel-mode component (not yet implemented). Phase 1 provides detection, configuration, and the exit-handler design.

Inject a DLL into target process. Win32 only. Modes: loadlibrary (LoadLibraryW injection) or manualmap (manual mapping). Requires JSHOOK_INJECTION_ENABLE=1.

Inject shellcode into target process. Win32 only. Methods: createremote (CreateRemoteThread) or ntcreatethread (NtCreateThreadEx). Requires JSHOOK_INJECTION_ENABLE=1.

Detect hooks in process modules. scanMode "inline" (default) compares the first 16 bytes of each exported function disk-vs-memory and recognises 8 hook patterns (JMP/CALL/short-jmp/MOV+JMP/MOV+CALL/PUSH+RET/INT3/padding). scanMode "iat" detects Import Address Table hooks (entries redirected outside their source module — evades inline detection, used by EasyHook/MinHook/Detours). scanMode "both" runs both scans.

Check executable memory regions against their corresponding on-disk PE files (.text sections) to detect modifications like inline hooks or code patches.

List all memory regions in a process with protection flags. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

List all registered custom scan types.

List Mono assemblies loaded in the root domain of a Unity/Mono process. Returns assembly name, address, and image address. Optionally filter by name substring.

List Mono classes in a specific assembly from a Unity/Mono process. Reads the MonoImage type definition table (MONO_TABLE_TYPEDEF) and resolves class names from the string heap. Optionally filter by namespace.

Detect Mono or IL2CPP runtime in a target process. Returns runtime kind (mono/il2cpp), module name, pointer size, and root domain address if resolved. Works on Unity games and other Mono/.NET applications.

Read field values from a Mono object at the given address. Resolves the class via vtable pointer, walks MonoClass fields, and decodes each field value with type-aware heuristics (int, float, string pointer detection).

Inspect method count for a Mono class in a Unity/Mono process. Full method name enumeration requires walking the MonoMethod table from MonoImage (not yet implemented — returns methodCount from the type definition table).

Find live Mono objects of a specific class in the managed heap. Resolves class vtable, then scans writable heap regions for vtable pointer matches. Returns object addresses with class name and estimated size.

Narrow an existing scan session. Supports delta modes: changed_by (value changed by exactly N), increased_by (value increased by at least N), decreased_by (value decreased by at least N), changed_by_variable (returns per-address delta in results).

Parse a Windows Minidump (.dmp) file and extract forensic information: loaded modules (base/size/name/timestamp), threads (ID/stack/context), memory ranges (64-bit or 32-bit), system info (OS/CPU), and exception records. Optionally resolve a list of addresses against the dump contents. Pure TS — cross-platform (can analyze Windows dumps on Linux/macOS).

Write bytes to target process at address. Saves original bytes for undo. Use for runtime code patching.

NOP out instructions at address (replace with 0x90). Useful for disabling checks or jumps.

Undo a previous patch by restoring the original bytes.

Parse PE headers (DOS, NT, File, Optional) from a module base address in process memory. Returns machine type, entry point, image base, section count, and data directory info.

Parse import and/or export tables from a PE module in process memory. Returns DLL names, function names, ordinals, hints, and forwarded exports. Cross-platform: parses ELF .dynsym / Mach-O LC_SYMTAB from disk when moduleName is given on Linux/macOS.

Pointer chain operations: scan (multi-level BFS), autoscan (auto-discover pointer chains by recursively scanning for pointers that point to or near the target address), validate, resolve, or export as JSON. autoscan is Cheat Engine's "pointer scan" equivalent — no manual base/offsets needed.

Save, load, or compare pointer maps for cross-instance filtering (Cheat Engine .PTR parity). save: serialize pointer scan results to a .ptr.json file in <project>/.ptr/. load: deserialize a pointer map from file. compare: load 2+ pointer map files and find addresses that appear in ALL maps — the CE "rescan across multiple instances" workflow for finding stable pointer chains.

Find pointers to a target address.

Suspend or resume a target process for consistent memory snapshots. Suspend freezes all threads (NtSuspendProcess on Win32, SIGSTOP on Linux, task_suspend on macOS) so memory reads/scans see a consistent state. Resume thaws all threads. Useful before memory_dump or memory_first_scan for processes with actively-changing memory. Cross-platform.

Change memory page protection for a region in the target process. Wraps VirtualProtectEx (Win32) / mprotect (Linux) / mach_vm_protect (macOS). Protection: r (read-only), rw (read-write), rx (read-execute), rwx (all), none (no-access). Returns the old protection. Destructive — audit trail recorded.

Read memory from a process at a specific address. Requires elevated privileges. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Read process memory as typed numeric values with explicit endianness. Decodes consecutive values starting at address via koffi endian-sensitive integer types (uint64_le / int32_be / …) — no manual byte swapping needed. 64-bit values are returned as decimal strings alongside two's-complement hex. float/double use IEEE-754 with the requested endianness. Supports up to 1024 consecutive values. Ideal for struct inspection, big-endian network payloads, and game memory analysis.

Compare two memory regions byte-by-byte and return a diff summary. Equivalent to Cheat Engine's compareMemory(). Returns identical flag, diff count, and per-offset differences (byte1, byte2). Max compare size: 64KB.

Enumerate memory regions in a target process. Cross-platform: Windows (VirtualQueryEx), macOS (mach_vm_region), Linux (/proc/pid/maps). Returns base address, size, protection (r/w/x/rw/rx/rwx), state, type (image/mapped/private), and module name (if module-backed). Emulator mode (mode="emulator"): use with memory_emulator_detect to get emulator-specific memory region descriptors (EE RAM for PCSX2, MEM1/MEM2 for Dolphin, etc.) and filter results.

Register a custom value type for memory scanning (Cheat Engine parity). Registered types can be used as valueType in memory_first_scan, memory_unknown_scan, etc. Types are session-scoped (live as long as the domain handler instance).

Connect to a remote jshookmcp MCP server via WebSocket for remote debugging. Enables ceserver-style remote memory operations: connect to a remote instance, forward tool calls (memory read/write, process enumerate, etc.), and receive results. Uses JSON-RPC 2.0 over WebSocket with auth token support and auto-reconnect. Actions: connect (establish WebSocket link), disconnect (tear down), status (connection state + stats), forward (proxy a tool call to the remote instance).

Reverse memory write trace — given a code address, find what data addresses the instruction accesses. Inverse of memory_find_accesses. Disassembles the instruction at the given address using Capstone, then resolves RIP-relative and absolute memory operands to their target addresses. Returns instruction text, raw bytes, and a list of accessed addresses with access type (READ/WRITE/RIP_REL). Useful for understanding what data a specific piece of code operates on.

Parse MSVC RTTI (Run-Time Type Information) at an object address. Reads vtable pointer, follows the Complete Object Locator chain, extracts class name, base classes, and class hierarchy descriptor. Equivalent to CE's "Find out what addresses this code accesses" for type discovery — quickly answer "what type is this object?" without a full structure analysis. Only works on MSVC x64 binaries with RTTI enabled.

Scan process memory for a pattern or value. Requires elevated privileges. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Refine a previous memory scan with filtered addresses. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Manage scan sessions. Actions: list (all sessions), delete (by sessionId), export (as JSON).

Search process memory for strings matching a pattern. Wraps memory_first_scan with valueType=string for convenience and adds substring/regex post-filtering. Optionally also searches for UTF-16LE (wide) strings.

Export a scan session's complete state as structured JSON. Returns sessionId, pid, valueType, addresses[], values{}, and metadata. Pure data export — no workflow, no replay. Addresses are capped at 100K with a truncated flag when the cap is hit.

Hook time APIs (GetTickCount64/GetTickCount/QueryPerformanceCounter/QueryPerformanceFrequency/timeGetTime/GetSystemTimeAsFileTime) to scale process time via an in-process SSE2 trampoline. time via an in-process SSE2 trampoline. Actions: apply (hook + set speed), set (adjust speed without re-hooking), restore (unhook and restore original functions). Speed range 0.01–100x; values outside this range are rejected to avoid destabilising the target.

Analyze memory at an address to infer data structure layout.

Compare struct instances to identify differing vs constant fields. Two modes: (1) Pairwise—compare address1 vs address2. (2) Group comparison (CE dissect data parity)—pass arrays of addresses in group1Addresses and group2Addresses. Group mode computes per-offset statistics and classifies fields as: between_groups (differs across groups—likely gameplay state), within_group (varies within groups—dynamic), constant_all (same everywhere—likely vtable, type flags). Returns confidence scores.

Export an inferred structure as a C-style struct definition, ReClass.NET XML, Rust #[repr(C)], or C# [StructLayout] with explicit FieldOffset attributes. C export auto-detects composite types (Vector3, Matrix4x4, pointer arrays).

Ultimap-style instruction-level code tracing. Sets INT3 (0xCC) software breakpoints at function entry points and logs every execution. Aggregates hit counts per address to produce a hot-code-path heat map. Win32-only — requires the Win32 debug API (DebugActiveProcess). Provide either "addresses" (list of specific hex addresses) or "startAddress" + "size" (range to scan for 0x55 push-rbp prologues). Max trace time: 30s, max hits: 10000.

Override field types in an inferred structure. Actions: set (define a type at offset+size), list (show all overrides), clear (remove all overrides). Overrides are applied in subsequent memory_structure_analyze calls. Supported types: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float, double, pointer, string_ptr, vtable_ptr, hex, padding, unknown.

Start an unknown initial value scan.

Remove a registered custom scan type by name.

Parse a vtable to enumerate virtual function pointers and resolve them to module+offset. Also attempts RTTI parsing for class name and inheritance hierarchy.

Poll a memory address until its value changes (like scanmem's "watch" command). Reads the current value, then polls at a configurable interval. Returns immediately with the old value, new value, and elapsed time when a change is detected. If no change occurs within the timeout, returns the unchanged value and a hint. Useful for "tell me when this variable changes" workflows.

Write data to process memory at a given address. If pid is omitted, the active browser renderer PID is auto-discovered from the current browser session.

Undo or redo the last memory write operation. Pass pid to scope the operation to a specific process — per-PID undo prevents reverting an unrelated process's write when multiple processes are being edited concurrently.

Write a typed value to a memory address. Supports undo/redo via memory_write_history(action=undo|redo).

Analyze an unpacked miniapp package.

Scan local directories for miniapp package files.

Unpack a miniapp package.

Decode a Mojo IPC hex payload into a structured field map.

Encode a structured Mojo IPC message into a hex payload.

Report Mojo IPC monitoring availability.

List discovered Mojo IPC interfaces and their pending message counts.

Retrieve captured Mojo IPC messages from the active monitoring session.

Aggregate the captured Mojo IPC buffer (non-destructive) into interface/method/direction breakdowns, top-N lists, and a capture time window. Does not drain the buffer.

Start or stop Mojo IPC monitoring for the active Chromium-based target.

Generate a Frida verification script that probes a target Chromium process for known Mojo C-API exports (MojoWriteMessage, MojoWriteMessageNew) across modules. Uses a curated symbol database covering Chromium M96+ across Win32, Linux, and macOS. Returns a ready-to-run Frida script and probe metadata. Honest boundary (B-class): symbol DB is manually curated; symbols may vary by build config. Verified flag is always false — confirm against the live binary.

Check native bridge backend health.

Export native symbols to connected analysis backends. Supports json/csv/idc/sqlite output; an optional sinceHash requests an incremental export (only changed symbols) from backends that support it.

Allocate raw guest memory (NOT a JNI handle — a real char* address). Optionally fill with initial data via fillBytes (base64). Returns the guest address to pass as an integer arg to call_symbol. Use at the start of a session to stage encrypted blobs for a native decrypt/signing routine, then read the output with nemu_read_memory.

Batch-bind host functions to ALL resolved import stubs in the GOT. Reads the GOT table (0x74000 range), finds every unique resolved address, and binds the given JS function body to each. Call after load_library to mock every unresolved shell import at once.

Register a JavaScript host function at a specific guest address, overriding any existing stub. The function receives guest registers (ctx.x(0)..x(7)), can read/write guest memory (ctx.read/ctx.write), and returns a BigInt value placed in x0. Use to mock custom shell imports at their resolved GOT addresses.

Decode a u32 LiteVM bytecode word into its opcode fields: group (G0-G7), sub-opcode, a1 register index, fl field index, imm signed offset, and validity. Matches the Python LiteVM Opcode.is_valid_opcode() semantics. No session needed — pure computation. Use to understand what a native bytecode word means without external scripts.

Scan a guest memory region and decode all valid LiteVM bytecode words. Reads `count` u32 words starting at `address`, decodes each one, and returns only the valid opcodes with their offsets. Much faster than manual decode+filter — one call to survey an entire bytecode table.

Call a function at an arbitrary guest address (e.g. a native method registered via RegisterNatives). Uses AArch64 AAPCS with args in x0..x7; returns x0. Set injectJni=true to prepend guest JNIEnv* as x0 + thiz=0 as x1 (standard JNI method convention).

Invoke an exported `Java_*` JNI function. Injects the guest `JNIEnv*` and thiz, then the Java arguments. Returns x0 — an int/jboolean directly, or a jobject/jbyteArray/jstring handle to resolve via read_byte_array. The main entry point for reversing a native signing/crypto routine.

Invoke an exported function by name following AArch64 AAPCS (integer args in x0..x7, result in x0). Auto-detects JNI signatures. Set injectJni=false to force raw arguments. Set debug=true for auto-NOP on NULL indirect calls + auto TLS prep.

Report native-emulator backend availability, supported features, and explicit ISA/SIMD gaps. Unsupported opcodes fail loudly instead of being reported as emulated.

Create a mock JNI object handle pre-populated with controlled data. Use BEFORE calling JNI functions to seed the handle table so that GetStringUTFChars / GetObjectArrayElement / GetIntField return expected values. Returns the handle id to pass as an argument to nemu_call_address or nemu_call_symbol.

Create an isolated ARM64 emulator session and return its sessionId. Each session owns its own CPU registers, guest stack, and JNI object table, so concurrent analyses never interfere. Destroy it with nemu_destroy_session when done; idle sessions auto-expire. Pass `files` to populate the virtual device filesystem (path→base64 content) so native code can fopen/fread assets like jiagu_config directly from the emulated FS.

Create a C++ vtable-backed object in guest memory. Allocates a vtable with `numSlots` entries (each pointing to a return-0 host stub) and an object that points to it. Use when native code does direct vtable dispatch (BLR X8 through [obj+offset]) — common in obfuscated SO files calling virtual methods on C++ objects. Returns {objectAddr, vtableAddr} for use with nemu_call_address/nemu_call_symbol.

Read a guest memory region and format it as a structured table of u32 or u64 values. Each row shows offset, hex value, ASCII preview, and optional annotations. Auto-classifies each word as pointer, bytecode, ASCII, or raw data. Pointers are resolved to show target data when possible.

Destroy an emulator session and free its memory (mapped library, stack, JNI tables).

Disassemble instructions. Two modes: (1) single-instruction — pass `opcode` (a number, 0x hex string, or hex bytes) and optional `pc`; no session needed. (2) batch — pass `sessionId`, `vaddr`, and `count`; reads `count` 4-byte words from guest memory starting at `vaddr` and returns a `{pc, opcode, asm}[]` list. Batch supports fixed-width ISAs only (arm64/aarch64, riscv32/riscv64, mips/mips32/mipsel); x86/x64 are rejected. A local lightweight decoder for trace readability, including common SSE/AVX/AVX2/AVX-512 EVEX, RISC-V, and MIPS instructions.

Read the dlsym resolution log from the current session. Tracks every symbol lookup the emulated code requested via dlsym() — essential for discovering which VM handler names an obfuscated dispatch engine tries to resolve. Actions: read (default, reads+clears), snapshot (read-only), clear.

Read and decode a CreateLitevm frame structure from guest memory. Parses the 256-byte frame fields: chain pointer, bytecode count, frame data, and sub-function flags. Essential for understanding the VM dispatch state at any point during execution.

Dump the PLT trampoline → GOT → symbol mapping for an AArch64 ELF shared object. Scans .text for the 4-instruction trampoline pattern (adrp x16 → ldr x17 → add x17,x16,x17 → br x17) used by obfuscated SO files and cross-references each slot against dynamic relocations to resolve the callee name. Use this when you need to know what "bl 0xACD0" actually calls without manual readelf + Python scripting.

List the loadable arm64-v8a native libraries (.so) packaged inside an APK, with their byte sizes. Use nemu_load_apk_library to load one. Note: libapp.so (Flutter Dart AOT) is listed but is not executable here — route it to the Dart layer.

GDB Remote Serial Protocol (RSP) TCP server. Starts a real TCP server on host:port that GDB clients can connect to. Provides full register read/write, memory read/write, step, continue, software breakpoints (Z0/z0), vCont extended step/continue, qXfer target description, thread listing, and feature negotiation (qSupported). The server dispatches commands to the nemu emulator session in real-time. Packet format: $data#checksum (RFC 5.1 GDB Remote Serial Protocol). Actions: start (launch TCP server), stop (shut down), status (server + clients). Note: step/continue are simulated (PC += 4, immedia…

Get the guest stub address for a JNI table index. Pass a specific `index` to look up one entry (returns 0 + bound=false if the index was never bound), or omit to return all bound index→stubAddress mappings. Use to read stub addresses from a session so they can be written into SO caches or external tooling that expects specific JNI function addresses (especially the extended indices 280-336 used by obfuscation VM dispatch bridges).

Inspect an AArch64 ELF .so before emulation and list imported symbols from dynamic relocations, including GOT offsets and whether each import is backed by the built-in bionic stubs. Use this to diagnose PLT/GOT NULL indirect-call failures without writing ad-hoc readelf/Capstone scripts.

Read the JNI diagnostic log for a session. Tracks every JNI function call (FindClass, GetMethodID, CallIntMethod, etc.) and unimplemented stub invocations. Use after nemu_call_symbol or nemu_trace to see what Java methods the native code tried to call. Actions: "read" (default) reads and clears the log; "snapshot" reads without clearing; "clear" clears without returning.

List all JNI object handles allocated in a session, with their kind and summary. Handles are opaque IDs (jclass, jstring, jbyteArray, jobject) that native code passes around. Use to verify mock setups and debug handle leaks. Optionally filter by kind (e.g. "class", "string", "bytes", "method", "field", "auto-object", "mock-int", "mock-string", "mock-boolean", "objarray") or by specific handle number.

List active emulator sessions with their creation and last-use timestamps.

List the exported function symbols of the loaded library — the names callable via call_symbol / call_jni_export.

Extract a specific arm64-v8a .so from an APK by name and load it into a session in one step (no temp files). Pair with nemu_extract_apk_libs to discover library names.

Load an AArch64 ELF shared object (.so) from a filesystem path into a session, mapping its segments and resolving exported symbols. Prerequisite for list_symbols / call_symbol / call_jni_export.

Load a chain of dependent libraries into a session, resolving inter-library imports. Pass dependency .so paths as dependencyPaths (loaded first in order), then the primary .so path. Each dependency exports are visible to the primary and later dependencies. Use this for FFmpeg-style multi-library loads where libijkplayer.so calls exports from libijkffmpeg.so and libijksdl.so.

Single convergence entry point for the guest-memory inspection family — one tool, five `action` subcommands, each mapping 1:1 onto an existing read-only memory tool (which remains available unchanged): read → nemu_read_memory (raw bytes as base64 preview/data), dump → nemu_data_dump (u32/u64 word table with pointer/bytecode/ASCII classification), chain → nemu_pointer_chain (follow pointer indirection hops), frame → nemu_dump_frame (decode a 256-byte CreateLitevm frame), scan → nemu_scan_memory (byte-pattern search over an address range, pattern as base64). Each subcommand accepts exactly the p…

Map a memory region in guest address space. Use to extend the mapped area for output buffers or scratch data that would otherwise cause unmapped-memory faults. Idempotent — safe to call on already-mapped regions.

Add a shadow memory overlay at a specific address. Reads from shadow take priority over underlying memory — use to provide mock data at addresses that would otherwise crash (e.g. address 0 where SO ELF header resides). Does NOT modify the underlying SO mapping.

Wrap base64 bytes as a JNI jbyteArray handle to pass as an argument into call_jni_export (e.g. the plaintext a signing routine consumes). Returns the handle.

Apply multiple memory patches in a single call. Each patch is {address, dataBase64, writeProtect?}. Faster than repeated nemu_write_memory calls — essential for atomic code patches that must be applied together to avoid intermediate corrupt states.

Walk a chain of pointers in guest memory. Starting from `base`, reads a u64 pointer, then follows it to the next address, repeating up to `maxDepth` times. At each hop, shows the address, the pointer value, and the first 32 bytes of data there. Essential for understanding CreateLitevm's x24 table indirection structure.

Map the TPIDR_EL0 (thread-pointer) TLS block so its memory is accessible for pre-population via nemu_write_regions. Returns the TLS base address. Use this before writing data to TLS offsets (e.g. frame-table pointer at +0x1768) that native code reads via mrs xN, tpidr_el0; ldr xM, [xN, #large_offset].

Resolve a jbyteArray handle (e.g. a native call's return value) back to its bytes, returned as base64 plus length.

Read raw bytes from guest memory at a given address. Returns a bounded preview by default; set includeDataBase64=true for full base64 within the configured cap.

Restore GPR registers from a previously-saved snapshot (created by nemu_regs_save). Partially restores: only registers that were saved are written back. Use after an obfuscated function call to recover decode/context registers.

Save a named snapshot of current GPR registers (x0-x30, sp). Returns a snapshot id usable with nemu_regs_restore. The snapshot persists until the session is destroyed or the name is overwritten. Use to preserve registers before calling an obfuscated function that corrupts callee-saved state.

Connect to a remote native-emulator session via IPC relay. Proxies nemu operations through a named pipe (Windows) or Unix domain socket (Linux/macOS) with JSON-RPC over length-prefixed frames. Use to drive ARM64 nemu sessions on a Linux host from a Windows MCP server (or vice versa).

Scan emulated memory for a byte pattern (like Volatility). Searches a guest address range for an exact byte match using Boyer-Moore-Horspool. Returns a list of matched addresses. Skips unmapped regions silently — use nemu_mem_map to extend the scan range if needed.

Inspect one emulator session without executing native code. Returns timestamps, exported symbols, unresolved imports, constructor faults, and active session count.

Load a JSON-serialised array of tool calls and execute them sequentially to set up a session. Each entry is {tool, args}. Supported tools: alloc_memory, write_regions, call_address, call_symbol, prepare_tls, setup_java_mocks, map_memory, bind_host_fn. Use this to replay a debug session from a saved JSON plan without repeating ~20 manual MCP calls.

Configure the ARMv8.3 Pointer Authentication key set used by PACIA/PACIB/AUTIA/AUTIB/PACGA instructions in this emulator session. Set a 128-bit key (32 hex chars) by key slot (ia/ib/da/db/ga) to match keys dumped from a real device via Frida. Note: the emulator signs with an 8-bit PAC field and a 32→64 duplicated modifier, so AUT of pointers signed by real hardware verifies as a mismatch (stripped in-place, control flow preserved) — round-trips inside the emulator stay self-consistent.

Set arbitrary CPU registers by index. Pass an object mapping register number to value (e.g. {0: 0x60000000, 10: 0, 11: 0x55150}). Supports x0-x30 and floating-point d0-d31. Use to fix up loop variables or inject context pointers before/after host function calls.

Override a specific vtable slot with a custom host function. The slot at vtableAddr + slotIndex*8 is rewritten to point to a stub executing `fnBody` (JS, with ctx.x/ctx.writeU64/ctx.persistReg etc.). Use to mock specific C++ virtual methods after creating a vtable with nemu_create_vtable.

Register a mock Java field the emulated native code reads back via JNI (GetFieldID/GetStaticFieldID + Get<Type>Field). Declaratively specify the value with valueInt, valueString, or valueBytes (base64) — the 'Java world' constant a native routine folds into its result. No code is executed.

Register a mock Java method for JNI callbacks. returnInt/returnString/returnBytes for single constant; returnMap (JSON) for per-key dispatch: first Java arg matched as key→{type,value}. Single-constant is fallback for unmatched keys.

Batch-register multiple Java method mocks in one call. Each entry in the array has the same fields as nemu_setup_java_mock: className, methodName, signature, plus one return value (returnInt, returnString, returnBytes, returnObject, returnArray, or returnMap). Use this to define the full mock chain without rebuilding jshook.

Invoke an exported symbol while recording every instruction executed (pc, opcode, step), optionally snapshotting named registers per step. Bounded by maxSteps. Use to follow the control flow / algorithm of an obfuscated native function.

Compare native VM state (read from guest memory) against an expected state (e.g. Python LiteVM dump). For each of ctx, table, and output, reports whether they match and lists the first mismatches. Use to cross-validate native VM execution against the known-good Python implementation.

Dump LiteVM state from guest memory at specified base addresses. Reads ctx (32×64-bit), table (32×64-bit), and optional output buffer. Returns structured hex values suitable for comparison with Python LiteVM dumps. Use after nemu_call_symbol to inspect native VM execution results.

Load VM state into guest memory. Takes ctx values and table values as hex strings and writes them at the specified base addresses. Use to bridge Python LiteVM state into native VM: run Python vm.run(), dump ctx/table as hex, then load into nemu guest memory before calling bb2i34u32clsb.

Write raw bytes into guest memory at a given address via base64 data. Use to update an input buffer between call_symbol invocations without re-allocating, or to patch code/data in place.

Write multiple memory regions in a single call. Accepts an array of {address, dataBase64} objects. Essential for atomic code patching: apply all patches in one call to avoid intermediate corrupt states.

XOR a region of emulated memory with a single-byte key. Returns the XOR result as base64. Use for quick decryption testing — XOR a buffer with a candidate key byte and inspect the preview without modifying guest state. Set dryRun=false to write the XOR result back into guest memory.

Listen on a local TCP port for one incoming connection.

Send raw TCP data to a remote host; accepts hex or text input.

Listen on a local UDP port for an incoming datagram.

Send a raw UDP datagram and wait for a response.

Analyze captured requests for bot-detection signals. Optionally supply a JA3/JA4 TLS fingerprint (from network_tls_fingerprint parse_client_hello) plus user-defined knownBad hash lists; matching hashes raise the bot score. Ships NO hardcoded feature library — the caller decides which hashes are bot-like.

Disable network request monitoring

Enable network request monitoring.

Export captured network traffic as HAR.

Extract authentication data from captured network requests.

Get captured network requests.

Get the response body for a captured request.

Get network statistics.

Get network monitoring status.

Compute an Akamai-style HTTP/2 fingerprint from one or more captured HTTP/2 frames (the client connection preface: SETTINGS + stream-0 WINDOW_UPDATE + any PRIORITY frames). Returns the canonical "<settings>|<window_update>|<priority>" string, a sha256 hash, and the structured fields (settings entries, window update increment, priorities). Ships NO hardcoded feature library — the structured fields are authoritative; the caller decides what is "bad". Pair with network_tls_fingerprint for full client identity.

Run an ICMP echo probe.

Manage network interception rules.

Measure repeated latency and compute percentile stats.

Manage network request monitoring.

Replay a captured network request with optional changes.

Measure round-trip time to a target URL.

Compute TLS/HTTP fingerprints for bot detection. compute_tls/compute_http build fingerprints from user-supplied lists; parse_client_hello parses a raw ClientHello record (hex) and emits JA3 + JA4 from the real wire bytes; analyze_request links a captured requestId.

Run an ICMP traceroute.

Navigate back in browser history.

Manage script blocking rules by URL pattern. Blocked scripts are prevented from loading/executing. Actions: add/block (add a rule), remove/unblock (remove a rule), list (show all rules), clear (remove all).

Click a page element by CSS selector.

Manage page cookies; clear requires matching expectedCount.

Start JS+CSS code coverage collection on the active page. Coverage tracks which bytes of each loaded script/stylesheet are actually executed. Use page_coverage_stop to stop collection and retrieve results.

Stop coverage collection and return per-script JS+CSS coverage results. Includes total bytes, used bytes, and coverage percentage per URL.

Emulate a mobile device profile.

Execute JavaScript in page context.

Navigate forward in browser history.

Control how JavaScript dialogs (alert/confirm/prompt/beforeunload) are answered. By default installs a persistent handler that auto-dismisses all dialogs. Set dismissAll=false for one-shot handling of the next dialog.

Hover over an element by CSS selector.

Inject JavaScript to run on every page load.

List page frames for frame targeting.

Read, write, delete, or clear localStorage entries for the current origin.

Navigate the page to a URL with wait and network options.

Simulate a key press by name.

Reload the current page.

Capture a page or element screenshot.

Register a named reusable JS snippet in the Script Library. Execute with page_script_run.

Execute a named script from the Script Library with optional runtime params (__params__).

Scroll to absolute or relative coordinates.

Select option(s) in a <select> element.

Read, write, delete, or clear sessionStorage entries for the current origin.

Set the browser viewport dimensions.

Query navigator.storage.estimate() for {usage, quota} and navigator.storage.persisted() to inspect the origin storage budget and persistence status (offline/PWA reverse engineering).

Type text into an element.

Upload one or more local files into an <input type="file"> element.

Wait for an element to appear.

Apply deterministic byte-level mutations to a hex payload.

Build a deterministic payload from field definitions.

Read a classic PCAP file and return compact deterministic packet summaries. PCAPNG is intentionally not supported.

Write a compact classic PCAP file from deterministic packet byte records.

Read a PCAPNG (pcap-ng) capture file and return structured Section/Interface/Packet blocks. Supports Section Header, Interface Description, Enhanced/Simple Packet, Name Resolution, and Interface Statistics blocks; unknown block types are surfaced as warnings. For multi-MB captures pass async:true to parse in a background task (MCP 2.0 Tasks) and poll with tasks_get/tasks_result instead of blocking this call.

Write a PCAPNG (pcap-ng) capture file from one or more interfaces and deterministic packet byte records. Emits a Section Header Block, an Interface Description Block per interface, and an Enhanced Packet Block per packet.

Get page performance metrics.

Start or stop a Chrome performance trace.

Report platform tool backend availability.

Check if a process has a debug port enabled for CDP attachment.

Detect APC (Asynchronous Procedure Call) injection in a process. Enumerates threads, probes each thread APC queue via NtQueryInformationThread(ThreadApcState), and detects threads in alertable wait state (SleepEx/WaitForMultipleObjectsEx). Returns verdict (clean/suspicious/infected), confidence score, and risk reasons. Requires elevated privileges (run as Administrator). Win32 only.

Detect process hollowing (malware technique that unmaps original process image and injects malicious code). Compares process memory sections (.text, .data, .rdata) with on-disk PE file using SHA-256 hashes. Returns detection result with confidence score and list of differing sections. WARNING: autoRestore=true is HIGH RISK, may crash the target process, and is Win32-only. Cross-platform: Win32 compares PE sections; Linux/macOS compare ELF/Mach-O executable sections via IntegrityScanner (autoRestore unavailable).

Enumerate open handles for a process using NtQuerySystemInformation. Resolves handle type and object name, decodes access masks, identifies security risks (high-privilege handles to sensitive processes, dangerous Token handles, inheritable sensitive handles, Section handles to executables). Skips name resolution for File/EtwRegistration types (known to hang). Requires elevated privileges (run as Administrator). Win32 only.

Enumerate all threads in a process. Returns thread IDs, with optional per-thread context and diagnostics. Cross-platform: Win32 uses CreateToolhelp32Snapshot; Linux reads /proc/{pid}/task; macOS uses `ps -M`.

Search for processes by name pattern. Returns a list of matching processes with PID, name, path, and window information.

Get detailed information about a specific process by PID, including command line, parent PID, and debug port status.

Pure-TS static hollowing indicator scan. Analyses /proc/pid/maps (RWX regions), /proc/pid/exe (deleted backing file), and PE headers (suspicious section names, RWX sections, entry point anomalies, mismatched binary path) without requiring native OS APIs. Complements process_detect_hollowing (which does live memory comparison). Provide at least one of: mapsContent, exeLink, peHex, or expectedImagePath. Honest boundary: Win32 live detection needs native API — use process_detect_hollowing for confirmed detection.

Terminate a process by PID. Requires appropriate privileges.

Launch an executable with remote debugging port enabled.

List all running processes. This is an alias for process_find with an empty pattern.

Resume a previously suspended process. Cross-platform: NtResumeProcess (Win32), SIGCONT (Linux), task_resume (macOS).

Suspend a process for forensic snapshotting. Cross-platform: NtSuspendProcess (Win32), SIGSTOP (Linux), task_suspend (macOS). Pair with process_resume to restore. Use before memory_scan/dump for a consistent snapshot. Requires admin/root on most platforms.

Get all window handles for a process.

Start or stop CPU profiling.

Auto-detect a protocol pattern from one or more hex payload samples.

Define a protocol pattern with delimiter, byte order, and field layout.

Dissect a raw DNS payload (RFC 1035 + EDNS(0)) into header flags, questions, answers, authorities, and additionals with full compression-pointer handling and OPT pseudo-record decoding.

Dissect a raw HTTP/1.x request or response payload (RFC 7230) into the start line, headers, and body. Unwinds chunked transfer-encoding and reports Content-Length / Content-Type / Content-Encoding hints.

Export a protocol pattern to a schema definition. format: proto (default, .proto-like text), ksy (Kaitai Struct for Wireshark/010 Editor), json-schema (draft-07).

Identify protocol type from hex payload samples.

Infer likely protocol fields from repeated hex payload samples.

Infer a protocol state machine from captured message sequences.

Generate a Mermaid state diagram from a protocol state machine definition.

One-stop tool router: accepts a natural language task description, returns recommended tools and next actions. Automatically detects workflow patterns, recommends activation order, and provides example arguments. Use this instead of search_tools when you want guided tool discovery with actionable next steps.

Description is built at runtime.

Correlate requested Skia node identifiers with the extracted scene tree.

Detect the active Skia renderer backend from the current page context.

Extract a lightweight Skia scene tree from the selected canvas.

Open a TCP session.

Get WebGPU adapter information (vendor, architecture, device). Used for fingerprinting GPU capabilities and detecting hardware-level vulnerabilities.

Capture GPU command queue submissions (render passes, compute dispatches). Used for analyzing GPU workload and detecting malicious shader behavior.

Capture WebGPU validation/out-of-memory/internal errors the target app swallows (via device uncapturederror), plus the current device.lost state. Optionally wraps createBuffer/createTexture in error scopes to attribute failures to specific calls. Surfaces the real diagnostics behind "empty buffer" / "zero draw call" symptoms.

Measure per-frame CPU and GPU cost over a rAF loop using GPU timestamp queries (device.limits.timestampPeriod conversion). Answers "how long did the GPU take" and "CPU-bound vs GPU-bound". Degrades to CPU round-trip timing with precision=cpu-roundtrip when the timestamp-query feature is unavailable.

Analyze GPU memory allocations and buffer usage. Identifies memory layout patterns that may be vulnerable to side-channel attacks. With track=true, snapshots are stored on the shared state board (webgpu_memory_<canvasId>) and the response includes the delta vs the previous snapshot plus the growth rate in KB/s.

Enumerate active render/compute pipelines, bind-group layouts, and render-pass descriptors by hooking GPUDevice createRenderPipeline / createComputePipeline / createBindGroupLayout (plus async variants). Captures the full descriptor (vertex/fragment entry points, buffer stride/attributes, bind-group layout entries, visibility) so a captured bindGroups index can be resolved to actual resources.

Compile WGSL shader and extract metadata (entry points, bindings, attributes). Validates shader code and detects potential security issues.

Parse WGSL or SPIR-V shader into AST and generate human-readable disassembly. Used for reverse engineering shader logic. SPIR-V input (hex/base64) is reflected into entry points, bindings, structs, and locations without compilation.

Capture WGSL shader sources a running app compiles via GPUDevice.createShaderModule — the only artifact revealing what a compute/render pipeline computes (e.g. physics vs. cryptominer). Pairs with webgpu_capture_commands to reconstruct what data each draw/dispatch operated on.

GPU timing analysis for side-channel detection. Measures GPU command execution time variance to detect cache-based side-channel attacks (Graz University 2025 research).