💻 computer science

Vulnerabilities, Secrets and Misconfiguration in the Highest-Exposure Docker Hub Images

This paper introduces ChimangoScan, a large-scale pipeline that analyzes the most exposed Docker Hub images using six independent scanners to reveal that vulnerabilities and misconfigurations are nearly universal, scanner results are highly tool-dependent with low agreement, and the majority of detected secrets are false positives.

Original authors: Cristhian Kapelinski, Beatriz Machado, Diego Kreutz

Published 2026-08-05

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Cristhian Kapelinski, Beatriz Machado, Diego Kreutz

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the internet as a massive, bustling city where software is the lifeblood. In this city, most applications aren't built from scratch anymore; they are assembled like LEGO sets using pre-made blocks called "containers." These containers are like standardized shipping crates that hold everything an app needs to run, from code to tools. The central warehouse where everyone stores and grabs these crates is called Docker Hub. It's the heart of the software supply chain, handling billions of downloads every month.

However, just like a real warehouse, if a crate is built with a cracked brick (a vulnerability) or has a loose latch (a misconfiguration), every single building constructed using that crate inherits the flaw. Even worse, some crates contain hidden traps like open safes (secrets or passwords) left inside. For years, security experts have tried to count how many of these dangerous crates exist, but they've usually relied on just one "security guard" (a scanner) to do the inspection. This is like trying to find all the potholes in a city with only one pair of eyes; you might miss a lot, or see things that aren't actually there. The big question is: How dangerous is this warehouse really, and does using just one scanner give us a true picture?

The Great Docker Detective Hunt

A team of researchers from Brazil, calling themselves ChimangoScan, decided to tackle this mystery with a massive, multi-layered investigation. Instead of hiring just one security guard, they built a super-pipeline that deployed six different scanners to inspect the most popular crates in the Docker Hub warehouse. Their goal wasn't just to count the bad crates, but to figure out which ones mattered most.

The "Exposure Score": Why Some Crates Matter More

Imagine a single cracked brick in a foundation stone used by a skyscraper versus a cracked brick in a tiny garden shed. The skyscraper's flaw is a disaster; the shed's is a minor annoyance. The researchers realized that simply counting how many times a crate was downloaded wasn't enough. They needed to know how many other crates were built on top of it.

They created a new metric called the Exposure Score. Think of it as a "danger radius." If a base image (like a popular Linux version) is downloaded 100 times, but it's also the foundation for 1,000 other images that are downloaded 100 times each, its exposure score is massive. The team ranked the top 52,895 images by this score. These weren't just the most downloaded; they were the ones whose flaws would ripple out to the most people. In total, these top images accounted for 84.7% of all 663.8 billion recorded pulls in history.

The Findings: A City Full of Cracks

When ChimangoScan ran its six scanners on these high-exposure images, the results were startlingly clear: almost everything was broken.

Vulnerabilities are everywhere: 96.3% of the images carried at least one known software vulnerability. Even scarier, 93.4% of them had a "critical" vulnerability, the kind that could let a hacker take over the system.
Bad configurations are the norm: 98.0% of the images had misconfigurations, such as running as a "root" user (the digital equivalent of giving a stranger the master key to the building) or missing safety checks.
Secrets are tricky: The scanners found "secrets" (like passwords or API keys) in 76.9% of the images. However, when the researchers manually checked these hits, they discovered a massive catch: 99.7% of them were false alarms. These were just example keys, test data, or public information, not actual stolen credentials. The scanners were shouting "Fire!" mostly because they smelled smoke from a burnt toast, not an actual inferno.

The Scanner Problem: One Tool Isn't Enough

Perhaps the most important discovery was about the tools themselves. The researchers found that the six scanners didn't agree on what they were seeing.

If you used only one scanner, you would get a very different picture of the danger level than if you used another.

When looking at distinct vulnerabilities, only 2.7% were found by all three vulnerability scanners.
A staggering 66.8% of the vulnerabilities were found by only one of the scanners.

This means that if a company relies on a single security tool, they are likely missing two out of every three potential problems. The "security score" of an image isn't an absolute fact; it's largely an artifact of which tool you used to measure it.

The "Inheritance" Effect

The study also showed how dangerous a single flaw can be when it sits in a popular base image. They found that a single critical flaw in a library like zlib or glibc (which are used in almost every base image) could theoretically affect 47.3% of the entire ecosystem's exposure. One bad brick in the foundation of a popular base image doesn't just hurt that one image; it compromises the entire family tree of applications built on top of it.

What This Means for You

The researchers concluded that we can't trust a single number from a single scanner. To keep the software supply chain safe, we need to:

Use multiple scanners: Since no single tool catches everything, running a battery of different scanners is necessary to get a real picture.
Prioritize by exposure: Fixing the flaws in the most "exposed" base images (the ones everyone builds on) will save more people than fixing flaws in obscure, rarely used images.
Don't panic over every "secret" alert: Since most detected secrets are false positives, we need better ways to verify them before treating them as emergencies.

In short, the Docker Hub warehouse is full of cracks, and the cracks in the foundation are the most dangerous. But the way we measure those cracks matters just as much as the cracks themselves. We need more eyes on the job to see the whole picture.

Technical Summary: Vulnerabilities, Secrets and Misconfiguration in the Highest-Exposure Docker Hub Images

Problem Statement
Docker Hub serves as the foundational registry for the containerized software supply chain, hosting over 14 million images and facilitating hundreds of billions of downloads. However, large-scale security measurements of this ecosystem are infrequent and historically rely on single vulnerability scanners. This reliance creates unquantified tool-dependence, where reported security postures may reflect the specific limitations of a detector rather than the actual state of the registry. Furthermore, prior studies often fail to account for the "parent-to-child" propagation of flaws: a vulnerability in a base image (e.g., alpine) is inherited by every image built upon it, potentially affecting billions of pulls, whereas a flaw in a rarely used leaf image affects almost nothing. Existing measurements also struggle to distinguish between raw detector hits and actual exploitable secrets, often conflating test fixtures with real credentials.

Methodology: The ChimangoScan Pipeline
To address these gaps, the authors present ChimangoScan, a three-stage pipeline designed to crawl Docker Hub, reconstruct the image layer graph, and scan the highest-exposure images using multiple independent tools.

Stage I: Repository Discovery: The pipeline enumerates the Docker Hub namespace using a prefix-trie traversal of repository names via the public Search API. This "cap-refining" approach handles API result limits (10,000 results per query) by recursively expanding saturated prefixes. The crawler indexed 12,716,568 repositories, recording pull counts, stars, and timestamps.
Stage II: Image Resolution and Layer Graph: The system resolves repositories into concrete image digests and reconstructs the layer graph. Using an ancestry-hashed identifier (SHA-256 of parent ID concatenated with layer digest), it builds a directed forest of 84.7 million nodes and 54.4 million edges representing IS_BASE_OF relationships. This structure captures how layers are shared across images.
Exposure-Based Prioritization: Unlike prior work that ranks by simple descendant counts, ChimangoScan introduces an Exposure Score $E(I)$ . This scalar combines an image's own pull count with the pull counts of all images in its downstream subtree. This metric prioritizes images whose flaws would propagate to the largest share of the ecosystem.
Stage III: Multi-Scanner Execution: The pipeline scans the top 52,895 highest-exposure repositories (covering 84.7% of all recorded pulls) using six open-source scanners:
- Software Inventory: Syft.
- Vulnerability Scanning: Trivy, Grype, and OSV-Scanner (utilizing NVD, Anchore VulnDB, and OSV databases respectively).
- Misconfiguration: Dockle (CIS Docker Benchmark).
- Secrets: TruffleHog (700+ detectors).
  Findings are consolidated per image but not deduplicated across scanners to allow for the measurement of inter-scanner disagreement.

Key Contributions

Exposure Score: The first metric to fold an image's own popularity and its entire downstream subtree's reach into a single scalar, enabling prioritization based on ecosystem impact rather than just image count.
Scale and Breadth: A measurement of 52,895 top-ranked repositories (approx. 170.4 million findings), representing two orders of magnitude more images than previous multi-scanner studies.
Inter-Scanner Disagreement Analysis: An ecosystem-scale quantification of how much security posture depends on the tool used.
Public Dataset: Release of metadata for 12.7 million repositories, the full layer graph, and multi-scanner reports for the scanned images.

Key Results

Near-Universal Vulnerabilities: Known vulnerabilities are pervasive. 96.3% of scanned images carry at least one known package vulnerability, 93.4% carry a critical one, and 98.0% contain a misconfiguration. The median image carries 885 merged findings.
Scanner Dependence: The reported security posture is heavily artifact-driven by the scanner. Of the distinct vulnerabilities found, only 2.7% are reported by all three vulnerability scanners, while 66.8% are reported by only one. A single-tool measurement misses approximately one distinct vulnerability in three.
Secrets vs. False Positives: While TruffleHog flags secrets in 76.9% of images, hand-labeling of a random sample reveals that 99.7% of these hits are non-credentials (e.g., package checksums, test fixtures, documentation examples). Only ~0.3% are plausible live credentials.
Misconfiguration Prevalence: Dockle flags misconfigurations in 98.0% of images, with the most common being missing content-trust configurations, missing HEALTHCHECK instructions, and containers running as root.
Exposure vs. Security: There is no correlation between an image's popularity (pull count) or exposure score and its vulnerability count. Even the most heavily reused base images (e.g., alpine, ubuntu) almost universally ship critical findings.
Propagation Impact: Weighting CVEs by exposure reveals that flaws in core libraries (e.g., zlib, glibc) affect a share of the ecosystem far larger than their raw image count suggests. A single top-reach CVE affects images accounting for 47.3% of the corpus's total exposure.

Significance and Claims
The paper claims that ecosystem-scale security measurements should not rely on a single scanner's count, as the reported posture is substantially an artifact of that tool. Instead, audits and CI pipelines should employ a battery of scanners backed by different databases. Furthermore, the authors argue that remediation efforts should be prioritized by exposure (downstream reach) rather than raw image counts, as this targets the flaws that propagate to the largest share of the supply chain. Finally, the paper emphasizes that raw secret detection rates are misleading without validation, as the vast majority of hits are false positives.

The study concludes that while vulnerabilities and misconfigurations are near-universal in the highest-exposure Docker Hub images, the specific metrics used to describe them are highly tool-dependent, necessitating a multi-scanner approach for accurate assessment.