Skip to content

ISO 27001, SOC 2, the DPDP Act and manual VAPT. Book a Free Scoping Call

Part of VAPT7 services in this practice area

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.

The Engagement, End to End

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.

Read the handover cards on their own and you have the paper trail. Select a phase to see what happens inside it.
  1. 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 Engagement

    Activities

    • Confirm Android and iOS builds in scope
    • Provision test accounts and backend endpoints
    • Agree instrumented test devices
    • Set testing windows and contacts
  2. 02

    Static Analysis

    We decompile and inspect the app for hardcoded secrets, weak crypto, insecure storage and unsafe configuration on both platforms.

    OutputStatic Analysis Findings

    Activities

    • Decompile the Android and iOS binaries
    • Hunt for hardcoded secrets and keys
    • Review local storage and crypto use
    • Check platform configuration flags
  3. 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 Findings

    Activities

    • Run the app on instrumented devices
    • Intercept and inspect network traffic
    • Observe runtime data and session handling
    • Trace calls to platform APIs
  4. 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 Findings

    Activities

    • Bypass root and jailbreak detection
    • Defeat certificate pinning with Frida
    • Attack biometric and local auth
    • Abuse the app's own business logic
  5. 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 Assessment

    Activities

    • Test the backend API the app calls
    • Chain device-side and server-side flaws
    • Map exposed accounts and data
    • Assess combined business impact
  6. 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 Retest

    Activities

    • 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.

Scope

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
One pass of testing and analysis, one set of findings, then that single set is graded against every standard on the right. You are not paying for the same work once per framework.

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.

Request an Assessment

Questions

What Clients Ask Us

Something here not covered? Ask Us Directly.

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