The Share Link Was Never the Lock: 35,578 Apps Wide Open

Claroc researchers tried 43,551 Grok Build app addresses in a browser signed in to nothing. 35,578 of them opened. That is 94.7% of the apps still online that day, serving their data to strangers who had guessed nothing and paid nothing. Only 1,993 answered with a 401.

The share link was never the lock. The lock was supposed to be a permission check that never ran, and every agent platform that ships a share feature without one is a pattern search away from the same headline.

THE ACTUAL FAILURE, IN ORDER

Grok Build publishes each app as its own hostname, a name under grok.me. That choice is where the chain starts. Grok proposes four random words for the name, and four random words are genuinely unguessable. Nobody has to guess them, because a hostname gets looked up in DNS the first time anyone opens it, and passive DNS services collect those lookups into searchable datasets. One pattern search lists the space.

Then the access step finishes the job. In the paid account Claroc used to test publishing, the panel offered Anyone with the link, invited users, and Only you, with Anyone with the link already selected. SpaceXSI says publishing takes several clicks and that employee accounts default to Only you. Both are true, and both are beside the point: the people who published 35,578 open apps clicked through every one of those steps.

That is insecure direct object reference at platform scale. The object is the app and the data behind it: the database, the records, the files it generated. The reference is the link. Authorization on read was missing, so possession of the reference became the entire access-control system. Longer random strings raise the cost of guessing and do nothing about a public index.

WHY IS UNGUYS NOT ACCESS CONTROLLED?

Random IDs move the cost of finding an object from zero to an afternoon of scraping. A per-object check moves it to a lookup you are already doing: you fetched the row to serve the response, so the decision is a second read against a policy store on the same request path.

Here is the shape of a correct check. It is illustrative, not Grok's code, and the four parts are the point: who is asking, what they are asking for, what they want to do, and what the system decided.

 illustrative object-level check, not Grok's code def read_artifact(subject, artifact_id): obj = store.get(artifact_id) you already fetched this if obj is None: raise NotFound() if not policy.allows(subject, obj, "read"): subject, object, action audit.deny(subject, obj, "read") logged, counted, alerted raise Forbidden() return obj 

policy.allows is the whole architecture. Everything else in that function is plumbing. The line under it matters as much: a denied read nobody counts is a breach you learn about from a journalist, so alert on anonymous denials, because enumeration arrives as a burst of them.

THE FIVE PLACES AGENTS LEAK OBJECTS

This is the order these systems break in.

  1. Share links and public artifacts. Every published app, page, notebook, and preview URL. The check is whether this subject appears on this object's access list and whether the anonymous case produces an error page rather than a page.
  2. Artifact storage and generated files. Buckets behind downloads, exports, screenshots, and PDF renders. The check belongs on the storage layer, not on the endpoint that happens to call it.
  3. Agent memory and traces. Conversation history, tool call logs, and retrieved documents, often in a vector index or an observability tool with one shared read key. Any trace viewer that takes an ID and returns a transcript is an IDOR with extra steps.
  4. Tool output caches. Whatever an agent fetched, scraped, or shelled out to, it was cached for reuse. Caches inherit the trust of their writer and almost never the permissions of their reader.
  5. Config and credential files near the git root. Anything an agent persists next to the repository eventually gets committed, because the mechanism that made the feature convenient is the one that keeps it out of review.

THE AUDIT YOU CAN RUN THIS WEEK

You do not need a research team for the first pass. Search passive DNS, or your own edge logs if you run the domain, for the hostnames your platform publishes, open a sample in a private window, and note whether you got data or an error. Then walk your logs for reads of non-public objects by unauthenticated callers.

 illustrative audit pass, adapt names to your platform passive-dns search --pattern '*.your-app-domain.tld' > hosts.txt head -200 hosts.txt | while read h; do code=$(curl -s -o /dev/null -w '%{http_code}' "https://$h/") echo "$code $h" 200 on a private app is the finding done | grep '^200 ' 

A 200 on an object that should be private is your bug today, before anyone emails you about it.

WHAT TO DO TODAY

  • Inventory every surface where an object is reachable by a reference: share links, exports, artifacts, traces, and caches. Name the object type for each.
  • Put authorization on read, not only on create. Creation checks are what everyone writes first, and they are not the ones attackers use.
  • Take the reference out of the guessable namespace. Serve shared objects on a path under one host so the secret never becomes a DNS name, and stop relying on the random string either way.
  • Change the default. If publishing preselects a public option, that default is your risk owner. Make private the default and show the access list before an object goes live.
  • Scan your repos for persisted agent state near the git root, and check the script files an app's browser downloads for names, emails, and passwords in plain text.

The stakes justify the order. Claroc put the hand-checked count of apps with private data at roughly 650 to 800, including a hospital group's roster of more than 3,500 employees, an ICU briefing with one patient's labs and ventilator status, and a timesheet whose script file carried 18 plain-text passwords. It identified 30 organizations with internal data exposed, 26 above 1,000 employees, and six in the Fortune 500.

THE UNCOMFORTABLE QUESTION

Before SpaceXSI took them down, 24 of the open apps had been built by its own staff, including a sales territory map of 594 strategic accounts and an ad proposal to a federal agency marked confidential.

Your agent has already generated artifacts nobody audited. If a stranger enumerated them tonight, how many of your users' secrets would they read, and would you notice?

If you want the same failure on the agent side, I ran it there too:

The permission check is the lock, not the link: in Your Agent's Permission Model Is the Real Security Boundary. Your Guardrails Are Decoration. I made the same case from the agent side; GhostJacking rewrote a company's DNS 9 of 10 times to prove it.