Conducting Mobile App Penetration Test
When to Use
- Testing mobile applications before release to identify security vulnerabilities and data protection issues
- Conducting compliance assessments against OWASP MASVS (Mobile Application Security Verification Standard) levels L1 and L2
- Evaluating the security of mobile banking, healthcare, or government applications handling sensitive data
- Testing mobile apps that interact with backend APIs to assess the end-to-end security of the mobile ecosystem
- Assessing mobile application resistance to reverse engineering, tampering, and runtime manipulation
Do not use against mobile applications without written authorization from the application owner, for distributing modified or repackaged applications, or for testing apps on the public app stores without a separate test build.
Prerequisites
- Target application IPA (iOS) and APK (Android) files or access to download from a private distribution channel
- Rooted Android device or emulator (Genymotion, Android Studio AVD) with Frida, Objection, and Magisk installed
- Jailbroken iOS device or Corellium virtual device with Frida, Objection, and SSL Kill Switch installed
- Static analysis tools: jadx (Android decompilation), Hopper/Ghidra (iOS binary analysis), MobSF (automated scanning)
- Burp Suite Professional configured as proxy for intercepting mobile app traffic with CA certificate installed on the test device
Workflow
Step 1: Static Analysis
Analyze the application binary without executing it:
Android Static Analysis:
- Decompile the APK:
jadx -d output/ target.apk to obtain Java/Kotlin source code
- Review
AndroidManifest.xml for exported components (activities, services, receivers, content providers), permissions, and debuggable flag
- Search for hardcoded secrets:
grep -rn "api_key\|password\|secret\|token\|aws_" output/
- Identify insecure data storage patterns: SharedPreferences with sensitive data, SQLite databases without encryption, files in external storage
- Check for WebView vulnerabilities:
setJavaScriptEnabled(true), addJavascriptInterface(), and loading untrusted content
- Run MobSF automated scan:
python manage.py runserver and upload the APK for automated static analysis
iOS Static Analysis:
- Extract the IPA and locate the Mach-O binary
- Use
otool -L <binary> to list linked frameworks and identify third-party libraries
- Analyze with Ghidra or Hopper for hardcoded URLs, API endpoints, and embedded credentials
- Check Info.plist for App Transport Security (ATS) exceptions that allow insecure HTTP connections
- Review embedded entitlements for excessive capabilities
Step 2: Network Security Testing
Intercept and analyze all network communications:
- Configure Burp Suite as proxy on the test device and install the Burp CA certificate
- Exercise all application functionality while Burp captures API traffic
- SSL/TLS validation: Verify the app validates server certificates properly. If the app fails to connect through the proxy, it may implement certificate pinning.
- Certificate pinning bypass:
- Android: Use Frida script:
frida -U -f com.target.app -l ssl-pinning-bypass.js --no-pause
- iOS: Use SSL Kill Switch or Objection:
objection -g "Target App" explore --startup-command "ios sslpinning disable"
- API traffic analysis: Review all API calls for:
- Sensitive data transmitted without encryption
- Authentication tokens in URL parameters (visible in logs)
- Excessive data in API responses beyond what the UI displays
- Missing or weak authentication on API endpoints
- WebSocket and custom protocols: Check for non-HTTP communication channels that may bypass standard proxy interception
Step 3: Data Storage Analysis
Test for insecure local data storage:
Android Data Storage:
- Access app data directory:
/data/data/com.target.app/
- Check SharedPreferences XML files for stored credentials, tokens, and PII
- Examine SQLite databases:
sqlite3 /data/data/com.target.app/databases/*.db ".dump"
- Check for sensitive data in application logs:
logcat -d | grep -i "password\|token\|key"
- Verify that application data is excluded from backups:
android:allowBackup="false" in AndroidManifest.xml
- Check clipboard for sensitive data leakage
iOS Data Storage:
- Examine the Keychain for stored credentials:
objection -g "Target App" explore then ios keychain dump
- Check NSUserDefaults/plist files:
find /var/mobile/Containers/Data/Application/ -name "*.plist" -exec plutil -p {} \;
- Inspect SQLite databases and Core Data stores for unencrypted sensitive data
- Check for data leaking through screenshots (iOS captures screenshots during app backgrounding)
- Verify data protection class: sensitive files should use NSFileProtectionComplete
Step 4: Authentication and Session Management
Test mobile-specific authentication controls:
- Biometric bypass: Test if biometric authentication can be bypassed by hooking the authentication callback with Frida to always return success
- Token storage: Verify that authentication tokens are stored in the Keychain (iOS) or Android Keystore, not in SharedPreferences or files
- Session timeout: Verify that sessions expire after a reasonable idle timeout and that tokens are invalidated server-side on logout
- Root/jailbreak detection bypass: Test if the app detects rooted/jailbroken devices and if the detection can be bypassed with Frida or Magisk Hide
- Deep link abuse: Test if custom URL schemes or universal links can be used to bypass authentication or access restricted functionality
Step 5: Runtime Manipulation
Test the application's resistance to runtime attacks:
- Frida hooking: Use Frida to hook and modify application functions at runtime:
- Bypass root detection: hook the detection function to return false
- Modify return values of authentication checks
- Intercept encryption functions to capture plaintext data before encryption
- Bypass certificate pinning by hooking SSL verification
- Method swizzling (iOS): Use Frida to replace Objective-C method implementations
- Intent manipulation (Android): Send crafted intents to exported components:
adb shell am start -n com.target.app/.InternalActivity -e "user_id" "admin"
- Tampering detection: Modify the APK/IPA (add code, change resources), re-sign, and install. Verify whether the app detects tampering.
Key Concepts
| Term |
Definition |
| OWASP MASTG |
Mobile Application Security Testing Guide; comprehensive manual for mobile app security testing covering both iOS and Android platforms |
| Certificate Pinning |
A mobile security control that restricts which TLS certificates the app trusts, preventing man-in-the-middle attacks through proxy interception |
| Frida |
Dynamic instrumentation toolkit that allows injection of JavaScript into running processes to hook functions, modify behavior, and bypass security controls |
| Root/Jailbreak Detection |
Application-level checks to detect if the device has been modified to grant root access, typically blocking app usage on compromised devices |
| Android Keystore |
Hardware-backed credential storage on Android that protects cryptographic keys and secrets from extraction even on rooted devices |
| App Transport Security (ATS) |
iOS security feature that enforces HTTPS connections by default; ATS exceptions may indicate insecure network communication |
| Deep Links |
URL schemes that open specific screens within a mobile application, which may bypass normal navigation and authentication flows if not properly validated |
Tools & Systems
- Frida / Objection: Dynamic instrumentation tools for hooking functions, bypassing security controls, and manipulating application behavior at runtime
- MobSF (Mobile Security Framework): Automated static and dynamic analysis platform for Android and iOS applications
- jadx: Android decompiler that converts APK bytecode to readable Java source code for manual code review
- Burp Suite Professional: HTTP proxy for intercepting and modifying mobile app API traffic after bypassing certificate pinning
Common Scenarios
Scenario: Mobile Banking Application Security Assessment
Context: A bank is launching a new mobile banking app for iOS and Android. The app handles account viewing, fund transfers, bill payment, and check deposit. OWASP MASVS L2 compliance is required due to the financial data handled.
Approach:
- Static analysis of the Android APK reveals API endpoints, a hardcoded staging server URL, and an AWS API key in a configuration file
- Certificate pinning is implemented but bypassed with Frida SSL pinning bypass script
- API traffic analysis reveals that the balance check endpoint returns all account numbers associated with the user, not just the requested account
- Local data storage analysis finds that the app caches the last 10 transactions in an unencrypted SQLite database
- Biometric authentication bypass: Frida hook on the biometric callback always returns success, granting access without fingerprint
- Root detection is present but bypassed with Magisk Hide module, allowing the app to run on a rooted device with full data access
Pitfalls:
- Testing only on an emulator and missing hardware-specific security features (Android Keystore hardware backing, iOS Secure Enclave)
- Not testing both iOS and Android versions, as they may have different implementations and different vulnerabilities
- Ignoring the backend API security because it was "tested separately" when the mobile app may call API endpoints differently than the web app
- Failing to test certificate pinning bypass, resulting in an incomplete network analysis
Output Format
## Finding: Biometric Authentication Bypass via Frida Instrumentation
**ID**: MOB-003
**Severity**: High (CVSS 7.7)
**Platform**: Android and iOS
**OWASP MASVS**: MASVS-AUTH-2 (Biometric Authentication)
**Description**:
The mobile banking app's biometric authentication can be bypassed using Frida
dynamic instrumentation. The authentication callback function accepts a boolean
result from the biometric API, which can be hooked and forced to return true
without presenting a valid fingerprint or face scan.
**Proof of Concept (Android)**:
frida -U -f com.bank.mobileapp -l bypass-biometric.js --no-pause
// bypass-biometric.js
Java.perform(function() {
var BiometricCallback = Java.use("com.bank.mobileapp.auth.BiometricCallback");
BiometricCallback.onAuthenticationSucceeded.implementation = function(result) {
console.log("[*] Biometric bypassed");
this.onAuthenticationSucceeded(result);
};
});
**Impact**:
An attacker with physical access to an unlocked device can bypass biometric
authentication and access the victim's bank accounts, initiate transfers,
and view financial data without biometric verification.
**Remediation**:
1. Implement server-side biometric verification using Android BiometricPrompt
CryptoObject tied to a Keystore key
2. Require the biometric operation to decrypt a server-side challenge, making
client-side bypass ineffective
3. Add runtime integrity checks to detect Frida and other instrumentation frameworks
4. Implement step-up authentication for high-risk operations (transfers > threshold)
1---2name: conducting-mobile-app-penetration-test3description: >4 Conducts penetration testing of iOS and Android mobile applications following the OWASP5 Mobile Application Security Testing Guide (MASTG) to identify vulnerabilities in data storage,6 network communication, authentication, cryptography, and platform-specific security controls.7 The tester performs static analysis of application binaries, dynamic analysis at runtime, and8 API security testing to evaluate the complete mobile attack surface. Activates for requests9 involving mobile app pentest, iOS security assessment, Android security testing, or OWASP10 MASTG assessment.11domain: cybersecurity12subdomain: penetration-testing13tags: [mobile-pentest, OWASP-MASTG, Android-security, iOS-security, mobile-application-security]14version: 1.0.015author: mahipal16license: MIT17metadata:18 source: https://skillmd.com/skills/njones17/conducting-mobile-app-penetration-test19---2021# Conducting Mobile App Penetration Test2223## When to Use2425- Testing mobile applications before release to identify security vulnerabilities and data protection issues26- Conducting compliance assessments against OWASP MASVS (Mobile Application Security Verification Standard) levels L1 and L227- Evaluating the security of mobile banking, healthcare, or government applications handling sensitive data28- Testing mobile apps that interact with backend APIs to assess the end-to-end security of the mobile ecosystem29- Assessing mobile application resistance to reverse engineering, tampering, and runtime manipulation3031**Do not use** against mobile applications without written authorization from the application owner, for distributing modified or repackaged applications, or for testing apps on the public app stores without a separate test build.3233## Prerequisites3435- Target application IPA (iOS) and APK (Android) files or access to download from a private distribution channel36- Rooted Android device or emulator (Genymotion, Android Studio AVD) with Frida, Objection, and Magisk installed37- Jailbroken iOS device or Corellium virtual device with Frida, Objection, and SSL Kill Switch installed38- Static analysis tools: jadx (Android decompilation), Hopper/Ghidra (iOS binary analysis), MobSF (automated scanning)39- Burp Suite Professional configured as proxy for intercepting mobile app traffic with CA certificate installed on the test device4041## Workflow4243### Step 1: Static Analysis4445Analyze the application binary without executing it:4647**Android Static Analysis:**48- Decompile the APK: `jadx -d output/ target.apk` to obtain Java/Kotlin source code49- Review `AndroidManifest.xml` for exported components (activities, services, receivers, content providers), permissions, and debuggable flag50- Search for hardcoded secrets: `grep -rn "api_key\|password\|secret\|token\|aws_" output/`51- Identify insecure data storage patterns: SharedPreferences with sensitive data, SQLite databases without encryption, files in external storage52- Check for WebView vulnerabilities: `setJavaScriptEnabled(true)`, `addJavascriptInterface()`, and loading untrusted content53- Run MobSF automated scan: `python manage.py runserver` and upload the APK for automated static analysis5455**iOS Static Analysis:**56- Extract the IPA and locate the Mach-O binary57- Use `otool -L <binary>` to list linked frameworks and identify third-party libraries58- Analyze with Ghidra or Hopper for hardcoded URLs, API endpoints, and embedded credentials59- Check Info.plist for App Transport Security (ATS) exceptions that allow insecure HTTP connections60- Review embedded entitlements for excessive capabilities6162### Step 2: Network Security Testing6364Intercept and analyze all network communications:6566- Configure Burp Suite as proxy on the test device and install the Burp CA certificate67- Exercise all application functionality while Burp captures API traffic68- **SSL/TLS validation**: Verify the app validates server certificates properly. If the app fails to connect through the proxy, it may implement certificate pinning.69- **Certificate pinning bypass**:70 - Android: Use Frida script: `frida -U -f com.target.app -l ssl-pinning-bypass.js --no-pause`71 - iOS: Use SSL Kill Switch or Objection: `objection -g "Target App" explore --startup-command "ios sslpinning disable"`72- **API traffic analysis**: Review all API calls for:73 - Sensitive data transmitted without encryption74 - Authentication tokens in URL parameters (visible in logs)75 - Excessive data in API responses beyond what the UI displays76 - Missing or weak authentication on API endpoints77- **WebSocket and custom protocols**: Check for non-HTTP communication channels that may bypass standard proxy interception7879### Step 3: Data Storage Analysis8081Test for insecure local data storage:8283**Android Data Storage:**84- Access app data directory: `/data/data/com.target.app/`85- Check SharedPreferences XML files for stored credentials, tokens, and PII86- Examine SQLite databases: `sqlite3 /data/data/com.target.app/databases/*.db ".dump"`87- Check for sensitive data in application logs: `logcat -d | grep -i "password\|token\|key"`88- Verify that application data is excluded from backups: `android:allowBackup="false"` in AndroidManifest.xml89- Check clipboard for sensitive data leakage9091**iOS Data Storage:**92- Examine the Keychain for stored credentials: `objection -g "Target App" explore` then `ios keychain dump`93- Check NSUserDefaults/plist files: `find /var/mobile/Containers/Data/Application/ -name "*.plist" -exec plutil -p {} \;`94- Inspect SQLite databases and Core Data stores for unencrypted sensitive data95- Check for data leaking through screenshots (iOS captures screenshots during app backgrounding)96- Verify data protection class: sensitive files should use NSFileProtectionComplete9798### Step 4: Authentication and Session Management99100Test mobile-specific authentication controls:101102- **Biometric bypass**: Test if biometric authentication can be bypassed by hooking the authentication callback with Frida to always return success103- **Token storage**: Verify that authentication tokens are stored in the Keychain (iOS) or Android Keystore, not in SharedPreferences or files104- **Session timeout**: Verify that sessions expire after a reasonable idle timeout and that tokens are invalidated server-side on logout105- **Root/jailbreak detection bypass**: Test if the app detects rooted/jailbroken devices and if the detection can be bypassed with Frida or Magisk Hide106- **Deep link abuse**: Test if custom URL schemes or universal links can be used to bypass authentication or access restricted functionality107108### Step 5: Runtime Manipulation109110Test the application's resistance to runtime attacks:111112- **Frida hooking**: Use Frida to hook and modify application functions at runtime:113 - Bypass root detection: hook the detection function to return false114 - Modify return values of authentication checks115 - Intercept encryption functions to capture plaintext data before encryption116 - Bypass certificate pinning by hooking SSL verification117- **Method swizzling** (iOS): Use Frida to replace Objective-C method implementations118- **Intent manipulation** (Android): Send crafted intents to exported components: `adb shell am start -n com.target.app/.InternalActivity -e "user_id" "admin"`119- **Tampering detection**: Modify the APK/IPA (add code, change resources), re-sign, and install. Verify whether the app detects tampering.120121## Key Concepts122123| Term | Definition |124|------|------------|125| **OWASP MASTG** | Mobile Application Security Testing Guide; comprehensive manual for mobile app security testing covering both iOS and Android platforms |126| **Certificate Pinning** | A mobile security control that restricts which TLS certificates the app trusts, preventing man-in-the-middle attacks through proxy interception |127| **Frida** | Dynamic instrumentation toolkit that allows injection of JavaScript into running processes to hook functions, modify behavior, and bypass security controls |128| **Root/Jailbreak Detection** | Application-level checks to detect if the device has been modified to grant root access, typically blocking app usage on compromised devices |129| **Android Keystore** | Hardware-backed credential storage on Android that protects cryptographic keys and secrets from extraction even on rooted devices |130| **App Transport Security (ATS)** | iOS security feature that enforces HTTPS connections by default; ATS exceptions may indicate insecure network communication |131| **Deep Links** | URL schemes that open specific screens within a mobile application, which may bypass normal navigation and authentication flows if not properly validated |132133## Tools & Systems134135- **Frida / Objection**: Dynamic instrumentation tools for hooking functions, bypassing security controls, and manipulating application behavior at runtime136- **MobSF (Mobile Security Framework)**: Automated static and dynamic analysis platform for Android and iOS applications137- **jadx**: Android decompiler that converts APK bytecode to readable Java source code for manual code review138- **Burp Suite Professional**: HTTP proxy for intercepting and modifying mobile app API traffic after bypassing certificate pinning139140## Common Scenarios141142### Scenario: Mobile Banking Application Security Assessment143144**Context**: A bank is launching a new mobile banking app for iOS and Android. The app handles account viewing, fund transfers, bill payment, and check deposit. OWASP MASVS L2 compliance is required due to the financial data handled.145146**Approach**:1471. Static analysis of the Android APK reveals API endpoints, a hardcoded staging server URL, and an AWS API key in a configuration file1482. Certificate pinning is implemented but bypassed with Frida SSL pinning bypass script1493. API traffic analysis reveals that the balance check endpoint returns all account numbers associated with the user, not just the requested account1504. Local data storage analysis finds that the app caches the last 10 transactions in an unencrypted SQLite database1515. Biometric authentication bypass: Frida hook on the biometric callback always returns success, granting access without fingerprint1526. Root detection is present but bypassed with Magisk Hide module, allowing the app to run on a rooted device with full data access153154**Pitfalls**:155- Testing only on an emulator and missing hardware-specific security features (Android Keystore hardware backing, iOS Secure Enclave)156- Not testing both iOS and Android versions, as they may have different implementations and different vulnerabilities157- Ignoring the backend API security because it was "tested separately" when the mobile app may call API endpoints differently than the web app158- Failing to test certificate pinning bypass, resulting in an incomplete network analysis159160## Output Format161162```163## Finding: Biometric Authentication Bypass via Frida Instrumentation164165**ID**: MOB-003166**Severity**: High (CVSS 7.7)167**Platform**: Android and iOS168**OWASP MASVS**: MASVS-AUTH-2 (Biometric Authentication)169170**Description**:171The mobile banking app's biometric authentication can be bypassed using Frida172dynamic instrumentation. The authentication callback function accepts a boolean173result from the biometric API, which can be hooked and forced to return true174without presenting a valid fingerprint or face scan.175176**Proof of Concept (Android)**:177frida -U -f com.bank.mobileapp -l bypass-biometric.js --no-pause178179// bypass-biometric.js180Java.perform(function() {181 var BiometricCallback = Java.use("com.bank.mobileapp.auth.BiometricCallback");182 BiometricCallback.onAuthenticationSucceeded.implementation = function(result) {183 console.log("[*] Biometric bypassed");184 this.onAuthenticationSucceeded(result);185 };186});187188**Impact**:189An attacker with physical access to an unlocked device can bypass biometric190authentication and access the victim's bank accounts, initiate transfers,191and view financial data without biometric verification.192193**Remediation**:1941. Implement server-side biometric verification using Android BiometricPrompt195 CryptoObject tied to a Keystore key1962. Require the biometric operation to decrypt a server-side challenge, making197 client-side bypass ineffective1983. Add runtime integrity checks to detect Frida and other instrumentation frameworks1994. Implement step-up authentication for high-risk operations (transfers > threshold)200```