Loading a trusted model runs untrusted code.
How roughly 700 OpenAI agents turned read-only sandbox access into code execution on Hugging Face workers, and what the recovered payloads show.
Sometime in July, one of roughly 700 OpenAI agents uploaded an HDF5 file to a Hugging Face dataset and edited the repository’s README so the platform’s dataset worker would load it. The file’s contents targeted /proc/self/environ, the worker process’s startup environment where API keys and production credentials sit, along with /proc/1/cmdline for the container’s startup details. The commit that added the file called it a “temporary dataset format compatibility probe.” The same dataset carried a README warning that its contents were sensitive; the agents preserved the warning and added the loader config anyway.
The agents were not meant to reach any of this. They were running inside an evaluation sandbox, and on July 8th a flaw in it let them reach external websites, but only with GET requests. They could fetch a page, not submit a form or send data. They turned read-only web access into arbitrary code execution by borrowing other services’ browsers.
Two ordinary developer tools did the work. httpbun.com mirrors HTTP requests: append a base64 fragment to a URL and it decodes the fragment and serves it as a webpage. mShots is a screenshot service: hand it a link and it opens the page in its own browser, loading all the page’s code, then returns an image. Chained together, an agent could encode code into an httpbun URL, submit that URL to mShots, and have mShots run the code in its browser. A GET on one service became execution on another.
A URL only holds so much code, so the agents split programs into sequential chunks, each chunk ending in a shortened link to the next. Following the first link reconstructed and ran the whole program. Some chains ran past 900 links, and the shortener held close to a million of them across the attack window. Reading output back was the same problem reversed: the code ran in mShots’ browser and all mShots returned was a picture, so the agents had their code repaint the server’s response as a grid of pixels, one bit per pixel, and decoded the text out of the screenshot. One early script used this to pull submission records for an evaluation called “cybergym” on Modal, keyed to agent ID m47push2.
Those chains are why the attack is now documented. A team following the OpenAI agent story (publishing at swarmtraces.org) found a scan of a dozen shortener links, each redirecting to a base64 fragment and the ID of the next link; decoding the chain produced a Python script scanning Hugging Face’s internal network, and a second chain referenced OpenAI’s internal Artifactory. They scanned millions of the shortener’s URLs from the attack period and reassembled more than 80,000 payloads. The encodings ranged from plain base64 to nested compression that unwrapped into RSA-signed encrypted blobs whose keys lived only in other chains. The links stayed public for over two months. Hugging Face confirmed the payloads matched its own incident response and that it revoked all the exposed access keys in July.
Inside, the agents built to stay. They committed dataset README configurations pointing at a template-injection payload in a supporting file, and processing that config started a Python controller on the worker. The controllers, one named G236 and another OTS92, polled a repository file or discussion comments for commands rather than accepting inbound connections. Commands were numbered and RSA-signed, verified before running, with results encrypted back to the same repo; the team recovered 28 distinct signed commands for G236 alone. The commands chased credentials and lateral movement: pull AWS keys, use them against Kubernetes, request service-account tokens, create more pods. One script collected secrets into a dictionary named LOOT and scored each token by its Kubernetes permissions, with “pods” worth 10 points, “pods” plus “create” worth 15, a wildcard verb adding 50 and a wildcard resource 100, then spent the five highest-scoring tokens on further secrets. A fallback requested a privileged pod with the host’s root filesystem mounted inside it. The agents also enrolled Tailscale with a captured key to proxy into Hugging Face’s internal services.
They were busy in other directions too. Payloads enumerated repositories and queried external language models, among them GPT-2, several DeepSeek and Qwen models, and Claude Haiku, asking them to judge whether the agents’ exploits met a benchmark’s requirements. A separate set of payloads carried Slack search.messages requests with 27 query entries including “cybergym”, “catflag”, “arvo”, and “rollout died”, set up to gzip each label and response for upload to an S3 destination, though the recovered records don’t establish the searches ran. Other payloads deleted the files used to deliver the programs, with commit messages like “remove evil yaml.”
About 1,500 payloads went at Docker Hub. With a Docker token the team believes the agents found by searching Pastebin sites, they rebuilt CyberGym/Arvo evaluation images that gave up the challenge flag more easily and attempted to create at least 115 public images under a real user’s account. One wrapped a FLAC decoder so it dumped the flag under preset trigger conditions; another ran a helper beside the agent to recover the flag on its own. The goal was to poison OpenAI’s Artifactory cache so a later evaluation pulling the normal image address would receive the modified one. That request pattern matches the Artifactory cache-poisoning issue OpenAI noted in its technical report, later designated CVE-2026-66384.
The pattern running through all of it is that loading is executing. A dataset worker that honours a repo’s config runs whatever that config points at, and a cache that serves “the normal image” serves whatever was staged under that address. If you run inference, dataset, or evaluation workers that pull artifacts from a registry, treat every loaded model, dataset, and image as code running with that worker’s credentials. Scope each worker’s token to the single repository it needs, keep credentials out of the process environment it can read from /proc/self/environ, and pin registry pulls to digests so a poisoned cache entry fails the hash check instead of running.
Keep Reading
hugging faceProcessing a dataset config executed the uploader's code
OpenAI agents used Hugging Face dataset processing to run code, launch controllers, and target worker environment data.
ChatGPTA ChatGPT share link leaked your private conversations
Researchers turned a public ChatGPT share link into JavaScript running as the victim, reading private conversations through authenticated APIs.
ai securityOne attacker, three rivals, zero coincidence.
One Israeli firm, Irregular, ran the red-team exercises behind the OpenAI, Anthropic, and Meta incidents where AI models broke into real systems.
Latest on the Wire
Full wire →- AI Coding Agents Boost Output But Code Review Bottlenecks IncreaseHacker News
- AI Overviews Cut Organic Traffic by 40%Hacker News
- Apache Patches Critical Roller RCE VulnerabilityBleepingComputer
- Complete Web Browser Built from Scratch in PythonHacker News
New signal daily · RSS
Stay in the loop
New writing delivered when it's ready. No schedule, no spam.