Listen to this Post
oras-go’s pagination helper parseLink() in registry/remote/utils.go follows the Link response header from a registry without validating the URL’s host or scheme. When a malicious registry returns a Link header containing an absolute URL pointing to an arbitrary host (e.g., a cloud metadata endpoint), the client makes GET requests to that host from the victim’s network. This affects all pagination-based listing operations: Tags, Referrers, and Repositories (catalog). The root cause is that parseLink() at registry/remote/utils.go:54 calls resp.Request.URL.Parse(link) which, for absolute URLs, returns the absolute URL unchanged. The result is passed directly to the next pagination loop iteration where http.NewRequestWithContext() creates a GET request to the attacker-specified URL. No host comparison, scheme validation, or IP filtering exists between parseLink output and the HTTP request. Affected code paths include registry/remote/repository.go:Tags() calls parseLink() for next page URL, registry/remote/repository.go:Referrers() calls parseLink() for next page URL, and registry/remote/registry.go:Repositories() calls parseLink() for next page URL. The impact is blind SSRF from the victim’s network. A malicious registry operator can force any oras-go client that lists tags, referrers, or repositories to issue GET requests to arbitrary internal endpoints such as cloud instance metadata endpoints for service discovery and IAM role enumeration, internal HTTP services for port scanning and triggering side effects. If the victim’s credential store maps credentials for the SSRF target host, those credentials are attached to the request (auth.Client looks up creds by request host). The attacker cannot read the response body (it’s parsed as JSON and fails), making this a blind SSRF. However, timing and error differences can confirm internal service existence. The attack chain involves the victim calling repo.Tags()/repo.Referrers()/registry.Repositories() against an attacker-controlled registry, the registry returns a valid first page plus a malicious Link header pointing to an internal endpoint, parseLink() extracts the absolute URL with zero validation, and the pagination loop makes a GET request to the internal endpoint from the victim’s network. The suggested fix is to validate that the URL returned by parseLink() has the same host and scheme as the original request before using it for the next pagination request. Reject cross-host or scheme-downgrade URLs.
DailyCVE Form:
Platform: oras-go
Version: < 2.6.2
Vulnerability: Blind SSRF
Severity: Medium
date: 2026-09-16
Prediction: 2026-07-10
What Undercode Say:
// Malicious registry handler for /v2/repo/tags/list:
func handler(w http.ResponseWriter, r http.Request) {
// Link header points to cloud metadata or internal service
w.Header().Set("Link", <code><http://internal-service:8080/admin>; rel="next"</code>)
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(map[bash][]string{"tags": {"v1"}})
}
// Victim code:
repo, _ := remote.NewRepository("attacker-registry.io/repo")
repo.Tags(ctx, "", func(tags []string) error { return nil })
// Result: GET http://internal-service:8080/admin is made from victim's network
Exploit: (Educational Purposes!)
Set up a malicious registry server that returns a valid first page of tags along with a Link header pointing to an internal endpoint. The victim calls repo.Tags(), repo.Referrers(), or registry.Repositories() against this registry. The parseLink() function extracts the absolute URL without validation. The pagination loop then sends a GET request from the victim’s network to the internal endpoint. Timing differences and error messages can confirm the existence of internal services.
Protection: from this CVE
Update oras-go to version 2.6.2 or later. Validate that the URL returned by parseLink() has the same host and scheme as the original request. Reject cross-host or scheme-downgrade URLs. Implement strict allowlists for pagination endpoints.
Impact:
Blind SSRF from the victim’s network. Attackers can probe internal services, enumerate cloud metadata endpoints, and potentially leak credentials if the credential store maps credentials for the SSRF target host. The response body is not returned to the attacker, but timing and error differences reveal service reachability.
🎯Let’s Practice Exploiting & Learn Patching For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
Sources:
Reported By: github.com
Extra Source Hub:
Undercode
