Repository navigation
Commit def280d
authored
Update module oras.land/oras-go/v2 to v2.6.1 [SECURITY] (#4474)
This PR contains the following updates:
| Package | Type | Update | Change |
|---|---|---|---|
| oras.land/oras-go/v2 | require | patch | `v2.6.0` -> `v2.6.1` |
---
> [!WARNING]
> Some dependencies could not be looked up. Check the Dependency
Dashboard for more information.
### GitHub Vulnerability Alerts
####
[CVE-2026-48978](https://redirect.github.com/oras-project/oras-go/security/advisories/GHSA-xf85-363p-868w)
## Summary
oras-go's `auth.Client` follows the `realm` URL from a registry's
`WWW-Authenticate: Bearer` challenge without validating its scheme or
host. The `realm` field is server-controlled by design in the
OCI/distribution spec — registries legitimately point token requests at
a separate auth endpoint (e.g. Docker Hub's `registry-1.docker.io` ->
`auth.docker.io`), so cross-host realms on public DNS names are not in
themselves a vulnerability. Two specific patterns, however, are never
legitimate under any registry trust model and can be abused by a
malicious or compromised registry (or a man-in-the-middle on a plaintext
connection):
1. **SSRF to internal networks.** A realm of
`http://169.254.169.254/...` (AWS/Azure IMDS), `http://10.0.0.x/...`
(RFC 1918), or `http://127.0.0.1/...` causes oras-go running on a cloud
VM or corporate workstation to issue outbound HTTP requests from inside
the user's trust boundary to an endpoint the user did not choose. The
user's stored credentials are attached to those requests, but the
principal harm is the network primitive — probing internal endpoints
from the client. On IMDSv1 the response body is recoverable from log
channels; on IMDSv2 the probe itself can still be used for service
discovery.
2. **TLS downgrade.** A registry contacted over `https://` can return a
realm with an `http://` scheme, causing oras-go to send the user's
credentials over plaintext to the token endpoint. This defeats the
transport security the user chose when typing `https://`.
## What is NOT claimed
This advisory does **not** claim that credential forwarding to an
arbitrary public attacker host through a server-controlled realm is, on
its own, a vulnerability. The distribution spec defines `realm` as a
server-controlled field; a strict same-host or same-eTLD+1 enforcement
would deviate from the spec and break legitimate split-host deployments.
Operators who want defense-in-depth against cross-host realm forwarding
can use the opt-in `Client.TrustedRealmHosts` allowlist (added
separately).
## Affected versions
`oras.land/oras-go/v2 <= v2.6.0`
## Severity
Medium. Network attack vector, low complexity, no privileges required,
user interaction required (victim runs an oras command against the
malicious or MITM'd registry), unchanged scope. Confidentiality impact
is limited — IMDS probe responses can disclose information, and TLS
downgrade exposes the realm request to passive observers — but the
attacker does not obtain credentials beyond what the malicious endpoint
already controls.
## Affected code
- `registry/remote/auth/client.go` — `Client.Do()` (bearer challenge
handling)
- `registry/remote/auth/client.go` — `Client.fetchBearerToken()` /
`fetchDistributionToken` / `fetchOAuth2Token`
The `realm` parameter from `parseChallenge` is threaded through to
`http.NewRequestWithContext` without scheme or host validation.
## CWE
- CWE-918: Server-Side Request Forgery (SSRF)
- CWE-319: Cleartext Transmission of Sensitive Information
## Patch
`registry/remote/auth/client.go` now rejects realm URLs that:
- use a scheme other than `http` or `https`
- use `http` when the registry was contacted over `https` (TLS
downgrade)
- use an IP literal in a loopback, link-local, private, or unspecified
range, unless the registry itself was reached at the same hostname (so
loopback / in-cluster deployments are unaffected)
Cross-host realms on public DNS names continue to be accepted.
## Credit
Reported by bugbunny.ai.
####
[CVE-2026-50151](https://redirect.github.com/oras-project/oras-go/security/advisories/GHSA-jxpm-75mh-9fp7)
## Summary
oras-go follows a registry-controlled `Location` header during the
monolithic blob upload flow and reuses the `Authorization` header from
the initial `POST` request for the subsequent `PUT` request. If a
malicious registry returns a cross-host `Location`, oras-go can send the
caller's credentials to an attacker-controlled endpoint.
## Affected Versions
tested: v2.6.0 (commit 03243809936cce826494b5506f724c6dc11115b1, as-of
2026-01-24)
range: unknown; likely affects earlier v2.x releases that include the
same upload flow
## Impact
Credential leak to an attacker-controlled endpoint and client-side ssrf
to a cross-host target.
## Affected Component
- `registry/remote/repository.go:878-916`
(`blobStore.completePushAfterInitialPost`)
## Reproduction
Attachments include `poc.zip` with a local-only harness (no real
registry required). It runs a fake registry server that returns a
cross-host `Location` and a second server that records whether it
received `Authorization`.
```bash
unzip -q -o poc.zip -d /tmp/poc
cd /tmp/poc/poc-F-ORAS-LOCATION-UPLOAD-001
make canonical
make control
```
## Recommended Fix
- validate `Location` before uploading (scheme + hostname + effective
port) against the original request, or require an explicit opt-in
allowlist for cross-host upload urls
- never forward `Authorization` when the upload target changes host or
scheme
## references
- security policy:
https://github.com/oras-project/oras-go/security/policy
- vulnerable code: `registry/remote/repository.go` (see
`blobStore.completePushAfterInitialPost`)
####
[CVE-2026-50162](https://redirect.github.com/oras-project/oras-go/security/advisories/GHSA-8xwf-rjm4-xvhv)
The file content store in `oras-go` attempts to confine writes to
`workingDir` when `AllowPathTraversalOnWrite=false`, but the guard is
lexical and does not account for symlink traversal. If `workingDir`
contains a symlink path component and an attacker-controlled blob title
(via `ocispec.AnnotationTitle`) targets a path under that symlink,
`pushFile()` can create a file outside `workingDir`.
## relevant links
- repository: https://github.com/oras-project/oras-go
- commit: 03243809936cce826494b5506f724c6dc11115b1
- callsite: content/file/file.go:609 `resolveWritePath()` (used by
`pushFile()`)
## vulnerability details
**pins:** oras-project/oras-go@0324380
**as-of:** 2026-02-17
**policy:** GitHub Security Advisory (oras-project/oras-go)
**callsite:** content/file/file.go:609 `resolveWritePath()` →
`pushFile()`
**attacker control:** Attacker controls the pushed name
(`ocispec.AnnotationTitle`) and can select a path with a symlink path
component under `workingDir` → `resolveWritePath()` blocks `..` via
`filepath.Rel` but does not prevent symlink traversal → `pushFile()`
opens/creates the final path and follows the symlink → a file is created
outside `workingDir`
### root cause
`resolveWritePath()` enforces the write boundary using a
`filepath.Rel`-style check against `workingDir`. This prevents `../`
escapes but is purely lexical and does not resolve symlinks. If a path
component under `workingDir` is a symlink to an external location, the
subsequent filesystem operation in `pushFile()` follows that symlink and
performs the write outside `workingDir` while still passing the lexical
boundary check.
### attack path
1. Attacker provides a blob title (via `ocispec.AnnotationTitle`) that
contains a path like `out/pwn.txt`.
2. Victim uses `oras-go` file store with
`AllowPathTraversalOnWrite=false` and a `workingDir` that contains a
symlink directory `out -> /some/outside/dir`.
3. The lexical boundary check accepts `out/pwn.txt` as being under
`workingDir`.
4. The write follows the symlink and creates
`/some/outside/dir/pwn.txt`.
## impact
This is a filesystem boundary bypass that permits writes outside
`workingDir` when a symlink path component exists under `workingDir`.
The concrete security impact depends on the runtime environment (what
filesystem locations are writable by the process and what downstream
consumers do with the written file), but the intended confinement
guarantee is violated.
## proof of concept
the attached `poc.zip` contains a small, self-contained go harness that
demonstrates:
- canonical (vulnerable): prints `[CALLSITE_HIT]` and `[PROOF_MARKER]`
and shows the file is created outside `workingDir`
- control (no symlink component): prints `[NC_MARKER]` and confirms no
outside write occurs
run:
```bash
unzip -q -o poc.zip -d /tmp
cd /tmp/poc-F-ORAS-SYMLINK-WRITE-001
make test
```
**expected:** when `AllowPathTraversalOnWrite=false`, file store writes
should not be able to escape `workingDir`, including via symlink
traversal.
**actual:** A symlink path component under `workingDir` allows writes to
escape `workingDir` even when `AllowPathTraversalOnWrite=false`.
## recommended fix
ensure confinement checks account for symlink traversal. Options include
rejecting symlinks in any path component (walk components with
`os.Lstat`), validating the resolved parent directory via `EvalSymlinks`
and enforcing it remains under the resolved `workingDir`, or using an
`openat()`-style approach so the check and open happen relative to a
trusted directory file descriptor.
**fix accepted when:** The canonical PoC no longer prints
`[PROOF_MARKER]` for the same attacker-controlled inputs.
cheers,
Oleh
####
[GHSA-vh4v-2xq2-g5cg](https://redirect.github.com/oras-project/oras-go/security/advisories/GHSA-vh4v-2xq2-g5cg)
# ORAS Go forwards registry credentials across registry redirects
Reporter / public credit: JUNYI LIU
## Summary
ORAS Go can forward registry credentials configured for one registry
origin to a different HTTP origin during registry redirects.
There are two related paths:
1. A manifest or metadata request authenticates to the origin registry,
then the origin returns a redirect to another host or port. The
redirected request can carry the origin `Authorization` header to the
redirect target.
2. A blob upload `POST` authenticates to the origin registry, then the
origin returns an upload `Location` on another host or port. The
follow-up `PUT` can carry the origin `Authorization` header to the
`Location` target.
The upload `Location` issue appears related to the existing public fix
in pull request #​1152 / GHSA-jxpm-75mh-9fp7. The manifest
redirect path is a residual adjacent route: the v2 branch after the
upload `Location` fix still forwards Basic credentials on an
authenticated manifest redirect.
## Impact
A registry response can cause an ORAS Go or ORAS CLI client to send
configured registry credentials to an unintended endpoint. In common
workflows, those credentials may come from a registry config /
Docker-style auth file rather than command-line flags.
This is a credential exposure across the registry-origin boundary. I am
not claiming remote code execution, registry compromise, arbitrary token
theft, or live third-party impact.
## Affected Versions Tested
- `oras-go v2.6.0`: affected.
- `oras-go` main at commit `a57383e580c8f2c97fb67dedfc5c9945c8c3614e`:
affected.
- `oras-go` v2 branch at commit
`d593d504779be8b69f0ba034ac9fd407d1fc8cfc`: upload `Location` path is
blocked, but manifest redirect credential forwarding is still affected.
- ORAS CLI at commit `3d2646279c70ba60415440e44c2ff97896e4a209`, using
`oras-go v2.6.0`: affected when using `--registry-config`.
## Security Invariant
Credentials resolved for one registry origin should not be silently
forwarded to a different origin reached through a registry redirect or
upload `Location` response.
## Local Reproduction Overview
All testing used loopback servers and fake credentials only.
Manifest redirect flow:
1. The client requests a manifest from the origin registry.
2. The origin returns `401` with a Basic challenge.
3. The client retries the origin request with the origin credential.
4. The origin returns `307` to another port on the same hostname.
5. The redirect sink receives the origin `Authorization` header.
ORAS CLI stored-credential flow:
1. A temporary registry config contains a fake Basic credential for the
origin registry only.
2. Run:
```sh
oras manifest fetch --plain-http --registry-config <config> <origin>/probe:latest
```
3. The origin authenticates the request and redirects it to another
port.
4. The redirect sink receives the origin `Authorization` header.
Blob upload `Location` flow:
1. The client starts a blob upload with `POST` to the origin registry.
2. The origin challenges with Basic and then accepts the authenticated
`POST`.
3. The origin returns an upload `Location` URL on another port.
4. In affected versions, the follow-up `PUT` to the `Location` target
carries the origin `Authorization` header.
## Expected Result
Redirect and upload `Location` targets on a different HTTP origin should
not receive the origin `Authorization` header.
## Observed Result
In affected versions, redirect or `Location` sinks received:
```http
Authorization: Basic <base64 origin_user:origin_pass>
```
## Standalone Reproducer
```go
package main
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"sync"
"github.com/opencontainers/go-digest"
"github.com/oras-project/oras-go/v3/registry/remote"
"github.com/oras-project/oras-go/v3/registry/remote/auth"
"github.com/oras-project/oras-go/v3/registry/remote/credentials"
)
type hit struct {
Method string `json:"method"`
Path string `json:"path"`
Host string `json:"host"`
Auth string `json:"auth,omitempty"`
}
func main() {
const username = "origin_user"
const password = "origin_pass"
const expectedAuth = "Basic b3JpZ2luX3VzZXI6b3JpZ2luX3Bhc3M="
var mu sync.Mutex
var originHits, sinkHits []hit
record := func(dst *[]hit, r *http.Request) {
mu.Lock()
defer mu.Unlock()
*dst = append(*dst, hit{
Method: r.Method,
Path: r.URL.RequestURI(),
Host: r.Host,
Auth: r.Header.Get("Authorization"),
})
}
manifest := []byte(`{"schemaVersion":2,"mediaType":"application/vnd.oci.image.manifest.v1+json","config":{"mediaType":"application/vnd.unknown.config.v1+json","digest":"sha256:44136fa355b3678a1146ad16f7e8649e94fb4fc21fe77e8310c060f61caaff8a","size":2},"layers":[]}`)
manifestDigest := digest.FromBytes(manifest).String()
sink := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
record(&sinkHits, r)
if r.Header.Get("Authorization") != expectedAuth {
w.Header().Set("Www-Authenticate", `Basic realm="redirect-sink"`)
w.WriteHeader(http.StatusUnauthorized)
return
}
w.Header().Set("Content-Type", "application/vnd.oci.image.manifest.v1+json")
w.Header().Set("Docker-Content-Digest", manifestDigest)
w.Header().Set("Content-Length", fmt.Sprint(len(manifest)))
_, _ = w.Write(manifest)
}))
defer sink.Close()
origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
record(&originHits, r)
if r.Header.Get("Authorization") != expectedAuth {
w.Header().Set("Www-Authenticate", `Basic realm="origin"`)
w.WriteHeader(http.StatusUnauthorized)
return
}
http.Redirect(w, r, sink.URL+r.URL.RequestURI(), http.StatusTemporaryRedirect)
}))
defer origin.Close()
repo, err := remote.NewRepository(origin.Listener.Addr().String() + "/probe")
if err != nil {
panic(err)
}
repo.PlainHTTP = true
repo.Client = &auth.Client{
Client: origin.Client(),
CredentialFunc: credentials.StaticCredentialFunc(origin.Listener.Addr().String(), credentials.Credential{
Username: username,
Password: password,
}),
}
_, _, err = repo.Manifests().FetchReference(context.Background(), "latest")
leaked := false
for _, h := range sinkHits {
if h.Auth == expectedAuth {
leaked = true
}
}
result := map[string]any{
"origin_hits": originHits,
"sink_hits": sinkHits,
"error": "",
"leaked": leaked,
}
if err != nil {
result["error"] = err.Error()
}
encoded, _ := json.MarshalIndent(result, "", " ")
fmt.Println(string(encoded))
if leaked {
fmt.Println("VULNERABLE_BEHAVIOR_CONFIRMED")
return
}
fmt.Println("BOUNDARY_HELD_NO_CREDENTIAL_LEAK")
os.Exit(1)
}
```
## Candidate Fix
The candidate fix does two things:
1. In the auth client, wrap redirect handling so `Authorization` is
removed when a redirect changes HTTP origin, while preserving any
caller-provided `CheckRedirect` callback.
2. In blob upload completion, only reuse the previous `POST`
`Authorization` header when the upload `Location` remains on the same
HTTP origin.
The patch also adds regression coverage for both redirect cases:
- redirect before origin authentication reaches a different origin;
- redirect after origin authentication reaches a different origin.
```diff
diff --git a/registry/remote/auth/client.go b/registry/remote/auth/client.go
index 35826eb..60c9f88 100644
--- a/registry/remote/auth/client.go
+++ b/registry/remote/auth/client.go
@​@​ -122,7 +122,23 @​@​ func (c *Client) send(req *http.Request) (*http.Response, error) {
for key, values := range c.Header {
req.Header[key] = append(req.Header[key], values...)
}
- return c.client().Do(req)
+ client := c.client()
+ clientCopy := *client
+ checkRedirect := client.CheckRedirect
+ clientCopy.CheckRedirect = func(redirectReq *http.Request, via []*http.Request) error {
+ if len(via) > 0 && !sameHTTPOrigin(via[len(via)-1].URL, redirectReq.URL) {
+ redirectReq.Header.Del(headerAuthorization)
+ }
+ if checkRedirect != nil {
+ return checkRedirect(redirectReq, via)
+ }
+ return nil
+ }
+ return clientCopy.Do(req)
+}
+
+func sameHTTPOrigin(a, b *url.URL) bool {
+ return strings.EqualFold(a.Scheme, b.Scheme) && strings.EqualFold(a.Host, b.Host)
}
// credential resolves the credential for the given registry.
@​@​ -168,6 +184,9 @​@​ func (c *Client) Do(originalReq *http.Request) (*http.Response, error) {
var attemptedKey string
cache := c.cache()
host := originalReq.Host
+ if host == "" {
+ host = originalReq.URL.Host
+ }
scheme, err := cache.GetScheme(ctx, host)
if err == nil {
switch scheme {
@​@​ -193,6 +212,13 @​@​ func (c *Client) Do(originalReq *http.Request) (*http.Response, error) {
if resp.StatusCode != http.StatusUnauthorized {
return resp, nil
}
+ respHost := resp.Request.Host
+ if respHost == "" {
+ respHost = resp.Request.URL.Host
+ }
+ if respHost != host {
+ return resp, nil
+ }
// attempt again with credentials for recognized schemes
challenge := resp.Header.Get(headerWWWAuthenticate)
diff --git a/registry/remote/repository.go b/registry/remote/repository.go
index 74d6b89..0bd20ec 100644
--- a/registry/remote/repository.go
+++ b/registry/remote/repository.go
@​@​ -982,6 +983,7 @​@​ func (s *blobStore) Push(ctx context.Context, expected ocispec.Descriptor, conte
// Push or by Mount when the receiving repository does not implement the
// mount endpoint.
func (s *blobStore) completePushAfterInitialPost(ctx context.Context, req *http.Request, resp *http.Response, expected ocispec.Descriptor, content io.Reader) error {
+ originalURL := req.URL
reqHostname := req.URL.Hostname()
reqPort := req.URL.Port()
// monolithic upload
@​@​ -1016,8 +1018,9 @​@​ func (s *blobStore) completePushAfterInitialPost(ctx context.Context, req *http.
q.Set("digest", expected.Digest.String())
req.URL.RawQuery = q.Encode()
- // reuse credential from previous POST request
- if auth := resp.Request.Header.Get("Authorization"); auth != "" {
+ // reuse credential from previous POST request only when the upload location
+ // remains on the same origin.
+ if auth := resp.Request.Header.Get("Authorization"); auth != "" && sameHTTPOrigin(originalURL, location) {
req.Header.Set("Authorization", auth)
}
resp, err = s.repo.do(req)
@​@​ -1032,6 +1035,10 @​@​ func (s *blobStore) completePushAfterInitialPost(ctx context.Context, req *http.
return nil
}
+func sameHTTPOrigin(a, b *url.URL) bool {
+ return strings.EqualFold(a.Scheme, b.Scheme) && strings.EqualFold(a.Host, b.Host)
+}
+
// Exists returns true if the described content exists.
func (s *blobStore) Exists(ctx context.Context, target ocispec.Descriptor) (bool, error) {
if err := s.repo.checkPolicy(ctx, ""); err != nil {
```
## Validation Performed
The repaired candidate fix blocked:
- manifest redirect credential forwarding;
- upload `Location` credential forwarding.
Targeted tests passed:
```sh
go test ./registry/remote/auth -run 'TestClient_Do_Basic_Auth_Redirect|TestClient_Do' -count=1
go test ./registry/remote -run 'Test_BlobStore_Push|TestRepository' -count=1
```
## Prior Art / Duplicate Notes
Public pull request #​1152 fixes credential forwarding via
unvalidated blob upload `Location` and references GHSA-jxpm-75mh-9fp7.
The residual manifest redirect path described here is adjacent but not
covered by that PR's stated upload `Location` scope.
Bearer realm credential exfiltration appears to be a separate issue
family and is not part of this report's primary claim.
## Claim Boundaries
Proven:
- Origin registry Basic credentials can reach a different redirect or
upload `Location` origin in local loopback tests.
- ORAS CLI stored registry credentials can reach a redirect sink in a
normal manifest fetch workflow.
- The candidate fix blocks the tested redirect and upload `Location`
credential exposures.
Not claimed:
- Live third-party exploitation.
- RCE, host compromise, or registry compromise.
- Arbitrary-host exposure beyond the tested redirect/`Location` origin
transitions.
- Bearer realm behavior as part of the same claim.
---
### Configuration
📅 **Schedule**: Branch creation - "" (UTC), Automerge - Monday through
Friday ( * * * * 1-5 ) (UTC).
🚦 **Automerge**: Enabled.
♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the
rebase/retry checkbox.
🔕 **Ignore**: Close this PR and you won't be reminded about this update
again.
---
- [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check
this box
---
This PR has been generated by [Renovate
Bot](https://redirect.github.com/renovatebot/renovate).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzOS4yNjQuMCIsInVwZGF0ZWRJblZlciI6IjM5LjI2NC4wIiwidGFyZ2V0QnJhbmNoIjoibWFzdGVyIiwibGFiZWxzIjpbImRlcGVuZGVuY2llcyIsImltcGFjdC9uby1jaGFuZ2Vsb2ctcmVxdWlyZWQiXX0=-->
Co-authored-by: pulumi-renovate[bot] <189166143+pulumi-renovate[bot]@users.noreply.github.com>1 parent 4161eb9 commit def280d
4 files changed
Lines changed: 6 additions & 6 deletions
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
252 | 252 | | |
253 | 253 | | |
254 | 254 | | |
255 | | - | |
| 255 | + | |
256 | 256 | | |
257 | 257 | | |
258 | 258 | | |
| |||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
852 | 852 | | |
853 | 853 | | |
854 | 854 | | |
855 | | - | |
856 | | - | |
| 855 | + | |
| 856 | + | |
857 | 857 | | |
858 | 858 | | |
859 | 859 | | |
| |||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
23 | 23 | | |
24 | 24 | | |
25 | 25 | | |
26 | | - | |
| 26 | + | |
27 | 27 | | |
28 | 28 | | |
29 | 29 | | |
| |||
| Original file line number | Diff line number | Diff line change | |
|---|---|---|---|
| |||
897 | 897 | | |
898 | 898 | | |
899 | 899 | | |
900 | | - | |
901 | | - | |
| 900 | + | |
| 901 | + | |
902 | 902 | | |
903 | 903 | | |
904 | 904 | | |
| |||
0 commit comments