Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
refactor: use coreos/go-oidc library for oidc auth
Kyle Mendell80317bbf9301
diff --git a/backend/.air.toml b/backend/.air.tomlindex 15c6544e5..3fac86c47 100644--- a/backend/.air.toml+++ b/backend/.air.toml@@ -3,7 +3,7 @@ tmp_dir = ".bin"[build]bin = "./.bin/arcane"- cmd = "CGO_ENABLED=0 go build -tags 'exclude_frontend playwright' -o ./.bin/arcane ./cmd"+ cmd = "CGO_ENABLED=1 go build -tags 'exclude_frontend playwright' -o ./.bin/arcane ./cmd"exclude_dir = [".bin", "data"]stop_on_error = truedelay = 1000diff --git a/backend/go.mod b/backend/go.modindex bb2ac16ec..58171e64f 100644--- a/backend/go.mod+++ b/backend/go.mod@@ -5,6 +5,7 @@ go 1.25.0require (github.com/cenkalti/backoff/v5 v5.0.3github.com/compose-spec/compose-go/v2 v2.9.0+ github.com/coreos/go-oidc/v3 v3.15.0github.com/distribution/reference v0.6.0github.com/docker/cli v28.4.0+incompatiblegithub.com/docker/compose/v2 v2.39.4@@ -29,6 +30,7 @@ require (github.com/shirou/gopsutil/v3 v3.24.5github.com/stretchr/testify v1.11.1golang.org/x/crypto v0.42.0+ golang.org/x/oauth2 v0.31.0golang.org/x/sync v0.17.0gorm.io/driver/postgres v1.6.0gorm.io/gorm v1.31.0@@ -90,6 +92,7 @@ require (github.com/gabriel-vasile/mimetype v1.4.10 // indirectgithub.com/gin-contrib/sse v1.1.0 // indirectgithub.com/glebarez/go-sqlite v1.22.0 // indirect+ github.com/go-jose/go-jose/v4 v4.1.1 // indirectgithub.com/go-logr/logr v1.4.3 // indirectgithub.com/go-logr/stdr v1.2.2 // indirectgithub.com/go-ole/go-ole v1.3.0 // indirect@@ -236,7 +239,6 @@ require (golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirectgolang.org/x/mod v0.28.0 // indirectgolang.org/x/net v0.44.0 // indirect- golang.org/x/oauth2 v0.31.0 // indirectgolang.org/x/sys v0.36.0 // indirectgolang.org/x/term v0.35.0 // indirectgolang.org/x/text v0.29.0 // indirectdiff --git a/backend/go.sum b/backend/go.sumindex 85123b96a..4f6814544 100644--- a/backend/go.sum+++ b/backend/go.sum@@ -119,6 +119,8 @@ github.com/containerd/ttrpc v1.2.7 h1:qIrroQvuOL9HQ1X6KHe2ohc7p+HP/0VE6XPU7elJRqgithub.com/containerd/ttrpc v1.2.7/go.mod h1:YCXHsb32f+Sq5/72xHubdiJRQY9inL4a4ZQrAbN1q9o=github.com/containerd/typeurl/v2 v2.2.3 h1:yNA/94zxWdvYACdYO8zofhrTVuQY73fFU1y++dYSw40=github.com/containerd/typeurl/v2 v2.2.3/go.mod h1:95ljDnPfD3bAbDJRugOiShd/DlAAsxGtUBhJxIn7SCk=+github.com/coreos/go-oidc/v3 v3.15.0 h1:R6Oz8Z4bqWR7VFQ+sPSvZPQv4x8M+sJkDO5ojgwlyAg=+github.com/coreos/go-oidc/v3 v3.15.0/go.mod h1:HaZ3szPaZ0e4r6ebqvsLWlk2Tn+aejfmrfah6hnSYEU=github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=github.com/creack/pty v1.1.17/go.mod h1:MOBLtS5ELjhRRrroQr9kyvTxUAFNvYEK993ew/Vr4O4=@@ -195,6 +197,8 @@ github.com/glebarez/sqlite v1.11.0 h1:wSG0irqzP6VurnMEpFGer5Li19RpIRi2qvQz++w0GMgithub.com/glebarez/sqlite v1.11.0/go.mod h1:h8/o8j5wiAsqSPoWELDUdJXhjAhsVliSn7bWZjOhrgQ=github.com/go-co-op/gocron/v2 v2.16.6 h1:zI2Ya9sqvuLcgqJgV79LwoJXM8h20Z/drtB7ATbpRWo=github.com/go-co-op/gocron/v2 v2.16.6/go.mod h1:zAfC/GFQ668qHxOVl/D68Jh5Ce7sDqX6TJnSQyRkRBc=+github.com/go-jose/go-jose/v4 v4.1.1 h1:JYhSgy4mXXzAdF3nUx3ygx347LRXJRrpgyU3adRmkAI=+github.com/go-jose/go-jose/v4 v4.1.1/go.mod h1:BdsZGqgdO3b6tTc6LSE56wcDbMMLuPsw5d4ZD5f94kA=github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.goindex 975ee06ee..bb5319765 100644--- a/backend/internal/services/oidc_service.go+++ b/backend/internal/services/oidc_service.go@@ -12,6 +12,11 @@ import ("strings""time"+ "log/slog"++ "github.com/coreos/go-oidc/v3/oidc"+ "golang.org/x/oauth2"+"github.com/ofkm/arcane-backend/internal/config""github.com/ofkm/arcane-backend/internal/dto""github.com/ofkm/arcane-backend/internal/models"@@ -42,107 +47,53 @@ func NewOidcService(authService *AuthService, cfg *config.Config, httpClient *ht}}-func (s *OidcService) discoverOidcEndpoints(ctx context.Context, issuerURL string) (*dto.OidcDiscoveryDocument, error) {- wellKnownURL := strings.TrimSuffix(issuerURL, "/") + "/.well-known/openid-configuration"-- req, err := http.NewRequestWithContext(ctx, http.MethodGet, wellKnownURL, nil)- if err != nil {- return nil, fmt.Errorf("failed to create discovery request: %w", err)- }-- req.Header.Set("Accept", "application/json")- req.Header.Set("User-Agent", "Arcane-OIDC-Client/1.0")-- resp, err := s.httpClient.Do(req)- if err != nil {- return nil, fmt.Errorf("failed to fetch OIDC discovery document from %s: %w", wellKnownURL, err)- }- defer resp.Body.Close()-- bodyBytes, err := io.ReadAll(resp.Body)- if err != nil {- return nil, fmt.Errorf("failed to read discovery response body: %w", err)- }-- if resp.StatusCode != http.StatusOK {- return nil, fmt.Errorf("OIDC discovery endpoint %s returned %d: %s",- wellKnownURL, resp.StatusCode, string(bodyBytes))- }-- contentType := resp.Header.Get("Content-Type")- if !strings.Contains(contentType, "application/json") {- return nil, fmt.Errorf("OIDC discovery endpoint returned non-JSON content-type: %s, body: %s",- contentType, string(bodyBytes[:min(500, len(bodyBytes))]))- }-- var discovery dto.OidcDiscoveryDocument- if err := json.Unmarshal(bodyBytes, &discovery); err != nil {- return nil, fmt.Errorf("failed to decode discovery document from %s: %w. Response body: %s",- wellKnownURL, err, string(bodyBytes[:min(500, len(bodyBytes))]))- }-- if discovery.AuthorizationEndpoint == "" || discovery.TokenEndpoint == "" {- return nil, fmt.Errorf("discovery document missing required endpoints. Auth: %s, Token: %s",- discovery.AuthorizationEndpoint, discovery.TokenEndpoint)- }-- return &discovery, nil-}-func (s *OidcService) getEffectiveConfig(ctx context.Context) (*models.OidcConfig, error) {config, err := s.authService.GetOidcConfig(ctx)if err != nil {return nil, err}-if config.IssuerURL == "" {return nil, errors.New("either issuerUrl or explicit endpoints must be configured")}-- discovery, err := s.discoverOidcEndpoints(ctx, config.IssuerURL)- if err != nil {- return nil, fmt.Errorf("failed to discover OIDC endpoints: %w", err)- }-- effectiveConfig := *config- effectiveConfig.AuthorizationEndpoint = discovery.AuthorizationEndpoint- effectiveConfig.TokenEndpoint = discovery.TokenEndpoint- effectiveConfig.UserinfoEndpoint = discovery.UserinfoEndpoint- effectiveConfig.JwksURI = discovery.JwksURI-- return &effectiveConfig, nil+ return config, nil}func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (string, string, error) {config, err := s.getEffectiveConfig(ctx)if err != nil {+ slog.Error("GenerateAuthURL: failed to get OIDC config", "error", err)return "", "", err}+ // Use provider discovery via go-oidc+ providerCtx := oidc.ClientContext(ctx, s.httpClient)+ provider, err := oidc.NewProvider(providerCtx, config.IssuerURL)+ if err != nil {+ slog.Error("GenerateAuthURL: provider discovery failed", "issuer", config.IssuerURL, "error", err)+ return "", "", fmt.Errorf("failed to discover provider: %w", err)+ }+state := utils.GenerateRandomString(32)codeVerifier := utils.GenerateRandomString(128)codeChallenge := utils.GenerateCodeChallenge(codeVerifier)scopes := strings.Fields(config.Scopes)if len(scopes) == 0 {- scopes = []string{"openid", "email", "profile"}+ scopes = []string{oidc.ScopeOpenID, "email", "profile"}}- authURL, err := url.Parse(config.AuthorizationEndpoint)- if err != nil {- return "", "", fmt.Errorf("invalid authorization endpoint: %w", err)+ oauth2Config := oauth2.Config{+ ClientID: config.ClientID,+ ClientSecret: config.ClientSecret,+ Endpoint: provider.Endpoint(),+ RedirectURL: s.config.GetOidcRedirectURI(),+ Scopes: scopes,}- redirectURI := s.config.GetOidcRedirectURI()- query := authURL.Query()- query.Set("response_type", "code")- query.Set("client_id", config.ClientID)- query.Set("redirect_uri", redirectURI)- query.Set("scope", strings.Join(scopes, " "))- query.Set("state", state)- query.Set("code_challenge", codeChallenge)- query.Set("code_challenge_method", "S256")- authURL.RawQuery = query.Encode()+ authURL := oauth2Config.AuthCodeURL(state,+ oauth2.SetAuthURLParam("code_challenge", codeChallenge),+ oauth2.SetAuthURLParam("code_challenge_method", "S256"),+ )stateData := OidcState{State: state,@@ -153,173 +104,252 @@ func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (sstateJSON, err := json.Marshal(stateData)if err != nil {+ slog.Error("GenerateAuthURL: failed to marshal state", "error", err)return "", "", err}encodedState := base64.URLEncoding.EncodeToString(stateJSON)- return authURL.String(), encodedState, nil+ return authURL, encodedState, nil+}++func (s *OidcService) discoverProvider(ctx context.Context, issuer string) (*oidc.Provider, error) {+ providerCtx := oidc.ClientContext(ctx, s.httpClient)+ provider, err := oidc.NewProvider(providerCtx, issuer)+ if err != nil {+ slog.Error("discoverProvider: discovery failed", "issuer", issuer, "error", err)+ return nil, fmt.Errorf("failed to discover provider: %w", err)+ }+ return provider, nil+}++func (s *OidcService) exchangeToken(ctx context.Context, cfg *models.OidcConfig, provider *oidc.Provider, code string, verifier string) (*oauth2.Token, error) {+ oauth2Config := oauth2.Config{+ ClientID: cfg.ClientID,+ ClientSecret: cfg.ClientSecret,+ Endpoint: provider.Endpoint(),+ RedirectURL: s.config.GetOidcRedirectURI(),+ Scopes: strings.Fields(cfg.Scopes),+ }+ providerCtx := oidc.ClientContext(ctx, s.httpClient)+ token, err := oauth2Config.Exchange(providerCtx, code, oauth2.SetAuthURLParam("code_verifier", verifier))+ if err != nil {+ slog.Error("exchangeToken: token exchange failed", "token_endpoint", oauth2Config.Endpoint.TokenURL, "error", err)+ return nil, fmt.Errorf("failed to exchange code for tokens: %w", err)+ }+ return token, nil+}++func (s *OidcService) fetchClaims(ctx context.Context, provider *oidc.Provider, token *oauth2.Token, idToken *oidc.IDToken, cfg *models.OidcConfig) (map[string]any, error) {+ providerCtx := oidc.ClientContext(ctx, s.httpClient)+ var rawClaims map[string]any++ userInfo, uerr := provider.UserInfo(providerCtx, oauth2.StaticTokenSource(token))+ if uerr == nil && userInfo != nil {+ if cerr := userInfo.Claims(&rawClaims); cerr == nil {+ slog.Debug("fetchClaims: userinfo claims fetched")+ return rawClaims, nil+ } else {+ slog.Debug("fetchClaims: userinfo claims decode failed", "error", cerr)+ }+ } else if uerr != nil {+ slog.Debug("fetchClaims: userinfo endpoint call failed", "error", uerr)+ }++ if idToken != nil {+ if err := idToken.Claims(&rawClaims); err != nil {+ slog.Debug("fetchClaims: id_token claims decode failed", "error", err)+ }+ slog.Debug("fetchClaims: claims extracted from id_token")+ return rawClaims, nil++ }++ wellKnown := strings.TrimSuffix(cfg.IssuerURL, "/") + "/.well-known/openid-configuration"+ req, rerr := http.NewRequestWithContext(providerCtx, http.MethodGet, wellKnown, nil)+ if rerr != nil {+ slog.Debug("fetchClaims: well-known request creation failed", "error", rerr)+ return nil, errors.New("no claims available")+ }+ req.Header.Set("Accept", "application/json")+ resp, derr := s.httpClient.Do(req)+ if derr != nil || resp == nil {+ if derr != nil {+ slog.Debug("fetchClaims: discovery request failed", "error", derr)+ }+ return nil, errors.New("no claims available")+ }+ body, _ := io.ReadAll(resp.Body)+ resp.Body.Close()+ var disco dto.OidcDiscoveryDocument+ if json.Unmarshal(body, &disco) == nil && disco.UserinfoEndpoint != "" {+ slog.Debug("fetchClaims: discovered userinfo endpoint", "userinfo_endpoint", disco.UserinfoEndpoint)+ req2, _ := http.NewRequestWithContext(providerCtx, http.MethodGet, disco.UserinfoEndpoint, nil)+ req2.Header.Set("Authorization", "Bearer "+token.AccessToken)+ req2.Header.Set("Accept", "application/json")+ if resp2, err2 := s.httpClient.Do(req2); err2 == nil && resp2 != nil {+ var tmp map[string]any+ if json.NewDecoder(resp2.Body).Decode(&tmp) == nil {+ resp2.Body.Close()+ slog.Debug("fetchClaims: direct userinfo endpoint returned claims")+ return tmp, nil+ }+ resp2.Body.Close()+ slog.Debug("fetchClaims: direct userinfo decode failed")+ } else if err2 != nil {+ slog.Debug("fetchClaims: direct userinfo request failed", "error", err2)+ }+ }++ return nil, errors.New("no claims available")}func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedState string) (*dto.OidcUserInfo, *dto.OidcTokenResponse, error) {+ slog.Debug("HandleCallback: start", "code_len", len(code), "state_len", len(state))+stateData, err := s.decodeState(storedState)if err != nil {+ slog.Error("HandleCallback: failed to decode stored state", "error", err)return nil, nil, fmt.Errorf("failed to decode state: %w", err)}if state != stateData.State {+ slog.Error("HandleCallback: invalid state parameter", "received", state, "expected_len", len(stateData.State))return nil, nil, errors.New("invalid state parameter")}- // Check if state is not too old (10 minutes max)if time.Since(stateData.CreatedAt) > 10*time.Minute {+ slog.Error("HandleCallback: state expired", "created_at", stateData.CreatedAt)return nil, nil, errors.New("state has expired")}- config, err := s.getEffectiveConfig(ctx)+ cfg, err := s.getEffectiveConfig(ctx)if err != nil {+ slog.Error("HandleCallback: failed to get effective config", "error", err)return nil, nil, err}- tokenResponse, err := s.exchangeCodeForTokens(ctx, config, code, stateData.CodeVerifier)+ provider, err := s.discoverProvider(ctx, cfg.IssuerURL)if err != nil {- return nil, nil, fmt.Errorf("failed to exchange code for tokens: %w", err)+ return nil, nil, err}- userInfo, err := s.getUserInfo(ctx, config, tokenResponse.AccessToken)+ token, err := s.exchangeToken(ctx, cfg, provider, code, stateData.CodeVerifier)if err != nil {- return nil, nil, fmt.Errorf("failed to get user info: %w", err)+ return nil, nil, err}- return userInfo, tokenResponse, nil-}--func (s *OidcService) RefreshToken(ctx context.Context, refreshToken string) (*dto.OidcTokenResponse, error) {- config, err := s.getEffectiveConfig(ctx)- if err != nil {- return nil, err+ var rawIDToken string+ if t := token.Extra("id_token"); t != nil {+ if sID, ok := t.(string); ok {+ rawIDToken = sID+ }}- data := url.Values{}- data.Set("grant_type", "refresh_token")- data.Set("refresh_token", refreshToken)- data.Set("client_id", config.ClientID)- data.Set("client_secret", config.ClientSecret)-- req, err := http.NewRequestWithContext(ctx, http.MethodPost, config.TokenEndpoint, strings.NewReader(data.Encode()))- if err != nil {- return nil, err+ var idToken *oidc.IDToken+ if rawIDToken != "" {+ verifier := provider.Verifier(&oidc.Config{ClientID: cfg.ClientID})+ idToken, err = verifier.Verify(oidc.ClientContext(ctx, s.httpClient), rawIDToken)+ if err != nil {+ slog.Error("HandleCallback: id_token verification failed", "error", err)+ return nil, nil, fmt.Errorf("failed to verify id_token: %w", err)+ }+ slog.Debug("HandleCallback: id_token verified", "id_token_len", len(rawIDToken))+ } else {+ slog.Debug("HandleCallback: no id_token present in token response")}- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")- req.Header.Set("Accept", "application/json")- resp, err := s.httpClient.Do(req)- if err != nil {- return nil, err+ rawClaims, cerr := s.fetchClaims(ctx, provider, token, idToken, cfg)+ if cerr != nil {+ slog.Debug("HandleCallback: fetchClaims returned no claims", "error", cerr)+ rawClaims = map[string]any{}}- defer resp.Body.Close()- if resp.StatusCode != http.StatusOK {- bodyBytes, _ := io.ReadAll(resp.Body)- return nil, fmt.Errorf("token endpoint returned %d on refresh: %s", resp.StatusCode, string(bodyBytes))+ userInfoDto := dto.OidcUserInfo{+ Subject: utils.GetStringClaim(rawClaims, "sub"),+ Name: utils.GetStringClaim(rawClaims, "name"),+ Email: utils.GetStringClaim(rawClaims, "email"),+ PreferredUsername: utils.GetStringClaim(rawClaims, "preferred_username"),+ GivenName: utils.GetStringClaim(rawClaims, "given_name"),+ FamilyName: utils.GetStringClaim(rawClaims, "family_name"),+ Admin: utils.GetBoolClaim(rawClaims, "admin"),+ Roles: utils.GetStringSliceClaim(rawClaims, "roles"),+ Groups: utils.GetStringSliceClaim(rawClaims, "groups"),+ Extra: rawClaims,}- var tokenResponse dto.OidcTokenResponse- if err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {- return nil, err+ if userInfoDto.Subject == "" {+ slog.Error("HandleCallback: missing 'sub' claim after all attempts", "claims_empty", len(rawClaims) == 0)+ return nil, nil, errors.New("missing required 'sub' field in userinfo/claims")}- return &tokenResponse, nil-}--func (s *OidcService) exchangeCodeForTokens(ctx context.Context, config *models.OidcConfig, code, codeVerifier string) (*dto.OidcTokenResponse, error) {- redirectURI := s.config.GetOidcRedirectURI()- data := url.Values{}- data.Set("grant_type", "authorization_code")- data.Set("code", code)- data.Set("redirect_uri", redirectURI)- data.Set("client_id", config.ClientID)- data.Set("client_secret", config.ClientSecret)- data.Set("code_verifier", codeVerifier)-- req, err := http.NewRequestWithContext(ctx, http.MethodPost, config.TokenEndpoint, strings.NewReader(data.Encode()))- if err != nil {- return nil, err+ tokenResp := &dto.OidcTokenResponse{+ AccessToken: token.AccessToken,+ RefreshToken: token.RefreshToken,+ IDToken: rawIDToken,}-- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")- req.Header.Set("Accept", "application/json")-- resp, err := s.httpClient.Do(req)- if err != nil {- return nil, err+ if !token.Expiry.IsZero() {+ tokenResp.ExpiresIn = int(time.Until(token.Expiry).Seconds())}- defer resp.Body.Close()- if resp.StatusCode != http.StatusOK {- bodyBytes, _ := io.ReadAll(resp.Body)- return nil, fmt.Errorf("token endpoint returned %d: %s", resp.StatusCode, string(bodyBytes))- }+ slog.Debug("HandleCallback: completed successfully", "subject", userInfoDto.Subject)- var tokenResponse dto.OidcTokenResponse- if err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {+ return &userInfoDto, tokenResp, nil+}++func (s *OidcService) RefreshToken(ctx context.Context, refreshToken string) (*dto.OidcTokenResponse, error) {+ cfg, err := s.getEffectiveConfig(ctx)+ if err != nil {+ slog.Error("RefreshToken: failed to get effective config", "error", err)return nil, err}- return &tokenResponse, nil-}+ // Use oauth2 token refresh via token endpoint+ data := url.Values{}+ data.Set("grant_type", "refresh_token")+ data.Set("refresh_token", refreshToken)+ data.Set("client_id", cfg.ClientID)+ data.Set("client_secret", cfg.ClientSecret)-func (s *OidcService) getUserInfo(ctx context.Context, config *models.OidcConfig, accessToken string) (*dto.OidcUserInfo, error) {- req, err := http.NewRequestWithContext(ctx, http.MethodGet, config.UserinfoEndpoint, nil)+ req, err := http.NewRequestWithContext(ctx, http.MethodPost, cfg.TokenEndpoint, strings.NewReader(data.Encode()))if err != nil {+ slog.Error("RefreshToken: failed to create request", "error", err)return nil, err}- req.Header.Set("Authorization", "Bearer "+accessToken)+ req.Header.Set("Content-Type", "application/x-www-form-urlencoded")req.Header.Set("Accept", "application/json")resp, err := s.httpClient.Do(req)if err != nil {+ slog.Error("RefreshToken: token endpoint request failed", "token_endpoint", cfg.TokenEndpoint, "error", err)return nil, err}defer resp.Body.Close()if resp.StatusCode != http.StatusOK {bodyBytes, _ := io.ReadAll(resp.Body)- return nil, fmt.Errorf("userinfo endpoint returned %d: %s", resp.StatusCode, string(bodyBytes))+ slog.Error("RefreshToken: token endpoint returned non-200", "status", resp.StatusCode, "body", string(bodyBytes))+ return nil, fmt.Errorf("token endpoint returned %d on refresh: %s", resp.StatusCode, string(bodyBytes))}- var raw map[string]any- if err := json.NewDecoder(resp.Body).Decode(&raw); err != nil {+ var tokenResponse dto.OidcTokenResponse+ if err := json.NewDecoder(resp.Body).Decode(&tokenResponse); err != nil {+ slog.Error("RefreshToken: failed to decode token response", "error", err)return nil, err}-- userInfo := dto.OidcUserInfo{- Subject: utils.GetStringClaim(raw, "sub"),- Name: utils.GetStringClaim(raw, "name"),- Email: utils.GetStringClaim(raw, "email"),- PreferredUsername: utils.GetStringClaim(raw, "preferred_username"),- GivenName: utils.GetStringClaim(raw, "given_name"),- FamilyName: utils.GetStringClaim(raw, "family_name"),- Admin: utils.GetBoolClaim(raw, "admin"),- Roles: utils.GetStringSliceClaim(raw, "roles"),- Groups: utils.GetStringSliceClaim(raw, "groups"),- Extra: raw,- }-- if userInfo.Subject == "" {- return nil, errors.New("missing required 'sub' field in userinfo response")- }-- return &userInfo, nil+ slog.Debug("RefreshToken: refresh successful", "has_refresh_token", tokenResponse.RefreshToken != "")+ return &tokenResponse, nil}func (s *OidcService) decodeState(encodedState string) (*OidcState, error) {stateJSON, err := base64.URLEncoding.DecodeString(encodedState)if err != nil {+ slog.Error("decodeState: failed to decode base64 state", "error", err)return nil, err}var stateData OidcStateif err := json.Unmarshal(stateJSON, &stateData); err != nil {+ slog.Error("decodeState: failed to unmarshal state JSON", "error", err)return nil, err}diff --git a/backend/internal/services/oidc_service_test.go b/backend/internal/services/oidc_service_test.godeleted file mode 100644index 72570ade2..000000000--- a/backend/internal/services/oidc_service_test.go+++ /dev/null@@ -1,366 +0,0 @@-package services--import (- "context"- "encoding/base64"- "encoding/json"- "io"- "net/http"- "net/http/httptest"- "net/url"- "strings"- "testing"- "time"-- "github.com/ofkm/arcane-backend/internal/config"- "github.com/ofkm/arcane-backend/internal/dto"- "github.com/ofkm/arcane-backend/internal/models"-)--func newTestOidcService() *OidcService {- return &OidcService{- authService: nil, // not used in these tests- config: &config.Config{}, // redirect URI may be empty; that's fine for these unit tests- httpClient: &http.Client{}, // overridden per-test with server.Client()- }-}--func TestDiscoverOidcEndpoints_Success(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {- w.Header().Set("Content-Type", "application/json; charset=utf-8")- if err := json.NewEncoder(w).Encode(dto.OidcDiscoveryDocument{- AuthorizationEndpoint: "https://example/authorize",- TokenEndpoint: "https://example/token",- UserinfoEndpoint: "https://example/userinfo",- JwksURI: "https://example/jwks",- }); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- doc, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)- if err != nil {- t.Fatalf("discoverOidcEndpoints: %v", err)- }- if doc.AuthorizationEndpoint == "" || doc.TokenEndpoint == "" || doc.UserinfoEndpoint == "" || doc.JwksURI == "" {- t.Fatalf("unexpected discovery doc: %+v", doc)- }-}--func TestDiscoverOidcEndpoints_NonJSON(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {- w.Header().Set("Content-Type", "text/plain")- w.WriteHeader(http.StatusOK)- if _, err := w.Write([]byte("not json")); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- _, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)- if err == nil || !strings.Contains(err.Error(), "non-JSON") {- t.Fatalf("expected non-JSON error, got %v", err)- }-}--func TestDiscoverOidcEndpoints_HTTPError(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {- http.Error(w, "boom", http.StatusBadGateway)- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- _, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)- if err == nil || !strings.Contains(err.Error(), "returned 502") {- t.Fatalf("expected status error, got %v", err)- }-}--func TestDiscoverOidcEndpoints_MissingEndpoints(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/.well-known/openid-configuration", func(w http.ResponseWriter, r *http.Request) {- w.Header().Set("Content-Type", "application/json")- w.WriteHeader(http.StatusOK)- if _, err := w.Write([]byte(`{"authorization_endpoint":"https://example/auth"}`)); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- _, err := svc.discoverOidcEndpoints(context.Background(), srv.URL)- if err == nil || !strings.Contains(err.Error(), "missing required endpoints") {- t.Fatalf("expected missing endpoints error, got %v", err)- }-}--func TestExchangeCodeForTokens_Success(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {- if err := r.ParseForm(); err != nil {- http.Error(w, "bad form", http.StatusBadRequest)- return- }- if r.Form.Get("grant_type") != "authorization_code" || r.Form.Get("code") != "abc123" {- http.Error(w, "invalid grant", http.StatusBadRequest)- return- }- w.Header().Set("Content-Type", "application/json")- if err := json.NewEncoder(w).Encode(dto.OidcTokenResponse{- AccessToken: "access-1",- RefreshToken: "refresh-1",- ExpiresIn: 3600,- IDToken: "id-1",- TokenType: "Bearer",- }); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- cfg := &models.OidcConfig{- TokenEndpoint: srv.URL + "/token",- ClientID: "client",- ClientSecret: "secret",- }- tok, err := svc.exchangeCodeForTokens(context.Background(), cfg, "abc123", "verifier")- if err != nil {- t.Fatalf("exchangeCodeForTokens: %v", err)- }- if tok.AccessToken != "access-1" || tok.RefreshToken != "refresh-1" || tok.TokenType != "Bearer" {- t.Fatalf("unexpected token response: %+v", tok)- }-}--func TestExchangeCodeForTokens_Non200(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {- http.Error(w, "bad", http.StatusBadRequest)- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- cfg := &models.OidcConfig{TokenEndpoint: srv.URL + "/token"}- _, err := svc.exchangeCodeForTokens(context.Background(), cfg, "x", "y")- if err == nil || !strings.Contains(err.Error(), "returned 400") {- t.Fatalf("expected 400 error, got %v", err)- }-}--func TestGetUserInfo_Success(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/userinfo", func(w http.ResponseWriter, r *http.Request) {- if got := r.Header.Get("Authorization"); !strings.HasPrefix(got, "Bearer ") {- http.Error(w, "no bearer", http.StatusUnauthorized)- return- }- w.Header().Set("Content-Type", "application/json")- const body = `{- "sub": "user-1",- "name": "Alice",- "email": "[email protected]",- "preferred_username": "alice",- "given_name": "Alice",- "family_name": "A",- "admin": true,- "roles": ["admin","user"],- "groups": ["devs","ops"]- }`- if _, err := w.Write([]byte(body)); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- cfg := &models.OidcConfig{UserinfoEndpoint: srv.URL + "/userinfo"}- ui, err := svc.getUserInfo(context.Background(), cfg, "token-123")- if err != nil {- t.Fatalf("getUserInfo: %v", err)- }- if ui.Subject != "user-1" || ui.Email != "[email protected]" || !ui.Admin {- t.Fatalf("unexpected user info: %+v", ui)- }- if len(ui.Roles) != 2 || ui.Roles[0] != "admin" {- t.Fatalf("roles not parsed: %+v", ui.Roles)- }- if len(ui.Groups) != 2 || ui.Groups[1] != "ops" {- t.Fatalf("groups not parsed: %+v", ui.Groups)- }-}--func TestGetUserInfo_MissingSub(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/userinfo", func(w http.ResponseWriter, r *http.Request) {- w.Header().Set("Content-Type", "application/json")- if _, err := w.Write([]byte(`{"email":"[email protected]"}`)); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- cfg := &models.OidcConfig{UserinfoEndpoint: srv.URL + "/userinfo"}- _, err := svc.getUserInfo(context.Background(), cfg, "t")- if err == nil || !strings.Contains(err.Error(), "missing required 'sub'") {- t.Fatalf("expected missing sub error, got %v", err)- }-}--func TestGetUserInfo_Non200(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/userinfo", func(w http.ResponseWriter, r *http.Request) {- http.Error(w, "nope", http.StatusUnauthorized)- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()-- cfg := &models.OidcConfig{UserinfoEndpoint: srv.URL + "/userinfo"}- _, err := svc.getUserInfo(context.Background(), cfg, "t")- if err == nil || !strings.Contains(err.Error(), "returned 401") {- t.Fatalf("expected 401 error, got %v", err)- }-}--func TestDecodeState_Success(t *testing.T) {- now := time.Now().Round(time.Second)- state := OidcState{- State: "s123",- CodeVerifier: "v456",- RedirectTo: "/home",- CreatedAt: now,- }- raw, err := json.Marshal(state)- if err != nil {- t.Fatalf("json.Marshal(state): %v", err)- }- enc := base64.URLEncoding.EncodeToString(raw)-- svc := newTestOidcService()- got, err := svc.decodeState(enc)- if err != nil {- t.Fatalf("decodeState: %v", err)- }- if got.State != "s123" || got.CodeVerifier != "v456" || got.RedirectTo != "/home" || got.CreatedAt.IsZero() {- t.Fatalf("unexpected decoded state: %+v", got)- }-}--func TestDecodeState_InvalidBase64(t *testing.T) {- svc := newTestOidcService()- _, err := svc.decodeState("###not-base64###")- if err == nil {- t.Fatalf("expected base64 error")- }-}--func TestHandleCallback_StateMismatch(t *testing.T) {- stored := OidcState{- State: "good",- CodeVerifier: "cv",- RedirectTo: "/",- CreatedAt: time.Now(),- }- raw, err := json.Marshal(stored)- if err != nil {- t.Fatalf("json.Marshal(stored): %v", err)- }- enc := base64.URLEncoding.EncodeToString(raw)-- svc := newTestOidcService()- _, _, err = svc.HandleCallback(context.Background(), "code", "bad", enc)- if err == nil || !strings.Contains(err.Error(), "invalid state parameter") {- t.Fatalf("expected invalid state error, got %v", err)- }-}--func TestHandleCallback_ExpiredState(t *testing.T) {- stored := OidcState{- State: "s",- CodeVerifier: "cv",- RedirectTo: "/",- CreatedAt: time.Now().Add(-11 * time.Minute),- }- raw, err := json.Marshal(stored)- if err != nil {- t.Fatalf("json.Marshal(stored): %v", err)- }- enc := base64.URLEncoding.EncodeToString(raw)-- svc := newTestOidcService()- _, _, err = svc.HandleCallback(context.Background(), "code", "s", enc)- if err == nil || !strings.Contains(err.Error(), "state has expired") {- t.Fatalf("expected expired state error, got %v", err)- }-}--// Helper to ensure form bodies are parsed as expected (optional smoke test)-func TestTokenEndpoint_FormShape(t *testing.T) {- mux := http.NewServeMux()- mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {- if ct := r.Header.Get("Content-Type"); !strings.HasPrefix(ct, "application/x-www-form-urlencoded") {- http.Error(w, "bad content-type", http.StatusUnsupportedMediaType)- return- }- body, _ := url.ParseQuery(readAll(t, r))- if body.Get("grant_type") == "" {- http.Error(w, "missing grant_type", http.StatusBadRequest)- return- }- w.Header().Set("Content-Type", "application/json")- if _, err := w.Write([]byte(`{"access_token":"a","token_type":"Bearer","expires_in":1,"refresh_token":"r"}`)); err != nil {- http.Error(w, err.Error(), http.StatusInternalServerError)- }- })- srv := httptest.NewServer(mux)- defer srv.Close()-- svc := newTestOidcService()- svc.httpClient = srv.Client()- cfg := &models.OidcConfig{TokenEndpoint: srv.URL + "/token"}-- if _, err := svc.exchangeCodeForTokens(context.Background(), cfg, "c", "v"); err != nil {- t.Fatalf("exchangeCodeForTokens: %v", err)- }-}-func readAll(t *testing.T, r *http.Request) string {- t.Helper()- defer r.Body.Close()- b := new(strings.Builder)- _, _ = io.Copy(b, r.Body)- return b.String()-}