Skip to content

Modern Docker Management, Designed for Everyone

refactor: use coreos/go-oidc library for oidc auth

Kyle Mendell80317bbf9301
diff --git a/backend/.air.toml b/backend/.air.toml
index 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 = true
delay = 1000
diff --git a/backend/go.mod b/backend/go.mod
index bb2ac16ec..58171e64f 100644
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -5,6 +5,7 @@ go 1.25.0
require (
github.com/cenkalti/backoff/v5 v5.0.3
github.com/compose-spec/compose-go/v2 v2.9.0
+ github.com/coreos/go-oidc/v3 v3.15.0
github.com/distribution/reference v0.6.0
github.com/docker/cli v28.4.0+incompatible
github.com/docker/compose/v2 v2.39.4
@@ -29,6 +30,7 @@ require (
github.com/shirou/gopsutil/v3 v3.24.5
github.com/stretchr/testify v1.11.1
golang.org/x/crypto v0.42.0
+ golang.org/x/oauth2 v0.31.0
golang.org/x/sync v0.17.0
gorm.io/driver/postgres v1.6.0
gorm.io/gorm v1.31.0
@@ -90,6 +92,7 @@ require (
github.com/gabriel-vasile/mimetype v1.4.10 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect
github.com/glebarez/go-sqlite v1.22.0 // indirect
+ github.com/go-jose/go-jose/v4 v4.1.1 // indirect
github.com/go-logr/logr v1.4.3 // indirect
github.com/go-logr/stdr v1.2.2 // indirect
github.com/go-ole/go-ole v1.3.0 // indirect
@@ -236,7 +239,6 @@ require (
golang.org/x/exp v0.0.0-20250911091902-df9299821621 // indirect
golang.org/x/mod v0.28.0 // indirect
golang.org/x/net v0.44.0 // indirect
- golang.org/x/oauth2 v0.31.0 // indirect
golang.org/x/sys v0.36.0 // indirect
golang.org/x/term v0.35.0 // indirect
golang.org/x/text v0.29.0 // indirect
diff --git a/backend/go.sum b/backend/go.sum
index 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/0VE6XPU7elJRq
github.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++w0GM
github.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.go
index 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) (s
stateJSON, 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 OidcState
if 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.go
deleted file mode 100644
index 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()
-}