manifestvet
Audits Android app attack surface without needing aapt, Java, or the Android SDK: parses compiled AXML manifests (plus APK/AAB/ZIP archives, standalone AndroidManifest.xml files, or source trees), resolves exported-component and permission defaults into a model, and reports findings from 40 rules with byte-level offsets. Exposes tools to scan an artifact, audit inline manifest text, tabulate components (exported, guard, weak guard), explain a rule, list rules, and emit SARIF 2.1.0 for CI.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
manifestvet
Read an Android manifest the way an attacker does — with the bytes that prove each answer, and no aapt, no Java, no dependency to install.
中文说明 · Rule reference · Why AXML needs its own reader
$ manifestvet scan app-release.apk
app-release.apk
package=com.example.vault minSdk=19 targetSdk=29 components=16 format=axml shift=0
45 findings critical=2 high=15 medium=16 low=10 note=2 risk=100/100
[critical] MVT001 Application is debuggable
android:debuggable="true" -- JDWP is reachable, private data is readable via adb
at line 19, offset 0xcc0
bytes: debuggable="true"
fix: Remove android:debuggable, or gate it on a build type (debuggable true only in debug).
[critical] MVT037 Exported component is gated by a permission any app can hold
activity .GuardedActivity is exported and guarded by android.permission.INTERNET
-- a normal/dangerous platform permission any app can request
at line 61, offset 0x1450
bytes: android:permission="android.permission.INTERNET"
fix: Guard with a signature-level permission, or set exported="false" and pass
data over a Binder interface with a caller check (getCallingUid).Contents
Related MCP server: APK Security Guard MCP Suite
Three steps
# 1. run it without installing anything
uvx --from git+https://github.com/xuange-hu/manifestvet manifestvet demo
# 2. audit an APK, a manifest file, or a whole source tree
uvx --from git+https://github.com/xuange-hu/manifestvet manifestvet scan path/to/app.apk
uvx --from git+https://github.com/xuange-hu/manifestvet manifestvet scan app/src/main/AndroidManifest.xml
# 3. put it in CI
uvx --from git+https://github.com/xuange-hu/manifestvet manifestvet scan app-release.apk \
--format sarif --fail-on high > manifestvet.sarifscan accepts .apk, .aab, .zip, a bare AndroidManifest.xml (compiled or source),
or a directory it walks, skipping build/, .gradle/ and intermediates/.
Baselines: accept known findings, fail only on new ones
# snapshot today's reality (exits 0 even with findings)
manifestvet scan app-release.apk --save-baseline .manifestvet-baseline.json
# later runs: findings recorded in the baseline are accepted; a NEW finding exits 1
manifestvet scan app-release.apk --baseline .manifestvet-baseline.jsonThe baseline file is diff-friendly JSON keyed by (rule, where, message) — deliberately
not line or offset, which move on every recompile. Targets are keyed relative to the
scan root, so the file survives a different checkout path. Commit it next to your CI
workflow.
resources.arsc: resolve @0x... values to real strings
An APK keeps android:label="@string/app_name" as a numeric reference. When the
APK carries resources.arsc, scan resolves those references (through chains)
to their literal values before the rules run, so findings name things instead of
ids. The table is readable on its own too:
manifestvet arsc app-release.apk # package / type / entry counts
manifestvet arsc app-release.apk --id 0x7f010001 # one id -> value, name, entry offsetPython 3.10+. Zero runtime dependencies. The mcp extra is the only optional one.
Why this exists
Every existing manifest checker either wraps aapt/apktool (so it needs a JDK and an
SDK, and can only tell you that the manifest says something) or reimplements the format
in a heavyweight framework. Three things follow from that, and they are the whole design:
1. Byte-level provenance. Findings carry the byte offset of the ResXMLTree_node — or
of the exact attribute — plus the line aapt recorded. --format sarif turns them into code
scanning annotations; manifestvet attrs dumps the whole tree with offsets so you can check
the tool's work instead of trusting it.
2. AXML is parsed, not shelled out. Attribute names do not exist in a compiled manifest:
android:exported is the integer 0x01010010, and the local name has to be recovered from
the resource map. That recovery is where manifests get misread, so it is implemented here,
tested against a real aapt2-produced APK, and documented in docs/axml.md.
3. The model, not the XML, is what gets audited. Rules ask an App object
"which components can another app reach without holding a permission?" — which means
android:exported defaults, <application android:permission> inheritance and
protectionLevel bitmasks are resolved once, correctly, in model.py.
The rules
40 rules in three stages. Full text with reasoning and fixes: docs/rules.md.
stage | what it looks at | examples |
1 — element | one node at a time |
|
2 — component | component + its intent-filters | exported service with no guard, provider with |
3 — app | relationships across components | a guard any app can hold ( |
The ones that catch real bugs rather than style:
MVT037 — an exported component "protected" by a normal/dangerous permission. Any app can request
android.permission.INTERNETand be granted at install; the guard is decorative. This is the most common false sense of security in Android manifests.MVT039 —
android:permission="com.example.app.SIG"where no<permission>of that name exists. Silently ignored, so the component is open while reading as guarded.MVT038 — two providers on one authority. One of them never installs, or one answers queries meant for the other.
MVT018/MVT019 —
grantUriPermissionsplus apath="/"rule: acontent://URI becomes a transferable capability that reads the file from any app.
MCP
Seven tools, for Claude Code / Cursor / Cline:
{
"mcpServers": {
"manifestvet": {
"command": "uvx",
"args": ["--from", "git+https://github.com/xuange-hu/manifestvet[mcp]", "manifestvet-mcp"]
}
}
}tool | use |
| audit an APK / manifest / directory |
| audit manifest text pasted inline — no file needed |
| the attack surface as a table: component, exported, guard, weak guard |
| one rule: what, why, fix, doc anchor |
| the table, filtered by stage or severity |
| SARIF 2.1.0 |
| audit a generated corpus; one call proves all 40 rules work |
manifestvet mcp --check prints the same list from the CLI.
How it compares
manifestvet | MobSF | apkleaks |
| |
runtime | Python stdlib | Django app + JADX + JDK | Python + jadx | Android SDK |
output | rules + byte offsets | web report | strings/URLs | raw attribute dump |
source manifests | yes (same rules) | no | no | no |
CI (SARIF, exit codes) | yes | no | no | no |
model of | yes | partial | n/a | no judgement |
Verified, not asserted
manifestvet demobuilds three manifests at runtime, compiles them to AXML, and asserts that all 40 rules fire across the corpus (tests/test_demo.py). Nothing is a checked-in binary fixture, so a rule cannot quietly stop being covered.The reader is tested against a real aapt2-compiled APK: package,
targetSdkVersion,debuggable, providerexported=falseand aandroid.permission.DUMPguard are asserted semantically, not just "it parsed".Source-XML and AXML inputs are asserted to produce identical findings — the same manifest audited on a dev machine and in CI cannot disagree.
ruffclean, tests on 3.10 / 3.11 / 3.12 / 3.13.
Limitations
Java/Kotlin code is not analysed: an exported activity that validates its extras is still reported, because the finding is about reachability, not about whether the code is careful.
android:protectionLevelis decoded from the bitmask; app-defined permission groups are not modelled.Resource references are resolved when the APK carries
resources.arsc; bag values (styles, arrays) are recorded but not decoded, and config qualifiers only pick the default-locale winner instead of ranking every configuration.AAB input reads
base/manifest/AndroidManifest.xml; feature-module manifests are audited when you point the tool at the source tree instead.
License
MIT.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
39 MCP tools (7 free, 39 Pro/Team): AI guardrails, PII/secrets, MCP lint, SSRF, JSON & EU checks.
Remote MCP for Android CLI agent build gate, structured receipts, audit logs, and reviewer-ready evi
MCP server for static security analysis of Android source code
Zero-config MCP security scanner for AI-generated apps. 25K+ vulnerability patterns.
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
- FlicenseNot gradedqualityDmaintenanceIntegrates multiple Android APK security analysis tools into MCP standard APIs for automated static and dynamic analysis and vulnerability detection.-
- 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-
- AlicenseBqualityBmaintenanceEnables safe, read-only analysis of Android APKs through six typed MCP tools, including manifest decoding, class listing, source decompilation, and reference searching, with paginated structured output and strict path/timeout limits.1819Apache 2.0