Frida Mobile MCP

Dump a loaded module from process memory to a file on the host (e.g. an unpacked/decrypted library). The file is laid out base-relative: file offset 0 is the module base, readable ranges are copied in 1 MiB chunks, unreadable gaps are zero-filled, so it can be imported into Ghidra/IDA as a raw binary at the returned `base`. out_path must be absolute and inside the current directory, the OS temp directory or ~/.config/frida-mobile-mcp/dumps.

List exports (functions and variables) of a specific module, paginated with offset/limit. Hook results with hook_method using "module!name". Addresses are absolute runtime pointers; subtract the module base to get the Ghidra/IDA offset (or use resolve_address with a "module+0xoff" target).

List imports of a specific module (functions it calls in other libraries), paginated with offset/limit. Each entry carries the providing `module` when known, so "module!name" can be hooked directly. Addresses are absolute runtime pointers; subtract the module base to get the Ghidra/IDA offset (or use resolve_address with a "module+0xoff" target).

List loaded modules (shared libraries) in the target process with name, base, end (base+size), size and path. Optional case-insensitive regex `filter` matches against name or path. Use base/end to rebase a Ghidra/IDA project; Addresses are absolute runtime pointers; subtract the module base to get the Ghidra/IDA offset (or use resolve_address with a "module+0xoff" target).

List symbols (including non-exported/debug symbols) of a specific module. Only available on Linux, Android, iOS and macOS. Filtering (case-insensitive regex on the symbol name) and offset/limit paging happen inside the agent, so large symbol tables stay cheap. Addresses are absolute runtime pointers; subtract the module base to get the Ghidra/IDA offset (or use resolve_address with a "module+0xoff" target).

Make a loaded script survive session detach: frida pins it in the target so it keeps running after we detach (or the host exits). Trade-off — once eternalized the script can no longer send messages back, be unloaded, or be inspected; it is fire-and-forget persistence. Use it to leave a bypass/monitor running while you free the session. Give the session_id and the script_id returned by hook_method / execute_script / watch_loads.

Execute a custom Frida JavaScript/TypeScript script in a target process (Frida 17 agent). Provide either inline source code or a file path. Three source kinds are supported and detected automatically (override with `source_kind`): classic (non-module) JavaScript, where the `Java` and `ObjC` globals are auto-injected by platform (Java on Android, ObjC on iOS/macOS; override with `bridges`) so legacy Java.perform()/ObjC scripts keep working with their own line numbers; ES modules (import/export, JS or TS) such as `import Java from "frida-java-bridge"`, which are compiled on the host with the Fri…

Launch a mobile app and gather comprehensive initial context including loaded classes, modules, and libraries. This is the recommended starting point for any app analysis. The app will be spawned in suspended mode, instrumented, then resumed. Returns: pid, platform, loaded modules, and filtered class list.

Turn a Frida script into a STANDALONE classic .js file that the plain frida / frida-tools 17 CLI can run with `frida -U -f <package> -l file.js`, without this MCP server. The output is a header comment + the frida-mobile-mcp preamble helpers + the script body. Provide exactly one of source (inline) or name (a saved script). It does NOT bundle the Java/ObjC bridges (the Frida 17 CLI injects those) and does NOT emit TypeScript. With out_path the file is written and its path returned; otherwise the text is returned inline. This tool only transforms text, so it does not require allowCustomScripts.

Scan live process memory for the STRUCTURE of secrets, not just names or byte patterns. Finds keys even when you never reached the code that uses them: an RC4 key schedule (256-byte permutation of 0..255, byte[] or Java int[256] — the rc4demo case), an AES key schedule (aeskeyfind-style verification, AES-128/192/256, both encryption AND decryption schedules — and it is MODE-INDEPENDENT: the same expanded key backs CBC/CTR/GCM/XTS), a ChaCha20/XChaCha20 key (located by the exact "expand 32-byte k" sigma constant, key at +16) and Salsa20 state, high-entropy 16/24/32-byte buffers (candidate symme…

Get help on how to use frida-mobile-mcp tools. Use this to learn about available capabilities, method hooking patterns, address notation, script kinds (classic/esm/bundle), TLS capture and example workflows. Topics: overview, hooking, tracing, memory, scripts, native, tls, mobile, examples, advanced, evasion, script_catalog, script_api, recipes.

Push a local frida-server binary to an Android device and make it executable (adb push + chmod 755). Download and decompress the correct .xz for the device ABI first (frida_server_status gives the asset URL).

Start frida-server detached on an Android device (adb shell, daemonized with -D), optionally via su. Supports a custom listen address/port and a renamed binary path for stealth setups, then confirms the server came up.

Report whether frida-server is running on an Android device (via adb): its PIDs, the device CPU ABI, the matching frida release arch, and the exact GitHub .xz asset URL to download for the installed frida-node version.

Stop frida-server on an Android device by sending a signal to the matching process (adb shell pkill, optionally via su), then report any remaining PIDs.

Turn a secret you already located (e.g. from find_secrets_in_memory) into a reusable anchor pattern: a stable byte signature near the key plus the offset from it to the key. Reads a small window around the address, then derives a recognizer-aware anchor (ChaCha sigma constant, PEM/DER/JWT header, or the longest stable run adjacent to the key). Returns a scan_memory pattern to re-locate the secret by shape across restarts, plus a friTap offsets entry and an ms_agent anchor to hand to capture_tls. This finds no new secret — give it one you have.

Get detailed information about a device including OS version, architecture, and system parameters.

Get the currently foreground application on the device.

Retrieve buffered messages from active scripts and hooks. Messages include hook invocations, trace hits, script output (send() calls), and errors. Use "since" for pagination to get only new messages.

Get an overview of connected devices, active sessions (with platform, script count and last activity), hooks, traces, and the most recent session detaches / process crashes (recent_detaches). Use this first to understand what is available before starting any instrumentation work, and after a session is lost to see why.

Low-level hook with custom onEnter/onLeave JavaScript handlers. For advanced use when hook_method does not provide enough control. Custom handler bodies require allowCustomScripts: true in config; without them the hook sends default enter/leave events. Handler bodies are compiled as functions (new Function) inside the agent: `this` is the Interceptor invocation context (this.context, this.returnAddress, this.threadId, and any fields you set in on_enter are visible in on_leave). Java/ObjC globals are available (auto-injected by platform). A static-analysis finding can be passed as evidence {mod…

Hook a method to intercept calls with auto device/session management. Provide the app target (or a session_id of an existing session) and method pattern. Supports Java methods (Android: "com.example.Class.method"), Objective-C methods (iOS: "-[NSURLSession dataTaskWithRequest:]"), and native functions in any notation: "libssl.so!SSL_read" (module export), "libfoo.so+0x1234" or "libfoo.so+4660" (module-relative offset, as shown by Ghidra/IDA), "0x7f1234567890" (absolute address), or "!open" (global export searched across all modules). Native backtraces are reported as "module+0xoff (symbol)". J…

Inject a native agent library (.so/.dylib) from the host into a target process via Frida's injector, independent of the JS engine — the parity path for a prebuilt Frida gadget/agent or a custom .so. Runs arbitrary native code in the target, so it needs allowNativeInjection (a capability separate from allowCustomScripts). The library must match the device architecture (arm64-v8a etc.); its optional exported entrypoint is called with the data string. Returns the frida injectee id.

Kill a process on the target device.

List installed and running applications on the target device.

Enumerate all Frida-visible devices including local, USB, and remote devices. Equivalent to frida-ls-devices CLI command.

List running processes on the target device. Equivalent to frida-ps CLI command.

List the Frida scripts saved in the local library (~/.config/frida-mobile-mcp/scripts/) with their description, creation time and size. Returns an empty list when nothing has been saved yet. No device is required.

List all active Frida sessions managed by this server.

List the threads of the target process (id, name, state, current pc as module+0xoffset). With backtraces: true each thread also gets a symbolised backtrace (up to 8 frames) captured from its register context.

Gateway to mobile-mcp UI automation tools. Perform screenshots, taps, swipes, text input, app management and more. Common actions: mobile_take_screenshot, mobile_list_elements_on_screen, mobile_click_on_screen_at_coordinates (params: {x, y}), mobile_swipe_on_screen (params: {direction}), mobile_type_keys (params: {text}), mobile_launch_app (params: {appId}), mobile_list_apps. Call without action to see all available actions.

Cast a wide net over cryptography instead of hooking one method at a time. In a single persistent script it discovers and hooks ALL likely crypto sinks at once — app-owned Java classes whose name matches a crypto pattern (every overload of every declared method), plus the framework sinks that almost every app funnels through: javax.crypto Cipher (doFinal/init/getInstance), Mac, MessageDigest and SecretKeySpec on Android; CommonCrypto (CCCrypt, CCCryptorCreate, CC_SHA256, CC_MD5) on iOS; and native OpenSSL/BoringSSL (EVP_*Update, RC4, AES_set_encrypt_key). Every call dumps its byte[]/String key…

Read raw memory from a target process. Requires an active session. Address in any notation: "0x7fff12345678" (absolute), "libfoo.so+0x1234" or "libfoo.so+4660" (module-relative offset), "libssl.so!SSL_read" (module export), or "!open" / "open" (global export). Max 4MB per read. Returns hex-encoded bytes plus the resolved absolute address and module+offset (rva).

Translate between absolute process addresses and static-analysis coordinates. Give "0x7f..." to get module+0xoffset (+ nearest symbol); give "libfoo.so+0x1234" or "libfoo.so!func" to get the absolute runtime address. Use it to hand addresses between Frida and Ghidra/IDA.

Resume a suspended process (after spawn_process).

Run a pre-built Frida script from the built-in library. Call without script_name to list all available scripts. Available scripts include: ssl_pinning_bypass, root_jailbreak_bypass, class_enumeration, method_hook, crypto_monitor, network_inspector, keychain_prefs, filesystem_monitor, anti_frida_evasion.

Load a script previously saved with save_script into a target process. Resolves (or reuses) a session the same way execute_script does and runs the stored source as a custom agent: classic JavaScript gets the Java/ObjC bridges injected by platform, ES modules are compiled with the Frida Compiler, and frida-compile bundles are loaded as-is. Provide a target (app id, process name or PID) or an existing session_id. Requires allowCustomScripts to be enabled in config.

Save a Frida script to the local library (~/.config/frida-mobile-mcp/scripts/) so it can be re-run later with run_saved_script or shared with export_script. Stores the raw source as <name>.js plus a <name>.json metadata file (sha256, size, created timestamp, description). Names are restricted to letters, digits, underscores and hyphens. Refuses to overwrite an existing script unless overwrite is true. Requires allowCustomScripts to be enabled in config.

Scan process memory for a byte pattern. Pattern format: "48 89 5c 24 ?? 57" where ?? is a wildcard. Optionally limit scan to a specific module.

Search for classes and their methods by pattern in a running app. Combines class enumeration and method listing. Use regex patterns like "Login", "com\.example\.auth.*", or "NSURLSession". Returns matching classes with their methods when include_methods is true.

Search the purpose-indexed library of ready-to-run classic-JS Frida recipes (custom Java crypto-key capture, standard javax.crypto key/IV, native export hook, JNI RegisterNatives discovery, custom-classloader enumeration, intent/deeplink trace, WebView bridge, iOS Keychain). Returns ranked recipes with their classic-JS source and usage notes; adapt the source and run it with execute_script. An empty query lists the whole library.

Explicitly select the active Frida device for subsequent operations.

Enable, disable, or list device-wide spawn gating. When enabled, every newly spawned process (including app-launched child/isolated processes that often run RASP/anti-Frida checks) is held suspended until released. Use "list" to see pending spawns and children, then attach_process + hook_method, and resume_process to release each by PID.

Spawn a new process in suspended state for early instrumentation. The process will be paused until resume_process is called.

Clean up all hooks, scripts, and traces on a target. The "undo everything" tool. Detaches the Frida session and frees all resources. Use when you are done analyzing an app or want to start fresh.

Arm a broad set of cheap entry-hooks over a target set and track which have been REACHED (covered) vs which are still COLD — the reachability signal for a drive loop. Unlike trace_method (time-boxed, logs every call), this is persistent and entry-only: it answers "what code have I NOT exercised yet, so where should I keep driving?". Scope can be a single class (all its methods), a class/package glob ("com.example.*"), a native module glob ("libfoo.so!*"), or an ObjC pattern ("-[MyClass *]"). Workflow: arm it, then alternate trigger_and_wait (drive the UI) with trace_coverage {report_only:true}…

Trace function calls matching a pattern for a specified duration. Simplified frida-trace equivalent. Supports glob patterns like "com.example.network.*" for Java, "-[NSURL*]" for ObjC, and "libssl.so!SSL_*" for native. Returns all captured invocations after the duration expires.

Correlate a UI action with instrumentation output in one round-trip: optionally perform a mobile_action (tap/launch/type) on the session's device, then block until at least `expect_messages` new messages/hook hits arrive (or timeout). Returns exactly the messages the trigger produced and which hooks fired. This is how you confirm "this tap ran the hooked code" — or learn "nothing fired, the hypothesis is wrong" — instead of tapping blindly and polling get_messages. Install hooks first (hook_method / discover_crypto → hook_method), then trigger_and_wait.

Remove a specific hook by its hook ID.

Unload a single script (hook, trace or custom script) from a session while keeping the session attached. Use the script_id returned by hook_method, trace_method, execute_script or run_prebuilt_script. Hooks and traces that belong to the script are removed from the server state. Use stop_instrumentation to tear down a whole session instead.

Check a Frida script for syntax, type and Frida 17 API problems without a device. Use it before execute_script. Classic (non-module) scripts get a JavaScript syntax check plus a lint for APIs removed in Frida 17 (static Module/Memory helpers, *Sync enumerators); referencing them throws at runtime, so they make the result not ok. ES module scripts (import/export) are compiled with the Frida Compiler: strict (default) runs a full TypeScript type check; plain JavaScript is only syntax-checked unless language is "ts". frida-compile bundles (source starting with the 📦 marker) are accepted as-is. P…

Install a persistent watcher that reports what the app does AFTER attach, straight into the session message buffer. Three signal families, each toggleable: (1) native libraries (.so) loaded late (dlopen/android_dlopen_ext), observed via Frida's loader module-load notifications — no dlopen hook, so it will not destabilize the target — meaning a library that only appears after a UI action is still seen; (2) Java classes loaded late via ClassLoader.loadClass (Android only; the Java.available guard makes it a no-op elsewhere); (3) anti-instrumentation / anti-debug reads of canonical /proc location…

Write raw bytes to process memory. DISABLED by default for safety - enable via config (memoryWriteEnabled: true). Provide hex-encoded data. Address in any notation: "0x7fff12345678" (absolute), "libfoo.so+0x1234" or "libfoo.so+4660" (module-relative offset), "libssl.so!SSL_read" (module export), or "!open" / "open" (global export).