- What can be pulled from a lost or jailbroken iPhone?01Keychain items, data protection classes, Core Data and SQLite stores, plist files, caches, screenshots and backups inspected for tokens and personal data.
- Are secrets compiled into the app?02The decrypted IPA reviewed for API keys, credentials, private endpoints and configuration, each tested to see what it grants.
- Can the app's traffic be read and changed?03App Transport Security reviewed and certificate pinning bypassed with runtime instrumentation, then every request modified and replayed.
- Can a link take over an account?04Universal links, custom URL schemes and WebViews tested for token theft, open redirects and unauthorised actions.
- Does the API trust the app too much?05Every endpoint the app uses attacked directly for BOLA, privilege escalation and logic flaws.
Scope this engagement
Tell us what you need proven. A senior tester replies with a fixed-scope proposal.
What we test in an iOS app
iOS gives apps strong isolation, encryption and a curated App Store, which leads many teams to assume their iPhone app is secure by default. In practice, the platform protects apps from each other, not from their own design decisions. Our iOS app penetration testing covers:
- Local data storage: what the app writes to the keychain and which accessibility and data protection classes it uses, plus Core Data, SQLite, Realm, plist files, NSUserDefaults, caches, logs and screenshots taken when the app goes to the background.
- The binary: decrypting the IPA and reviewing the Swift or Objective-C binary, frameworks and configuration for hard-coded keys, private endpoints, debug code and feature flags.
- Network security: App Transport Security exceptions, TLS validation and certificate pinning, and whether pinning can be bypassed with runtime instrumentation such as Frida.
- Links and inter-app communication: universal links, custom URL schemes, app extensions, the pasteboard and WebViews, which are common routes to token theft and account takeover.
- Authentication and biometrics: how Face ID and Touch ID are used, whether biometric checks can be bypassed at runtime, and how sessions are stored and refreshed.
- Jailbreak detection and anti-tampering: how much effort the app's own protections cost an attacker, and whether anything important relies on them.
- The API: every endpoint the app uses, attacked directly. See API penetration testing.
- 1Entry pointInstall on a jailbroken iPhoneApp Store or TestFlight build.
- 2Step 1Decrypt and inspect the IPABinary, frameworks, Info.plist, embedded keys.
- 3Step 2Hook the app at runtimeBypass pinning and jailbreak checks.
- 4Step 3Tokens in the keychain and logsReusable outside the app.
- ObjectiveAnother user's account via the APIReplayed requests with swapped IDs.
Common iOS findings
- Session tokens or refresh tokens stored in plain files or NSUserDefaults rather than the keychain.
- Keychain items saved with an accessibility class that survives device backups or is readable while the phone is locked.
- Third-party SDK keys and internal API endpoints in the binary.
- Universal link or URL scheme handlers that perform actions without confirming the user, or leak tokens to the caller.
- Biometric login that only checks a boolean in the app and can be bypassed at runtime.
- Security decisions made in the app rather than enforced by the API, so they disappear when requests are replayed directly.
How iOS testing works
We test on jailbroken iPhones and iPads running supported iOS versions, using the App Store, TestFlight or an enterprise build. Static analysis comes first: decrypting the app and reviewing its binary and configuration. Dynamic testing follows: running the app, instrumenting it at runtime, intercepting and modifying its traffic, and exercising links and platform features. Finally we attack the back end directly. Critical findings are reported the same day.
Testing is aligned to the OWASP Mobile Application Security Verification Standard (MASVS) and Testing Guide (MASTG), and reported in the same format as our web application and Android testing, so a combined engagement produces one consistent report. For the full picture of mobile testing, see mobile app penetration testing.

