A baseline methodology for assessing Android/iOS application security, covering static analysis, dynamic testing, and backend API review. Suitable as a starting point for most mobile app engagements.
Identify the app's platform, architecture, backend endpoints, and third-party components before testing begins.
1. Identify target platform(s) (Android APK/AAB, iOS IPA) and obtain the application binary through an authorized channel. 2. Extract basic metadata: package name/bundle ID, version, minimum OS version, and permissions requested. 3. Identify backend API endpoints and third-party SDKs referenced in the binary or observed during initial traffic capture. 4. Set up a testing environment (rooted/jailbroken device or emulator, proxy tooling) for dynamic analysis. 5. Document the full attack surface: binary, backend endpoints, and third-party integrations identified.
Decompile the application and review its manifest, permissions, and embedded configuration for issues.
1. Decompile/unpack the binary (apktool/jadx for Android, class-dump/Hopper for iOS) for static review. 2. Review the manifest/plist for over-permissioned entries, exported components, and debug flags left enabled. 3. Search decompiled code and resource files for hardcoded API keys, secrets, or internal URLs. 4. Check for exposed backup rules, cleartext traffic permissions, and debuggable/testable build flags. 5. Document all static findings with their exact file/line location for reproducibility.
Determine whether sensitive data is stored insecurely on-device (plaintext files, weak encryption, exposed databases).
1. Use the application through its normal flows while monitoring on-device storage (SQLite databases, shared preferences/UserDefaults, cache/temp files). 2. Check for sensitive data (tokens, PII, credentials) stored in plaintext or with reversible encoding. 3. Review the platform keychain/keystore usage for storing secrets - confirm it's used correctly, not bypassed. 4. Check for sensitive data leaking into device logs, crash reports, or clipboard. 5. Document any sensitive data found unprotected, with the storage location and access requirements.
Verify network traffic is properly encrypted and resistant to interception via a proxy.
1. Configure an intercepting proxy (Burp Suite/mitmproxy) and attempt to capture app traffic with a trusted user CA certificate. 2. If traffic is visible, confirm whether certificate pinning is implemented and attempt to bypass it (Frida/Objection scripts, patched binary). 3. Review TLS configuration for weak ciphers, deprecated protocol versions, or certificate validation gaps. 4. Check for any traffic (analytics, ads, non-primary API calls) still sent over unencrypted HTTP. 5. Document whether pinning is present, whether it was bypassed, and any cleartext traffic observed.
Test the login flow, token handling, and session lifecycle for weaknesses.
1. Capture the authentication flow and review how tokens (JWT, OAuth, session cookies) are issued and stored. 2. Test token expiration, refresh behavior, and revocation on logout. 3. Check whether tokens are transmitted or stored in a way that's recoverable from the device (storage review, logs). 4. Test for account enumeration and weak lockout policy in the login/registration flow. 5. Verify server-side session invalidation on logout, not just local token deletion.
Assess whether device-level authentication (PIN, biometric) actually gates access to sensitive app functionality.
1. Identify all app features gated behind local authentication (app unlock, payment confirmation, sensitive data reveal). 2. Test whether the local auth check can be bypassed by manipulating the app's local state/response (Frida hooking the auth callback). 3. Test biometric fallback behavior (PIN fallback) for weaknesses. 4. Confirm sensitive actions are also re-validated server-side, not solely gated by client-side biometric checks. 5. Document any local authentication bypass found and the sensitive action it exposed.
Test exported components and custom URL schemes for hijacking and injection risks.
1. Enumerate exported Activities/Services/Broadcast Receivers (Android) or registered URL schemes/Universal Links (iOS). 2. Test exported components for unauthorized invocation from another app without proper permission checks. 3. Test custom URL schemes/deep links for parameter injection, unintended navigation, or data leakage. 4. Check for intent/URL-based bypass of authentication or business logic checks. 5. Document any exported component or deep link that can be abused by a malicious app on the same device.
Assess the difficulty of reverse engineering the application and whether tamper detection is effective.
1. Assess the level of obfuscation applied to the binary (ProGuard/R8 for Android, symbol stripping for iOS). 2. Attempt to recompile/repackage the app with a modified behavior (e.g. bypassing a client-side check) and reinstall it. 3. Test whether the app detects the repackaged/re-signed binary and refuses to run or alerts the backend. 4. Attempt runtime instrumentation with Frida to hook and modify function behavior at runtime. 5. Document the app's resistance (or lack thereof) to tampering and runtime instrumentation.
Verify root/jailbreak detection is present and cannot be trivially bypassed.
1. Run the application on a rooted (Android) or jailbroken (iOS) device/emulator and observe its behavior. 2. If detection is present, attempt common bypass techniques (Magisk Hide/Zygisk, Frida-based hooking of the detection routine, hooking libraries). 3. Confirm whether sensitive functionality (payments, sensitive data access) is actually blocked on a compromised device, or only a warning is shown. 4. Test for debugger detection and anti-Frida/anti-instrumentation checks. 5. Document detection presence, bypass success/failure, and what functionality remained accessible on a compromised device.
Test the backend APIs the mobile app talks to using the same methodology as a web API assessment.
1. Capture the full set of API endpoints called by the app across all its features (proxy capture during full app walkthrough). 2. Test each endpoint for broken object-level authorization (BOLA) by substituting IDs belonging to another test account. 3. Test for excessive data exposure - check whether API responses return more fields than the app UI displays. 4. Test rate limiting on sensitive endpoints (login, OTP, password reset) called by the mobile client. 5. Document any backend API finding, noting it applies regardless of client-side mitigations.
Review bundled third-party SDKs and libraries for known vulnerabilities and excessive data collection.
1. Enumerate all third-party SDKs and libraries bundled in the application (dependency manifest, decompiled package list). 2. Check each against known CVE databases for the specific bundled version. 3. Review what data each third-party SDK (analytics, ads, crash reporting) collects and transmits. 4. Flag any SDK collecting data beyond what's disclosed in the app's privacy policy. 5. Document outdated/vulnerable SDKs and any undisclosed data collection found.
Consolidate all findings with evidence, severity, and remediation guidance.
1. Compile all confirmed findings from static, dynamic, and backend testing into a single report. 2. Assign a severity to each finding (Critical/High/Medium/Low/Info) based on impact and exploitability. 3. Attach evidence (screenshots, code snippets, request/response pairs) for each finding. 4. Write remediation guidance specific to each finding, referencing OWASP MASVS controls where applicable. 5. Review the report for false positives before delivery.