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.
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.
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.
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.
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.
Key benefits
Know what an attacker learns from your app.
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.
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.
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.
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."
In their words
"ForgePath has become a trusted security partner for YHB. Beyond helping us comply with FTC Safeguards requirements, they provide the governance, oversight, and guidance we rely on to protect our firm and our clients’ data. Their team understands how a CPA firm operates and has helped us build a security program that’s both practical and sustainable."
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.








