Public exposure is sometimes deliberate, so the hard question isn't whether an endpoint is open but whether its openness matches policy. When applications span many teams and cloud services and keep changing, answering that requires repeated checks rather than a one-time review. Overexposed covers two kinds of internet-facing services — Kubernetes Ingresses on Google Kubernetes Engine (GKE) and Cloud Run services — beginning from the cloud's own inventory of what is deployed and then testing whether each candidate permits access without a login. Every candidate endpoint ends up with a verdict and the reasoning behind it.
Scan pipeline
- Enumerate deployed resources: The Cloud Asset Inventory API supplies Ingresses and Cloud Run services that could be reachable from the internet.
- Probe anonymously: One unauthenticated HTTP request per endpoint, interpreted as an outsider would see it.
- Apply policy: The response is mapped to one of six verdicts: exposed, expected, protected, not found, unreachable, or inconclusive. Anonymous access that is intentional is recorded in a reviewed allowlist matched on exact host and path; a match turns exposed into expected, while a probe finding the entry protected suggests it is stale and is flagged.
- Persist verdict plus evidence: Each endpoint is stored with what was configured, what the probe observed, where access was blocked, and the owning team.
Why configuration files were abandoned
The original scanner read Kubernetes files from the infrastructure repository, flagging Ingresses on a public hostname without an authentication setting and then issuing a live request to each. That approach broke in three distinct ways:
- False positives: Teams that set proxy authentication annotations directly were not recognized, so protected applications were reported as exposed.
- False negatives: An admission controller may rewrite settings as a cluster accepts an Ingress. Where the controller doesn't run, a correct-looking setting has no effect.
- Blind spots: Ingresses created from other repositories or by platform tooling were invisible to the scanner.
A repository records intent, not what the cluster actually enforces. Cloud Asset Inventory instead reflects the Ingresses GKE accepted after every admission controller ran, along with Cloud Run services and load balancers. One search returns the resources and a second returns their access policies, with no cluster credentials required. The inventory also surfaced Cloud Run services in many projects the first scanner never saw; these were added to the scan.
Probing from the outside
Inventory establishes what can be exposed; only an external request establishes what is. The probe behaves as an anonymous user under these rules:
- Send HEAD first, falling back to GET only if the server rejects HEAD.
- Never follow redirects automatically: limit to three, checking each one.
- A redirect to an identity provider counts as protected.
- A 401 with an authentication challenge counts as protected.
- A 200 with real content counts as exposed.
- If only
/adminis protected, try/ADMINand similar variants, since path rules can be case-sensitive.
Cloud Run: two independent controls
Ingress settings determine which networks can reach a service; Identity and Access Management (IAM) determines who may call it. A service is public only when anonymous users — the principal allUsers in GCP — hold the invoker role, or when the invoker check is disabled. A service that allows all traffic but restricts the invoker role returns 403 to strangers, which is not an exposure. A load balancer complicates the picture: the service behind it can allow anonymous calls, with authentication then enforced by the load balancer or the application itself, for example via Identity-Aware Proxy (IAP). The scanner reads the load balancer's URL map to determine which service answers each path.
Hardening the scanner
A scanner is itself an SSRF vector: an attacker could use it to reach internal systems, and an ordinary-looking hostname can resolve to a private address. Every hostname and every IP returned by DNS is checked, rejecting known internal names and disallowed addresses such as private and loopback ranges. The scanner connects to the validated IP directly rather than re-resolving the hostname, so a second lookup cannot redirect the destination; the original hostname is retained for the HTTP request and HTTPS certificate checks, and destination checks repeat before each redirected request.
These checks reduce risk, but they are not enough on their own. Also restrict the scanner's network access to block internal services and cloud metadata endpoints.
Turning responses into verdicts
An HTTP response is a clue rather than an answer, so the classifier combines what was deployed, what the anonymous probe observed, and whether the endpoint is approved to be public:
- Exposed: anonymous access worked, no allowlist entry matched; needs review.
- Expected: anonymous access worked and matched an approved allowlist entry.
- Protected: authentication or another access control blocked the request.
- Not found: the service responded but the endpoint was absent.
- Unreachable: the scanner could not connect.
- Inconclusive: a response arrived but evidence was insufficient to decide.
Keeping all rules in a single table lets reviewers see them together, and it exposed a complication: one status code can carry different meanings. A 404 behind an Ingress means the proxy answered and the path does not exist. On Cloud Run, Google's front end can return 404 before the application runs at all, so that status says nothing about authentication. Likewise, a 403 is not proof of protection, since many applications emit one for unrelated reasons.
Allowlists as context
An allowlist entry never removes an endpoint from scanning. Exceptions live in code so additions and changes pass through review, but the probe still runs every time; when anonymous access works and matches the approved host and path, the outcome shifts from exposed to expected. Because services change, allowlisted endpoints are rechecked on each run — one may start requiring authentication or vanish entirely, in which case the result is kept and the entry marked for review. The guiding rule: uncertainty does not mean protected. Incomplete or contradictory evidence yields inconclusive, kept visible for investigation.
Evidence and iteration
Each result records what was configured, what the probe saw, whether an allowlist entry applied, and, where available, the owning team. Response bodies and credentials are never stored: they may hold sensitive information and are not needed to explain a verdict. Only what supports explanation, investigation, and comparison with later scans is kept.
Early runs were dominated by incompleteness — roughly three in four results were inconclusive in one July run. Grouping results by reason and working through the largest groups, the team added clearer verdicts (not found, unreachable) where evidence supported them and left genuinely unclear results inconclusive. Before any rule change ships, it is replayed against saved results from previous scans with every verdict compared, making the impact visible in advance. Within a few weeks, inconclusive Ingress results fell by about 80%.
Testing a scanner built with AI
AI coding agents helped write Overexposed, and AI code review covered every pull request. That speed carries a specific hazard: a test can pass while checking the wrong thing. One test verified that a SQL parameter existed without verifying the query used it. Mutation testing guards against gaps of this kind — remove the fix, run the tests, and if they still pass, the tests are wrong. Alongside this, one canary target per verdict with a known expected result catches misclassification, and that testing is built into the periodically running pipeline so regressions surface early.
Lessons learned
Three principles shaped the scanner. The inventory has to be built from what the cloud actually runs rather than from what a repository declares; the probe has to run as a stranger; and every result must come with a reason attached. On top of that, changes to the rules should be tested against saved results rather than against live traffic.
Build the inventory from runtime, not from repos
Finding apps without authentication starts with knowing what is really deployed. A repository-based list will not give a true inventory, so the scanner derives its target set from the cloud. Only then does probing make sense.
Probe as a stranger
The scanner should look at each endpoint the way an unauthenticated outsider would. Probing as a stranger makes the resulting verdicts reflect real exposure instead of assumptions inherited from the codebase.
Give every verdict a reason
A scanner that guesses is not something we can rely on. One that explains each verdict gives teams what they need: a way to confirm access is expected, to investigate cases that look uncertain, and to tighten access controls where the findings call for it. Team members can then act with context rather than reacting to an opaque list.
Test rule changes on saved results
Because the assessment rules will evolve, changes should be validated against saved results before they shape live assessments. This keeps the verdicts consistent and makes it easier to see how a rule adjustment affects previously observed exposure.
For teams that want to build something similar for their own environment, Shopify has published a starting point for a similar scanner. How do you discover and assess your applications’ internet exposure? Shopify is collecting answers via @ShopifyEng.



