Skip to content

Modern Docker Management, Designed for Everyone

fix: issue a compact browser session cookie instead of the bigger ML-DSA access JWT

Kyle Mendelldf7c24c85e9d
diff --git a/backend/api/buildables.go b/backend/api/buildables.go
index 6324e1f90..adb7ef827 100644
--- a/backend/api/buildables.go
+++ b/backend/api/buildables.go
@@ -89,7 +89,7 @@ func registerAutoLoginRoutes(apiGroup *echo.Group, authService *auth.AuthService
maxAge += 60
expiresAt := tokenPair.ExpiresAt
- for _, tokenCookie := range cookie.BuildTokenCookieStringFor(maxAge, tokenPair.AccessToken, cookie.SecureCookieFromRequest(c.Request())) {
+ for _, tokenCookie := range cookie.BuildTokenCookieStringFor(maxAge, tokenPair.BrowserToken, cookie.SecureCookieFromRequest(c.Request())) {
c.Response().Header().Add("Set-Cookie", tokenCookie)
}
return c.JSON(http.StatusOK, base.ApiResponse[authtypes.AuthenticationResponse]{
diff --git a/backend/internal/auth/handler.go b/backend/internal/auth/handler.go
index 33e2fb35d..acd6b2bd8 100644
--- a/backend/internal/auth/handler.go
+++ b/backend/internal/auth/handler.go
@@ -256,7 +256,7 @@ func (h *AuthHandler) Login(ctx context.Context, input *LoginInput) (*LoginOutpu
expiresAt := tokenPair.ExpiresAt
return &LoginOutput{
- SetCookie: cookie.BuildTokenCookieStringFor(maxAge, tokenPair.AccessToken, cookie.SecureCookieFromContext(ctx)),
+ SetCookie: cookie.BuildTokenCookieStringFor(maxAge, tokenPair.BrowserToken, cookie.SecureCookieFromContext(ctx)),
Body: base.ApiResponse[authtypes.AuthenticationResponse]{
Success: true,
Data: authtypes.AuthenticationResponse{
@@ -338,7 +338,7 @@ func (h *AuthHandler) RefreshToken(ctx context.Context, input *RefreshTokenInput
maxAge += 60
return &RefreshTokenOutput{
- SetCookie: cookie.BuildTokenCookieStringFor(maxAge, tokenPair.AccessToken, cookie.SecureCookieFromContext(ctx)),
+ SetCookie: cookie.BuildTokenCookieStringFor(maxAge, tokenPair.BrowserToken, cookie.SecureCookieFromContext(ctx)),
Body: base.ApiResponse[authtypes.TokenRefreshResponse]{
Success: true,
Data: authtypes.TokenRefreshResponse{
diff --git a/backend/internal/auth/huma_middleware.go b/backend/internal/auth/huma_middleware.go
index 9e230fcca..dcc7e25bf 100644
--- a/backend/internal/auth/huma_middleware.go
+++ b/backend/internal/auth/huma_middleware.go
@@ -70,11 +70,18 @@ func parseSecurityRequirementsInternal(api huma.API, ctx operationProvider) secu
// the caller can distinguish a missing/invalid token from a token-version
// mismatch (which requires clearing the stale cookie).
func tryBearerAuthInternal(ctx huma.Context, authService *AuthService) (*common.User, string, error) {
- token := extractBearerTokenInternal(ctx)
+ token, fromCookie := extractBearerTokenInternal(ctx)
if token == "" {
return nil, "", nil
}
- user, sessionID, err := authService.VerifyToken(ctx.Context(), token)
+ var user *common.User
+ var sessionID string
+ var err error
+ if fromCookie {
+ user, sessionID, err = authService.VerifyBrowserToken(ctx.Context(), token)
+ } else {
+ user, sessionID, err = authService.VerifyToken(ctx.Context(), token)
+ }
if err != nil {
return nil, "", err
}
@@ -243,7 +250,7 @@ func tryAgentAuthCtxInternal(ctx huma.Context, cfg *config.Config) (huma.Context
// bearer token is present, but never fails the request. Used for public routes
// (e.g. logout) that still need to know who the caller is when a token exists.
func opportunisticBearerAuthInternal(ctx huma.Context, authService *AuthService, permResolver PermissionResolver) huma.Context {
- if extractBearerTokenInternal(ctx) == "" {
+ if token, _ := extractBearerTokenInternal(ctx); token == "" {
return ctx
}
user, sessionID, err := tryBearerAuthInternal(ctx, authService)
@@ -273,7 +280,7 @@ func handleApiKeyAuthInternal(api huma.API, ctx huma.Context, authService *AuthS
return
}
if user, env, ok := tryEnvironmentAccessTokenAuthInternal(ctx, envTokenResolver, ctx.Header(utils.HeaderApiKey)); ok {
- if allowBearerFallback && extractBearerTokenInternal(ctx) != "" {
+ if token, _ := extractBearerTokenInternal(ctx); allowBearerFallback && token != "" {
nextCtx, handled := handleBearerAuthInternal(api, ctx, authService, permResolver)
if handled {
if nextCtx != nil {
@@ -343,22 +350,22 @@ func resolveApiKeyPermissionsInternal(ctx context.Context, permResolver Permissi
return ps
}
-// extractBearerTokenInternal extracts the JWT token from Authorization header or cookie.
-func extractBearerTokenInternal(ctx huma.Context) string {
+// extractBearerTokenInternal extracts the JWT token and reports whether it came from a cookie.
+func extractBearerTokenInternal(ctx huma.Context) (string, bool) {
// Try Authorization header first
authHeader := ctx.Header("Authorization")
if len(authHeader) > 7 && strings.ToLower(authHeader[:7]) == "bearer " {
- return authHeader[7:]
+ return authHeader[7:], false
}
// Try cookie as fallback
if cookieHeader := ctx.Header("Cookie"); cookieHeader != "" {
if token, err := cookie.GetTokenCookieFromHeader(cookieHeader); err == nil {
- return token
+ return token, true
}
}
- return ""
+ return "", false
}
// setUserInContextInternal adds the authenticated user and the resolved
diff --git a/backend/internal/auth/huma_middleware_test.go b/backend/internal/auth/huma_middleware_test.go
index 644e0bf61..0114ca928 100644
--- a/backend/internal/auth/huma_middleware_test.go
+++ b/backend/internal/auth/huma_middleware_test.go
@@ -7,6 +7,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
+ "bytes"
"context"
"crypto/mldsa"
"net/http"
@@ -23,8 +24,11 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/user"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cookie"
authtypes "github.com/getarcaneapp/arcane/types/v2/auth"
"github.com/labstack/echo/v5"
+ "github.com/lestrrat-go/jwx/v4/jwa"
+ "github.com/lestrrat-go/jwx/v4/jwt"
"github.com/libtnb/sqlite"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
@@ -316,7 +320,7 @@ func TestNewHumaMiddleware_OpportunisticAuthOnPublicRoute(t *testing.T) {
t.Run("populates session ID when valid token presented", func(t *testing.T) {
sawSessionID = ""
req := httptest.NewRequest(http.MethodPost, "/api/public", nil)
- req.Header.Set("Authorization", "Bearer "+token)
+ req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: token})
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
@@ -353,8 +357,10 @@ func TestNewHumaMiddleware_VersionMismatchIsRecoverable(t *testing.T) {
sessionSvc := session.NewSessionService(db)
signingKey := newTestSigningKeyInternal()
+ browserSigningKey := bytes.Repeat([]byte{0x24}, browserSessionSigningKeySize)
cfg := &config.Config{JWTRefreshExpiry: 24 * time.Hour}
authSvc := NewAuthService(userSvc, nil, nil, sessionSvc, nil, cfg, nil).WithSigningKey(signingKey)
+ authSvc.browserSigningKey = browserSigningKey
_, err := userSvc.CreateUser(context.Background(), &common.User{
ID: "u-ver",
@@ -368,19 +374,21 @@ func TestNewHumaMiddleware_VersionMismatchIsRecoverable(t *testing.T) {
// An empty appVersion omits the claim, which passes the version check (no pin).
mintToken := func(appVersion string) string {
- claims := map[string]any{
- "jti": "u-ver",
- "sub": "access",
- "iat": time.Now().Unix(),
- "exp": exp.Unix(),
- "sid": session.ID,
- "user_id": "u-ver",
- "username": "vertest",
- }
+ builder := jwt.NewBuilder().
+ JwtID("browser-"+appVersion).
+ Subject(browserTokenSubject).
+ IssuedAt(time.Now()).
+ Expiration(exp).
+ Claim(claimSessionID, session.ID).
+ Claim(claimUserID, "u-ver")
if appVersion != "" {
- claims["app_version"] = appVersion
+ builder.Claim(claimAppVersion, appVersion)
}
- return signJWXTokenInternal(t, signingKey, claims)
+ token, err := builder.Build()
+ require.NoError(t, err)
+ signed, err := jwt.Sign(token, jwt.WithKey(jwa.HS512(), browserSigningKey))
+ require.NoError(t, err)
+ return string(signed)
}
router := echo.New()
@@ -403,7 +411,7 @@ func TestNewHumaMiddleware_VersionMismatchIsRecoverable(t *testing.T) {
t.Run("version mismatch returns a recoverable 401 without clearing cookies", func(t *testing.T) {
req := httptest.NewRequest(http.MethodGet, "/api/protected", nil)
- req.Header.Set("Authorization", "Bearer "+mintToken("v0.0.0-stale"))
+ req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: mintToken("v0.0.0-stale")})
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
@@ -415,11 +423,18 @@ func TestNewHumaMiddleware_VersionMismatchIsRecoverable(t *testing.T) {
})
t.Run("token without a version pin still authenticates", func(t *testing.T) {
+ token := mintToken("")
req := httptest.NewRequest(http.MethodGet, "/api/protected", nil)
- req.Header.Set("Authorization", "Bearer "+mintToken(""))
+ req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: token})
rec := httptest.NewRecorder()
router.ServeHTTP(rec, req)
require.Equal(t, http.StatusOK, rec.Code)
+
+ req = httptest.NewRequest(http.MethodGet, "/api/protected", nil)
+ req.Header.Set("Authorization", "Bearer "+token)
+ rec = httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+ require.Equal(t, http.StatusUnauthorized, rec.Code)
})
}
diff --git a/backend/internal/auth/middleware.go b/backend/internal/auth/middleware.go
index 00a28c036..c54bf74f3 100644
--- a/backend/internal/auth/middleware.go
+++ b/backend/internal/auth/middleware.go
@@ -162,7 +162,7 @@ func (m *AuthMiddleware) managerAuth(ctx context.Context, c *echo.Context, next
return m.apiKeyHeaderAuth(ctx, c, next, apiKey)
}
- token := extractBearerOrCookieTokenInternal(c)
+ token, fromCookie := extractBearerOrCookieTokenInternal(c)
if token == "" {
if m.options.SuccessOptional {
return next(c)
@@ -173,7 +173,14 @@ func (m *AuthMiddleware) managerAuth(ctx context.Context, c *echo.Context, next
})
}
- user, sessionID, err := m.authService.VerifyToken(ctx, token)
+ var user *common.User
+ var sessionID string
+ var err error
+ if fromCookie {
+ user, sessionID, err = m.authService.VerifyBrowserToken(ctx, token)
+ } else {
+ user, sessionID, err = m.authService.VerifyToken(ctx, token)
+ }
if err != nil {
// A version mismatch means the app self-updated; the session is still valid
// (the refresh path tolerates the version change and rotates the token), so do
@@ -324,14 +331,14 @@ func environmentScopedInternal(c *echo.Context, env *environment.Environment) {
c.Set(string(middleware.ContextKeyAuthMethod), "environment_access_token")
}
-func extractBearerOrCookieTokenInternal(c *echo.Context) string {
+func extractBearerOrCookieTokenInternal(c *echo.Context) (string, bool) {
req := c.Request()
authHeader := req.Header.Get("Authorization")
if after, ok := strings.CutPrefix(authHeader, "Bearer "); ok {
- return after
+ return after, false
}
if tok, err := cookie.GetTokenCookie(req); err == nil && tok != "" {
- return tok
+ return tok, true
}
- return ""
+ return "", false
}
diff --git a/backend/internal/auth/middleware_test.go b/backend/internal/auth/middleware_test.go
index 747b064ea..f0d9db893 100644
--- a/backend/internal/auth/middleware_test.go
+++ b/backend/internal/auth/middleware_test.go
@@ -11,9 +11,14 @@ import (
"net/http"
"net/http/httptest"
"testing"
+ "time"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
+ "github.com/getarcaneapp/arcane/backend/v2/internal/session"
+ usersvc "github.com/getarcaneapp/arcane/backend/v2/internal/user"
"github.com/getarcaneapp/arcane/backend/v2/pkg/authz"
+ "github.com/getarcaneapp/arcane/backend/v2/pkg/utils/cookie"
+ authtypes "github.com/getarcaneapp/arcane/types/v2/auth"
"github.com/labstack/echo/v5"
"github.com/stretchr/testify/require"
)
@@ -101,6 +106,53 @@ func TestAuthMiddleware_ManagerAuthResolvesPermissionsByKeyKind(t *testing.T) {
require.Equal(t, http.StatusOK, rec.Code)
})
}
+
+ t.Run("browser cookie uses owner role permissions", func(t *testing.T) {
+ ctx := context.Background()
+ db := setupAuthMiddlewareTestDBInternal(t)
+ userSvc := usersvc.NewUserService(db)
+ sessionSvc := session.NewSessionService(db)
+ settingsSvc, err := newSettingsServiceForAuthTestInternal(t, ctx, db)
+ require.NoError(t, err)
+ authSvc := newTestAuthService()
+ authSvc.userService = userSvc
+ authSvc.settingsService = settingsSvc
+ authSvc.sessionService = sessionSvc
+
+ browserUser := &common.User{ID: "browser-owner", Username: "browser-owner"}
+ _, err = userSvc.CreateUser(ctx, browserUser)
+ require.NoError(t, err)
+ expiresAt := time.Now().Add(time.Hour)
+ browserSession, refreshJTI, err := sessionSvc.CreateSession(ctx, browserUser.ID, expiresAt, authtypes.SessionMeta{})
+ require.NoError(t, err)
+ tokenPair, err := authSvc.buildTokenPairInternal(ctx, browserUser, browserSession, refreshJTI)
+ require.NoError(t, err)
+
+ router := echo.New()
+ router.Use(
+ NewAuthMiddleware(authSvc, &config.Config{}).
+ WithPermissionResolver(testPermissionResolver{}).
+ Add(),
+ )
+ router.GET("/secure", func(c *echo.Context) error {
+ ps, ok := c.Get("userPermissions").(*authz.PermissionSet)
+ require.True(t, ok)
+ require.True(t, ps.Allows("containers:list", ""))
+ return c.NoContent(http.StatusOK)
+ })
+
+ req := httptest.NewRequest(http.MethodGet, "/secure", nil)
+ req.Header.Set("Authorization", "Bearer "+tokenPair.BrowserToken)
+ rec := httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+ require.Equal(t, http.StatusUnauthorized, rec.Code)
+
+ req = httptest.NewRequest(http.MethodGet, "/secure", nil)
+ req.AddCookie(&http.Cookie{Name: cookie.InsecureTokenCookieName, Value: tokenPair.BrowserToken})
+ rec = httptest.NewRecorder()
+ router.ServeHTTP(rec, req)
+ require.Equal(t, http.StatusOK, rec.Code)
+ })
}
func TestAuthMiddleware_ManagerAuthAcceptsEnvironmentAccessTokenViaAPIKey(t *testing.T) {
diff --git a/backend/internal/auth/service.go b/backend/internal/auth/service.go
index cd8a666bd..24d7d188a 100644
--- a/backend/internal/auth/service.go
+++ b/backend/internal/auth/service.go
@@ -43,6 +43,7 @@ const (
type TokenPair struct {
AccessToken string `json:"accessToken"`
+ BrowserToken string `json:"-"`
RefreshToken string `json:"refreshToken"`
ExpiresAt time.Time `json:"expiresAt"`
}
@@ -60,16 +61,17 @@ type verifiedTokenEntry struct {
}
type AuthService struct {
- userService *user.UserService
- settingsService *settings.SettingsService
- eventService *event.EventService
- sessionService *session.SessionService
- roleService *role.RoleService
- signingKeyMu sync.Mutex
- signingKey *mldsa.PrivateKey
- refreshExpiry time.Duration
- config *config.Config
- errorHandler emperror.ErrorHandler
+ userService *user.UserService
+ settingsService *settings.SettingsService
+ eventService *event.EventService
+ sessionService *session.SessionService
+ roleService *role.RoleService
+ signingKeyMu sync.Mutex
+ signingKey *mldsa.PrivateKey
+ browserSigningKey []byte
+ refreshExpiry time.Duration
+ config *config.Config
+ errorHandler emperror.ErrorHandler
// tokenCache is a per-process in-memory cache for parsed user/token data.
// Cached entries still revalidate persisted session state so revocation
// performed by another process takes effect immediately.
@@ -703,6 +705,26 @@ func (s *AuthService) signingKeyInternal(ctx context.Context) (*mldsa.PrivateKey
return key, nil
}
+func (s *AuthService) browserSigningKeyInternal(ctx context.Context) ([]byte, error) {
+ s.signingKeyMu.Lock()
+ defer s.signingKeyMu.Unlock()
+ if len(s.browserSigningKey) == browserSessionSigningKeySize {
+ return s.browserSigningKey, nil
+ }
+ if s.settingsService == nil {
+ return nil, common.Classify(common.ErrUnavailable, errors.New("browser session signing key is not configured"))
+ }
+ key, err := s.settingsService.EnsureBrowserSessionSigningKey(ctx)
+ if err != nil {
+ return nil, err
+ }
+ if len(key) != browserSessionSigningKeySize {
+ return nil, common.Classify(common.ErrUnavailable, errors.New("browser session signing key has invalid length"))
+ }
+ s.browserSigningKey = key
+ return key, nil
+}
+
func (s *AuthService) RefreshToken(ctx context.Context, refreshToken string, meta auth.SessionMeta) (*TokenPair, error) {
signingKey, err := s.signingKeyInternal(ctx)
if err != nil {
@@ -754,7 +776,33 @@ func (s *AuthService) VerifyToken(ctx context.Context, accessToken string) (*com
if err != nil {
return nil, "", err
}
+ return s.verifyTokenClaimsInternal(ctx, accessToken, claims)
+}
+
+func (s *AuthService) VerifyBrowserToken(ctx context.Context, browserToken string) (*common.User, string, error) {
+ algorithm, ok := signedTokenAlgorithmInternal(browserToken)
+ if !ok {
+ return nil, "", common.ErrInvalidToken
+ }
+ switch algorithm {
+ case jwa.HS512().String():
+ key, err := s.browserSigningKeyInternal(ctx)
+ if err != nil {
+ return nil, "", err
+ }
+ claims, err := parseBrowserTokenInternal(ctx, browserToken, key)
+ if err != nil {
+ return nil, "", err
+ }
+ return s.verifyTokenClaimsInternal(ctx, browserToken, claims)
+ case jwa.MLDSA87().String():
+ return s.VerifyToken(ctx, browserToken)
+ default:
+ return nil, "", common.ErrInvalidToken
+ }
+}
+func (s *AuthService) verifyTokenClaimsInternal(ctx context.Context, rawToken string, claims *accessTokenClaims) (*common.User, string, error) {
if claims.AppVersion != "" && claims.AppVersion != config.Version {
slog.InfoContext(ctx, "Token version mismatch detected", "tokenVersion", claims.AppVersion, "currentVersion", config.Version, "user", claims.Username)
return nil, "", common.ErrTokenVersionMismatch
@@ -763,7 +811,7 @@ func (s *AuthService) VerifyToken(ctx context.Context, accessToken string) (*com
return nil, "", common.Classify(common.ErrUnavailable, errors.New("Session service is not configured"))
}
- tokenHash := hashTokenInternal(accessToken)
+ tokenHash := hashTokenInternal(rawToken)
if cached, ok, _ := s.tokenCache.Get(tokenHash); ok {
if cached.User.ID != claims.UserID || cached.SessionID != claims.SessionID {
s.tokenCache.Delete(tokenHash)
@@ -975,8 +1023,32 @@ func (s *AuthService) buildTokenPairInternal(ctx context.Context, user *common.U
return nil, err
}
+ browserSigningKey, err := s.browserSigningKeyInternal(ctx)
+ if err != nil {
+ return nil, err
+ }
+ browserBuilder := jwt.NewBuilder().
+ JwtID(uuid.New().String()).
+ Subject(browserTokenSubject).
+ IssuedAt(now).
+ Expiration(accessTokenExpiry).
+ Claim(claimSessionID, session.ID).
+ Claim(claimUserID, user.ID)
+ if config.Version != "" {
+ browserBuilder.Claim(claimAppVersion, config.Version)
+ }
+ browserToken, err := browserBuilder.Build()
+ if err != nil {
+ return nil, err
+ }
+ browserTokenBytes, err := jwt.Sign(browserToken, jwt.WithKey(jwa.HS512(), browserSigningKey))
+ if err != nil {
+ return nil, err
+ }
+
return &TokenPair{
AccessToken: string(accessTokenBytes),
+ BrowserToken: string(browserTokenBytes),
RefreshToken: string(refreshTokenBytes),
ExpiresAt: accessTokenExpiry,
}, nil
diff --git a/backend/internal/auth/service_test.go b/backend/internal/auth/service_test.go
index dbe4ab749..bd7fb4850 100644
--- a/backend/internal/auth/service_test.go
+++ b/backend/internal/auth/service_test.go
@@ -7,6 +7,7 @@ import (
"github.com/getarcaneapp/arcane/backend/v2/internal/environment"
+ "bytes"
"context"
"crypto/mldsa"
"encoding/base64"
@@ -85,9 +86,10 @@ func newTestSigningKeyInternal() *mldsa.PrivateKey {
func newTestAuthService() *AuthService {
return &AuthService{
- signingKey: newTestSigningKeyInternal(),
- refreshExpiry: 24 * time.Hour,
- config: &config.Config{},
+ signingKey: newTestSigningKeyInternal(),
+ browserSigningKey: bytes.Repeat([]byte{0x42}, browserSessionSigningKeySize),
+ refreshExpiry: 24 * time.Hour,
+ config: &config.Config{},
tokenCache: hot.NewHotCache[string, verifiedTokenEntry](hot.LRU, 4096).
WithTTL(15 * time.Second).
WithJanitor().
@@ -231,7 +233,7 @@ func TestVerifyToken_ValidClaims(t *testing.T) {
func TestVerifyToken_RejectsNonMLDSAAlg(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
- token := makeUnsignedToken(t, map[string]any{
+ payload, err := json.Marshal(map[string]any{
"jti": "u1",
"sub": "access",
"iat": time.Now().Unix(),
@@ -240,8 +242,13 @@ func TestVerifyToken_RejectsNonMLDSAAlg(t *testing.T) {
"username": "bob",
"app_version": config.Version,
})
+ require.NoError(t, err)
+ parsed, err := jwt.ParseInsecure(payload)
+ require.NoError(t, err)
+ token, err := jwt.Sign(parsed, jwt.WithKey(jwa.HS512(), s.browserSigningKey))
+ require.NoError(t, err)
- _, _, err := s.VerifyToken(context.Background(), token)
+ _, _, err = s.VerifyToken(context.Background(), string(token))
assert.ErrorIs(t, err, common.ErrInvalidToken,
"want common.ErrInvalidToken, got %v", err)
@@ -407,7 +414,19 @@ func TestRefreshToken_Valid(t *testing.T) {
require.NoError(t, err)
require.NotNil(t, tokenPair)
require.NotEmpty(t, tokenPair.AccessToken)
+ require.NotEmpty(t, tokenPair.BrowserToken)
require.NotEmpty(t, tokenPair.RefreshToken)
+ require.Less(t, len(tokenPair.BrowserToken), 1024)
+
+ accessAlgorithm, ok := signedTokenAlgorithmInternal(tokenPair.AccessToken)
+ require.True(t, ok)
+ require.Equal(t, jwa.MLDSA87().String(), accessAlgorithm)
+ browserAlgorithm, ok := signedTokenAlgorithmInternal(tokenPair.BrowserToken)
+ require.True(t, ok)
+ require.Equal(t, jwa.HS512().String(), browserAlgorithm)
+ refreshAlgorithm, ok := signedTokenAlgorithmInternal(tokenPair.RefreshToken)
+ require.True(t, ok)
+ require.Equal(t, jwa.MLDSA87().String(), refreshAlgorithm)
}
// A refresh token minted under an older config.Version must still refresh successfully
@@ -451,6 +470,21 @@ func TestRefreshToken_VersionMismatchRotates(t *testing.T) {
require.NoError(t, err)
require.Equal(t, "2.0.0", accessVersion)
+ parsedBrowser, err := jwt.ParseString(tokenPair.BrowserToken, jwt.WithKey(jwa.HS512(), s.browserSigningKey))
+ require.NoError(t, err)
+ browserSubject, ok := parsedBrowser.Subject()
+ require.True(t, ok)
+ require.Equal(t, browserTokenSubject, browserSubject)
+ browserSessionID, err := jwt.Get[string](parsedBrowser, claimSessionID)
+ require.NoError(t, err)
+ require.Equal(t, session.ID, browserSessionID)
+ browserUserID, err := jwt.Get[string](parsedBrowser, claimUserID)
+ require.NoError(t, err)
+ require.Equal(t, user.ID, browserUserID)
+ browserVersion, err := jwt.Get[string](parsedBrowser, claimAppVersion)
+ require.NoError(t, err)
+ require.Equal(t, "2.0.0", browserVersion)
+
parsedRefresh, err := jwt.ParseString(tokenPair.RefreshToken, jwt.WithKey(jwa.MLDSA87(), s.signingKey.PublicKey()))
require.NoError(t, err)
refreshVersion, err := jwt.Get[string](parsedRefresh, claimAppVersion)
@@ -474,11 +508,24 @@ func TestVerifyToken_RejectsRevokedSession(t *testing.T) {
exp := time.Now().Add(5 * time.Minute)
session, _ := createTestSession(t, db, user.ID, exp)
- require.NoError(t, s.RevokeSession(context.Background(), session.ID))
token := makeAccessToken(t, s.signingKey, "access", user.ID, user.Username, []string{"user"}, "", "", exp, session.ID)
+ browser, err := jwt.NewBuilder().
+ JwtID("revoked-browser-token").
+ Subject(browserTokenSubject).
+ IssuedAt(time.Now()).
+ Expiration(exp).
+ Claim(claimSessionID, session.ID).
+ Claim(claimUserID, user.ID).
+ Build()
+ require.NoError(t, err)
+ browserToken, err := jwt.Sign(browser, jwt.WithKey(jwa.HS512(), s.browserSigningKey))
+ require.NoError(t, err)
+ require.NoError(t, s.RevokeSession(context.Background(), session.ID))
_, _, err = s.VerifyToken(context.Background(), token)
require.ErrorIs(t, err, common.ErrSessionRevoked)
+ _, _, err = s.VerifyBrowserToken(context.Background(), string(browserToken))
+ require.ErrorIs(t, err, common.ErrSessionRevoked)
}
func TestVerifyToken_RejectsMissingSessionID(t *testing.T) {
diff --git a/backend/internal/auth/token.go b/backend/internal/auth/token.go
index 00409c846..947c61ce9 100644
--- a/backend/internal/auth/token.go
+++ b/backend/internal/auth/token.go
@@ -6,13 +6,17 @@ import (
"emperror.dev/errors"
"github.com/lestrrat-go/jwx/v4/jwa"
+ "github.com/lestrrat-go/jwx/v4/jws"
"github.com/lestrrat-go/jwx/v4/jwt"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
)
const (
+ browserSessionSigningKeySize = 64
+
accessTokenSubject = "access"
+ browserTokenSubject = "browser_session"
refreshTokenSubject = "refresh"
claimSessionID = "sid"
@@ -78,6 +82,50 @@ func parseAccessTokenInternal(ctx context.Context, rawToken string, key *mldsa.P
return new(accessTokenClaims{UserID: userID, SessionID: sessionID, Username: username, AppVersion: appVersion}), nil
}
+func parseBrowserTokenInternal(ctx context.Context, rawToken string, key []byte) (*accessTokenClaims, error) {
+ token, err := jwt.ParseString(rawToken, append(tokenParseOptions, jwt.WithKey(jwa.HS512(), key), jwt.WithContext(ctx))...)
+ if err != nil {
+ switch {
+ case errors.Is(err, jwt.TokenExpiredError{}):
+ return nil, common.ErrExpiredToken
+ case errors.Is(err, jwt.MissingRequiredClaimError{}), errors.Is(err, jwt.ClaimValidationError{}):
+ return nil, common.ErrTokenValidation
+ default:
+ return nil, common.ErrInvalidToken
+ }
+ }
+
+ subject, _ := token.Subject()
+ id, _ := token.JwtID()
+ userID, _ := jwt.Get[string](token, claimUserID)
+ sessionID, _ := jwt.Get[string](token, claimSessionID)
+ if subject != browserTokenSubject || id == "" || userID == "" || sessionID == "" {
+ return nil, common.ErrTokenValidation
+ }
+
+ appVersion, appVersionErr := jwt.Get[string](token, claimAppVersion)
+ if errors.Is(appVersionErr, jwt.ClaimTypeMismatchError{}) {
+ return nil, common.ErrTokenValidation
+ }
+ return new(accessTokenClaims{UserID: userID, SessionID: sessionID, AppVersion: appVersion}), nil
+}
+
+func signedTokenAlgorithmInternal(rawToken string) (string, bool) {
+ message, err := jws.Parse([]byte(rawToken), jws.WithCompact())
+ if err != nil {
+ return "", false
+ }
+ signatures := message.Signatures()
+ if len(signatures) != 1 || signatures[0].ProtectedHeaders() == nil {
+ return "", false
+ }
+ algorithm, ok := signatures[0].ProtectedHeaders().Algorithm()
+ if !ok {
+ return "", false
+ }
+ return algorithm.String(), true
+}
+
func parseRefreshTokenInternal(ctx context.Context, rawToken string, key *mldsa.PublicKey) (*refreshTokenClaims, error) {
token, err := jwt.ParseString(rawToken, append(tokenParseOptions, jwt.WithKey(jwa.MLDSA87(), key), jwt.WithContext(ctx))...)
if err != nil {
diff --git a/backend/internal/bootstrap/router_bootstrap.go b/backend/internal/bootstrap/router_bootstrap.go
index 5a725c24a..8cbae4f9f 100644
--- a/backend/internal/bootstrap/router_bootstrap.go
+++ b/backend/internal/bootstrap/router_bootstrap.go
@@ -144,26 +144,28 @@ func createAuthValidatorInternal(deps api.HandlerDeps) middleware.AuthValidator
return nil, nil, false
}
- // Check for Bearer token authentication
- token := ""
- if auth := req.Header.Get("Authorization"); strings.HasPrefix(auth, "Bearer ") {
- token = strings.TrimPrefix(auth, "Bearer ")
- } else if cookieToken, err := cookie.GetTokenCookie(req); err == nil && cookieToken != "" {
- token = cookieToken
- }
-
- if token == "" {
- return nil, nil, false
- }
-
- user, _, err := deps.Auth.Service().VerifyToken(ctx, token)
- if err != nil || user == nil {
+ user, ok := verifyRouterRequestUserInternal(ctx, deps.Auth.Service(), req)
+ if !ok {
return nil, nil, false
}
return resolveUser(ctx, user), user, true
}
}
+func verifyRouterRequestUserInternal(ctx context.Context, authService *auth.AuthService, req *http.Request) (*common.User, bool) {
+ if authHeader := req.Header.Get("Authorization"); strings.HasPrefix(authHeader, "Bearer ") {
+ user, _, err := authService.VerifyToken(ctx, strings.TrimPrefix(authHeader, "Bearer "))
+ return user, err == nil && user != nil
+ }
+
+ browserToken, err := cookie.GetTokenCookie(req)
+ if err != nil || browserToken == "" {
+ return nil, false
+ }
+ user, _, err := authService.VerifyBrowserToken(ctx, browserToken)
+ return user, err == nil && user != nil
+}
+
type RouterParams struct {
fx.In
diff --git a/backend/internal/oidc/handler.go b/backend/internal/oidc/handler.go
index e2ced27f4..23bb83c98 100644
--- a/backend/internal/oidc/handler.go
+++ b/backend/internal/oidc/handler.go
@@ -100,8 +100,7 @@ type ExchangeDeviceTokenInput struct {
}
type ExchangeDeviceTokenOutput struct {
- SetCookie []string `header:"Set-Cookie" doc:"Session token cookie"`
- Body authtypes.AuthenticationResponse
+ Body authtypes.AuthenticationResponse
}
// --- OIDC role mapping I/O ---
@@ -392,7 +391,7 @@ func (h *OidcHandler) HandleOidcCallback(ctx context.Context, input *HandleOidcC
if mobileRedirectURI == "" {
maxAge := max(int(time.Until(tokenPair.ExpiresAt).Seconds()), 0)
maxAge += 60 // Add 60 seconds buffer for clock skew
- setCookies = append(setCookies, cookie.BuildTokenCookieStringFor(maxAge, tokenPair.AccessToken, cookie.SecureCookieFromContext(ctx))...)
+ setCookies = append(setCookies, cookie.BuildTokenCookieStringFor(maxAge, tokenPair.BrowserToken, cookie.SecureCookieFromContext(ctx))...)
}
expiresAt := tokenPair.ExpiresAt
@@ -480,19 +479,14 @@ func (h *OidcHandler) ExchangeDeviceToken(ctx context.Context, input *ExchangeDe
return nil, huma.Error500InternalServerError("Authentication failed")
}
- maxAge := max(int(time.Until(tokenPair.ExpiresAt).Seconds()), 0)
- maxAge += 60
expiresAt := tokenPair.ExpiresAt
- tokenCookies := cookie.BuildTokenCookieStringFor(maxAge, tokenPair.AccessToken, cookie.SecureCookieFromContext(ctx))
-
userDto, err := h.userService.ToUserResponseDto(ctx, *userModel)
if err != nil {
return nil, huma.Error500InternalServerError("Failed to map user")
}
return &ExchangeDeviceTokenOutput{
- SetCookie: tokenCookies,
Body: authtypes.AuthenticationResponse{
Success: true,
Status: authtypes.AuthenticationStatusAuthenticated,
diff --git a/backend/internal/passkey/handler.go b/backend/internal/passkey/handler.go
index 5df42b0e6..e78b5b5c7 100644
--- a/backend/internal/passkey/handler.go
+++ b/backend/internal/passkey/handler.go
@@ -93,8 +93,7 @@ type MobilePasskeyExchangeInput struct {
}
type MobilePasskeyExchangeOutput struct {
- SetCookie []string `header:"Set-Cookie" doc:"Session cookie"`
- Body base.ApiResponse[authtypes.AuthenticationResponse]
+ Body base.ApiResponse[authtypes.AuthenticationResponse]
}
type PasskeyMFAStartInput struct {
@@ -400,8 +399,7 @@ func (h *PasskeyHandler) ExchangeMobilePasskeyLogin(ctx context.Context, input *
return nil, err
}
return &MobilePasskeyExchangeOutput{
- SetCookie: tokenCookieInternal(ctx, tokenPair),
- Body: base.ApiResponse[authtypes.AuthenticationResponse]{Success: true, Data: *response},
+ Body: base.ApiResponse[authtypes.AuthenticationResponse]{Success: true, Data: *response},
}, nil
}
@@ -681,7 +679,7 @@ func marshalCredentialInternal(credential map[string]any) ([]byte, error) {
func tokenCookieInternal(ctx context.Context, tokenPair *auth.TokenPair) []string {
maxAge := max(int(time.Until(tokenPair.ExpiresAt).Seconds()), 0) + 60
- return cookie.BuildTokenCookieStringFor(maxAge, tokenPair.AccessToken, cookie.SecureCookieFromContext(ctx))
+ return cookie.BuildTokenCookieStringFor(maxAge, tokenPair.BrowserToken, cookie.SecureCookieFromContext(ctx))
}
func passkeyHTTPErrorInternal(err error) error {
diff --git a/backend/internal/settings/model.go b/backend/internal/settings/model.go
index 69843c048..184a8fd49 100644
--- a/backend/internal/settings/model.go
+++ b/backend/internal/settings/model.go
@@ -174,9 +174,10 @@ type Settings struct {
ApnsChannelID SettingVariable `key:"apnsChannelId,internal"`
ApnsSigningKey SettingVariable `key:"apnsSigningKey,internal,sensitive"`
- AgentToken SettingVariable `key:"agentToken,internal,sensitive"`
- JwtSigningKeySeed SettingVariable `key:"jwtSigningKeySeed,internal,sensitive"`
- InstanceID SettingVariable `key:"instanceId,internal"`
+ AgentToken SettingVariable `key:"agentToken,internal,sensitive"`
+ BrowserSessionSigningKey SettingVariable `key:"browserSessionSigningKey,internal,sensitive"`
+ JwtSigningKeySeed SettingVariable `key:"jwtSigningKeySeed,internal,sensitive"`
+ InstanceID SettingVariable `key:"instanceId,internal"`
// Users category (admin management page - no actual settings)
UsersCategoryPlaceholder SettingVariable `key:"usersCategory,internal" meta:"label=Users;type=internal;keywords=users,accounts,management,admin,access,permissions,roles;category=users;description=Manage user accounts and permissions" catmeta:"id=users;title=Users;icon=user;url=/settings/users;description=Manage user accounts and access control"`
diff --git a/backend/internal/settings/service.go b/backend/internal/settings/service.go
index b152de4ff..d458d9aad 100644
--- a/backend/internal/settings/service.go
+++ b/backend/internal/settings/service.go
@@ -3,6 +3,7 @@ package settings
import (
"context"
"crypto/mldsa"
+ "crypto/rand"
"crypto/sha256"
"encoding/base64"
"fmt"
@@ -36,6 +37,8 @@ import (
)
const (
+ browserSessionSigningKeySize = 64
+
// DefaultArcaneToolsImage is the shared Arcane toolbox image used for helper commands.
DefaultArcaneToolsImage = "ghcr.io/getarcaneapp/tools:latest"
// DefaultTrivyImage is the default vulnerability scanner image setting.
@@ -1037,48 +1040,59 @@ func (s *SettingsService) EnsureEncryptionKey(ctx context.Context) (string, erro
}
func (s *SettingsService) EnsureJwtSigningKey(ctx context.Context) (*mldsa.PrivateKey, error) {
- return s.writes.Execute(ctx, "ensure jwt signing key", func(writeCtx context.Context) (*mldsa.PrivateKey, error) {
- const keyName = "jwtSigningKeySeed"
- var key *mldsa.PrivateKey
+ seed, err := s.ensureEncryptedKeyInternal(ctx, "ensure jwt signing key", "jwtSigningKeySeed", mldsa.PrivateKeySize)
+ if err != nil {
+ return nil, err
+ }
+ key, err := mldsa.NewPrivateKey(mldsa.MLDSA87(), seed)
+ return key, errors.WrapIf(err, "failed to load jwt signing key")
+}
+
+func (s *SettingsService) EnsureBrowserSessionSigningKey(ctx context.Context) ([]byte, error) {
+ return s.ensureEncryptedKeyInternal(ctx, "ensure browser session signing key", "browserSessionSigningKey", browserSessionSigningKeySize)
+}
+
+func (s *SettingsService) ensureEncryptedKeyInternal(ctx context.Context, operation, keyName string, size int) ([]byte, error) {
+ return s.writes.Execute(ctx, operation, func(writeCtx context.Context) ([]byte, error) {
+ var key []byte
err := s.db.WithContext(writeCtx).Transaction(func(tx *gorm.DB) error {
var sv SettingVariable
err := tx.Where("key = ?", keyName).First(&sv).Error
-
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
- return errors.WrapIf(err, "failed to load jwt signing key")
+ return errors.WrapIf(err, "failed to load signing key")
}
if sv.Value != "" {
decoded, decErr := libcrypto.Decrypt(sv.Value)
if decErr != nil {
- return errors.WrapIf(decErr, "failed to decrypt jwt signing key")
+ return errors.WrapIf(decErr, "failed to decrypt signing key")
}
- seed, decErr := base64.StdEncoding.DecodeString(decoded)
+ key, decErr = base64.StdEncoding.DecodeString(decoded)
if decErr != nil {
- return errors.WrapIf(decErr, "failed to decode jwt signing key")
+ return errors.WrapIf(decErr, "failed to decode signing key")
+ }
+ if len(key) != size {
+ return errors.Errorf("invalid signing key length: got %d, want %d", len(key), size)
}
- key, decErr = mldsa.NewPrivateKey(mldsa.MLDSA87(), seed)
- return errors.WrapIf(decErr, "failed to load jwt signing key")
+ return nil
}
- notFound := errors.Is(err, gorm.ErrRecordNotFound)
- generated, genErr := mldsa.GenerateKey(mldsa.MLDSA87())
- if genErr != nil {
- return errors.WrapIf(genErr, "failed to generate jwt signing key")
+ key = make([]byte, size)
+ if _, genErr := rand.Read(key); genErr != nil {
+ return errors.WrapIf(genErr, "failed to generate signing key")
}
- encrypted, encErr := libcrypto.Encrypt(base64.StdEncoding.EncodeToString(generated.Bytes()))
+ encrypted, encErr := libcrypto.Encrypt(base64.StdEncoding.EncodeToString(key))
if encErr != nil {
- return errors.WrapIf(encErr, "failed to encrypt jwt signing key")
+ return errors.WrapIf(encErr, "failed to encrypt signing key")
}
- key = generated
- if notFound {
- return errors.WrapIf(tx.Create(&SettingVariable{Key: keyName, Value: encrypted}).Error, "failed to persist jwt signing key")
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return errors.WrapIf(tx.Create(&SettingVariable{Key: keyName, Value: encrypted}).Error, "failed to persist signing key")
}
return errors.WrapIf(tx.Model(&SettingVariable{}).
Where("key = ?", keyName).
- Update("value", encrypted).Error, "failed to update jwt signing key")
+ Update("value", encrypted).Error, "failed to update signing key")
})
if err != nil {
return nil, err
diff --git a/backend/internal/settings/service_test.go b/backend/internal/settings/service_test.go
index ebe36d7c4..7747c44ea 100644
--- a/backend/internal/settings/service_test.go
+++ b/backend/internal/settings/service_test.go
@@ -2,6 +2,7 @@ package settings
import (
"context"
+ "encoding/base64"
"path/filepath"
"strings"
"sync/atomic"
@@ -10,6 +11,7 @@ import (
"github.com/libtnb/sqlite"
"github.com/stretchr/testify/require"
+ libcrypto "go.getarcane.app/sys/crypto"
"go.uber.org/fx/fxtest"
"gorm.io/gorm"
@@ -764,6 +766,19 @@ func TestSettingsService_EnsureEncryptionKey(t *testing.T) {
var sv SettingVariable
require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "encryptionKey").First(&sv).Error)
require.Equal(t, k1, sv.Value)
+ libcrypto.InitEncryption(&libcrypto.Config{EncryptionKey: k1, Environment: "development"})
+
+ browserKey1, err := svc.EnsureBrowserSessionSigningKey(ctx)
+ require.NoError(t, err)
+ require.Len(t, browserKey1, browserSessionSigningKeySize)
+ browserKey2, err := svc.EnsureBrowserSessionSigningKey(ctx)
+ require.NoError(t, err)
+ require.Equal(t, browserKey1, browserKey2, "browser signing key should be stable between calls")
+
+ var browserSetting SettingVariable
+ require.NoError(t, svc.db.WithContext(ctx).Where("key = ?", "browserSessionSigningKey").First(&browserSetting).Error)
+ require.NotEmpty(t, browserSetting.Value)
+ require.NotEqual(t, base64.StdEncoding.EncodeToString(browserKey1), browserSetting.Value)
}
func TestSettingsService_LoadDatabaseSettings_ReloadsChanges(t *testing.T) {
diff --git a/backend/pkg/utils/cookie/cookie_util.go b/backend/pkg/utils/cookie/cookie_util.go
index 087a5acce..7adfa3454 100644
--- a/backend/pkg/utils/cookie/cookie_util.go
+++ b/backend/pkg/utils/cookie/cookie_util.go
@@ -13,8 +13,8 @@ var (
OidcStateCookieName = "oidc_state"
)
-// Browsers cap a single cookie (name + value) at 4096 bytes, so tokens larger
-// than that are split across numbered chunk cookies and reassembled on read.
+// Legacy ML-DSA browser tokens exceed the 4096-byte cookie limit, so readers
+// retain numbered chunk support until existing sessions expire or refresh.
const (
tokenCookieChunkSize = 3072
tokenCookieMaxChunks = 4
@@ -87,9 +87,9 @@ func readTokenCookieInternal(r *http.Request, base string) (string, error) {
}
// BuildTokenCookieStringFor builds Set-Cookie header strings matching the
-// current request security context, splitting the token across chunk cookies
-// when it exceeds the per-cookie browser limit and clearing unused chunk slots
-// so stale chunks from a longer previous token cannot corrupt reassembly.
+// current request security context. Compact browser tokens use one cookie;
+// legacy oversized tokens are chunked for upgrade compatibility. Unused chunk
+// slots are cleared so stale legacy chunks cannot corrupt reassembly.
// Callers must pass the trusted secure flag from SecureCookieFromContext /
// SecureCookieFromRequest so the cookie name (__Host-token vs. token)
// round-trips correctly behind HTTPS reverse proxies.
diff --git a/backend/pkg/utils/cookie/cookie_util_test.go b/backend/pkg/utils/cookie/cookie_util_test.go
index 12427f8fd..6e647755e 100644
--- a/backend/pkg/utils/cookie/cookie_util_test.go
+++ b/backend/pkg/utils/cookie/cookie_util_test.go
@@ -33,9 +33,14 @@ func TestSecureCookieFromRequest(t *testing.T) {
func TestBuildTokenCookieStringFor(t *testing.T) {
t.Run("secure uses host-prefixed secure cookie", func(t *testing.T) {
headers := BuildTokenCookieStringFor(60, "abc", true)
+ headerBytes := 0
+ for _, header := range headers {
+ headerBytes += len("Set-Cookie: ") + len(header) + len("\r\n")
+ }
cookies := readSetCookieHeadersInternal(t, headers...)
require.Len(t, cookies, tokenCookieMaxChunks)
+ require.Less(t, headerBytes, 1024)
assert.Equal(t, TokenCookieName, cookies[0].Name)
assert.Equal(t, "abc", cookies[0].Value)
assert.True(t, cookies[0].Secure)
diff --git a/frontend/messages/en.json b/frontend/messages/en.json
index b634db30a..4a08149bf 100644
--- a/frontend/messages/en.json
+++ b/frontend/messages/en.json
@@ -372,6 +372,7 @@
"auth_tagline_line2": "Designed for everyone.",
"auth_login_problem_title": "Login Problem",
"auth_failed_title": "Authentication Failed",
+ "auth_proxy_login_error": "Arcane couldn't complete login through the reverse proxy. Check that Arcane is reachable and that the proxy allows the authentication headers, then try again.",
"auth_no_login_methods_title": "No Login Methods Configured",
"auth_no_login_methods_description": "There are currently no login methods enabled. Please contact an administrator.",
"auth_username_placeholder": "Enter your username or email",
diff --git a/frontend/src/lib/components/auth/mfa-challenge.svelte b/frontend/src/lib/components/auth/mfa-challenge.svelte
index 1b252af7a..4e4403d27 100644
--- a/frontend/src/lib/components/auth/mfa-challenge.svelte
+++ b/frontend/src/lib/components/auth/mfa-challenge.svelte
@@ -9,6 +9,7 @@
import * as InputGroup from '#lib/components/ui/input-group/index.js';
import { Label } from '#lib/components/ui/label/index.js';
import * as Alert from '#lib/components/ui/alert/index.js';
+ import { normalizeAuthenticationError } from '#lib/utils/auth';
let {
challenge,
@@ -39,7 +40,7 @@
await onComplete(response);
} catch (value) {
if (!isCancelledError(value)) {
- error = value instanceof Error ? value.message : m.auth_mfa_failed();
+ error = normalizeAuthenticationError(value, m.auth_mfa_failed()).message;
}
} finally {
busy = false;
@@ -56,7 +57,7 @@
const response = await passkeyService.finishRecovery(challenge.transactionId, recoveryCode.trim());
await onComplete(response);
} catch (value) {
- error = value instanceof Error ? value.message : m.auth_mfa_failed();
+ error = normalizeAuthenticationError(value, m.auth_mfa_failed()).message;
} finally {
busy = false;
}
diff --git a/frontend/src/lib/utils/auth.ts b/frontend/src/lib/utils/auth.ts
index 47cc8cbe8..18f1960b4 100644
--- a/frontend/src/lib/utils/auth.ts
+++ b/frontend/src/lib/utils/auth.ts
@@ -1,5 +1,7 @@
import userStore from '#lib/stores/user-store';
import { environmentStore } from '#lib/stores/environment.store.svelte';
+import { m } from '#lib/paraglide/messages';
+import { APIError } from '#lib/services/api-service';
import {
canReachAccessSurface,
getFallbackAccessSurfaces,
@@ -9,6 +11,34 @@ import {
import { GLOBAL_SCOPE, SUDO_PERMISSION } from '#lib/types/auth';
import type { PermissionsManifest, User } from '#lib/types/auth';
+export function normalizeAuthenticationError(error: unknown, fallback: string): { kind: 'proxy' | 'other'; message: string } {
+ if (error instanceof APIError) {
+ const responseData: unknown = error.response?.data;
+ const responseText = typeof responseData === 'string' ? responseData : '';
+ const lowerResponse = responseText.toLowerCase();
+ const isGatewayHTML =
+ error.status === 502 &&
+ (lowerResponse.includes('<html') || lowerResponse.includes('bad gateway') || lowerResponse.includes('openresty'));
+ const isHeaderLimit =
+ error.status === 431 ||
+ (error.status === 400 &&
+ (lowerResponse.includes('request header') || lowerResponse.includes('cookie')) &&
+ (lowerResponse.includes('large') || lowerResponse.includes('too big')));
+
+ if (isGatewayHTML || isHeaderLimit) {
+ return { kind: 'proxy', message: m.auth_proxy_login_error() };
+ }
+ if (responseText.trimStart().startsWith('<')) {
+ return { kind: 'other', message: fallback };
+ }
+ }
+
+ return {
+ kind: 'other',
+ message: error instanceof Error ? error.message : fallback
+ };
+}
+
// --- Store-backed permission checks (for .svelte / runtime) ---
function resolveEnvId(envId?: string): string | undefined {
diff --git a/frontend/src/routes/(auth)/login/+page.svelte b/frontend/src/routes/(auth)/login/+page.svelte
index 2f7a255fc..73b4bb89d 100644
--- a/frontend/src/routes/(auth)/login/+page.svelte
+++ b/frontend/src/routes/(auth)/login/+page.svelte
@@ -14,6 +14,7 @@
import { authService, MFARequiredError } from '#lib/services/auth-service';
import { passkeyService } from '#lib/services/passkey-service';
import type { AuthenticationResponse, MFAChallenge as MFAChallengeData } from '#lib/types/auth';
+ import { normalizeAuthenticationError } from '#lib/utils/auth';
import { getEffectiveLandingPage } from '#lib/utils/navigation';
import { queryKeys } from '#lib/query/query-keys';
import { getApplicationLogo } from '#lib/utils/docker';
@@ -75,7 +76,7 @@
error = null;
return;
}
- error = err instanceof Error ? err.message : m.auth_unexpected_error();
+ error = normalizeAuthenticationError(err, m.auth_unexpected_error()).message;
}
}));
@@ -102,7 +103,7 @@
error = m.auth_passkey_cancelled();
return;
}
- error = err instanceof Error ? err.message : m.auth_passkey_failed();
+ error = normalizeAuthenticationError(err, m.auth_passkey_failed()).message;
}
}));
diff --git a/frontend/src/routes/(auth)/oidc/callback/+page.svelte b/frontend/src/routes/(auth)/oidc/callback/+page.svelte
index 77d45ef01..e1175d50a 100644
--- a/frontend/src/routes/(auth)/oidc/callback/+page.svelte
+++ b/frontend/src/routes/(auth)/oidc/callback/+page.svelte
@@ -10,7 +10,7 @@
import { queryKeys } from '#lib/query/query-keys';
import { authService } from '#lib/services/auth-service';
import { environmentStore } from '#lib/stores/environment.store.svelte';
- import { getAuthRedirectPath } from '#lib/utils/auth';
+ import { getAuthRedirectPath, normalizeAuthenticationError } from '#lib/utils/auth';
import { getEffectiveLandingPage } from '#lib/utils/navigation';
import MFAChallenge from '#lib/components/auth/mfa-challenge.svelte';
import OidcStatusPanel from '#lib/components/oidc-status-panel.svelte';
@@ -167,12 +167,16 @@
redirectCode = String((err as CallbackFailure).code);
userMessage = String((err as CallbackFailure).userMessage);
} else {
+ const normalized = normalizeAuthenticationError(err, m.auth_oidc_callback_error());
const unknownError = err as { message?: string };
- if (unknownError?.message?.includes('network') || unknownError?.message?.includes('timeout')) {
+ if (normalized.kind === 'proxy') {
+ userMessage = normalized.message;
+ redirectCode = 'proxy_authentication_failed';
+ } else if (unknownError?.message?.includes('network') || unknownError?.message?.includes('timeout')) {
userMessage = String(m.auth_oidc_network_error());
redirectCode = 'oidc_network_error';
- } else if (unknownError?.message && !unknownError.message.includes('Request failed')) {
- userMessage = unknownError.message;
+ } else if (normalized.message && !normalized.message.includes('Request failed')) {
+ userMessage = normalized.message;
}
}
diff --git a/tests/spec/token-refresh.spec.ts b/tests/spec/token-refresh.spec.ts
index 0d733603a..1b92d2c76 100644
--- a/tests/spec/token-refresh.spec.ts
+++ b/tests/spec/token-refresh.spec.ts
@@ -108,15 +108,36 @@ test('signed-in OIDC callbacks reach the callback exchange', async ({ page }) =>
});
test.describe('Token refresh behaviour', () => {
- test('@cross-browser rejects invalid credentials and accepts the configured admin password', async ({
+ test('@cross-browser shows useful login errors and accepts the configured admin password', async ({
page
}) => {
await page.context().clearCookies();
+ let gatewayFailurePending = true;
+ await page.route(/\/api\/auth\/login$/, async (route) => {
+ if (!gatewayFailurePending) {
+ await route.continue();
+ return;
+ }
+ gatewayFailurePending = false;
+ await route.fulfill({
+ status: 502,
+ contentType: 'text/html',
+ body: '<html><head><title>502 Bad Gateway</title></head><body><center>openresty</center></body></html>'
+ });
+ });
await page.goto('/login');
await page.getByLabel('Username').fill('arcane');
await page.getByLabel('Password').fill('not-the-admin-password');
await page.getByRole('button', { name: 'Sign in to Arcane', exact: true }).click();
+ const proxyAlert = page
+ .getByRole('alert')
+ .filter({ hasText: "Arcane couldn't complete login through the reverse proxy" });
+ await expect(proxyAlert).toBeVisible();
+ await expect(proxyAlert).not.toContainText('openresty');
+
+ await page.getByLabel('Password').fill('not-the-admin-password');
+ await page.getByRole('button', { name: 'Sign in to Arcane', exact: true }).click();
await expect(
page.getByRole('alert').filter({ hasText: 'Invalid username or password' })
).toBeVisible();
@@ -128,6 +149,16 @@ test.describe('Token refresh behaviour', () => {
await expect(
page.locator('main').getByText('Dashboard', { exact: true }).first()
).toBeVisible();
+
+ const tokenCookies = (await page.context().cookies()).filter(
+ (cookie) =>
+ cookie.name === 'token' ||
+ cookie.name === '__Host-token' ||
+ cookie.name.startsWith('token.') ||
+ cookie.name.startsWith('__Host-token.')
+ );
+ expect(tokenCookies).toHaveLength(1);
+ expect(tokenCookies[0]?.value.length).toBeLessThan(1024);
});
test('version mismatch 401 on /auth/me during page load is silently recovered', async ({