Researchers Planted AWS Keys in 100 Public Docker Hub Images. The First Was Used 7.86 Seconds After Push, All 100 Within 15 Minutes. Scan Every Layer, Rotate Anything You Ever Pushed
If your team has ever pushed a container image to a public registry, do three things tonight. First, scan every layer of every public image you have pushed, not just the final filesystem, for cloud keys, LLM API keys and SSH or database passwords. Second, rotate any secret that has ever been in a pushed layer, even if you deleted the tag or overwrote it an hour later. Third, pull the access history for those keys (AWS CloudTrail, the OpenAI and Anthropic usage pages) and look for calls that did not come from you.
The reason for the hurry is a measurement, not a guess. Two researchers at Stony Brook University published 100 instrumented images on Docker Hub, each holding a live but locked-down AWS key. The fastest key was used 7.86 seconds after its image was pushed. The median was 51 seconds. Every one of the 100 keys had been used within 15 minutes.
What was measured
The paper is "Gone in 8 Seconds: Uncovering Malicious Bots Operating on Public Container Registries" by Billy Tsouvalas and Nick Nikiforakis (PragSec Lab, Stony Brook), in the proceedings of ACM CCS 2026. BleepingComputer covered it on Tuesday, November 17, 2026. We could not download the paper itself (the ACM Digital Library returned HTTP 403 to us), so the numbers below come from the authors' project page and their published artifact on Zenodo (doi 10.5281/zenodo.22739294): the raw logs plus the analysis notebooks with their outputs saved. Where we quote a number, it is the notebook's printed output, and we name the round it came from.
In the authors' words, from the project abstract: they deployed "300 instrumented container images across eight public container registries over a period of four months." Each image carried "static honeytokens (AWS, OpenAI, Claude API keys), decoy SSH and database credentials, and image lifecycle beacons" that call home if anyone builds, runs or opens a shell in the image.
Round 1 (100 images, Docker Hub only, pushed January 29 and 30, 2026, not advertised anywhere):
The images were pulled 58,819 times over 90 days.
All 100 AWS keys were used: 66,321 API requests from 3,842 unique IP addresses.
Time from push to first AWS call, across the 100 keys: minimum 7.86 seconds, median 51.19 seconds, mean 89.63 seconds, maximum 894 seconds (just under 15 minutes). 56 of the 100 keys were touched within the first minute and 93 within five minutes.
Not one lifecycle beacon fired. Nobody built, ran or opened a shell in any of the 100 images. In the paper's words, as quoted by BleepingComputer, the scanners "overwhelmingly do so through static analysis," pulling layers apart "without ever instantiating the container."
Round 2 (200 images from March 25, 2026, across Docker Hub, Amazon ECR Public, hosted Red Hat Quay, and self-hosted Harbor, CNCF Distribution, Sonatype Nexus, Zot and Red Hat Quay):
56 AWS keys were used, with 75,742 calls from 1,232 IPs. Docker Hub keys took 75,709 of those calls; keys planted on Harbor took 33.
On Docker Hub the median push-to-first-use was 100.7 seconds and the fastest 34.7 seconds. Keys on the self-hosted Harbor registry sat for about 6.57 days before first use.
Images with sensitive-sounding names (the top pulls included tokenauth/prod-token-validator and vaultservice/prod-keypair-store) drew more than twice the pulls of plainly named ones.
28 OpenAI keys and 4 Anthropic keys were used. Only three "run" beacons fired, on two images.
The decoy SSH and MySQL servers saw 18,852 SSH login attempts with 2 successful logins, and 95 MySQL queries.
The headline figures BleepingComputer and the abstract give, "over 140,000 API calls from more than 5,000 unique IP addresses," are the two rounds added together (66,321 plus 75,742; 3,842 plus 1,232). The same IP may appear in both rounds, so 5,000 is an upper bound on distinct sources.
What the scanners did with the keys
The authors sort every AWS call into three stages: validate (GetCallerIdentity, the "whoami" check), enumerate (List, Get and Describe calls) and exploit (anything that spends money or changes state). We counted the event names in the Round 1 CloudTrail export ourselves; these counts include a few test images the notebooks exclude, so they run slightly above the paper's totals.
Validation dominates. GetCallerIdentity was 19,771 of 67,963 raw Round 1 events.
Enumeration goes straight for the money: ECS and EKS clusters, EC2 instances, RDS databases, Lambda functions, DynamoDB tables, Secrets Manager, SES send quotas (can this account send spam?), SNS SMS settings, IAM users and roles, and billing calls such as GetCostAndUsage.
Exploitation targets AI and compute. In Round 1 we counted 4,043 Bedrock InvokeModel attempts, PutUseCaseForModelAccess calls (the form that requests access to Anthropic models on Bedrock), 500 CreateKeyPair attempts and 3 CreateUser attempts. In Round 2 there were 282 RunInstances attempts.
Every one of those exploit calls failed, and that is by design: the honey keys carried an explicit deny policy. A real leaked key with real permissions would have succeeded. The LLM keys had no such guard. The OpenAI and Claude keys "were drained of their full account balances in short, rapid bursts of exploitation," per the abstract. The Round 1 notebook shows 18.8 million OpenAI input tokens and 1.27 million Claude input tokens; in Round 2 one day, April 9, 2026, burned 13.2 million OpenAI tokens.
The user agents tell you what kind of tooling this is. In Round 1, the top families were aws-cli (21,406 calls), Boto3 (15,585), TruffleHog (14,410), aws-sdk-rust/1.3.9 built on a nightly Rust 1.93 toolchain (8,500) and Python aiohttp (5,355). Many of the CLI and Boto3 user agents carry an operating-system string ending in "-gcp," which means a Google Cloud kernel. The scanning runs on rented cloud machines. Round 2 added an aws-sdk-java client (8,563 calls), ReactorNetty (4,898) and 14,828 calls with no user agent at all, mostly DescribeImages. Three calls carried "kingfisher-scanner." The notebook's first-call list shows the same hashed source address making the first AWS call against image after image, a few minutes apart: an operator watching the registry's stream of new pushes.
A caution on the TruffleHog string: TruffleHog is a legitimate open-source scanner, and it confirms a key is live by calling GetCallerIdentity with that user agent. Defenders running it against their own images produce the same log line. That user agent tells you a key was tested, not who tested it.
Indicators
None that a defender can block. The artifact hashes every source IP address and every key, as the authors explain, for ethical reasons. No IPs, domains or file hashes were published in the sources we read (the project page, the Zenodo artifact and its appendix, and BleepingComputer's article), so we added nothing to our feed. The user agents above are worth an alert rule in CloudTrail. They are not worth a block: the same strings come from the official AWS SDKs and CLI.
What we could check is our own edge. Over the last 30 days (October 19 to November 19, 2026), our edge blocked 1,209 requests for /.aws/credentials and similar paths from 167 IP addresses, and our canary traps answered 637 more requests for /.aws/credentials paths from 403 IPs. DigitalOcean (AS14061) was the top network in both. Some came in through the Vite dev-server file-read path (/@fs/home/ubuntu/.aws/credentials). That is a different population from the paper's: web scanners looking for credential files on websites, not registry scanners. It shows the same demand, though. Nobody on our edge sent the TruffleHog, kingfisher or aws-sdk-rust user agents in that window (529,113 edge block records and 92,871 canary records scanned). That is expected, since those tools talk to AWS, not to us.
What Docker Hub does and does not do for you
The researchers recommend that Docker Hub scan images for secrets before they go live and warn the publisher, and that it rate-limit access to its public feed of newly pushed images. Tsouvalas told BleepingComputer they sent Docker the findings and the full paper in May and got an acknowledgment, nothing more. A smaller experiment in August found no change. Plan as if nothing between your docker push and the scanners will catch a key for you.
Am I affected? The self-check
List what you have pushed. For every public repository under your organization on Docker Hub (and ECR Public, Quay or any internet-facing registry), list all tags and all old digests, not just latest. A tag you overwrote still exists as a digest that anyone who copied it can pull.
Scan every layer. TruffleHog's docker mode reads each layer separately: run "trufflehog docker --image yourorg/yourimage:tag" for each tag. Without a scanner, run "docker save yourorg/yourimage:tag -o image.tar", unpack it, unpack each layer tarball inside, and search for AKIA (AWS access key IDs), sk-ant- (Anthropic), sk-proj- and sk- (OpenAI), "BEGIN OPENSSH PRIVATE KEY", "BEGIN RSA PRIVATE KEY", .env files, .aws/credentials, .npmrc, .pypirc and .docker/config.json. A file deleted in a later layer is still in the earlier one; that is exactly what the scanners read.
Check the build history. Run "docker history --no-trunc yourorg/yourimage:tag" and "docker inspect" on each image. Build arguments passed with --build-arg and every ENV value are stored in the image metadata in plain text, even when no file ever held the secret.
If you find a key, assume it was used, and rotate it before you investigate. Then check:
Stop it happening again
Use BuildKit secret mounts for anything the build needs (a package token, a private registry login): "RUN --mount=type=secret,id=npmrc" in the Dockerfile and "docker build --secret id=npmrc,src=$HOME/.npmrc" on the command line. The secret is available during that RUN step and never written to a layer. Never use ARG or ENV for secrets.
Keep credentials out of the build context entirely. Add .env, .aws, .ssh, *.pem, .npmrc, .pypirc and .docker to .dockerignore, so a COPY . . cannot pick them up.
Use multi-stage builds so build tools and their configs stay in a stage you never push. Remember that "RUN rm secret" in the same stage does not help: the file still exists in the layer before it.
Scan the built image in CI before pushing, and fail the build on a verified secret. Seconds count here. Every scanner in this study ran on the published image, so anything you catch has to be caught before the push.
Prefer credentials that expire. A container that needs AWS should get a role from the platform (IAM roles for ECS tasks or EKS pods, GitHub Actions OIDC for CI), not a static access key. A key that does not exist cannot leak.
Make private the default for anything that is not meant to be public, and remember that a sensitive-sounding image name draws twice the pulls.
How we know
We downloaded the authors' Zenodo artifact (88 MB: CloudTrail exports, OpenAI and Anthropic usage logs, beacon and honeypot logs, five notebooks with saved outputs) and read the notebook outputs and the artifact appendix directly. The Round 1 and Round 2 user-agent, event-name and error-code counts are our own counts from the raw CloudTrail CSVs in that artifact. The quoted phrases come from the project page abstract and from BleepingComputer's article. The disclosure timeline (May report, acknowledgment only, August retest) comes only from BleepingComputer's interview with Tsouvalas. We have not read the full paper, and the 7.86-second, median and 15-minute figures come from the notebooks, not from the paper's text. Our edge figures come from our own ttp-check scan of edge-shield block events and edge canary records for October 19 to November 19, 2026.
Sources
Billy Tsouvalas and Nick Nikiforakis, "Gone in 8 Seconds: Uncovering Malicious Bots Operating on Public Container Registries," ACM CCS 2026, doi 10.1145/3830454.3846791. Project page: https://containerbots.github.io/
Artifact (logs and notebooks, CC BY 4.0): https://doi.org/10.5281/zenodo.22739294
BleepingComputer, November 17, 2026: https://www.bleepingcomputer.com/news/security/cloud-keys-leaked-in-docker-hub-images-are-stolen-within-seconds/
Read next: once a key leaks, how long does it stay live? Truffle Security says 81% of the leaked keys it reported were still valid six months later.
Every indicator in this post is in the feed. Free.
1.58M+ IOCs, STIX 2.1 / TAXII, 88% novel vs ThreatFox, exploited-CVE leads ahead of CISA. No credit card — a free API key in 30 seconds, and you can audit every claim above against the live endpoints.



Comments