I built a pipeline that starts at the Play Store and ends at a disclosure email. This is the first post about it. Everything here describes the system. I don’t name apps or developers in public writing.
What is in an APK
Decompile an APK and you get a messy source tree. Java and Kotlin, yes, but also AndroidManifest.xml, strings.xml, generated BuildConfig values, Firebase configuration, SDK metadata, native libraries, and web assets.
The web assets are a bigger share than they used to be. Cordova, Capacitor, NativeScript, and React Native put a real application in JavaScript, HTML, and CSS, and production builds minify it, sometimes into one line hundreds of kilobytes long. Minification strips whitespace and renames variables. A credential the app needs at runtime survives it.
That is why APK scanning works at all. The client has to be able to read the secret, so it is in the package. What varies is how well it is obfuscated, what it is scoped to, and whether anyone has looked.
Why scan the package
Secret scanning usually watches the repository: scan commits, block the pull request. That covers what a developer writes. A credential can also arrive through a prebuild step, a third-party SDK, a config file injected by CI, or a web bundle built from a different repository. The APK is the last place to catch those, and the only one that matches what users install.
Scale is the other reason. The Play Store is a catalog of other people’s build outputs. To learn how a class of apps handles configuration you need hundreds of them, not the three on your phone.
The pipeline
Five stages, each a separate service, each handoff an event:
- Discover apps on the Play Store.
- Acquire the APK.
- Decompile it.
- Analyze what is inside.
- Draft, review, and send a disclosure.
Every state change is recorded, APKs and decompiled source go to object storage (the APK is deleted once analysis succeeds), and the heavy stages scale with the size of their queue, since a category import can produce thousands of apps and then nothing for hours.
Throughput was never the hard constraint. Any stage can fail, retry, or deliver the same message twice, and the record of what happened to an app has to stay correct anyway. At-least-once delivery means you will see the message again. It says nothing about whether the work is already done.
The project page covers the stages in more detail.
What the analyzer reports
A mobile build mixes file formats, so the analyzer reads Java, Kotlin, XML, JavaScript, HTML, CSS, bundles, and config files, then turns matches into claims a person can check.
- Firebase: database and storage URLs are pulled from source and web assets and probed for unauthenticated access. A URL that answers is not a finding by itself. What matters is what the database exposes and whether the access is intended.
- Cloud storage: bucket URLs are checked for provider, access level, and object sensitivity. A public bucket matters when it holds something worth protecting.
- Credentials: two independent scanners run over the source. They disagree sometimes, and the disagreements are the ones worth reading.
- Encoded strings: Base64 blobs are decoded and rescanned, because mobile builds often hide configuration and endpoints this way.
- Validation: where a provider offers a safe way to test a key, the analyzer uses it. Otherwise the finding stays unvalidated. The system should be able to defend any claim that a key is live.
An LLM then reads each finding, names the provider, assigns a severity, and writes a short reason a human can check. It ranks the queue and explains itself. It does not decide what gets sent, and I care more about that than about which model does the ranking.
Disclosure
People ask about the scanner. The disclosure path decides whether the project is worth running.
“Your app contains a Firebase URL” gives a maintainer nothing to do. “This database is readable without authentication, here is the app version and source path, here is what it exposes, and here is how to close it” does. Most of the difference is work: confirming the current state, proving access without exploiting it, and writing for the person who has to fix it.
The rules the pipeline follows:
- Report the current state. The latest app version and the newest probe decide. A database that was public last month and is closed today gets no report.
- Show the evidence: provider, location, access, impact, remediation.
- I approve every email that is sent. An LLM review catches weak or overclaimed drafts, and the approval step stays even in automated mode.
- Route by program. Apps without one get an email from a dedicated disclosure address. Apps matched to a bounty program go through it and never get a second email on the side.
- Track each report from drafted to approved, sent, acknowledged, and remediated, with replies and bounces matched back to it.
The research does not bypass authentication, modify data, or use what it finds beyond proving access. I hold to that for ethical reasons, and it also keeps the reports credible.
What goes wrong
Minified bundles make source locations ugly and explanations harder. Cross-platform frameworks repeat the same configuration in three places. An app can reference a key from a code path no user reaches. A finding can be true and not matter, and a key can be live and scoped to nothing interesting.
Staleness causes the most trouble. The app version you analyzed may not be the one you are about to write about. A database can close between the probe and the draft, and a developer can ship a fix the same afternoon. A report that doesn’t re-check current state is just confident noise.
Maintainers are also busy. A report from an unknown researcher has to establish who sent it, explain the problem without talking down, and make the fix easy to verify. Every extra paragraph of scanner output works against that.
Next
I’ll write about the event model, the analyzer, and the disclosure desk, including what broke in each.
If you maintain an Android app, unzip your latest release and read what is in it. It may not match what your repository says should be there. If you received a disclosure report about your app, the aim is to close the exposure, and replying with questions is welcome.