- Can another app on the phone use yours against the user?01Exported activities, services, receivers and content providers called from a test app, and intents and pending intents tested for hijacking.
- What does the app leave in storage?02Shared preferences, SQLite and Room databases, external storage, logs and backups inspected for tokens and personal data, and keystore use reviewed.
- Are secrets compiled into the APK?03The APK or AAB decompiled and searched for API keys, credentials, Firebase and cloud configuration and private endpoints, each tested for what it unlocks.
- Can the app's traffic be read and changed?04Network security config reviewed, pinning and root detection bypassed, and every request modified and replayed.
- 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 Android app
Android is more open than iOS: apps can talk to each other through intents, packages are easy to decompile, and the same app runs across thousands of device models and OS versions. That flexibility creates its own class of findings. Our Android app penetration testing covers:
- The app package: decompiling the APK or AAB with tools such as jadx and apktool, reviewing the manifest, code and resources, and checking how much obfuscation actually protects.
- Exported components: activities, services, broadcast receivers and content providers reachable by other apps, and the permissions that guard them.
- Intents and links: implicit intents, pending intents, Android App Links and custom schemes, and WebViews with JavaScript bridges.
- Local storage: shared preferences, SQLite and Room databases, files on internal and external storage, logs, and whether backups expose app data.
- The keystore and cryptography: whether keys live in the Android Keystore, how biometrics are used, and home-grown encryption.
- Network security: the network security config, cleartext traffic, TLS validation and certificate pinning, and whether pinning and root detection can be bypassed with runtime instrumentation such as Frida.
- Embedded cloud configuration: Firebase, Google Cloud and other keys shipped in the app, and whether the services behind them are locked down.
- The API: every endpoint the app uses, attacked directly. See API penetration testing.
- 1Entry pointPull the APK from Google PlayAnyone can download it.
- 2Step 1Decompile to readable codeEndpoints, keys, Firebase config.
- 3Step 2Exported component foundCallable by any app on the phone.
- 4Step 3Malicious app or link triggers itReads data or acts as the user.
- ObjectiveAccount data takenWithout the user noticing.
Embedded cloud keys
One of the most damaging Android findings is not in the app at all. Many apps ship with Firebase or other cloud configuration, which is expected, but the database, storage bucket or functions behind it rely on security rules being right. We test those rules directly.
- 1Entry pointFirebase or cloud keys in the APKShipped in every install.
- 2Step 1Query the database or bucket directlyOutside the app entirely.
- 3Step 2Security rules too permissiveRead or write without the right user.
- ObjectiveAll users' records exposed
Common Android findings
- Exported activities or content providers that return user data or perform actions without checking the caller.
- Tokens and personal data in shared preferences or on external storage.
- Debuggable or backup-enabled release builds.
- Cleartext traffic permitted by the network security config.
- WebViews with JavaScript bridges that load untrusted content.
- Firebase databases or storage buckets readable or writable without the right user.
- Security decisions made in the app rather than enforced by the API.
How Android testing works
We test on rooted Android devices and emulators across supported Android versions, using the Play Store build or an APK or AAB you provide. Static analysis comes first: decompiling the app and reviewing its manifest, code and configuration. Dynamic testing follows: running the app, calling its exported components from a test app, instrumenting it at runtime, and intercepting and modifying its traffic. Finally we attack the back end directly. Critical findings are reported the same day.
Testing is aligned to OWASP MASVS and MASTG, and reported in the same format as our web application and iOS testing, so a combined engagement produces one consistent report. For the full picture, see mobile app penetration testing.

