Skip to content

Modern Docker Management, Designed for Everyone

fix: use distribution reference for image digests (#484)

Kyle Mendellb93297643ca5
diff --git a/backend/go.mod b/backend/go.mod
index ba55f5530..5b0900625 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -5,6 +5,7 @@ go 1.25.0
require (
github.com/cenkalti/backoff/v5 v5.0.3
github.com/compose-spec/compose-go/v2 v2.8.2
+ github.com/distribution/reference v0.6.0
github.com/docker/docker v28.4.0+incompatible
github.com/docker/go-connections v0.6.0
github.com/fsnotify/fsnotify v1.9.0
@@ -36,7 +37,6 @@ require (
github.com/containerd/errdefs v1.0.0 // indirect
github.com/containerd/errdefs/pkg v0.3.0 // indirect
github.com/containerd/log v0.1.0 // indirect
- github.com/distribution/reference v0.6.0 // indirect
github.com/docker/go-units v0.5.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/felixge/httpsnoop v1.0.4 // indirect
diff --git a/backend/internal/services/image_update_service.go b/backend/internal/services/image_update_service.go
index 1f2c2933e..31fdda558 100644
--- a/backend/internal/services/image_update_service.go
+++ b/backend/internal/services/image_update_service.go
@@ -256,18 +256,11 @@ func (s *ImageUpdateService) checkDigestUpdate(ctx context.Context, parts *Image
start := time.Now()
remoteDigest, _, err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)
if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
- challenge := err.Error()
+ // Attempt to resolve auth header via registry helpers and retry once
enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)
- if newTok, method, user, aErr := registry.AcquireTokenViaChallenge(ctx, parts.Registry, normalizedRepo, challenge, enabledRegs); aErr == nil && newTok != "" {
- token = newTok
- auth.Method = method
- auth.Username = user
- if rd2, _, rd2Err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token); rd2Err == nil {
- remoteDigest = rd2
- err = nil
- } else {
- err = rd2Err
- }
+ authHeader, _, _, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, parts.Tag, enabledRegs)
+ if resolveErr == nil && authHeader != "" {
+ remoteDigest, _, err = rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, authHeader)
}
}
elapsed := time.Since(start)
@@ -428,20 +421,13 @@ func (s *ImageUpdateService) getImageTags(ctx context.Context, parts *ImageParts
tags, err := rc.GetImageTags(ctx, parts.Registry, normalizedRepo, token)
if err != nil && strings.Contains(strings.ToLower(err.Error()), "unauthorized") {
- challenge := err.Error()
- if idx := strings.Index(strings.ToLower(challenge), "bearer "); idx >= 0 {
- challenge = challenge[idx:]
- }
enabledRegs, _ := s.registryService.GetEnabledRegistries(ctx)
- if newTok, method, user, aErr := registry.AcquireTokenViaChallenge(ctx, parts.Registry, normalizedRepo, challenge, enabledRegs); aErr == nil && newTok != "" {
- token = newTok
- auth.Method = method
- auth.Username = user
- if retryTags, rErr := rc.GetImageTags(ctx, parts.Registry, normalizedRepo, token); rErr == nil {
- tags = retryTags
- err = nil
- } else {
- err = rErr
+ authHeader, method, username, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, "", enabledRegs)
+ if resolveErr == nil && authHeader != "" {
+ tags, err = rc.GetImageTags(ctx, parts.Registry, normalizedRepo, authHeader)
+ if err == nil {
+ // update auth info to reflect how we retried
+ auth = &authDetails{Method: method, Username: username, Registry: parts.Registry}
}
}
}
@@ -986,20 +972,11 @@ func (s *ImageUpdateService) checkSingleImageInBatch(
remoteDigest, _, digestErr := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token)
if digestErr != nil && strings.Contains(strings.ToLower(digestErr.Error()), "unauthorized") {
- challenge := digestErr.Error()
- if idx := strings.Index(strings.ToLower(challenge), "bearer "); idx >= 0 {
- challenge = challenge[idx:]
- }
- if newTok, method, user, aErr := registry.AcquireTokenViaChallenge(ctx, parts.Registry, normalizedRepo, challenge, enabledRegs); aErr == nil && newTok != "" {
- token = newTok
- auth.Method = method
- auth.Username = user
- // retry once
- if rd2, _, rd2Err := rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, token); rd2Err == nil {
- remoteDigest = rd2
- digestErr = nil
- } else {
- digestErr = rd2Err
+ authHeader, method, username, resolveErr := registry.ResolveAuthHeaderForRepository(ctx, parts.Registry, normalizedRepo, parts.Tag, enabledRegs)
+ if resolveErr == nil && authHeader != "" {
+ remoteDigest, _, digestErr = rc.GetLatestDigestTimed(ctx, parts.Registry, normalizedRepo, parts.Tag, authHeader)
+ if digestErr == nil {
+ auth = &authDetails{Method: method, Username: username, Registry: parts.Registry}
}
}
}
diff --git a/backend/internal/utils/registry/auth.go b/backend/internal/utils/registry/auth.go
index 7765607c1..329565c2b 100644
--- a/backend/internal/utils/registry/auth.go
+++ b/backend/internal/utils/registry/auth.go
@@ -2,6 +2,7 @@ package registry
import (
"context"
+ "encoding/base64"
"encoding/json"
"fmt"
"net/http"
@@ -233,3 +234,138 @@ func normalizeRepositoryForDockerIO(registryHost, repo string) string {
}
return repo
}
+
+func GetChallengeRequest(ctx context.Context, u url.URL) (*http.Request, error) {
+ req, err := http.NewRequestWithContext(ctx, http.MethodGet, u.String(), nil)
+ if err != nil {
+ return nil, err
+ }
+ req.Header.Set("Accept", "*/*")
+ req.Header.Set("User-Agent", "Arcane")
+ return req, nil
+}
+
+// GetChallengeURL returns https://<host>/v2/ for a given image ref (normalized).
+// host is normalized so docker.io => index.docker.io.
+func GetChallengeURL(imageRef string) (url.URL, error) {
+ named, err := parseNormalizedNamed(imageRef)
+ if err != nil {
+ return url.URL{}, err
+ }
+ host, err := GetRegistryAddress(named.Name())
+ if err != nil {
+ return url.URL{}, err
+ }
+ return url.URL{Scheme: "https", Host: host, Path: "/v2/"}, nil
+}
+
+// GetAuthHeaderForImage performs the /v2/ challenge for an image and returns a usable Authorization header.
+// It supports Basic and Bearer challenges. For Bearer, it reuses AcquireTokenViaChallenge which
+// looks up credentials from the database (enabledRegs) when needed.
+func GetAuthHeaderForImage(ctx context.Context, imageRef string, enabledRegs []models.ContainerRegistry) (string, error) {
+ chURL, err := GetChallengeURL(imageRef)
+ if err != nil {
+ return "", err
+ }
+
+ if _, ok := ctx.Deadline(); !ok {
+ var cancel context.CancelFunc
+ ctx, cancel = context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+ }
+
+ req, err := GetChallengeRequest(ctx, chURL)
+ if err != nil {
+ return "", err
+ }
+
+ c := NewClient()
+ resp, err := c.http.Do(req)
+ if err != nil {
+ return "", err
+ }
+ defer resp.Body.Close()
+
+ ch := resp.Header.Get(ChallengeHeader)
+ if ch == "" {
+ // try alternate case just in case
+ ch = resp.Header.Get("Www-Authenticate")
+ }
+
+ // If /v2/ returns 200 or there's no WWW-Authenticate header, the registry is open —
+ // no auth header required. Return empty header instead of an error.
+ if resp.StatusCode == http.StatusOK || strings.TrimSpace(ch) == "" {
+ return "", nil
+ }
+
+ chLower := strings.ToLower(strings.TrimSpace(ch))
+
+ named, err := parseNormalizedNamed(imageRef)
+ if err != nil {
+ return "", err
+ }
+ host, err := GetRegistryAddress(named.Name())
+ if err != nil {
+ return "", err
+ }
+ repo := referencePath(named)
+
+ switch {
+ case strings.HasPrefix(chLower, "basic"):
+ h := normalizeHost(host)
+ for _, cr := range enabledRegs {
+ if !cr.Enabled || cr.Username == "" || cr.Token == "" {
+ continue
+ }
+ if normalizeHost(cr.URL) != h {
+ continue
+ }
+ dec, err := utils.Decrypt(cr.Token)
+ if err != nil {
+ continue
+ }
+ ba := []byte(cr.Username + ":" + dec)
+ return "Basic " + base64.StdEncoding.EncodeToString(ba), nil
+ }
+ return "", fmt.Errorf("no credentials available for basic auth at %s", host)
+
+ case strings.HasPrefix(chLower, "bearer"):
+ token, _, _, err := AcquireTokenViaChallenge(ctx, host, repo, ch, enabledRegs)
+ if err != nil {
+ return "", err
+ }
+ if token == "" {
+ return "", fmt.Errorf("empty bearer token")
+ }
+ return "Bearer " + token, nil
+
+ default:
+ return "", fmt.Errorf("unsupported challenge type from registry: %q", ch)
+ }
+}
+
+func ResolveAuthHeaderForRepository(ctx context.Context, host, repository, tag string, enabledRegs []models.ContainerRegistry) (string, string, string, error) {
+ var imageRef string
+ if tag != "" {
+ imageRef = fmt.Sprintf("%s/%s:%s", host, repository, tag)
+ } else {
+ imageRef = fmt.Sprintf("%s/%s", host, repository)
+ }
+
+ hdr, err := GetAuthHeaderForImage(ctx, imageRef, enabledRegs)
+ if err != nil {
+ return "", "", "", err
+ }
+ if hdr == "" {
+ return "", "none", "", nil
+ }
+ lh := strings.ToLower(strings.TrimSpace(hdr))
+ switch {
+ case strings.HasPrefix(lh, "basic "):
+ return hdr, "basic", "", nil
+ case strings.HasPrefix(lh, "bearer "):
+ return hdr, "bearer", "", nil
+ default:
+ return hdr, "unknown", "", nil
+ }
+}
diff --git a/backend/internal/utils/registry/constants.go b/backend/internal/utils/registry/constants.go
index 655d01ca3..5b13f4472 100644
--- a/backend/internal/utils/registry/constants.go
+++ b/backend/internal/utils/registry/constants.go
@@ -1,3 +1,7 @@
package registry
const DefaultRegistry = "registry-1.docker.io"
+const DefaultRegistryDomain = "docker.io"
+const DefaultRegistryHost = "index.docker.io"
+const ContentDigestHeader = "Docker-Content-Digest"
+const ChallengeHeader = "WWW-Authenticate"
diff --git a/backend/internal/utils/registry/digest.go b/backend/internal/utils/registry/digest.go
index c63dbcd9b..2a1880a65 100644
--- a/backend/internal/utils/registry/digest.go
+++ b/backend/internal/utils/registry/digest.go
@@ -8,6 +8,30 @@ import (
"time"
)
+// buildAuthHeader constructs a proper Authorization header value from a token.
+// If token already has a scheme (Bearer/Basic), it's used as-is. Otherwise, Bearer is assumed.
+func buildAuthHeader(token string) string {
+ t := strings.TrimSpace(token)
+ if t == "" {
+ return ""
+ }
+ lower := strings.ToLower(t)
+ if strings.HasPrefix(lower, "bearer ") || strings.HasPrefix(lower, "basic ") {
+ return t
+ }
+ return "Bearer " + t
+}
+
+// getHeaderCI returns the first header value for the given key, case-insensitively.
+func getHeaderCI(h http.Header, key string) string {
+ for k, v := range h {
+ if strings.EqualFold(k, key) && len(v) > 0 {
+ return v[0]
+ }
+ }
+ return ""
+}
+
func (c *Client) GetLatestDigest(ctx context.Context, registry, repository, tag, token string) (string, error) {
url := fmt.Sprintf("%s/v2/%s/manifests/%s", c.GetRegistryURL(registry), repository, tag)
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
@@ -17,13 +41,16 @@ func (c *Client) GetLatestDigest(ctx context.Context, registry, repository, tag,
if err != nil {
return "", err
}
- req.Header.Set("Accept",
- "application/vnd.docker.distribution.manifest.list.v2+json, "+
- "application/vnd.docker.distribution.manifest.v2+json, "+
- "application/vnd.oci.image.index.v1+json, "+
- "application/vnd.oci.image.manifest.v1+json")
- if token != "" {
- req.Header.Set("Authorization", "Bearer "+token)
+
+ req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v2+json")
+ req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.list.v2+json")
+ req.Header.Add("Accept", "application/vnd.docker.distribution.manifest.v1+json")
+ req.Header.Add("Accept", "application/vnd.oci.image.index.v1+json")
+ req.Header.Add("Accept", "application/vnd.oci.image.manifest.v1+json")
+ req.Header.Set("User-Agent", "Arcane")
+
+ if ah := buildAuthHeader(token); ah != "" {
+ req.Header.Set("Authorization", ah)
}
resp, err := c.http.Do(req)
@@ -33,27 +60,28 @@ func (c *Client) GetLatestDigest(ctx context.Context, registry, repository, tag,
defer resp.Body.Close()
if resp.StatusCode == http.StatusUnauthorized {
- h := resp.Header.Get("WWW-Authenticate")
- if h == "" {
- h = resp.Header.Get("Www-Authenticate")
- }
+ h := getHeaderCI(resp.Header, "WWW-Authenticate")
if h != "" {
return "", fmt.Errorf("unauthorized: %s", h)
}
return "", fmt.Errorf("manifest request failed with status: 401")
}
if resp.StatusCode != http.StatusOK {
- return "", fmt.Errorf("manifest request failed with status: %d", resp.StatusCode)
+ www := getHeaderCI(resp.Header, "WWW-Authenticate")
+ if www == "" {
+ www = "not present"
+ }
+ return "", fmt.Errorf("manifest request failed with status: %d, auth: %q", resp.StatusCode, www)
}
- d := resp.Header.Get("Docker-Content-Digest")
- if d == "" {
- d = resp.Header.Get("docker-content-digest")
- }
+ d := getHeaderCI(resp.Header, ContentDigestHeader)
if d == "" {
- etag := resp.Header.Get("Etag")
- if etag != "" && strings.HasPrefix(etag, "sha256:") {
- d = strings.Trim(etag, `"`)
+ etag := getHeaderCI(resp.Header, "ETag")
+ if etag != "" {
+ etag = strings.Trim(etag, `"`)
+ if strings.HasPrefix(etag, "sha256:") {
+ d = etag
+ }
}
}
if d == "" {
diff --git a/backend/internal/utils/registry/helpers.go b/backend/internal/utils/registry/helpers.go
new file mode 100644
index 000000000..661b16998
--- /dev/null
+++ b/backend/internal/utils/registry/helpers.go
@@ -0,0 +1,13 @@
+package registry
+
+func GetRegistryAddress(imageRef string) (string, error) {
+ named, err := parseNormalizedNamed(imageRef)
+ if err != nil {
+ return "", err
+ }
+ addr := referenceDomain(named)
+ if addr == DefaultRegistryDomain {
+ return DefaultRegistryHost, nil
+ }
+ return addr, nil
+}
diff --git a/backend/internal/utils/registry/manifest.go b/backend/internal/utils/registry/manifest.go
new file mode 100644
index 000000000..6a7e57f04
--- /dev/null
+++ b/backend/internal/utils/registry/manifest.go
@@ -0,0 +1,27 @@
+package registry
+
+import "fmt"
+
+func BuildManifestURLFromRef(imageRef string) (string, error) {
+ named, err := parseNormalizedNamed(imageRef)
+ if err != nil {
+ return "", err
+ }
+ named = tagNameOnly(named)
+
+ host, err := GetRegistryAddress(named.String())
+ if err != nil {
+ return "", err
+ }
+
+ imgPath := referencePath(named)
+
+ identifier := "latest"
+ if dgst, ok := getDigest(named); ok {
+ identifier = dgst
+ } else if t, ok := getTag(named); ok {
+ identifier = t
+ }
+
+ return fmt.Sprintf("https://%s/v2/%s/manifests/%s", host, imgPath, identifier), nil
+}
diff --git a/backend/internal/utils/registry/reference.go b/backend/internal/utils/registry/reference.go
deleted file mode 100644
index 0b8ad900f..000000000
--- a/backend/internal/utils/registry/reference.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package registry
-
-import (
- "fmt"
- "strings"
-)
-
-func (c *Client) SplitImageReference(reference string) (string, string, string, error) {
- if reference == "" {
- return "", "", "", fmt.Errorf("empty reference provided")
- }
-
- splits := strings.Split(reference, "/")
- var registry, repositoryAndTag string
-
- switch len(splits) {
- case 1:
- registry = DefaultRegistry
- repositoryAndTag = reference
- default:
- switch {
- case splits[0] == "docker.io":
- registry = DefaultRegistry
- repositoryAndTag = strings.Join(splits[1:], "/")
- case splits[0] == "localhost" || strings.Contains(splits[0], ".") || strings.Contains(splits[0], ":"):
- registry = splits[0]
- repositoryAndTag = strings.Join(splits[1:], "/")
- default:
- registry = DefaultRegistry
- repositoryAndTag = reference
- }
- }
-
- repositoryAndTag = strings.Split(repositoryAndTag, "@")[0]
- tagSplits := strings.Split(repositoryAndTag, ":")
- var repository, tag string
- switch len(tagSplits) {
- case 1:
- repository = tagSplits[0]
- tag = "latest"
- case 2:
- repository = tagSplits[0]
- tag = tagSplits[1]
- default:
- return "", "", "", fmt.Errorf("invalid reference format: %s", repositoryAndTag)
- }
-
- if !strings.Contains(repository, "/") && registry == DefaultRegistry {
- repository = "library/" + repository
- }
- return registry, repository, tag, nil
-}
-
-// ExtractRegistryDomain normalizes docker hub to docker.io
-func ExtractRegistryDomain(imageRef string) (string, error) {
- c := NewClient()
- reg, _, _, err := c.SplitImageReference(imageRef)
- if err != nil {
- return "", err
- }
- if reg == DefaultRegistry {
- return "docker.io", nil
- }
- return reg, nil
-}
diff --git a/backend/internal/utils/registry/reference_shim.go b/backend/internal/utils/registry/reference_shim.go
new file mode 100644
index 000000000..5b0a08003
--- /dev/null
+++ b/backend/internal/utils/registry/reference_shim.go
@@ -0,0 +1,35 @@
+package registry
+
+import (
+ ref "github.com/distribution/reference"
+)
+
+func parseNormalizedNamed(s string) (ref.Named, error) {
+ return ref.ParseNormalizedNamed(s)
+}
+
+func referencePath(n ref.Named) string {
+ return ref.Path(n)
+}
+
+func tagNameOnly(n ref.Named) ref.Named {
+ return ref.TagNameOnly(n)
+}
+
+func referenceDomain(n ref.Named) string {
+ return ref.Domain(n)
+}
+
+func getTag(n ref.Named) (string, bool) {
+ if nt, ok := n.(ref.NamedTagged); ok {
+ return nt.Tag(), true
+ }
+ return "", false
+}
+
+func getDigest(n ref.Named) (string, bool) {
+ if d, ok := n.(ref.Digested); ok {
+ return d.Digest().String(), true
+ }
+ return "", false
+}
diff --git a/backend/internal/utils/registry/registry_test.go b/backend/internal/utils/registry/registry_test.go
index cb29af6bb..24fd36e8a 100644
--- a/backend/internal/utils/registry/registry_test.go
+++ b/backend/internal/utils/registry/registry_test.go
@@ -12,28 +12,6 @@ import (
"time"
)
-func TestSplitImageReference(t *testing.T) {
- t.Parallel()
- c := NewClient()
- tests := []struct {
- ref, reg, repo, tag string
- }{
- {"nginx", DefaultRegistry, "library/nginx", "latest"},
- {"nginx:alpine", DefaultRegistry, "library/nginx", "alpine"},
- {"docker.io/library/redis:7", DefaultRegistry, "library/redis", "7"},
- {"ghcr.io/acme/api:1.2.3", "ghcr.io", "acme/api", "1.2.3"},
- }
- for _, tc := range tests {
- r, repo, tag, err := c.SplitImageReference(tc.ref)
- if err != nil {
- t.Fatalf("err: %v", err)
- }
- if r != tc.reg || repo != tc.repo || tag != tc.tag {
- t.Fatalf("got (%s,%s,%s) want (%s,%s,%s)", r, repo, tag, tc.reg, tc.repo, tc.tag)
- }
- }
-}
-
func TestCheckAuthParsesRealmAndService(t *testing.T) {
t.Parallel()
realm := "https://auth.example/token"