Mobile app penetration testing is a manual, adversarial assessment of an iOS or Android app, the data it keeps on the device, and the APIs behind it. Measured against OWASP MASVS v2.1, testers verify eight control groups (storage, cryptography, authentication, network, platform interaction, code, resilience and privacy), then report exploitable findings with fixes.
Mobile apps get tested less often than web apps, and they’re easier to attack in one important way: the attacker holds the whole client. They can install your app on a rooted or jailbroken phone, decompile it, read what it stores, hook its functions at runtime and replay every request it makes to your backend. A useful mobile pentest assumes exactly that.
This guide explains what mobile app penetration testing covers, how each part maps to the OWASP Mobile Application Security Verification Standard (MASVS), the risks that matter most for apps with login and payments, the mistakes we see teams repeat, and what a realistic vendor timeline looks like.
What is OWASP MASVS, and how does it relate to MASTG?
The OWASP MASVS is the industry standard for mobile app security requirements. It defines what a secure app should do. The OWASP Mobile Application Security Testing Guide (MASTG) is its companion manual and describes how to test each requirement on iOS and Android.
Key facts worth knowing before you scope a test:
- Current version: MASVS v2.1.0, released January 18, 2024. It added the MASVS-PRIVACY group.
- Structure: 24 controls in 8 control groups. Each control is written as an outcome, such as “the app securely stores sensitive data.”
- No more L1/L2 levels inside the standard. Version 2.0 moved the old verification levels into the MASTG as MAS testing profiles: MAS-L1 (baseline security for any app), MAS-L2 (defense in depth for apps handling sensitive data, such as banking, healthcare or payments) and MAS-R (resilience against reverse engineering and tampering).
- Server-side security is out of scope for MASVS. OWASP points to the ASVS and the API Security Top 10 for the backend. In practice, a mobile test that skips the APIs misses where most high-severity findings live.
When a vendor says they test “against MASVS,” ask which testing profile they’re applying and whether the backend APIs are in scope.
What does mobile app penetration testing cover? The 8 MASVS control groups
Below is how we map testing to each MASVS control group. The “what we try” column is the attacker’s view: what a tester actively attempts, not just what a scanner flags.
| MASVS control group | What it requires | What testers actively try |
|---|---|---|
| MASVS-STORAGE | Sensitive data is stored securely and doesn’t leak | Pull tokens, PII and cached responses from app sandboxes, Android SharedPreferences, iOS NSUserDefaults and plists, SQLite and Realm databases, logs, backups, the clipboard and keyboard caches |
| MASVS-CRYPTO | Strong, correctly used cryptography and sound key management | Find hardcoded keys, weak or deprecated algorithms, static IVs and keys stored next to the data they protect |
| MASVS-AUTH | Secure authentication and authorization, correct local auth, step-up auth for sensitive actions | Bypass biometric prompts, replay or forge tokens, abuse password reset and session refresh, and check whether authorization is enforced on the server rather than in the client |
| MASVS-NETWORK | All traffic is secured; identity pinning where appropriate | Intercept traffic with a proxy, look for cleartext or weakened TLS, iOS App Transport Security exceptions, Android cleartext permissions, and test whether certificate pinning is present and enforced |
| MASVS-PLATFORM | Safe use of IPC, WebViews and the UI | Abuse exported Android activities, services, receivers and content providers; hijack deep links and URL schemes; exploit WebViews with JavaScript bridges; capture sensitive screens in app-switcher snapshots |
| MASVS-CODE | Current platform versions, enforced updates, no known-vulnerable components, input validation | Identify outdated SDKs and third-party libraries, test injection through intents and local inputs, check whether old app versions can still reach production APIs |
| MASVS-RESILIENCE | Platform integrity checks and protection against tampering, static analysis and dynamic analysis | Run on rooted and jailbroken devices, repackage the app, hook functions with dynamic instrumentation, and measure how long protections slow a determined attacker |
| MASVS-PRIVACY | Data minimization, no unnecessary user identification, transparency and user control | Compare what the app collects and sends to third-party SDKs against what it declares, and check for device identifiers and data sent without consent |
Resilience controls (MAS-R) are a judgment call. They raise the cost of attacking the client, but they never replace server-side security. Apps that handle money, protected content or regulated data usually justify them; a simple content app may not.
How is mobile app penetration testing different from a web app pentest?
A web app pentest tests code that runs on your servers. A mobile pentest also tests code that runs on a device you don’t control. That adds three areas web testing rarely touches:
- The binary itself. Testers decompile the APK or IPA, read the code and look for secrets, hidden endpoints, debug features and logic that should live on the server.
- On-device data. Anything the app writes locally can be read by an attacker with physical or root access, or by other apps if storage is misconfigured.
- Platform interaction. Deep links, inter-app communication, push notifications and WebViews create attack paths that have no direct web equivalent.
The backend overlaps heavily. Mobile apps usually call the same kind of REST or GraphQL APIs as your web front end, so authorization flaws such as broken object level authorization show up in both. Many teams combine mobile and API penetration testing into one engagement for that reason. If you’re also testing a browser front end, see our guide to web application penetration testing.
I’m building a mobile app with login and payments: what are the biggest AppSec risks to test?
Login and payments move an app into MAS-L2 territory. These are the risks to put at the top of the test plan:
Authentication and session handling
- Client-side biometric bypass. If Face ID, Touch ID or Android BiometricPrompt only returns a yes/no to the app, an attacker can hook that result and skip it. Biometrics should unlock a key held in the iOS Keychain or Android Keystore, not flip a boolean.
- Token storage and lifetime. Access and refresh tokens should sit in the Keychain or Keystore, expire sensibly and be revocable on the server when a user logs out or changes their password.
- Password reset and account recovery. Flows built for mobile, such as OTP-based reset, are frequent sources of account takeover when codes can be brute-forced or reused.
Authorization and backend APIs
- Broken object level authorization (BOLA). Changing an order, account or card ID in a request returns someone else’s data. It is #1 on the OWASP API Security Top 10 (2023) and the most common high-impact issue behind mobile apps.
- Trusting the client. Prices, discounts, entitlements, transaction limits and “is premium” flags must be decided on the server. Anything the app sends, an attacker can change.
Payment flows
- Amount and currency tampering between the app and the payment step.
- In-app purchase receipt validation done only on the device, which lets users unlock paid features with forged receipts.
- Race conditions and replay on payment confirmation, refunds, credits and promo codes.
- Card data handling. Using a payment provider’s SDK with tokenization keeps raw card numbers off your servers and usually reduces your PCI DSS scope. Testing should confirm card data never touches app storage or logs.
Transport and storage
- Interceptable traffic. No pinning on payment or auth endpoints makes man-in-the-middle testing trivial on a compromised device or hostile network.
- Sensitive data at rest. Cached account statements, receipts or KYC images in unprotected storage.
What are the most common mobile app security mistakes teams make?
These are the patterns that come up again and again in mobile assessments:
- Hardcoding secrets in the app. API keys, cloud credentials and third-party tokens compiled into the binary. Obfuscation slows extraction; it doesn’t prevent it. Anything in the app should be treated as public.
- Putting security decisions in the client. Hiding admin features in the UI, checking entitlements locally or enforcing limits only in app code.
- Treating jailbreak or root detection as a security control. It’s a speed bump. Instrumentation frameworks bypass most checks quickly, so the backend has to be safe even when the client is fully compromised.
- Logging too much. Tokens, PII and full API responses in debug logs that ship to production or go to crash-reporting tools.
- Storing tokens in plain preferences instead of the Keychain or Keystore.
- Leaving Android components exported or deep links unvalidated, letting other apps trigger sensitive actions.
- Weakening TLS during development and shipping it. Debug trust settings, disabled certificate validation or broad App Transport Security exceptions.
- Forgetting old app versions. Legacy builds with known flaws still talk to production APIs because nothing forces an update.
- Unreviewed third-party SDKs that collect more data than the privacy policy declares or bring known vulnerabilities.
- Testing the app but not the API, which leaves the highest-severity findings undiscovered.
How does Canary Trap test mobile apps? Our methodology
Every mobile application penetration testing engagement follows the same five phases as our penetration testing methodology, adapted for iOS and Android:
- Define. We confirm platforms, builds, user roles, test accounts, environments, workflows, rules of engagement, timing and contacts. For mobile, that includes which MAS testing profile applies (L1, L2, and whether resilience testing is in scope).
- Uncover. Senior testers combine static analysis (decompiling and reviewing the binary), dynamic analysis on real rooted and jailbroken devices, traffic interception and manual, role-aware testing of the APIs the app depends on. Tools support the work; they don’t replace it.
- Report. Findings are documented with evidence, severity, business context, reproduction steps and remediation guidance, mapped to the relevant MASVS control.
- Remediate. Your engineering team works through fixes with direction from the report and a findings review meeting.
- Retest. We retest remediated findings within the defined engagement window to confirm they’re fixed, not just marked closed.
What you receive: an executive summary for non-technical stakeholders, prioritized findings with business and security impact, evidence and reproduction detail, proof of exploitation where applicable, practical remediation guidance, a findings review meeting, retesting, and a letter of attestation where applicable. For complex findings, we can hand off to a secure code review.
Need a mobile app security test for iOS and Android: what’s a good vendor and timeline?
Timeline. For most application engagements, active testing runs one to three weeks, depending on the number of apps, platforms, roles and workflows in scope. Typical lead time to start is two to four weeks. If you’re working back from a launch, audit or customer security review, share the date during scoping so the schedule is built around it. A typical sequence:
| Stage | Typical duration |
|---|---|
| Scoping call and proposal | A few days |
| Lead time to start | 2–4 weeks (time-sensitive work can often be accommodated) |
| Active testing (iOS + Android + APIs) | 1–3 weeks |
| Report delivery and findings review | Following testing |
| Remediation | Set by your team |
| Retest | Within the defined engagement window |
What drives scope (and cost): the number of apps and platforms, user roles and workflows, whether backend APIs are included, whether resilience (MAS-R) testing is required, and whether you need compliance mapping. Be wary of quotes that differ widely; the scope almost always differs too.
Questions to ask any mobile pentest vendor (more in how to choose a penetration testing company):
- Who actually performs the testing, and how senior are they?
- Do you test both iOS and Android on real rooted and jailbroken devices?
- Are the backend APIs in scope, and is the testing role-aware?
- Which MASVS control groups and MAS testing profile will you report against?
- How much of the work is manual versus scanner output?
- Is retesting included, or billed separately?
- Can we see a redacted sample report?
Do compliance frameworks require mobile app penetration testing?
None of the major frameworks names MASVS, but each expects applications in scope to be tested, and a MASVS-mapped report is strong evidence:
- SOC 2: Auditors commonly expect independent penetration testing as evidence that security controls work. If your mobile app handles customer data, it belongs in scope. See SOC 2 penetration testing.
- ISO 27001:2022: Annex A control 8.29 covers security testing in development and acceptance. Pentest findings mapped to controls help show it’s operating. See ISO 27001 penetration testing.
- PCI DSS v4.0: Requirement 11.4 requires penetration testing, including the application layer, for systems in or connected to the cardholder data environment. Apps that take payments often fall under it unless card data is fully tokenized by a provider.
For a full breakdown, see penetration testing requirements by framework.
Mobile app penetration testing checklist (mapped to MASVS)
Use this checklist to scope a test, review a vendor’s proposal or check your own app before launch. For developer-side guidance on each area, the OWASP Mobile Application Security Cheat Sheet is a good companion.
Before testing (scoping)
- iOS (IPA or TestFlight) and Android (APK/AAB) builds for the release you’ll ship
- Test accounts for every user role, including two accounts per role for cross-user testing
- API documentation or a Postman/OpenAPI collection, plus the environment to test (staging that mirrors production is ideal)
- Payment sandbox credentials, if payments are in scope
- Agreed MAS testing profile (L1, L2, plus R if needed) and launch or audit dates
MASVS-STORAGE
- No tokens, passwords or PII in plain preferences, plists, databases or files
- Nothing sensitive in logs, crash reports, backups, the clipboard or keyboard cache
MASVS-CRYPTO
- No hardcoded keys or secrets in the binary
- Modern algorithms; keys held in the Keychain or Keystore
MASVS-AUTH
- Biometrics bound to a cryptographic key, not a boolean result
- Sessions expire and can be revoked server-side
- Step-up authentication for payments and account changes
- Authorization enforced on the server for every object and action (no BOLA)
MASVS-NETWORK
- TLS everywhere; no cleartext or broad ATS exceptions
- Certificate pinning on high-value endpoints, if your threat model calls for it
MASVS-PLATFORM
- No unintended exported Android components
- Deep links and URL schemes validated
- WebViews locked down; JavaScript bridges limited
- Sensitive screens hidden in app-switcher snapshots
MASVS-CODE
- Third-party libraries and SDKs current, with no known vulnerabilities
- Minimum supported OS version enforced; forced update path for vulnerable versions
- All untrusted input validated
MASVS-RESILIENCE (if in scope)
- Root/jailbreak, tampering, debugger and instrumentation detection tested for bypass
- Backend remains safe when every client-side protection is bypassed
MASVS-PRIVACY
- Data collected matches what’s declared in app store privacy labels and your policy
- Third-party SDK data flows reviewed
Payments (MAS-L2 apps)
- Price, amount and entitlement decided on the server
- Purchase receipts validated server-side
- Payment, refund and promo flows tested for replay and race conditions
FAQ
What is mobile app penetration testing?
It’s a security assessment where testers simulate real attacks on an iOS or Android app, its on-device data and its backend APIs to find exploitable weaknesses before attackers do, then report them with remediation guidance.
How long does mobile app penetration testing take?
Most engagements involve one to three weeks of active testing, depending on platforms, roles, workflows and whether APIs are included. Lead time to start is typically two to four weeks.
Is OWASP MASVS L1 or L2 still used?
Not inside the standard. Since MASVS v2.0, L1, L2 and R live in the MASTG as MAS testing profiles. MAS-L1 is the baseline, MAS-L2 adds defense in depth for sensitive apps, and MAS-R covers resilience against reverse engineering.
Do you need to test iOS and Android separately?
Yes. Even cross-platform apps built with React Native or Flutter behave differently on each platform: storage, keychains, IPC, permissions and network security settings all differ. The shared backend can be tested once.
Should a mobile pentest include the API?
It should. MASVS deliberately excludes server-side security, but most high-severity mobile findings, including broken object level authorization, sit in the APIs the app calls. Read more on what an API pentest covers.
What’s the difference between mobile app penetration testing and an automated mobile security scan?
Scanners are good at spotting known patterns in a binary, such as weak configuration or outdated libraries. A penetration test adds human-led exploitation: chaining issues, bypassing client protections and abusing business logic in login and payment flows, which scanners routinely miss.
Can mobile app penetration testing support ISO 27001 or SOC 2?
Yes. A report that maps findings to MASVS controls and shows retest results gives auditors evidence that application security testing happens and that findings are remediated.
What should I expect in a Canary Trap mobile pentest report? A
n executive summary, prioritized findings with business impact, evidence and reproduction steps, proof of exploitation where applicable, MASVS-mapped remediation guidance, a findings review meeting and retest results.
Get your mobile app tested
If you’re launching an app with login or payments, preparing for an audit or answering a customer security questionnaire, MASVS-mapped mobile app penetration testing gives you evidence of what was tested, what was found and what was fixed. Book a scoping call and tell us your launch or audit date; we’ll build the schedule around it.