mobile-re-mcp
This server is a static-analysis toolkit for mobile apps — it takes an APK or IPA file path and returns structured findings on configuration, permissions, secrets, and third-party SDKs.
Android (APK) analysis
Decompile and extract Retrofit HTTP annotations / OkHttp3 endpoints from smali, output as text or a Postman collection
Parse
AndroidManifest.xml: package info, activities, services, receivers, intent filters, exported components,debuggable,allowBackupList and categorize requested permissions, flagging dangerous ones separately
Scan for hardcoded secrets/API keys in dex,
resources.arsc, smali,strings.xmland assets (configurable min length)Pull Google/Firebase config from
google-services.jsonorres/values/strings.xmlInventory native
.solibraries per ABI, identify known packer/RASP/framework SDKs, and detect stripped/packed ELF section tablesDiff two builds of the same app: identity/SDK levels, security flags, permission and exported-component deltas, native library hash changes, optional secret deltas
iOS (IPA) analysis
Parse
Info.plist: bundle ID, version, URL schemes, App Transport Security, background modes, insecure configExtract privacy permission usage descriptions with HIGH/MEDIUM/LOW risk ratings
Analyze embedded entitlements via
codesign(get-task-allow, iCloud, keychain groups)Extract filtered binary strings (URLs, keys, emails, private IPs)
List bundled third-party frameworks mapped to categories (networking, analytics, ads, attribution, crash reporting)
Read
GoogleService-Info.plistfor Firebase/GCM/OAuth configTwo-layer secret scan of resource files plus the compiled app binary
Note: all operations are read-only file analysis requiring an absolute path — there are no live-device, hooking, patching, or network-capture tools in this schema.
Provides tools to analyze Android APK files for security issues, including manifest flags, dangerous permissions, Retrofit/OkHttp API endpoints, Firebase/GCP configuration, and hardcoded secrets.
Provides tools to analyze iOS IPA files for security issues, including Info.plist/ATS settings, privacy permissions, entitlements, binary strings, bundled frameworks, Firebase configuration, and hardcoded secrets.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mobile-re-mcp analyze /Users/me/Downloads/app.apk for hardcoded secrets"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
android-re-mcp is an MCP server for Android reverse engineering.
You point it at a real device and a target app, then just ask: what is this app, what's protecting it, and how do I get past that?
The assistant picks from 74 tools: decompile, hook, trace traffic, dump memory, patch smali or dex, sign and reinstall, and walks you through the answer.
It's one package: PyPI: android-re-mcp
The Python server (the PyPI package)
What it does exactly
pip install "android-re-mcp[all]" gives you an MCP server, started as android-re-mcp, that speaks MCP over stdio (or SSE on 127.0.0.1 with a bearer token) and exposes 74 tools over one Android target at a time:
Static work on the APK file itself — apktool and jadx decompilation, ripgrep searches across the decompiled folder, androguard manifest parsing and bytecode cross-references, apkid packer/obfuscator identification, apkleaks secret scanning, quark-engine behaviour rules (
quark_scan), and an orchestrator (apk_analyze_full) that runs all of those in one call and scores the protection tier.Dynamic work on a running app — spawn or attach a process with Frida, inject JavaScript, stream script output back, hook SSL pinning, dump and search process memory, trace storage, crypto and network calls from a built-in script collection you can extend with your own scripts.
Work on the phone — list devices, run shell commands, install APKs, pull and push files, capture logcat, mirror the screen with scrcpy, and take screenshots.
Network — start and stop mitmproxy (loopback only), read captured flows as structured JSON, export them as HAR for Chrome DevTools or Burp.
Patching and signing — edit smali in a decompiled folder, embed a Frida gadget so you can hook a non-rooted device, rebuild with apktool and sign with uber-apk-signer using your keystore or the debug one.
Native and cross-platform code — strings/exports/disassembly for
.sofiles, Il2CppDumper for Unity, Blutter and engine-version detection for Flutter, Hermes decoding for React Native.Workflow support — a RASP signature database and ready-made bypass scripts, per-target notes kept across sessions, a self-check of your toolchain, and 12 knowledge packs served as MCP resources and prompts (assessments, bypass escalation ladders, common mistakes).
It is Android only. Several tools change the device (install, push, patch), which is why the guard layer described below checks every call before it runs.
Install
pip install "android-re-mcp[all]"
android-re-mcp --setupIt needs Python 3.11 or newer. The base install is just the MCP server. The extras pick up the heavy libraries, and you can install parts instead of all:
Extra | What it adds | Which tools need it |
| frida, frida-tools | every |
| androguard, apkid, apkleaks |
|
| mitmproxy |
|
| quark-engine |
|
| capstone |
|
| everything above | — |
If Frida is already pinned in your environment, install without extras and the server will not touch it.
--setup downloads pinned, checksum-verified copies of apktool 2.12.1, jadx 1.5.6, uber-apk-signer 1.3.0, Il2CppDumper 6.7.46 and dexfile-cli 0.1.5 into ~/tools. adb comes from your package manager (sudo apt install adb); scrcpy and radare2 too. Run android-re-mcp --setup again any time to fill in whatever is missing.
Connect it
Claude Code:
claude mcp add android-re -- android-re-mcpopencode, in ~/.config/opencode/opencode.json:
{
"mcp": {
"android-re": { "type": "local", "command": ["/path/to/venv/bin/android-re-mcp"], "enabled": true }
}
}Claude Desktop, in claude_desktop_config.json:
{
"mcpServers": {
"android-re": { "command": "/path/to/venv/bin/android-re-mcp" }
}
}Use the full path to the command if it lives in a virtualenv. Any other client needs only the command, with no arguments. stdio is the default transport; --transport sse --port 8765 also works, listens on 127.0.0.1 only, and any other --host needs ANDROID_RE_MCP_TOKEN, which clients send as a bearer token.
Start with a check of what you have: ask "Run check_tools", and the assistant lists which tools it found (with versions) and which are missing, with install hints. On a set-up machine nearly everything reports available — only the optional extras you skipped show as missing.
A first session
Ask in plain language, and the assistant picks the tools. Some prompts and what they use:
"Check my devices and get frida-server onto the phone." (
adb_devices,frida_server_push)"Decompile /home/me/apks/app.apk and search the strings for token or secret." (
apk_decompile,search_strings)"What is this app, which framework, what protection does it use, and how bad is it overall?" (
apk_analyze_full)"Which protection does com.example.app use, and how do I get past it?" (
rasp_identify,rasp_bypass)"Track this app's network traffic." (
mitm_start, thenadb reverse tcp:8080 tcp:8080, open the app,mitm_read_flows,mitm_export_har)"Bypass SSL pinning in com.example.app and watch the requests." (
ssl_kill_switchor afrida_run_scriptofssl_pinning_universal)"Patch the license check in the smali, rebuild, sign and install it." (
smali_patch,apk_rebuild_sign,adb_install)"Swap one string in classes.dex without rebuilding the whole APK." (
dex_extract,dex_patch,dex_swap,apk_sign,adb_install— the dex-only fast loop: no apktool resource decode, no resource rebuild)"Dump the app's memory and find the session key." (
frida_attach,frida_find_bytes,frida_memdump)
The server also carries seven guided prompts (master-workflow, first-look, rasp-assess, bypass-ssl, bypass-root, bypass-frida, stuck) and keeps per-app notes so a later session can pick up where the last one stopped (memory_read, memory_write).
The tool set
Every tool returns structured JSON with a status field (ok, error, missing_tool) — your assistant can chain calls. File arguments are absolute paths validated by the guard. apk_decompile and apk_decompile_java land next to the APK (<name>_apktool/, <name>_jadx/); dumps and captures go to the private data folder.
Heavy list outputs are token-conserved: a search, a strings dump, logcat and Frida script output are capped per call (default 200 lines, ANDROID_RE_MCP_MAX_OUTPUT_LINES) with the honest total kept and an actionable narrowing hint, so one call can't flood the model's context.
Static analysis (11)
Tool | What it does | Needs |
| apktool decompile (smali + resources), or resources/smali only via | apktool |
| jadx decompile to Java source; falls back to apktool (smali) when jadx is unavailable, flagged with | jadx (apktool fallback) |
| apkid: packers, obfuscators, compilers, anti-tamper | apkid |
| apkleaks: hardcoded keys and credentials, report saved as JSON | apkleaks |
| runs apkid + apkleaks + manifest + quark in one call, adds framework guess and protection tier | apkid, apkleaks, androguard, (quark-engine) |
| two builds side by side: identity/SDK levels, security flags, permission and exported-component deltas, native-library sha256 changes, optional secret deltas, archive inventory | androguard (manifest section); everything else stdlib |
| Retrofit HTTP annotations, const-string URLs (deduped, host-grouped) and detected OkHttp3 client fields from smali, as a list or a ready-to-import Postman v2.1 collection | apktool (when given |
| Google/Firebase config: bundled | stdlib ( |
| quark-engine behaviour rules: scored matches like "send SMS" or "load dex from external source"; | quark-engine |
| androguard: package, versions, SDK levels, exported components, permissions, debuggable/allowBackup flags; | androguard |
| ripgrep with JSON output over any folder (a decompile, a dump, a HAR); capped per call with the honest total kept | ripgrep |
Bytecode deep-dive (3)
Tool | What it does | Needs |
| cross-reference callers/callees for classes and methods | androguard |
| list every javax.crypto / java.security call site and which API it uses | androguard |
| all URLs and hostnames from bytecode constants and assets, sorted into api/auth endpoints | androguard |
Frida sessions (6)
Tool | What it does | Needs |
| spawn an app with Frida and optionally inject a script | frida, rooted device or gadget |
| attach to an already-running process | same |
| inject another script into the live session | active session |
| drain what the hooking session printed (capped per call; the rest stays buffered) | active session |
| detach cleanly | active session |
| frida version, devices, server responsiveness, current session state — the "am I attached?" no-op read | frida |
| run any objection command against a package | objection |
Frida script library (3)
Tool | What it does | Needs |
| list available hook scripts by category (ssl_pinning, root_detection, crypto, memory, hooks, storage, network), including your own | nothing |
| read the JS source of a named script (8 ship with the package; yours override) | nothing |
| spawn + inject a named built-in script in one call, with config sent as | frida |
The 7 Java-hooking scripts ship as pre-built bundles with frida-java-bridge compiled in — frida 17 removed the Java global from script runtimes, so raw sources would die with ReferenceError on every modern client (memory_scan is pure-native and ships as-is). Rebuild them with python/src/android_re_mcp/frida_scripts/build_bundles.sh after editing the raw sources in that folder's src/. For a stealth frida-server (renamed binary on a non-default port), set ANDROID_RE_MCP_FRIDA_ENDPOINT (below).
Anti-detection (2)
Tool | What it does | Needs |
| push a frida-server (or the hluda/StrongR fork) matching your frida-tools version to the device | adb, frida-tools, binary in |
| spawn through the renamed hluda server so Frida port/name scans come up empty | hluda server running on the device |
Process memory (2)
Tool | What it does | Needs |
| dump every rw- memory region of the target to disk files | active session |
| search process memory for a UTF-8 string or hex pattern, with addresses | active session |
Device control (12)
Tool | What it does | Needs |
| list devices with serial and state | adb |
| run a shell command on the device (split on the host, safely) | adb |
| install an APK ( | adb |
| copy files between host and device | adb |
| stream and buffer up to 50k log lines in the background; reads are capped per call ( | adb |
| the current UI as structured elements (class, text, resource-id, bounds, clickable) | adb |
| extract and decode the React Native Hermes bundle to readable JS | hermes-dec or hbctool |
| mirror the device screen, optionally recording to MP4 | scrcpy |
| capture a PNG of the current screen | adb only |
Network (5)
Tool | What it does | Needs |
| start mitmdump bound to 127.0.0.1, write a | mitmproxy |
| stop it, report the capture path | — |
| parse the capture into JSON: method, URL, bodies, status | mitmproxy |
| export the capture as HAR for DevTools/Burp | mitmproxy |
| inject the ssl-kill-switch2 script (OkHttp, TrustKit, native SSL) into a running app | frida |
Patching and signing (4)
Tool | What it does | Needs |
| replace text or regex in one smali class, optionally scoped to one method; keeps a | a decompiled folder |
| full 6-step Frida-gadget embed: decompile, copy .so, write config, patch loadLibrary, rebuild, sign | apktool, java, gadget .so in |
| sign with uber-apk-signer (debug keystore or your | java, signer jar |
| apktool build + sign in one step | apktool, java, signer jar |
Native libraries (4)
Tool | What it does | Needs |
| strings from a | strings (or pure-Python fallback) |
| exported symbols per library | readelf/nm (or built-in ELF parser) |
| radare2 disassembly of a function (asm, graph or pseudocode) | radare2 |
| Unity: dump.cs + script.json from libil2cpp.so + global-metadata.dat | Il2CppDumper |
Native ELF security & code search (5) — added in the capstone integration review
Tool | What it does | Needs |
| checksec for an ELF: PIE, NX, RELRO, canary, fortify, RUNPATH | nothing (pure Python) |
| scan-based xrefs to an address in a .so: branches, adrp+add pairs, movz/movk immediates (literal pools/GOT not followed) | capstone |
| ROP gadget search ending in ret/bx/jmp-reg; | capstone |
| AES s-box, SHA-256/512 IVs, MD5 T-table, CRC-32, TEA delta, Base64 alphabets, Blowfish P-array — file offset + VA | nothing |
| arm64/x86_64 syscall number ↔ name, bundled from kernel headers | nothing |
DEX surgery (7) — added in the DexFile integration review (dexfile-cli 0.1.5)
Tool | What it does | Needs |
| version, target API, class/method/string counts, class list; magic-scans flat dex, 041 containers, wrapped cdex/dex (vdex parts incl. modern-era vdex, packer blobs, dey odex wrappers) | dexfile-cli.jar, java 17+ |
| pull every | dexfile-cli.jar |
| read any version → write the target (vdex/cdex → 037 by default — dex037 was introduced in API 24 and covers the cdex era; flat dex → 035 for jadx; 035 → 041 container); odex instructions written verbatim with an | dexfile-cli.jar |
| surgical dex-model edits: | dexfile-cli.jar |
| one smali class → dex ( | dexfile-cli.jar |
| shard a class list across dex files under the 64K-reference limit ( | dexfile-cli.jar |
| swap a patched dex back into an APK copy, other entries byte-identical (pure Python, no jar) | nothing |
Flutter / Dart (3)
Tool | What it does | Needs |
| engine commit hash + SDK/Dart version fingerprints from libflutter.so | nothing |
| AOT/JIT snapshot kind; warns when the ELF header was wiped (zShield) | nothing |
| Blutter run on libapp.so: class/method symbols, asm, pseudo-code for IDA/Ghidra | blutter clone |
RASP assessment (2)
Tool | What it does | Needs |
| vendor fingerprinting (Guardsquare, Arxan, Promon, Zimperium, custom) from APK entry names and apkid, plus a full native-library inventory: per-ABI ELF listing, known packer/RASP/framework/SDK/runtime identification, stripped/packed section-table signals | optional apkid |
| returns a ready Frida script for vendor + protection (root, SSL, Frida detection, integrity, emulator) | nothing |
Per-target notes (2) and Setup (2)
Tool | What it does | Needs |
| session notes per package, pre-seeded with a findings template so follow-up sessions can resume | nothing |
| full inventory of your toolchain with versions, paths, install hints and the MCP tools that use each entry ( | nothing |
| install a missing tool from a pinned SHA-256-checked download, pip or npm; | off unless |
Knowledge packs and prompts
Five MCP resources: knowledge://detection-patterns (root/Frida/emulator/integrity checks and their counters), knowledge://bypass-playbooks (escalation ladders), knowledge://framework-fingerprints (React Native, Flutter, Unity, Xamarin from artefacts), knowledge://crypto-patterns (hardcoded keys, weak IVs, insecure ciphers) and knowledge://common-mistakes. Seven MCP prompts wrap the same packs: master-workflow, first-look, rasp-assess, bypass-ssl, bypass-root, bypass-frida, stuck. Your client's prompt picker lists them; they cost nothing to call.
Eight bypass/monitor scripts ship with the package (ssl_pinning_universal, root_detection_bypass, frida_detection_bypass, crypto_monitor, memory_scan, method_tracer, storage_monitor, network_monitor) — every one accepts live config: post or send {type:'config', ...} (UPPER-case keys as shown by frida_list_scripts usage strings; lowercase accepted too). Drop your own script into ~/.local/share/android-re-mcp/frida_scripts using the same catalogue filename and yours is used instead of the shipped one.
Files and settings
Notes, captures and scratch files:
~/.local/share/android-re-mcp(ANDROID_RE_MCP_HOMEto move; created0700)Your settings:
~/.config/android-re-mcp/config.toml(ANDROID_RE_MCP_CONFIG) — today just[signing]keystore paths and passwordsDownloaded tools:
~/tools(ANDROID_RE_MCP_TOOLS_DIR); subfolders (jadx, platform-tools, il2cppdumper, scrcpy) are appended to the server's PATH if presentANDROID_RE_MCP_ALLOWED_DIRS— folders (separated by:) that all file arguments must stay insideANDROID_RE_MCP_DISABLE_TOOLS— comma-separated tools to switch off, e.g.adb_shell,adb_push,adb_pullANDROID_RE_MCP_MAX_OUTPUT_LINES— per-call cap for heavy list outputs (default 200;0disables) — the total stays honest and the result names how to narrowANDROID_RE_MCP_ALLOW_INSTALL=1— the only wayinstall_toolbecomes callable over MCP (--setupalways works)ANDROID_RE_MCP_FRIDA_ENDPOINT=127.0.0.1:31337— connect everyfrida_*tool to a remote frida-server instead of USB discovery. For a stealth setup (renamed server binary on a non-default port, reached viaadb forward tcp:31337 tcp:31337) USB discovery finds nothing — this is the switch that makes the dynamic tools work against it.
Staying safe
This server runs commands on your phone and your computer, so treat its tools with care.
Every call passes the guard first: file arguments reject a leading
-, NUL bytes, and protected locations (~/.ssh,~/.config/gh, shell rc files, keyrings, …);package,serial,portand similar arguments are pattern-checked; writes into/etcare refused.The stateful tools (
frida_spawn,adb_shell,adb_install,mitm_*, signing) change a real device — set them to ask first in your client, and keepANDROID_RE_MCP_DISABLE_TOOLSaround anything you do not want reachable.mitmproxy listens on 127.0.0.1. Run
adb reverse tcp:8080 tcp:8080and point the phone's proxy at 127.0.0.1:8080.SSE transport is loopback-only unless you set
ANDROID_RE_MCP_TOKEN; foreign Host headers are rejected.Downloads are pinned to a release and SHA-256-verified. Scratch files live in a private
0700folder, never/tmp.A sample you analyze can try to steer the assistant through its own strings and symbol names. Use a VM for hostile samples, and do not auto-approve tools that touch the device.
Related MCP server: mobile-security-mcp
Companion servers
Some capabilities are deliberately kept out of this package and paired with it as separate MCP servers — the token cost stays opt-in per project, and each tool keeps its own release cycle.
smali-lsp (github.com/surendrajat/smali-lsp) — a Language-Server-grade smali engine (224 Dalvik opcodes, inheritance-aware indexing) with a built-in MCP mode. It is the semantic layer this package deliberately does not reimplement: references, call graphs, workspace symbol search and — most valuably — smali_diagnostics, which reports what the assembler or verifier would reject after a hand edit. Wire it into the patching loop so a bad edit fails before apk_rebuild_sign burns a rebuild:
apk_decompile -> smali_index -> smali_patch edits -> smali_diagnostics -> apk_rebuild_signBuild it once (JDK 17+, ./gradlew shadowJar) or grab an upstream release, then register it as its own server — it needs an apktool decompile, which apk_decompile already produces (<name>_apktool/):
claude mcp add smali-lsp -- java -jar /path/to/smali-lsp.jar mcp// opencode / Claude Desktop config
{ "smali-lsp": { "type": "local", "command": ["java", "-jar", "/path/to/smali-lsp.jar", "mcp"], "enabled": true } }Its 14 tools add roughly 0.7k tokens of catalog when enabled — leave it off for sessions that never touch smali. The other integrations came from the same consolidation reviews: the native-ELF suite and the dex surgery are pinned-jar or in-package tools here (the full capstone server was rejected — 25 tools for mostly duplicative capability), all documented in docs/code-review-and-extensions.md.
Working on it
The Python server lives in python/ with its own README, config and tests. CONTRIBUTING.md explains how to add a tool or a detection pattern, SECURITY.md is for reporting vulnerabilities, and CHANGELOG.md lists what changed. docs/code-review-and-extensions.md documents the current function of the server, findings from a full review, and the proposed extensions.
License
MIT. © 2026 FlyPhantomFly.
Available Tools
14 toolsandroid_api_extractorA
Decompiles an APK and extracts Retrofit HTTP annotations and OkHttp3 endpoints from smali bytecode. Outputs a list of API endpoints or a Postman collection.
Inputs: apk_path, smali_folder, output_format.
android_google_servicesA
Extracts Google and Firebase configuration from an APK. Parses google-services.json if present, then scans resources.arsc for string values using the strings command. If a smali_folder (apktool output) is provided, parses res/values/strings.xml directly for structured key=value output.
Inputs: apk_path (required), smali_folder.
android_native_librariesB
Enumerates every ELF .so shipped in an APK (per ABI), identifies known packer/RASP/framework/SDK libraries by name, and inspects ELF headers for stripped-or-packed section tables.
Inputs: apk_path (required).
android_secrets_scannerA
Scans an APK for hardcoded secrets and API keys. Without smali_folder: runs strings on classes*.dex and resources.arsc, plus scans text assets inside the APK. With smali_folder (apktool output): scans res/values/strings.xml and assets as plain text files.
Inputs: apk_path (required), min_length, smali_folder.
apk_diffA
Diffs two builds of the same app (APK vs APK): identity/SDK levels, security flags, permission and exported-component deltas, native-library changes (sha256), optional secret deltas and an archive inventory.
Inputs: new_path (required), old_path (required), skip_secrets.
apk_manifest_analyzerA
Parses AndroidManifest.xml from an APK. Extracts package info, activities, services, receivers, intent filters, and highlights security-relevant flags like exported components, debuggable, and allowBackup.
Inputs: apk_path (required).
apk_permissions_checkerB
Extracts and categorizes permissions requested by an APK. Dangerous permissions (those that grant access to sensitive user data or device features) are highlighted separately.
Inputs: apk_path (required).
ios_binary_stringsA
Extracts printable strings from an iOS app binary and filters for security-relevant patterns: HTTP/S URLs, API keys, AWS/Firebase/Google credentials, email addresses, and private IP addresses.
Inputs: ipa_path (required), filter, min_length.
ios_entitlements_checkerA
Extracts and analyzes entitlements embedded in the iOS app binary using codesign. Detects dangerous entitlements like get-task-allow (debug builds), iCloud containers, and keychain groups.
Inputs: ipa_path (required).
ios_frameworks_detectorA
Lists all third-party frameworks bundled inside an IPA (from the Frameworks/ directory). Maps known frameworks to categories: networking, analytics, ads, attribution, crash reporting, etc. Highlights privacy-relevant SDKs.
Inputs: ipa_path (required).
ios_google_servicesA
Extracts Google and Firebase configuration from an IPA. Parses GoogleService-Info.plist for API key, project ID, database URL, storage bucket, GCM sender ID, and OAuth client IDs. Also applies Google pattern scanning across all text plist and JSON files in the IPA.
Inputs: ipa_path (required).
ios_manifest_analyzerA
Parses Info.plist from an IPA file. Extracts bundle ID, version, URL schemes, App Transport Security settings, background modes, and highlights insecure configurations.
Inputs: ipa_path (required).
ios_permissions_checkerB
Extracts privacy permission usage descriptions from an IPA's Info.plist. Each permission is categorized by risk level (HIGH / MEDIUM / LOW) with an explanation.
Inputs: ipa_path (required).
ios_secrets_scannerB
Scans an IPA for hardcoded secrets and API keys. Layer 1: scans text resource files (JSON, XML, .strings, XML plists) inside the IPA. Layer 2: extracts the app binary and runs the strings command to find constants in compiled code.
Inputs: ipa_path (required), min_length.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Android and iOS tools are cleanly separated by platform prefix, and each tool targets a distinct artifact (manifest, permissions, entitlements, secrets, google-services, frameworks, native libs). Minor overlap exists between the secrets scanners and the google-services tools, both of which perform pattern scanning over plists/resources, but the descriptions delineate them adequately.
Names are consistently snake_case with a platform prefix (android_, apk_, ios_) followed by the target artifact, which is readable and predictable. The mix of apk_ and android_ prefixes for what is essentially the same platform is a small deviation from a single uniform convention.
14 tools is squarely within a well-scoped range and each tool corresponds to a distinct static-analysis step on APK or IPA files. No tool feels redundant or padding.
The surface covers the core mobile RE workflow: manifest/plist parsing, permissions, entitlements, secrets, embedded SDKs, native libraries, endpoint extraction, and APK diffing. Gaps remain—no certificate/signing verification, no iOS binary diff counterpart to apk_diff, and no network security config parsing—but these are workaroundable.
Maintenance
Related MCP Connectors
Scan Android and iOS apps for security issues: findings, MASVS mapping and pentest reports.
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
MCP server for static security analysis of Android source code
Scan AI agent skills, MCP server packages and MCP configs before you install them. Static analysis.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceThis is an MCP (Model Context Protocol) compatible tool that allows MobSF (Mobile Security Framework) to scan APK and IPA files directly via Claude, 5ire, or any MCP-capable client.24MIT
- AlicenseAqualityDmaintenanceAn MCP server that enables AI assistants to analyze Android APK and iOS IPA files for security issues through natural language conversation, including permission auditing, secret detection, and SDK enumeration.1217 npm8MIT
- FlicenseBqualityDmaintenanceEnables local-first static and optional controlled dynamic analysis of Android APK artifacts, with provenance-aware downloads, Markdown reports, and structured security findings via MCP stdio tools.9-
- FlicenseNot gradedqualityBmaintenanceEnables Android APK security auditing through natural language by decompiling APKs with Apktool and running static analysis heuristics for attack surface, permissions, secrets, crypto, native libraries, and more, with every analysis logged to disk as markdown reports.-