Project

A research platform that finds issues developers don't know about

Developers rarely see what their apps expose once they ship: a database left open, a storage bucket holding sensitive files, a key compiled into the package. I built this system to find those issues and tell the people who can fix them.

Role Design, build, operations
Status Active
Targets Android apps
Disclosure Email, bug bounty

Most secret scanning watches a git repository. That catches what a developer commits. It does not catch what the build ships.

An APK carries Java and Kotlin, resources, native libraries, Firebase configuration, and, in a growing number of apps, a second application written in JavaScript. Cordova, Capacitor, NativeScript, and React Native keep their code in web assets, often minified into one enormous line.

If an app can read a credential at runtime, the credential is in the package. So the work is checking whether a string that looks like a key still works, what it opens, and who needs to know before someone less careful finds it.

Five stages, each a separate service. Stages hand off through events, every state change is recorded, and the heavy stages scale with the size of their queue.

  1. 01

    Discover

    Play Store categories, explicit package IDs, and queue policies that claim apps nobody has scanned yet.

  2. 02

    Acquire

    Pull the APK from multiple sources with fallbacks, store it, and announce it to the next stage.

  3. 03

    Decompile

    Turn the package back into Java, Kotlin, XML, and every minified web asset shipped inside it.

  4. 04

    Analyze

    Probe Firebase, test storage buckets, scan with two secret engines, decode strings, validate keys.

  5. 05

    Disclose

    Triage the signal, draft a report, keep a human on the send button, then file by email or bounty program.

A mobile build mixes languages and file formats, so the analyzer reads source, configuration, and minified bundles, then turns raw matches into findings a person can evaluate.

Firebase exposure

Database and storage URLs are extracted, probed for unauthenticated access, and classified by the data they expose.

Cloud storage

Bucket URLs found in source are checked for provider, access level, and object sensitivity. A public bucket is only useful if it holds something that matters.

Credentials

Two independent scanners run over the source, then each match is tied to a provider and validated against that provider where a safe check exists.

Encoded strings

Base64 blobs are decoded and rescanned. Mobile builds routinely hide configuration and endpoints this way, and scanners that only read plain text miss them.

Web assets

JavaScript, HTML, CSS, bundle files, and config formats are read alongside Java and XML. That is where cross-platform apps keep their actual application code.

LLM triage

A language model classifies findings with a provider, a severity, and a short reason a human can check. It ranks the queue; it does not decide what gets sent.

A finding that never reaches a maintainer is a row in a database. I built the disclosure path with as much care as the scanner.

  1. 01

    Verify current state

    Reports read the latest app version and the newest probe. A database that was public last month but is closed today does not get a report.

  2. 02

    Write for the person fixing it

    The draft names the provider, shows where the material sits, explains what it opens, and ends with a concrete remediation.

  3. 03

    Keep a human on the send button

    An LLM review catches weak or overclaimed reports. Approval is explicit. Even in automated mode the gate stays, on purpose.

  4. 04

    Route to the right place

    Apps without a program get an email from a dedicated disclosure address. Apps with a bug bounty program are routed there instead. A bounty-matched app is never emailed on the side.

  5. 05

    Follow it to fixed

    Each disclosure carries its own state: drafted, approved, sent, acknowledged, remediated. Replies and bounces are matched back to the report.

The research does not name apps or developers in public writing, does not bypass authentication, and does not attempt to use what it finds beyond proving access.

The work is event-driven because scanning arrives in bursts: one category import can produce thousands of apps, then nothing for hours.

The hard parts are the edges: duplicate delivery, jobs that die mid-scan, findings that go stale between discovery and send, and the difference between "the endpoint responded" and "this is safe to report."

All field notes