Skip to content

Test what ships to the phone

Mobile App
Penetration Testing

We test your iOS and Android apps the way an attacker would with the app on a device they control: pulling it apart, watching what it stores, and intercepting what it sends. Then we test the back end APIs it talks to, because that is where your users' data lives.

From the device to the API

What your app
gives away.

Testing follows the OWASP MASTG, with results reported against OWASP MASVS. We test on rooted and jailbroken devices, instrument the app at runtime with Frida, and route its traffic through Burp Suite. Back end APIs are tested to the same standard as a web application.

Phase 01 · Builds & scope

Agree the builds, platforms and back end.

A scope naming each app version, platform, API host and user role under test.

  • Store releases, or test builds through TestFlight or direct install.
  • Test accounts for each role, two per role where data separation matters.
  • The MASVS categories and any resilience testing you want covered.

Phase 02 · Static analysis

Take the app package apart.

A list of secrets, endpoints and weak settings found inside the shipped app.

  • The IPA and APK decompiled to read what ships to users.
  • Hardcoded secrets, API tokens and debug settings.
  • Permissions, exported components and URL handlers reviewed.

Phase 03 · Runtime & storage

Watch what the app does on a real device.

Evidence of sensitive data left on the device and controls that fail under instrumentation.

  • Local storage, Keychain and Keystore use checked for sensitive data.
  • Biometric and local authentication bypass attempts with Frida.
  • Certificate pinning and root or jailbreak detection tested, if present.

Phase 04 · Network & back end

Test the APIs the app depends on.

Proof of what a user can reach on the server by changing what the app sends.

  • Traffic intercepted and replayed through Burp Suite.
  • Access control tested between users and roles on every endpoint.
  • Transport security and session handling checked end to end.

Phase 05 · Report & readout

Give each platform team its own fix list.

Findings mapped to OWASP MASVS, split by iOS, Android and API, with a retest option.

  • Steps to reproduce with screenshots and request captures.
  • Fixes written for the platform each finding affects.
  • A readout with the practitioner who tested the apps.

Agree the builds, platforms and back end.

A scope naming each app version, platform, API host and user role under test.

  • Store releases, or test builds through TestFlight or direct install.
  • Test accounts for each role, two per role where data separation matters.
  • The MASVS categories and any resilience testing you want covered.

Key benefits

Know what an attacker learns from your app.

Secrets found in the build

API tokens, internal endpoints and debug flags sometimes ship inside mobile builds by mistake. Static analysis finds them so you can rotate and remove them before someone else pulls the app apart.

The back end tested too

An app is only as safe as the APIs behind it. We test what a user can reach by changing the requests the app sends, the same way we would test a web application.

Answers in MASVS terms

Results map to OWASP MASVS, so when a customer or partner asks how your app was tested, you can answer with a published standard instead of a vendor's private checklist.

What you get

What lands on
your desk.

Three handoffs, split so your iOS, Android and API teams each see their own work.

The document

The report

Executive summary, builds and platforms tested, MASVS coverage, and findings by severity with evidence, steps to reproduce and a fix written for the platform it affects.

The working file

The findings tracker

One row per issue with platform, app version, severity, status and an owner. Each team filters to its own list and tracks fixes into the next release.

The conversation

The readout

A working session with the practitioner who tested the apps and your mobile and API developers. We go through findings in priority order and agree what goes into the next build.

Client case studies

Real engagements.
Documented outcomes.

YHB | CPAs & Consultants testimonial

In their words

"ForgePath has become a trusted security partner for YHB. Their team understands how a CPA firm operates and has helped us build a security program that’s both practical and sustainable."

Cyrus Kapadia
Chief Technology & Information Officer, YHB | CPAs & Consultants

Trusted by industry leaders.

Before we install it

Asked by
mobile teams.

Straight answers from the practitioners who do the work. If yours is not here, ask us directly.

No, we can test the public release. A test build pointed at staging, with logging left on, makes testing faster and keeps real user data out of reach. We agree which build to use in scoping.

Yes, separately. The platforms store data, handle permissions and enforce security differently, so a flaw on one may not exist on the other. If you ship one codebase to both, we still test both builds.

If they are in scope, yes, and we report how hard it was. These controls slow an attacker down but do not stop a determined one, so we also test what is exposed once they are bypassed.

It is in scope by default, because the server is where user data lives. We test the APIs the app calls for access control, authentication and input handling. Endpoints the app does not use can be added in scoping.

Ready?

Bring us
the problem.

One conversation with a senior practitioner who has carried this responsibility before. We will tell you what we would do, and whether it is us.