StaticApkAuditor MCP

StaticApkAuditor MCP

A Model Context Protocol (MCP) server that exposes Apktool-based decompilation plus a suite of custom static-analysis heuristics for Android APK security assessment, through natural-language commands in Claude Code / Claude Desktop.

What this is for

You point it at an APK. It decompiles it, then gives an AI assistant a set of tools to analyze the result — attack surface, permissions, hardcoded secrets, crypto usage, native libraries, business logic candidates — and cross-checks findings from other tools like MobSF. Every call is logged to disk as a markdown report, so you end up with an audit trail, not just a chat transcript.

This is a static-analysis aid, not a complete pentest. Several tools produce candidates for manual/dynamic verification, not confirmed vulnerabilities — this is called out explicitly in tool descriptions and in the built-in prompts. Runtime behavior (race conditions, workflow bypasses, actual data exfiltration) needs dynamic testing (Frida, Burp/mitmproxy, a real device) to confirm.

Quick Start

Assumes Java, Apktool, and Python 3.10+ are already installed (see Prerequisites below if not).

# 1. Set up the project folder
mkdir static-apk-auditor && cd static-apk-auditor

# 2. Create a venv and install the one dependency
python3 -m venv venv
source venv/bin/activate          # Windows: venv\Scripts\activate
pip install -r requirements.txt

# 3. Sanity check — should hang waiting for stdio input, Ctrl+C to stop
python3 server.py

# 4. Register with Claude Code (adjust paths to your actual location)
claude mcp add static-apk-auditor \
  --env APKTOOL_WORK_DIR=$(pwd)/data \
  -- $(pwd)/venv/bin/python3 $(pwd)/server.py

# 5. Verify it connected
claude mcp list

Then, inside a claude session, in the same folder you ran claude mcp add from (registration defaults to that folder's scope):

/mcp__static-apk-auditor__security_audit
/absolute/path/to/some.apk

or just ask in plain language — the model will call decode_apk and the rest of the tools on its own:

Decompile /absolute/path/to/some.apk and give me a quick security triage.

See Prompts and Tools below for everything available, or run /mcp in a Claude Code session to browse them interactively.

Project structure

static-apk-auditor/                  # your folder can be named anything — this is just an example
├── server.py                    # the MCP server — single file, FastMCP-based
├── requirements.txt              # just "mcp"
├── README.md                     # this file
├── prompts/
│   ├── security_audit.md         # 16-point checklist, OWASP Mobile Top 10 mapping
│   └── mobsf_review.md           # MobSF finding validation workflow
├── venv/                         # created locally, not part of the repo
└── data/                         # created automatically on first decode_apk call
                                   # (this is APKTOOL_WORK_DIR — see Configuration below)

Runtime data layout (created automatically)

Every APK you analyze gets its own self-contained folder under APKTOOL_WORK_DIR:

$APKTOOL_WORK_DIR/<apk_filename_without_extension>/
├── source/
│   └── <original>.apk           # copy of the APK you pointed the tool at
├── decoded/
│   ├── AndroidManifest.xml
│   ├── smali/, smali_classes2/, ...
│   ├── res/, assets/, lib/
│   └── ...                      # apktool's decompiled output
├── reports/
│   ├── 20260706_175359_809_decode_apk.md
│   ├── 20260706_175412_112_analyze_manifest.md
│   ├── 20260706_175430_501_check_root_detection.md
│   └── ...                      # one markdown file per tool call, ever
└── final_reports/
    ├── 20260706_223500_123_security_audit.md
    └── 20260706_224100_456_mobsf_review.md
                                   # the finished, synthesized reports
                                   # (Summary + Detailed Findings + Risk Table),
                                   # saved explicitly via save_final_report

Every tool call — regardless of which tool, regardless of success or failure — writes a timestamped markdown file to that APK's reports/ folder. This isn't optional per-call logging; it's a decorator (@logged_tool) applied to every registered tool, so nothing calling into this server goes unrecorded. Each report contains the tool name, the parameters it was called with, and its full output.

reports/ and final_reports/ serve different purposes: reports/ is the raw call log (every individual tool invocation, useful for auditing exactly what was checked and when), while final_reports/ holds only the polished, human-readable write-ups — the actual deliverable you'd hand to a developer or client. The security_audit and mobsf_review prompts both end with a mandatory call to save_final_report, which is what populates final_reports/; without that call, the synthesized report only exists in the chat response and isn't persisted anywhere on disk.

Prerequisites

1. Java JDK 8+ (required by Apktool)

# Ubuntu/Debian
sudo apt update && sudo apt install default-jdk

# macOS
brew install openjdk
java -version

2. Apktool

# Ubuntu/Debian
sudo apt install apktool

# macOS
brew install apktool
apktool --version

3. Python 3.10+

python3 --version

4. (Optional) aapt — for full get_apk_info metadata without needing to decode first

brew install aapt   # or: brew install --cask android-commandlinetools

If aapt isn't installed, get_apk_info falls back to parsing the already-decoded AndroidManifest.xml instead of failing silently.

Installation

git clone <your-repo-or-just-copy-the-files> static-apk-auditor
cd static-apk-auditor
python3 -m venv venv
source venv/bin/activate      # Windows: venv\Scripts\activate
pip install -r requirements.txt

Sanity check:

python3 server.py
# Should hang waiting for stdio input (that's normal) — Ctrl+C to stop.

Connecting to Claude Code

claude mcp add apktool-pro \
  --env APKTOOL_WORK_DIR=/absolute/path/to/static-apk-auditor/data \
  -- /absolute/path/to/static-apk-auditor/venv/bin/python3 /absolute/path/to/static-apk-auditor/server.py

Verify:

claude mcp list
claude mcp get apktool-pro   # should show "✔ Connected"

Note: claude mcp add registers the server scoped to the current directory by default (local scope). If you want it available from any project, add --scope user.

Connecting to Claude Desktop (alternative)

Edit your config file (macOS: ~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "apktool-pro": {
      "command": "/absolute/path/to/static-apk-auditor/venv/bin/python3",
      "args": ["/absolute/path/to/static-apk-auditor/server.py"],
      "env": {
        "APKTOOL_WORK_DIR": "/absolute/path/to/static-apk-auditor/data"
      }
    }
  }
}

Restart Claude Desktop after saving.

Configuration (environment variables)

Tools

Core (decompilation & manifest)

Security heuristics

Business logic reconnaissance

MobSF report validation

Prompts (guided workflows)

Prompts are invoked explicitly as slash commands in Claude Code (/apktool-pro:<name>), unlike tools, which the model calls on its own as needed.

Usage examples

Use decode_apk to decompile /path/to/app.apk

/apktool-pro:security_audit apk_path="/path/to/app.apk"

Use check_root_detection on the decompiled output

/apktool-pro:mobsf_review apk_path="/path/to/app.apk" mobsf_report_path="/path/to/mobsf_report.json"

To see all available tools and their exact parameters at any time, run /mcp in a Claude Code session and select apktool-pro.

Getting a MobSF report

If you're running MobSF locally:

# upload the APK, get back a hash
curl -F 'file=@/path/to/app.apk' http://localhost:8000/api/v1/upload \
  -H "Authorization: <MOBSF_API_KEY>"

# fetch the JSON report using that hash
curl -X POST http://localhost:8000/api/v1/report_json \
  -H "Authorization: <MOBSF_API_KEY>" \
  --data "hash=<hash_from_upload>" -o mobsf_report.json

Known limitations

• Static analysis only. Nothing here executes the app or intercepts real traffic. Business-logic findings and some "confirmed" static findings still need dynamic verification before you treat them as proven.
• build_apk output is unsigned. Sign with apksigner before installing on a device.
• Regex-based heuristics (check_ssl_pinning, check_root_detection, map_sensitive_flows, etc.) can miss obfuscated/renamed code and can false-positive on unrelated matches — treat their output as a shortlist to review, not a verdict.
• install_framework is only needed for decoding system/OEM APKs that reference framework-res.apk; most third-party app analysis won't need it.

Design notes

• APKTOOL_WORK_DIR is always respected — every APK gets a persistent, self-contained folder (source/, decoded/, reports/, final_reports/); nothing writes to a throwaway tempdir.
• get_apk_info falls back to parsing the decoded manifest if aapt isn't installed, rather than returning nothing useful.
• Every tool call is auto-logged (reports/); finished, synthesized reports are saved separately via save_final_report (final_reports/).
• Built on FastMCP for straightforward tool/prompt registration.

Legal / responsible use

Only analyze APKs you own or have explicit written permission to test. Decompiled APKs may contain sensitive user data — handle output accordingly and clean up APKTOOL_WORK_DIR after an engagement if it contains client data. This tool does not perform any network exfiltration or active exploitation on its own; PoC commands in security_audit output (e.g. adb shell am start ...) are meant to be run manually against a device/emulator you control.