Skip to content

Modern Docker Management, Designed for Everyone

fix: surface JWKS initialization errors instead of readiness timeouts

Kyle Mendelleeb79a68e867
diff --git a/backend/pkg/utils/oidcjwk/errors.go b/backend/pkg/utils/oidcjwk/errors.go
new file mode 100644
index 000000000..b02f3aef7
--- /dev/null
+++ b/backend/pkg/utils/oidcjwk/errors.go
@@ -0,0 +1,18 @@
+package oidcjwk
+
+import "regexp"
+
+var errorURLPattern = regexp.MustCompile(`https?://[^\s"<>]+`)
+
+// Cache errors include endpoint and redirect URLs, which may contain credentials.
+type initializationError struct {
+ cause error
+}
+
+func (e *initializationError) Error() string {
+ return "failed to initialize JWKS: " + errorURLPattern.ReplaceAllString(e.cause.Error(), "[redacted URL]")
+}
+
+func (e *initializationError) Unwrap() error {
+ return e.cause
+}
diff --git a/backend/pkg/utils/oidcjwk/manager.go b/backend/pkg/utils/oidcjwk/manager.go
index 9ebb6a11b..ee96f7413 100644
--- a/backend/pkg/utils/oidcjwk/manager.go
+++ b/backend/pkg/utils/oidcjwk/manager.go
@@ -102,29 +102,9 @@ func (m *KeySetManager) KeySet(ctx context.Context, client *http.Client, jwksURL
}
m.mu.Unlock()
- registerCtx, cancel := context.WithTimeout(ctx, initialReadyTimeout)
- defer cancel()
- if registerErr := managed.cache.Register(registerCtx, jwksURL,
- jwkfetch.WithWaitReady(true),
- jwkfetch.WithMinInterval(minimumRefreshInterval),
- jwkfetch.WithMaxInterval(maximumRefreshInterval),
- ); registerErr != nil {
- cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
- defer cancel()
- if managed.cache.IsRegistered(cleanupCtx, jwksURL) {
- _ = managed.cache.Unregister(cleanupCtx, jwksURL)
- }
- return nil, errors.WrapIf(registerErr, "failed to register JWKS URL")
- }
-
- set, setErr := managed.cache.CachedSet(jwksURL)
- if setErr != nil {
- return nil, errors.WrapIf(setErr, "failed to create cached JWK set")
- }
- keySet := &keySet{
- cache: managed.cache,
- jwksURL: jwksURL,
- set: set,
+ keySet, initErr := managed.initializeKeySetInternal(ctx, jwksURL)
+ if initErr != nil {
+ return nil, initErr
}
m.mu.Lock()
@@ -145,6 +125,45 @@ func (m *KeySetManager) KeySet(ctx context.Context, client *http.Client, jwksURL
return keySet, nil
}
+func (m *managedCache) initializeKeySetInternal(ctx context.Context, jwksURL string) (*keySet, error) {
+ registerCtx, cancel := context.WithTimeout(ctx, initialReadyTimeout)
+ defer cancel()
+ initialized := false
+ defer func() {
+ if initialized {
+ return
+ }
+ cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second)
+ defer cancel()
+ if m.cache.IsRegistered(cleanupCtx, jwksURL) {
+ _ = m.cache.Unregister(cleanupCtx, jwksURL)
+ }
+ }()
+ if registerErr := m.cache.Register(registerCtx, jwksURL,
+ jwkfetch.WithWaitReady(false),
+ jwkfetch.WithMinInterval(minimumRefreshInterval),
+ jwkfetch.WithMaxInterval(maximumRefreshInterval),
+ ); registerErr != nil {
+ return nil, errors.WrapIf(registerErr, "failed to register JWKS URL")
+ }
+ // Refresh returns fetch and parse errors that the background readiness wait hides.
+ if _, refreshErr := m.cache.Refresh(registerCtx, jwksURL); refreshErr != nil {
+ return nil, &initializationError{cause: refreshErr}
+ }
+
+ set, setErr := m.cache.CachedSet(jwksURL)
+ if setErr != nil {
+ return nil, errors.WrapIf(setErr, "failed to create cached JWK set")
+ }
+ keySet := &keySet{
+ cache: m.cache,
+ jwksURL: jwksURL,
+ set: set,
+ }
+ initialized = true
+ return keySet, nil
+}
+
func (m *KeySetManager) createManagedCacheLockedInternal(client *http.Client) (*managedCache, error) {
if m.caches.Len() >= maxHTTPClientPolicies {
return nil, errors.New("oidcjwk: too many HTTP client policies")
diff --git a/backend/pkg/utils/oidcjwk/oidcjwk_test.go b/backend/pkg/utils/oidcjwk/oidcjwk_test.go
index d46920df3..117dc3554 100644
--- a/backend/pkg/utils/oidcjwk/oidcjwk_test.go
+++ b/backend/pkg/utils/oidcjwk/oidcjwk_test.go
@@ -8,11 +8,13 @@ import (
"fmt"
"net/http"
"net/http/httptest"
+ "sync/atomic"
"testing"
"time"
"github.com/coreos/go-oidc/v3/oidc"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/oidcjwk"
+ "github.com/lestrrat-go/httprc/v3"
"github.com/stretchr/testify/require"
)
@@ -30,26 +32,42 @@ func signCompactInternal(t *testing.T, sk *mldsa.PrivateKey, alg, kid string, cl
func TestKeySetVerifySignature(t *testing.T) {
tests := []struct {
- params mldsa.Parameters
- tamper bool
+ params mldsa.Parameters
+ tamper bool
+ initialFailure string
}{
{params: mldsa.MLDSA44()},
{params: mldsa.MLDSA65()},
{params: mldsa.MLDSA87()},
{params: mldsa.MLDSA87(), tamper: true},
+ {params: mldsa.MLDSA44(), initialFailure: "http"},
+ {params: mldsa.MLDSA44(), initialFailure: "json"},
}
for _, tc := range tests {
name := tc.params.String()
if tc.tamper {
name += "-tampered"
}
+ if tc.initialFailure != "" {
+ name += "-" + tc.initialFailure
+ }
t.Run(name, func(t *testing.T) {
sk, err := mldsa.GenerateKey(tc.params)
require.NoError(t, err)
jwks := fmt.Sprintf(`{"keys":[{"kty":"AKP","alg":%q,"kid":"pq","use":"sig","pub":%q}]}`,
tc.params.String(), base64.RawURLEncoding.EncodeToString(sk.PublicKey().Bytes()))
+ var failing atomic.Bool
+ failing.Store(tc.initialFailure != "")
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if failing.Load() {
+ if tc.initialFailure == "http" {
+ w.WriteHeader(http.StatusServiceUnavailable)
+ } else {
+ fmt.Fprint(w, `{"keys":`)
+ }
+ return
+ }
w.Header().Set("Content-Type", "application/json")
fmt.Fprint(w, jwks)
}))
@@ -68,13 +86,34 @@ func TestKeySetVerifySignature(t *testing.T) {
ctx := t.Context()
manager := oidcjwk.NewKeySetManager(ctx)
+ jwksURL := srv.URL + "/jwks?credential=test-secret"
t.Cleanup(func() {
shutdownCtx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
require.NoError(t, manager.Shutdown(shutdownCtx))
})
- keySet, err := manager.KeySet(ctx, srv.Client(), srv.URL)
+ if tc.initialFailure != "" {
+ initCtx, cancel := context.WithTimeout(ctx, 2*time.Second)
+ failedSet, initErr := manager.KeySet(initCtx, srv.Client(), jwksURL)
+ cancel()
+ require.Nil(t, failedSet)
+ require.Error(t, initErr)
+ require.NotErrorIs(t, initErr, context.DeadlineExceeded)
+ require.NotContains(t, initErr.Error(), "test-secret")
+ require.NotContains(t, fmt.Sprintf("%+v", initErr), "test-secret")
+ if tc.initialFailure == "http" {
+ require.ErrorIs(t, initErr, httprc.ErrUnexpectedStatusCode())
+ require.ErrorContains(t, initErr, "503")
+ } else {
+ require.ErrorIs(t, initErr, httprc.ErrTransformerFailed())
+ }
+ failing.Store(false)
+ }
+ keySet, err := manager.KeySet(ctx, srv.Client(), jwksURL)
+ require.NoError(t, err)
+ cachedSet, err := manager.KeySet(ctx, srv.Client(), jwksURL)
require.NoError(t, err)
+ require.Same(t, keySet, cachedSet)
verifier := oidc.NewVerifier(srv.URL, keySet, &oidc.Config{
ClientID: "arcane",
SupportedSigningAlgs: oidcjwk.SupportedSigningAlgs(),