Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package auth
import (
"bytes"
"context"
"crypto/mldsa"
"encoding/base64"
"encoding/json/v2"
"testing"
"time"
"github.com/getarcaneapp/arcane/types/v2/auth"
"github.com/lestrrat-go/jwx/v4/jwa"
"github.com/lestrrat-go/jwx/v4/jwt"
"github.com/libtnb/sqlite"
"github.com/samber/hot"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"gorm.io/gorm"
"github.com/getarcaneapp/arcane/backend/v2/internal/apikey"
"github.com/getarcaneapp/arcane/backend/v2/internal/common"
"github.com/getarcaneapp/arcane/backend/v2/internal/config"
"github.com/getarcaneapp/arcane/backend/v2/internal/database"
"github.com/getarcaneapp/arcane/backend/v2/internal/environment"
"github.com/getarcaneapp/arcane/backend/v2/internal/role"
"github.com/getarcaneapp/arcane/backend/v2/internal/session"
"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
"github.com/getarcaneapp/arcane/backend/v2/internal/user"
)
func setupAuthServiceTestDB(t *testing.T) *database.DB {
t.Helper()
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
require.NoError(t, err)
// Each pooled connection to a ":memory:" DSN gets its own empty database;
// keep a single connection so every query sees the migrated schema.
sqlDB, err := db.DB()
require.NoError(t, err)
sqlDB.SetMaxOpenConns(1)
require.NoError(t, db.AutoMigrate(
&settings.SettingVariable{},
&user.User{},
&session.UserSession{},
&environment.Environment{},
&role.Role{},
&role.UserRoleAssignment{},
&apikey.ApiKey{},
&role.ApiKeyPermission{},
&role.OidcRoleMapping{},
))
return &database.DB{DB: db}
}
func newSettingsServiceForAuthTest(t testing.TB, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
t.Helper()
svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
if err == nil {
t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
}
return svc, err
}
func newTestSigningKey() *mldsa.PrivateKey {
key, err := mldsa.GenerateKey(mldsa.MLDSA87())
if err != nil {
panic(err)
}
return key
}
func newTestAuthService() *AuthService {
return &AuthService{
signingKey: newTestSigningKey(),
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().
Build(),
}
}
func signLegacyToken(t testing.TB, key *mldsa.PrivateKey, claims map[string]any) string {
t.Helper()
header, err := json.Marshal(map[string]string{"alg": jwa.MLDSA87().String(), "typ": "JWT"})
require.NoError(t, err)
payload, err := json.Marshal(claims)
require.NoError(t, err)
signingInput := base64.RawURLEncoding.EncodeToString(header) + "." + base64.RawURLEncoding.EncodeToString(payload)
signature, err := key.Sign(nil, []byte(signingInput), nil)
require.NoError(t, err)
return signingInput + "." + base64.RawURLEncoding.EncodeToString(signature)
}
func signJWXToken(t testing.TB, key *mldsa.PrivateKey, claims map[string]any) string {
t.Helper()
payload, err := json.Marshal(claims)
require.NoError(t, err)
token, err := jwt.ParseInsecure(payload)
require.NoError(t, err)
signed, err := jwt.Sign(token, jwt.WithKey(jwa.MLDSA87(), key))
require.NoError(t, err)
return string(signed)
}
func signUnsignedToken(t testing.TB, claims map[string]any) string {
t.Helper()
payload, err := json.Marshal(claims)
require.NoError(t, err)
token, err := jwt.ParseInsecure(payload)
require.NoError(t, err)
signed, err := jwt.Sign(token, jwt.WithInsecureNoSignature())
require.NoError(t, err)
return string(signed)
}
func makeAccessToken(t *testing.T, key *mldsa.PrivateKey, subject, id, username string, _ []string, email, displayName string, exp time.Time, sessionIDs ...string) string {
t.Helper()
sessionID := ""
if len(sessionIDs) > 0 {
sessionID = sessionIDs[0]
}
claims := map[string]any{
"jti": id,
"sub": subject,
"iat": time.Now().Unix(),
"exp": exp.Unix(),
"sid": sessionID,
"user_id": id,
"username": username,
"email": email,
"display_name": displayName,
"app_version": config.Version,
}
return signLegacyToken(t, key, claims)
}
func makeRefreshToken(t *testing.T, key *mldsa.PrivateKey, id string, exp time.Time, userIDAndSessionID ...string) string {
t.Helper()
userID := id
sessionID := ""
if len(userIDAndSessionID) > 0 {
userID = userIDAndSessionID[0]
}
if len(userIDAndSessionID) > 1 {
sessionID = userIDAndSessionID[1]
}
claims := map[string]any{
"jti": id,
"sub": "refresh",
"iat": time.Now().Unix(),
"exp": exp.Unix(),
"user_id": userID,
"sid": sessionID,
"app_version": config.Version,
}
return signLegacyToken(t, key, claims)
}
func createTestSession(t *testing.T, db *database.DB, userID string, expiresAt time.Time) (*session.UserSession, string) {
t.Helper()
sessionSvc := session.NewSessionService(db)
localSession, refreshJTI, err := sessionSvc.CreateSession(t.Context(), userID, expiresAt, auth.SessionMeta{
UserAgent: "test-agent",
IPAddress: "127.0.0.1",
})
require.NoError(t, err)
return localSession, refreshJTI
}
func TestVerifyToken_ValidClaims(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
// Create user in DB
localUser := &user.User{
ID: "u123",
Username: "alice",
Email: new("[email protected]"),
DisplayName: new("Alice"),
}
_, err := userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, _ := createTestSession(t, db, "u123", exp)
token := makeAccessToken(t, s.signingKey, "access", "u123", "alice", []string{"user", "admin"}, "[email protected]", "Alice", exp, localSession.ID)
verifiedUser, _, err := s.VerifyToken(t.Context(), token)
require.NoError(t, err,
"VerifyToken error: %v", err)
assert.Equal(t, "u123", verifiedUser.ID,
"id %q", verifiedUser.ID)
assert.Equal(t, "alice", verifiedUser.Username,
"username %q", verifiedUser.Username)
assert.False(t, verifiedUser.Email == nil || *verifiedUser.Email != "[email protected]",
"email %v", verifiedUser.Email)
assert.False(t, verifiedUser.DisplayName == nil || *verifiedUser.DisplayName != "Alice",
"displayName %v", verifiedUser.DisplayName)
}
func TestVerifyToken_RejectsNonMLDSAAlg(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
payload, err := json.Marshal(map[string]any{
"jti": "u1",
"sub": "access",
"iat": time.Now().Unix(),
"exp": exp.Unix(),
"user_id": "u1",
"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(t.Context(), string(token))
assert.ErrorIs(t, err, common.ErrInvalidToken,
"want common.ErrInvalidToken, got %v", err)
}
func TestVerifyToken_Expired(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
// Create user in DB
localUser := &user.User{
ID: "u1",
Username: "bob",
}
_, err := userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(-1 * time.Minute)
token := makeAccessToken(t, s.signingKey, "access", "u1", "bob", []string{"user"}, "", "", exp)
_, _, err = s.VerifyToken(t.Context(), token)
assert.ErrorIs(t, err, common.ErrExpiredToken,
"want ErrExpiredToken, got %v", err)
}
func TestVerifyToken_InvalidSubject(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
token := makeAccessToken(t, s.signingKey, "refresh", "u1", "bob", []string{"user"}, "", "", exp)
_, _, err := s.VerifyToken(t.Context(), token)
require.ErrorIs(t, err, common.ErrTokenValidation)
}
func TestVerifyToken_InvalidSignature(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
otherKey := newTestSigningKey()
token := makeAccessToken(t, otherKey, "access", "u1", "bob", []string{"user"}, "", "", exp)
_, _, err := s.VerifyToken(t.Context(), token)
assert.ErrorIs(t, err, common.ErrInvalidToken,
"want common.ErrInvalidToken, got %v", err)
}
func TestVerifyToken_MissingUserID(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
token := makeAccessToken(t, s.signingKey, "access", "", "bob", []string{"user"}, "", "", exp)
_, _, err := s.VerifyToken(t.Context(), token)
require.ErrorIs(t, err, common.ErrTokenValidation)
}
func TestGenerateUsernameFromEmail(t *testing.T) {
u := generateUsernameFromEmail("[email protected]", "sub-abcdef01")
assert.Equal(t, "john.doe", u,
"username %q", u)
u2 := generateUsernameFromEmail("", "1234567890abcdef")
assert.Equal(t, "user_90abcdef", u2,
"fallback username %q", u2)
u3 := generateUsernameFromEmail("", "short")
assert.Equal(t, "user_short", u3,
"short subject username %q", u3)
}
func TestUniqueOidcUsername(t *testing.T) {
u := uniqueOidcUsername("alice", "1234567890abcdef")
assert.Equal(t, "alice_90abcdef", u,
"suffixed username %q", u)
u2 := uniqueOidcUsername("alice", "short")
assert.Equal(t, "alice_short", u2,
"short subject username %q", u2)
}
func TestPersistOidcTokens_SetsFields(t *testing.T) {
s := newTestAuthService()
localUser := &user.User{}
start := time.Now()
resp := &auth.OidcTokenResponse{
AccessToken: "at-123",
RefreshToken: "rt-456",
ExpiresIn: 7,
IDToken: "",
}
s.persistOidcTokens(localUser, resp)
assert.False(t, localUser.OidcAccessToken == nil || *localUser.OidcAccessToken != "at-123",
"access token %v", localUser.OidcAccessToken)
assert.False(t, localUser.OidcRefreshToken == nil || *localUser.OidcRefreshToken != "rt-456",
"refresh token %v", localUser.OidcRefreshToken)
assert.NotNil(t, localUser.OidcAccessTokenExpiresAt,
"expiresAt nil")
// Check approx expiry within [start+7s, start+12s] to allow CI slop
earliest := start.Add(7 * time.Second)
latest := start.Add(12 * time.Second)
assert.False(t, localUser.OidcAccessTokenExpiresAt.Before(earliest) || localUser.OidcAccessTokenExpiresAt.After(latest),
"expiresAt %v not in [%v,%v]", localUser.OidcAccessTokenExpiresAt, earliest, latest)
}
func TestVerifyToken_VersionMismatch(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
oldVersion := config.Version
config.Version = "1.0.0"
token := makeAccessToken(t, s.signingKey, "access", "u1", "bob", []string{"user"}, "", "", exp, "session-version-mismatch")
config.Version = "2.0.0"
_, _, err := s.VerifyToken(t.Context(), token)
assert.ErrorIs(t, err, common.ErrTokenVersionMismatch,
"want ErrTokenVersionMismatch, got %v", err)
config.Version = oldVersion
}
func TestRefreshToken_Valid(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s := newTestAuthService()
s.userService = userSvc
s.settingsService = settingsSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-refresh",
Username: "refresh-user",
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, refreshJTI := createTestSession(t, db, "u-refresh", exp)
token := makeRefreshToken(t, s.signingKey, refreshJTI, exp, "u-refresh", localSession.ID)
tokenPair, err := s.RefreshToken(t.Context(), token, auth.SessionMeta{})
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 := signedTokenAlgorithm(tokenPair.AccessToken)
require.True(t, ok)
require.Equal(t, jwa.MLDSA87().String(), accessAlgorithm)
browserAlgorithm, ok := signedTokenAlgorithm(tokenPair.BrowserToken)
require.True(t, ok)
require.Equal(t, jwa.HS512().String(), browserAlgorithm)
refreshAlgorithm, ok := signedTokenAlgorithm(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
// and the newly issued tokens must carry the current config.Version. This is what keeps
// users logged in across backend releases — see plans/how-can-we-make-compiled-quilt.md.
func TestRefreshToken_VersionMismatchRotates(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s := newTestAuthService()
s.userService = userSvc
s.settingsService = settingsSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-versionmismatch",
Username: "versionmismatch-user",
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, refreshJTI := createTestSession(t, db, localUser.ID, exp)
oldVersion := config.Version
t.Cleanup(func() { config.Version = oldVersion })
config.Version = "1.0.0"
token := makeRefreshToken(t, s.signingKey, refreshJTI, exp, localUser.ID, localSession.ID)
config.Version = "2.0.0"
tokenPair, err := s.RefreshToken(t.Context(), token, auth.SessionMeta{})
require.NoError(t, err)
require.NotNil(t, tokenPair)
require.NotEmpty(t, tokenPair.AccessToken)
require.NotEmpty(t, tokenPair.RefreshToken)
parsedAccess, err := jwt.ParseString(tokenPair.AccessToken, jwt.WithKey(jwa.MLDSA87(), s.signingKey.PublicKey()))
require.NoError(t, err)
accessVersion, err := jwt.Get[string](parsedAccess, claimAppVersion)
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, localSession.ID, browserSessionID)
browserUserID, err := jwt.Get[string](parsedBrowser, claimUserID)
require.NoError(t, err)
require.Equal(t, localUser.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)
require.NoError(t, err)
require.Equal(t, "2.0.0", refreshVersion)
}
func TestVerifyToken_RejectsRevokedSession(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-revoked",
Username: "revoked-user",
}
_, err := userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, _ := createTestSession(t, db, localUser.ID, exp)
token := makeAccessToken(t, s.signingKey, "access", localUser.ID, localUser.Username, []string{"user"}, "", "", exp, localSession.ID)
browser, err := jwt.NewBuilder().
JwtID("revoked-browser-token").
Subject(browserTokenSubject).
IssuedAt(time.Now()).
Expiration(exp).
Claim(claimSessionID, localSession.ID).
Claim(claimUserID, localUser.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(t.Context(), localSession.ID))
_, _, err = s.VerifyToken(t.Context(), token)
require.ErrorIs(t, err, common.ErrSessionRevoked)
_, _, err = s.VerifyBrowserToken(t.Context(), string(browserToken))
require.ErrorIs(t, err, common.ErrSessionRevoked)
}
func TestVerifyToken_RejectsMissingSessionID(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-no-sid",
Username: "no-sid-user",
}
_, err := userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
token := makeAccessToken(t, s.signingKey, "access", localUser.ID, localUser.Username, []string{"user"}, "", "", time.Now().Add(5*time.Minute))
_, _, err = s.VerifyToken(t.Context(), token)
require.ErrorIs(t, err, common.ErrTokenValidation)
}
func TestRevokeSessionThenVerifyTokenFails(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-logout",
Username: "logout-user",
}
_, err := userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, _ := createTestSession(t, db, localUser.ID, exp)
token := makeAccessToken(t, s.signingKey, "access", localUser.ID, localUser.Username, []string{"user"}, "", "", exp, localSession.ID)
require.NoError(t, s.RevokeSession(t.Context(), localSession.ID))
_, _, err = s.VerifyToken(t.Context(), token)
require.ErrorIs(t, err, common.ErrSessionRevoked)
}
func TestVerifyToken_RejectsRevokedCachedSession(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-cached-revoked",
Username: "cached-revoked-user",
}
_, err := userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
sessionRecord, _ := createTestSession(t, db, localUser.ID, exp)
token := makeAccessToken(t, s.signingKey, "access", localUser.ID, localUser.Username, []string{"user"}, "", "", exp, sessionRecord.ID)
_, _, err = s.VerifyToken(t.Context(), token)
require.NoError(t, err)
require.NoError(t, s.RevokeSession(t.Context(), sessionRecord.ID))
_, _, err = s.VerifyToken(t.Context(), token)
require.ErrorIs(t, err, common.ErrSessionRevoked, "expected cached access token to be rejected after revocation, got %v", err)
}
func TestRefreshToken_RotatesJTI(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s := newTestAuthService()
s.userService = userSvc
s.settingsService = settingsSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-rotate",
Username: "rotate-user",
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, refreshJTI := createTestSession(t, db, localUser.ID, exp)
token := makeRefreshToken(t, s.signingKey, refreshJTI, exp, localUser.ID, localSession.ID)
tokenPair, err := s.RefreshToken(t.Context(), token, auth.SessionMeta{})
require.NoError(t, err)
require.NotEmpty(t, tokenPair.RefreshToken)
_, err = s.RefreshToken(t.Context(), token, auth.SessionMeta{})
require.ErrorIs(t, err, common.ErrInvalidToken)
}
func TestRefreshToken_AcceptsBrowserRefreshToken(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s := newTestAuthService()
s.userService = userSvc
s.settingsService = settingsSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-browser-refresh",
Username: "browser-refresh-user",
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, refreshJTI := createTestSession(t, db, localUser.ID, exp)
first, err := s.RefreshToken(t.Context(), makeRefreshToken(t, s.signingKey, refreshJTI, exp, localUser.ID, localSession.ID), auth.SessionMeta{})
require.NoError(t, err)
require.NotEmpty(t, first.BrowserRefresh)
require.Less(t, len(first.BrowserRefresh), 4096)
require.WithinDuration(t, exp, first.RefreshExpiresAt, time.Second)
second, err := s.RefreshToken(t.Context(), first.BrowserRefresh, auth.SessionMeta{})
require.NoError(t, err)
_, err = s.RefreshToken(t.Context(), first.RefreshToken, auth.SessionMeta{})
require.ErrorIs(t, err, common.ErrInvalidToken)
_, err = s.RefreshToken(t.Context(), first.BrowserRefresh, auth.SessionMeta{})
require.ErrorIs(t, err, common.ErrInvalidToken)
require.NoError(t, s.RevokeSessionByRefreshToken(t.Context(), second.BrowserRefresh))
_, err = s.RefreshToken(t.Context(), second.BrowserRefresh, auth.SessionMeta{})
require.ErrorIs(t, err, common.ErrSessionRevoked)
}
func TestRefreshToken_RejectsRevokedSession(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s := newTestAuthService()
s.userService = userSvc
s.settingsService = settingsSvc
s.sessionService = session.NewSessionService(db)
localUser := &user.User{
ID: "u-refresh-revoked",
Username: "refresh-revoked-user",
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
exp := time.Now().Add(5 * time.Minute)
localSession, refreshJTI := createTestSession(t, db, localUser.ID, exp)
require.NoError(t, s.RevokeSession(t.Context(), localSession.ID))
token := makeRefreshToken(t, s.signingKey, refreshJTI, exp, localUser.ID, localSession.ID)
_, err = s.RefreshToken(t.Context(), token, auth.SessionMeta{})
require.ErrorIs(t, err, common.ErrSessionRevoked)
}
func TestChangePassword_RevokesAllSessions(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
passwordHash, err := userSvc.HashPassword(t.Context(), "old-password")
require.NoError(t, err)
localUser := &user.User{
ID: "u-password",
Username: "password-user",
PasswordHash: passwordHash,
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
sessionA, _ := createTestSession(t, db, localUser.ID, time.Now().Add(time.Hour))
sessionB, _ := createTestSession(t, db, localUser.ID, time.Now().Add(time.Hour))
require.NoError(t, s.ChangePassword(t.Context(), localUser.ID, "old-password", "New-password1!", ""))
sessionA, err = s.sessionService.GetSessionByID(t.Context(), sessionA.ID)
require.NoError(t, err)
sessionB, err = s.sessionService.GetSessionByID(t.Context(), sessionB.ID)
require.NoError(t, err)
require.NotNil(t, sessionA.RevokedAt)
require.NotNil(t, sessionB.RevokedAt)
}
func TestChangePassword_KeepsCurrentSessionAlive(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
s := newTestAuthService()
s.userService = userSvc
s.sessionService = session.NewSessionService(db)
passwordHash, err := userSvc.HashPassword(t.Context(), "old-password")
require.NoError(t, err)
localUser := &user.User{
ID: "u-keep",
Username: "keep-user",
PasswordHash: passwordHash,
}
_, err = userSvc.CreateUser(t.Context(), localUser)
require.NoError(t, err)
current, _ := createTestSession(t, db, localUser.ID, time.Now().Add(time.Hour))
other, _ := createTestSession(t, db, localUser.ID, time.Now().Add(time.Hour))
require.NoError(t, s.ChangePassword(t.Context(), localUser.ID, "old-password", "New-password1!", current.ID))
current, err = s.sessionService.GetSessionByID(t.Context(), current.ID)
require.NoError(t, err)
other, err = s.sessionService.GetSessionByID(t.Context(), other.ID)
require.NoError(t, err)
require.Nil(t, current.RevokedAt, "current session should remain active")
require.NotNil(t, other.RevokedAt, "other sessions should be revoked")
}
func TestRefreshToken_RejectsNonHMACAlg(t *testing.T) {
s := newTestAuthService()
exp := time.Now().Add(5 * time.Minute)
token := signUnsignedToken(t, map[string]any{
"jti": "u1",
"sub": "refresh",
"iat": time.Now().Unix(),
"exp": exp.Unix(),
})
_, err := s.RefreshToken(t.Context(), token, auth.SessionMeta{})
assert.ErrorIs(t, err, common.ErrInvalidToken,
"want common.ErrInvalidToken, got %v", err)
}
func TestGetOidcConfigurationStatus(t *testing.T) {
db := setupAuthServiceTestDB(t)
// Disabled
s := newTestAuthService()
s.config = &config.Config{}
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s.settingsService = settingsSvc
status, err := s.GetOidcConfigurationStatus(t.Context())
require.NoError(t, err,
"GetOidcConfigurationStatus error: %v", err)
assert.False(t, status.EnvForced || status.EnvConfigured,
"expected disabled, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)
// MergeAccounts will be false since GetSettings will fail
assert.False(t, status.MergeAccounts,
"expected mergeAccounts=false, got true")
// Explicit env override to false should still be treated as forced
t.Setenv("OIDC_ENABLED", "false")
settingsSvc, err = newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s.settingsService = settingsSvc
s.config.OidcEnabled = false
status, err = s.GetOidcConfigurationStatus(t.Context())
require.NoError(t, err,
"GetOidcConfigurationStatus error: %v", err)
assert.False(t, !status.EnvForced || status.EnvConfigured,
"expected forced=false-override and not configured, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)
// Enabled but missing fields
t.Setenv("OIDC_ENABLED", "true")
settingsSvc, err = newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s.settingsService = settingsSvc
s.config.OidcEnabled = true
status, err = s.GetOidcConfigurationStatus(t.Context())
require.NoError(t, err,
"GetOidcConfigurationStatus error: %v", err)
assert.False(t, !status.EnvForced || status.EnvConfigured,
"expected enabled but not configured, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)
// Enabled and configured
s.config.OidcClientID = "client-id"
s.config.OidcIssuerURL = "https://example.com"
status, err = s.GetOidcConfigurationStatus(t.Context())
require.NoError(t, err,
"GetOidcConfigurationStatus error: %v", err)
assert.False(t, !status.EnvForced || !status.EnvConfigured,
"expected enabled and configured, got forced=%v configured=%v", status.EnvForced, status.EnvConfigured)
}
func TestFindOrCreateOidcUser_MergeEnabled_EmailNotVerified_NoExistingUser_CreatesNewUser(t *testing.T) {
ctx := t.Context()
db := setupAuthServiceTestDB(t)
settingsSvc, err := newSettingsServiceForAuthTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsSvc.EnsureDefaultSettings(ctx))
require.NoError(t, settingsSvc.SetBoolSetting(ctx, "oidcMergeAccounts", true))
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
authSvc := newTestAuthService()
authSvc.userService = userSvc
authSvc.settingsService = settingsSvc
existing, err := userSvc.CreateUser(ctx, &user.User{
ID: "existing-canonical-identity", Username: "José", Email: new("né[email protected]"),
})
require.NoError(t, err)
userInfo := auth.OidcUserInfo{
Subject: "sub-123",
Email: " ne\u0301[email protected] ",
PreferredUsername: " Jose\u0301 ",
Name: " Jose\u0301 ",
EmailVerified: false, // provider omitted/false
}
created, isNew, err := authSvc.findOrCreateOidcUser(ctx, userInfo, &auth.OidcTokenResponse{AccessToken: "at"})
require.NoError(t, err)
require.True(t, isNew)
require.NotEqual(t, existing.ID, created.ID)
require.NotNil(t, created)
require.NotNil(t, created.OidcSubjectId)
require.Equal(t, userInfo.Subject, *created.OidcSubjectId)
require.NotNil(t, created.Email)
require.Equal(t, userInfo.Email, *created.Email)
require.Equal(t, "Jose\u0301", created.Username)
require.Equal(t, "José", *created.DisplayName)
require.NotEmpty(t, created.Username)
// Ensure the user actually persisted
fetched, err := userSvc.GetUserByOidcSubjectId(ctx, userInfo.Subject)
require.NoError(t, err)
require.Equal(t, created.ID, fetched.ID)
otherInfo := userInfo
otherInfo.Subject = "another-subject"
otherInfo.Email = "[email protected]"
other, isNew, err := authSvc.findOrCreateOidcUser(ctx, otherInfo, &auth.OidcTokenResponse{AccessToken: "other-token"})
require.NoError(t, err)
require.True(t, isNew)
require.NotEqual(t, created.ID, other.ID)
require.NotEqual(t, created.Username, other.Username)
}
func TestFindOrCreateOidcUser_MergeEnabled_WithExistingUser(t *testing.T) {
tests := []struct {
name string
emailVerified bool
extra map[string]any
wantMerge bool
}{
{name: "verified email merges", emailVerified: true, extra: map[string]any{"email_verified": true}, wantMerge: true},
{name: "explicit false rejected", extra: map[string]any{"email_verified": false}},
{name: "missing claim with nil extra rejected"},
{name: "missing claim with empty extra rejected", extra: map[string]any{}},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
ctx := t.Context()
db := setupAuthServiceTestDB(t)
settingsSvc, err := newSettingsServiceForAuthTest(t, ctx, db)
require.NoError(t, err)
require.NoError(t, settingsSvc.EnsureDefaultSettings(ctx))
require.NoError(t, settingsSvc.SetBoolSetting(ctx, "oidcMergeAccounts", true))
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
email := "[email protected]"
existing := &user.User{ID: "u1", Username: "existing", Email: &email}
_, err = userSvc.CreateUser(ctx, existing)
require.NoError(t, err)
authSvc := newTestAuthService()
authSvc.userService = userSvc
authSvc.settingsService = settingsSvc
userInfo := auth.OidcUserInfo{
Subject: "sub-merge",
Email: email,
Name: "OIDC Name",
EmailVerified: tc.emailVerified,
Extra: tc.extra,
}
got, isNew, err := authSvc.findOrCreateOidcUser(ctx, userInfo, &auth.OidcTokenResponse{AccessToken: "at", RefreshToken: "rt", ExpiresIn: 60})
fetched, fetchErr := userSvc.GetUserByID(ctx, existing.ID)
require.NoError(t, fetchErr)
if tc.wantMerge {
require.NoError(t, err)
require.False(t, isNew)
require.Equal(t, existing.ID, got.ID)
require.NotNil(t, fetched.OidcSubjectId)
require.Equal(t, userInfo.Subject, *fetched.OidcSubjectId)
require.NotNil(t, fetched.OidcAccessToken)
require.Equal(t, "at", *fetched.OidcAccessToken)
return
}
require.EqualError(t, err, "email not verified by OIDC provider; cannot merge accounts")
require.Nil(t, got)
require.False(t, isNew)
var userCount int64
require.NoError(t, db.Model(&user.User{}).Count(&userCount).Error)
require.Equal(t, int64(1), userCount, "no separate account should be created")
var roleAssignments int64
require.NoError(t, db.Model(&role.UserRoleAssignment{}).Where("user_id = ?", existing.ID).Count(&roleAssignments).Error)
require.Zero(t, roleAssignments)
require.True(t, fetched.OidcSubjectId == nil || *fetched.OidcSubjectId == "")
require.Nil(t, fetched.OidcAccessToken)
require.Nil(t, fetched.OidcRefreshToken)
require.Nil(t, fetched.OidcAccessTokenExpiresAt)
require.Nil(t, fetched.DisplayName)
require.Nil(t, fetched.LastLogin)
})
}
}
func TestAuthenticateLocalPrimary_EmailFallback(t *testing.T) {
db := setupAuthServiceTestDB(t)
userSvc := user.NewUserService(db, nil, session.RevokeAllUserSessionsExceptInDB)
settingsSvc, err := newSettingsServiceForAuthTest(t, t.Context(), db)
require.NoError(t, err)
s := newTestAuthService()
s.userService = userSvc
s.settingsService = settingsSvc
hash, err := userSvc.HashPassword(t.Context(), "hunter22!")
require.NoError(t, err)
dupHash, err := userSvc.HashPassword(t.Context(), "dup-two-pass!")
require.NoError(t, err)
for _, u := range []*user.User{
{ID: "u-email-login", Username: "bob", Email: new("[email protected]"), PasswordHash: hash},
{ID: "u-unicode", Username: "José", Email: new("josé@example.com"), PasswordHash: hash},
{ID: "u-decomposed", Username: "Jose\u0301", Email: new("jose\u0301@example.com"), PasswordHash: hash},
{ID: "u-dup-1", Username: "dup1", Email: new("[email protected]"), PasswordHash: hash},
{ID: "u-carol", Username: "[email protected]", Email: new("[email protected]"), PasswordHash: hash},
{ID: "u-col-a", Username: "[email protected]", PasswordHash: hash},
{ID: "u-col-b", Username: "colb", Email: new("[email protected]"), PasswordHash: dupHash},
} {
_, err = userSvc.CreateUser(t.Context(), u)
require.NoError(t, err)
}
require.NoError(t, db.Create(&user.User{ID: "u-dup-2", Username: "dup2", Email: new("[email protected]"), PasswordHash: dupHash}).Error)
require.NoError(t, db.Create(&user.User{
ID: "u-legacy-spaces", Username: " Jose\u0301 ", Email: new(" [email protected] "), PasswordHash: hash,
}).Error)
tests := []struct {
name string
login string
password string
wantID string
wantErr error
}{
{name: "composed username", login: "José", password: "hunter22!", wantID: "u-unicode"},
{name: "decomposed username stays distinct", login: "Jose\u0301", password: "hunter22!", wantID: "u-decomposed"},
{name: "composed email", login: "josé@example.com", password: "hunter22!", wantID: "u-unicode"},
{name: "decomposed email stays distinct", login: "jose\u0301@example.com", password: "hunter22!", wantID: "u-decomposed"},
{name: "legacy username whitespace", login: " Jose\u0301 ", password: "hunter22!", wantID: "u-legacy-spaces"},
{name: "legacy email whitespace", login: " [email protected] ", password: "hunter22!", wantID: "u-legacy-spaces"},
{name: "username whitespace is not a new alias", login: " José ", password: "hunter22!", wantErr: ErrInvalidCredentials},
{name: "email whitespace is not a new alias", login: " josé@example.com ", password: "hunter22!", wantErr: ErrInvalidCredentials},
{name: "password not trimmed", login: "José", password: " hunter22! ", wantErr: ErrInvalidCredentials},
{name: "email resolves user", login: "[email protected]", password: "hunter22!", wantID: "u-email-login"},
{name: "unknown email", login: "[email protected]", password: "hunter22!", wantErr: ErrInvalidCredentials},
{name: "duplicate email rejected", login: "[email protected]", password: "dup-two-pass!", wantErr: ErrInvalidCredentials},
{name: "username equal to own email", login: "[email protected]", password: "hunter22!", wantID: "u-carol"},
{name: "username-email collision rejected", login: "[email protected]", password: "dup-two-pass!", wantErr: ErrInvalidCredentials},
}
for _, tc := range tests {
t.Run(tc.name, func(t *testing.T) {
got, authenticateLocalPrimaryErr := s.AuthenticateLocalPrimary(t.Context(), tc.login, tc.password)
if tc.wantErr != nil {
require.ErrorIs(t, authenticateLocalPrimaryErr, tc.wantErr)
return
}
require.NoError(t, authenticateLocalPrimaryErr)
require.Equal(t, tc.wantID, got.ID)
})
}
}