Android and iOS, Tested Hard
Mobile Application Penetration Testing
We test your Android and iOS apps the way an attacker with the app in hand would. That means pulling the app apart, watching it run, and going after the API and the data it stores on the device.
See the engagement path, 6 phasesSee the full VAPT service index
Overview
A mobile application VAPT covers the app binary, its runtime behaviour and the backend it talks to. We look at how the app stores data, how it authenticates, how it protects itself from tampering, and how well the platform controls are used on both Android and iOS. The result is a clear view of what someone can extract, bypass or abuse once your app is on their phone.
Methodology
How the Engagement Runs
Every phase has a named output, so you always know what is being worked on and what lands on your side of the table.
6 Phases, 6 Named Handovers
Flow
Flow chart of the Mobile Application engagement, 6 phases in order, each one selectable. Phase 1, Scoping and Rules of Engagement. We agree the Android and iOS builds, test accounts and backend endpoints in scope, then set devices and testing windows. Activities: Confirm Android and iOS builds in scope; Provision test accounts and backend endpoints; Agree instrumented test devices; Set testing windows and contacts. Hands over Signed Rules of Engagement. Phase 2, Static Analysis. We decompile and inspect the app for hardcoded secrets, weak crypto, insecure storage and unsafe configuration on both platforms. Activities: Decompile the Android and iOS binaries; Hunt for hardcoded secrets and keys; Review local storage and crypto use; Check platform configuration flags. Hands over Static Analysis Findings. Phase 3, Dynamic Analysis. We run the app on instrumented devices, intercept its traffic and observe how it handles data, sessions and platform APIs at runtime. Activities: Run the app on instrumented devices; Intercept and inspect network traffic; Observe runtime data and session handling; Trace calls to platform APIs. Hands over Runtime Behaviour Findings. Phase 4, Manual Exploitation and Platform Checks. We attempt bypasses of root and jailbreak detection, certificate pinning, biometric and local auth, and abuse the app's own logic. Activities: Bypass root and jailbreak detection; Defeat certificate pinning with Frida; Attack biometric and local auth; Abuse the app's own business logic. Hands over Proven Client-Side Findings. Phase 5, Backend and Impact. We test the API behind the app and show how device-side and server-side flaws combine into real impact on accounts and data. Activities: Test the backend API the app calls; Chain device-side and server-side flaws; Map exposed accounts and data; Assess combined business impact. Hands over Impact and Risk Assessment. Phase 6, Reporting and Verified Retest. You get a report with proof of concept per platform and clear fixes, and we retest once you remediate to confirm closure. Activities: Write per-platform findings and fixes; Produce an executive summary; Walk your team through the results; Retest fixes and confirm closure. Hands over Final Report and Verified Retest. Each phase begins from the artefact the phase before it produced.
Phase 01 Scoping and Rules of Engagement
We agree the Android and iOS builds, test accounts and backend endpoints in scope, then set devices and testing windows.
What Happens In This Phase
- Confirm Android and iOS builds in scope
- Provision test accounts and backend endpoints
- Agree instrumented test devices
- Set testing windows and contacts
The Handover
Signed Rules of Engagement
The next phase starts from this.
Phase 01 Scoping and Rules of Engagement
We agree the Android and iOS builds, test accounts and backend endpoints in scope, then set devices and testing windows.
What Happens In This Phase
- Confirm Android and iOS builds in scope
- Provision test accounts and backend endpoints
- Agree instrumented test devices
- Set testing windows and contacts
The Handover
Signed Rules of Engagement
The next phase starts from this.
- 01
Scoping and Rules of Engagement
We agree the Android and iOS builds, test accounts and backend endpoints in scope, then set devices and testing windows.
OutputSigned Rules of EngagementActivities
- Confirm Android and iOS builds in scope
- Provision test accounts and backend endpoints
- Agree instrumented test devices
- Set testing windows and contacts
- 02
Static Analysis
We decompile and inspect the app for hardcoded secrets, weak crypto, insecure storage and unsafe configuration on both platforms.
OutputStatic Analysis FindingsActivities
- Decompile the Android and iOS binaries
- Hunt for hardcoded secrets and keys
- Review local storage and crypto use
- Check platform configuration flags
- 03
Dynamic Analysis
We run the app on instrumented devices, intercept its traffic and observe how it handles data, sessions and platform APIs at runtime.
OutputRuntime Behaviour FindingsActivities
- Run the app on instrumented devices
- Intercept and inspect network traffic
- Observe runtime data and session handling
- Trace calls to platform APIs
- 04
Manual Exploitation and Platform Checks
We attempt bypasses of root and jailbreak detection, certificate pinning, biometric and local auth, and abuse the app's own logic.
OutputProven Client-Side FindingsActivities
- Bypass root and jailbreak detection
- Defeat certificate pinning with Frida
- Attack biometric and local auth
- Abuse the app's own business logic
- 05
Backend and Impact
We test the API behind the app and show how device-side and server-side flaws combine into real impact on accounts and data.
OutputImpact and Risk AssessmentActivities
- Test the backend API the app calls
- Chain device-side and server-side flaws
- Map exposed accounts and data
- Assess combined business impact
- 06
Reporting and Verified Retest
You get a report with proof of concept per platform and clear fixes, and we retest once you remediate to confirm closure.
OutputFinal Report and Verified RetestActivities
- Write per-platform findings and fixes
- Produce an executive summary
- Walk your team through the results
- Retest fixes and confirm closure
Specification
What We Run, and What We Measure You Against
The tooling our engineers use on this work, and the published standards the findings and evidence are mapped to.
What Is Examined, and What it Is Measured Against
Map
Map of the Mobile Application scope, running left to right in three stages. Stage one, what we run, 9 tools and techniques: MobSF, Frida, Objection, Burp Suite Professional, apktool, jadx, Ghidra, class-dump, Nuclei. Stage two, findings from all of it are proven by hand and written up once. Stage three, measured against 6 published standards: OWASP MASVS, OWASP MASTG, OWASP Mobile Top 10, OWASP API Security Top 10, PTES, CVSS v4.0.
What We Run
9 tools
- MobSF
- Frida
- Objection
- Burp Suite Professional
- apktool
- jadx
- Ghidra
- class-dump
- Nuclei
Converges On
One Set of Proven Findings
Every issue is reproduced by hand before it is written down, and it is written down once.
Measured Against
6 standards
- OWASPMASVS
- OWASPMASTG
- OWASPMobile Top 10
- OWASPAPI Top 10
- PTES
- CVSS v4.0
Deliverables
What You Receive
- Findings report with proof of concept
- Per-platform results for Android and iOS
- Executive summary
- Remediation guidance
- Verified retest report
Scope This Engagement
Tell us about your environment, your timelines and any audit dates you are working to. We come back with scope, effort and a start date.
What It Costs
Indicative Ranges, Before You Ask
Every figure below is an indicative range, not a quote. Where you land in it depends on scope, and we confirm a fixed price only once scoping is done.
- Indicative rangeDepends on scope
Mobile application VAPT
₹50,000 to ₹4 lakh, retest included
Range as of 2 September 2026
What sets the figure
- Manual Android and iOS testing against the OWASP MASVS, on the binaries or with source
- Testing one platform or both, and the size of the backend the app talks to, sets where you land in the range
- Findings reported per platform with fixes, and a retest once you remediate
Indicative ranges in INR; the final quote depends on scope, and each range is dated on its own card.
Get a Fixed Price for Your Scope
Tell us what is in scope and when you need it. You get a written scope and a fixed price, not a band.
We build for Android and iOS from one codebase, so do we really need both platforms tested?
Usually yes, because a shared codebase does not give you shared security behaviour. Cross-platform frameworks still compile down to a native binary on each side, and the things an attacker cares about are decided by the platform rather than by your shared logic: where credentials come to rest, whether the keystore or the keychain is used and how it is configured, what happens to the screen when the app is backgrounded, what a neighbouring app on the same device is permitted to read, and which debugging and backup flags the build carries. That is why our static and dynamic phases run separately per platform and the findings are written per platform, so each team fixes what is theirs. If budget forces a sequence, start with the platform carrying more of your users or more of your sensitive flows. Whether we test one platform or both is also one of the things that moves you within the indicative range on this page.
Where do the serious findings usually come from, the app itself or the API behind it?
More often than not, the backend. A flaw that lives only on the handset is bounded by that handset: someone who already controls the device learns something about their own account. A flaw in the API behind the app is unbounded, because the same request can be replayed with another customer's identifier from anywhere. Mobile apps make this worse in a specific way. Teams put the authorisation decision in the screen rather than the endpoint, hide an administrative function behind a feature flag the client evaluates, or trust a price, a role or a user identifier the app sends up. Pull the app apart and those endpoints are simply listed for you. That is why the engagement has a phase dedicated to testing the backend the app calls and to chaining device-side and server-side flaws into one impact statement. If the API serves more than this app, our separate API penetration testing service is the fuller scope.
What do we actually have to supply before testing starts, and what if we cannot release source code?
Four things: installable builds for each platform in scope, working test accounts, the backend endpoints those builds point at, and a named contact who can answer questions during the test. For the builds, send us what you ship rather than a debug variant, since debug flags and logging change the answer. For accounts, give us at least two per role so we can test one user against another, and create them fresh rather than handing over a real customer's login. Tell us in advance about anything that will block installation on our instrumented devices, such as device attestation, an MDM wrapper or an enterprise distribution profile. Source code is optional. We test from the compiled app alone, which is where an attacker starts, and source makes the static phase deeper and faster rather than possible. These are agreed in the scoping phase and written into the Rules of Engagement before anyone touches the app.
You test on rooted and jailbroken devices, so does that tell us anything about users on ordinary phones?
It tells you something precise: what an attacker reaches once they hold the device, which is the situation after a phone is lost, sold, resold or infected. A rooted or jailbroken handset is the instrument, not the threat model. We use it to read what the app wrote to disk, to watch the traffic it thought was protected, and to reach the code paths a stock device hides, then we report the underlying weakness rather than the fact that we rooted a phone. That distinction matters when you read the report. A bypassed root check or a defeated pinning implementation is not in itself the damage; it is the door, and the finding is whatever we got through it, such as a token in plain storage or an endpoint that never checks who is asking. We say plainly which of your protections held and which did not, so you can judge how much delay they really buy.
We have a store submission coming up, so will this assessment get the app through Play Store or App Store review?
No, and it is worth separating the two. Store review checks policy, declared permissions and privacy disclosures; it is not a security assessment, and our report is not an approval. What the engagement does give you is evidence for the parts of that submission you have to declare honestly. The dynamic phase records what the app actually sends, to which hosts and over what transport, which is the same question a data safety form or a privacy label asks, and the static phase surfaces permissions and capabilities the build requests but never exercises. Where personal data is involved, that evidence also supports the notice and purpose obligations under the DPDP Act. Plan the sequence backwards from your submission date: scope early, leave room for the fix cycle, and keep the retest before you ship, so the version that goes to the store is the version whose fixes we confirmed.
Keep Moving Through VAPT
Service 2 of 7 in this practice area
Practice Area
More in VAPT
- Web ApplicationManual testing of your web apps against the OWASP WSTG
- APIREST, GraphQL and SOAP testing against the OWASP API Top 10
- Thick Client ApplicationDesktop app testing across binary, traffic and backend
- Network InfrastructureExternal and internal network testing with lateral movement
- IoT and EmbeddedDevice testing across firmware, hardware and radio
- CloudConfiguration and IAM testing across AWS, Azure and GCP