Skip to content

Modern Docker Management, Designed for Everyone

refactor(oidc): ensure proper handling of contexts and spec (#647)

Kyle Mendell58487c57ee75
diff --git a/backend/internal/services/oidc_service.go b/backend/internal/services/oidc_service.go
index cbefbaed8..7f6347d44 100644
--- a/backend/internal/services/oidc_service.go
+++ b/backend/internal/services/oidc_service.go
@@ -6,10 +6,9 @@ import (
"encoding/json"
"errors"
"fmt"
- "io"
"net/http"
- "net/url"
"strings"
+ "sync"
"time"
"log/slog"
@@ -24,13 +23,17 @@ import (
)
type OidcService struct {
- authService *AuthService
- config *config.Config
- httpClient *http.Client
+ authService *AuthService
+ config *config.Config
+ httpClient *http.Client
+ providerCache *oidc.Provider
+ providerMutex sync.RWMutex
+ cachedIssuer string
}
type OidcState struct {
State string `json:"state"`
+ Nonce string `json:"nonce"`
CodeVerifier string `json:"code_verifier"`
RedirectTo string `json:"redirect_to"`
CreatedAt time.Time `json:"created_at"`
@@ -50,14 +53,28 @@ func NewOidcService(authService *AuthService, cfg *config.Config, httpClient *ht
func (s *OidcService) getEffectiveConfig(ctx context.Context) (*models.OidcConfig, error) {
config, err := s.authService.GetOidcConfig(ctx)
if err != nil {
- return nil, err
+ return nil, fmt.Errorf("failed to get OIDC config: %w", err)
}
if config.IssuerURL == "" {
- return nil, errors.New("either issuerUrl or explicit endpoints must be configured")
+ return nil, errors.New("issuer URL must be configured")
}
return config, nil
}
+func (s *OidcService) ensureOpenIDScope(scopes []string) []string {
+ hasOpenID := false
+ for _, scope := range scopes {
+ if scope == oidc.ScopeOpenID {
+ hasOpenID = true
+ break
+ }
+ }
+ if !hasOpenID {
+ scopes = append([]string{oidc.ScopeOpenID}, scopes...)
+ }
+ return scopes
+}
+
func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (string, string, error) {
config, err := s.getEffectiveConfig(ctx)
if err != nil {
@@ -65,21 +82,21 @@ func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (s
return "", "", err
}
- // Use provider discovery via go-oidc
- providerCtx := oidc.ClientContext(ctx, s.httpClient)
- provider, err := oidc.NewProvider(providerCtx, config.IssuerURL)
+ provider, err := s.getOrDiscoverProvider(ctx, 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)
+ nonce := utils.GenerateRandomString(32)
codeVerifier := utils.GenerateRandomString(128)
scopes := strings.Fields(config.Scopes)
if len(scopes) == 0 {
- scopes = []string{oidc.ScopeOpenID, "email", "profile"}
+ scopes = []string{"email", "profile"}
}
+ scopes = s.ensureOpenIDScope(scopes)
oauth2Config := oauth2.Config{
ClientID: config.ClientID,
@@ -90,11 +107,13 @@ func (s *OidcService) GenerateAuthURL(ctx context.Context, redirectTo string) (s
}
authURL := oauth2Config.AuthCodeURL(state,
+ oauth2.SetAuthURLParam("nonce", nonce),
oauth2.S256ChallengeOption(codeVerifier),
)
stateData := OidcState{
State: state,
+ Nonce: nonce,
CodeVerifier: codeVerifier,
RedirectTo: redirectTo,
CreatedAt: time.Now(),
@@ -103,130 +122,140 @@ 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
+ return "", "", fmt.Errorf("failed to encode state: %w", err)
}
encodedState := base64.URLEncoding.EncodeToString(stateJSON)
+ slog.Debug("GenerateAuthURL: generated authorization URL", "issuer", config.IssuerURL, "scopes", scopes)
return authURL, encodedState, nil
}
-func (s *OidcService) discoverProvider(ctx context.Context, issuer string) (*oidc.Provider, error) {
+func (s *OidcService) getOrDiscoverProvider(ctx context.Context, issuer string) (*oidc.Provider, error) {
+ s.providerMutex.RLock()
+ if s.providerCache != nil && s.cachedIssuer == issuer {
+ provider := s.providerCache
+ s.providerMutex.RUnlock()
+ return provider, nil
+ }
+ s.providerMutex.RUnlock()
+
+ s.providerMutex.Lock()
+ defer s.providerMutex.Unlock()
+
+ if s.providerCache != nil && s.cachedIssuer == issuer {
+ return s.providerCache, nil
+ }
+
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)
+ slog.Error("getOrDiscoverProvider: discovery failed", "issuer", issuer, "error", err)
+ return nil, fmt.Errorf("failed to discover provider at %s: %w", issuer, err)
}
+
+ s.providerCache = provider
+ s.cachedIssuer = issuer
+ slog.Debug("getOrDiscoverProvider: provider cached", "issuer", issuer)
+
return provider, nil
}
func (s *OidcService) exchangeToken(ctx context.Context, cfg *models.OidcConfig, provider *oidc.Provider, code string, verifier string) (*oauth2.Token, error) {
+ scopes := strings.Fields(cfg.Scopes)
+ if len(scopes) == 0 {
+ scopes = []string{"email", "profile"}
+ }
+ scopes = s.ensureOpenIDScope(scopes)
+
oauth2Config := oauth2.Config{
ClientID: cfg.ClientID,
ClientSecret: cfg.ClientSecret,
Endpoint: provider.Endpoint(),
RedirectURL: s.config.GetOidcRedirectURI(),
- Scopes: strings.Fields(cfg.Scopes),
+ Scopes: scopes,
}
+
providerCtx := oidc.ClientContext(ctx, s.httpClient)
token, err := oauth2Config.Exchange(providerCtx, code, oauth2.VerifierOption(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 nil, fmt.Errorf("failed to exchange authorization code: %w", err)
}
+
+ slog.Debug("exchangeToken: token exchange successful", "has_access_token", token.AccessToken != "", "has_refresh_token", token.RefreshToken != "")
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) {
+func (s *OidcService) fetchClaims(ctx context.Context, provider *oidc.Provider, token *oauth2.Token, idToken *oidc.IDToken) (map[string]any, error) {
providerCtx := oidc.ClientContext(ctx, s.httpClient)
- var rawClaims map[string]any
+ var claims 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
+ if idToken != nil {
+ if err := idToken.Claims(&claims); err != nil {
+ slog.Warn("fetchClaims: failed to extract claims from ID token", "error", err)
} else {
- slog.Debug("fetchClaims: userinfo claims decode failed", "error", cerr)
+ slog.Debug("fetchClaims: extracted claims from ID token")
}
- } 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)
+ userInfo, err := provider.UserInfo(providerCtx, oauth2.StaticTokenSource(token))
+ if err != nil {
+ slog.Debug("fetchClaims: userinfo endpoint call failed", "error", err)
+ if claims != nil {
+ return claims, nil
}
- slog.Debug("fetchClaims: claims extracted from id_token")
- return rawClaims, nil
+ return nil, fmt.Errorf("failed to fetch userinfo: %w", err)
+ }
+ var userInfoClaims map[string]any
+ if err := userInfo.Claims(&userInfoClaims); err != nil {
+ slog.Warn("fetchClaims: failed to decode userinfo claims", "error", err)
+ if claims != nil {
+ return claims, nil
+ }
+ return nil, fmt.Errorf("failed to decode userinfo claims: %w", err)
}
- 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")
+ slog.Debug("fetchClaims: fetched userinfo claims successfully")
+
+ if claims == nil {
+ claims = make(map[string]any)
}
- 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)
+ for k, v := range userInfoClaims {
+ if _, exists := claims[k]; !exists {
+ claims[k] = v
}
}
- return nil, errors.New("no claims available")
+ return claims, nil
}
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))
+ slog.Debug("HandleCallback: processing callback", "code_present", code != "", "state_present", 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)
+ return nil, nil, fmt.Errorf("invalid state parameter: %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")
+ slog.Error("HandleCallback: state mismatch", "received_len", len(state), "expected_len", len(stateData.State))
+ return nil, nil, errors.New("state parameter mismatch")
}
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")
+ slog.Error("HandleCallback: state expired", "age", time.Since(stateData.CreatedAt))
+ return nil, nil, errors.New("authentication state has expired")
}
cfg, err := s.getEffectiveConfig(ctx)
if err != nil {
- slog.Error("HandleCallback: failed to get effective config", "error", err)
+ slog.Error("HandleCallback: failed to get OIDC config", "error", err)
return nil, nil, err
}
- provider, err := s.discoverProvider(ctx, cfg.IssuerURL)
+ provider, err := s.getOrDiscoverProvider(ctx, cfg.IssuerURL)
if err != nil {
return nil, nil, err
}
@@ -237,105 +266,175 @@ func (s *OidcService) HandleCallback(ctx context.Context, code, state, storedSta
}
var rawIDToken string
- if t := token.Extra("id_token"); t != nil {
- if sID, ok := t.(string); ok {
- rawIDToken = sID
+ if idTokenValue := token.Extra("id_token"); idTokenValue != nil {
+ if idTokenStr, ok := idTokenValue.(string); ok {
+ rawIDToken = idTokenStr
}
}
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 rawIDToken == "" {
+ slog.Warn("HandleCallback: no ID token in response (non-compliant OIDC response)")
+ } else {
+ verifierConfig := &oidc.Config{
+ ClientID: cfg.ClientID,
+ }
+
+ if stateData.Nonce != "" {
+ verifierConfig.Now = time.Now
+ }
+
+ verifier := provider.Verifier(verifierConfig)
+ providerCtx := oidc.ClientContext(ctx, s.httpClient)
+
+ idToken, err = verifier.Verify(providerCtx, 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.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")
+
+ if stateData.Nonce != "" {
+ var claims struct {
+ Nonce string `json:"nonce"`
+ }
+ if err := idToken.Claims(&claims); err != nil {
+ slog.Error("HandleCallback: failed to extract nonce from ID token", "error", err)
+ return nil, nil, fmt.Errorf("failed to verify nonce: %w", err)
+ }
+ if claims.Nonce != stateData.Nonce {
+ slog.Error("HandleCallback: nonce mismatch", "expected", stateData.Nonce, "got", claims.Nonce)
+ return nil, nil, errors.New("nonce verification failed")
+ }
+ }
+
+ slog.Debug("HandleCallback: ID token verified successfully", "subject", idToken.Subject, "issuer", idToken.Issuer)
+ }
+
+ claims, err := s.fetchClaims(ctx, provider, token, idToken)
+ if err != nil {
+ slog.Error("HandleCallback: failed to fetch claims", "error", err)
+ return nil, nil, fmt.Errorf("failed to fetch user claims: %w", 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{}
+ subject := utils.GetStringClaim(claims, "sub")
+ if subject == "" {
+ slog.Error("HandleCallback: missing required 'sub' claim")
+ return nil, nil, errors.New("missing required 'sub' claim in user info")
}
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,
+ Subject: subject,
+ Name: utils.GetStringClaim(claims, "name"),
+ Email: utils.GetStringClaim(claims, "email"),
+ PreferredUsername: utils.GetStringClaim(claims, "preferred_username"),
+ GivenName: utils.GetStringClaim(claims, "given_name"),
+ FamilyName: utils.GetStringClaim(claims, "family_name"),
+ Admin: utils.GetBoolClaim(claims, "admin"),
+ Roles: utils.GetStringSliceClaim(claims, "roles"),
+ Groups: utils.GetStringSliceClaim(claims, "groups"),
+ Extra: claims,
}
- 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")
+ tokenType := token.TokenType
+ if tokenType == "" {
+ tokenType = "Bearer"
}
tokenResp := &dto.OidcTokenResponse{
AccessToken: token.AccessToken,
+ TokenType: tokenType,
RefreshToken: token.RefreshToken,
IDToken: rawIDToken,
}
if !token.Expiry.IsZero() {
- tokenResp.ExpiresIn = int(time.Until(token.Expiry).Seconds())
+ expiresIn := int(time.Until(token.Expiry).Seconds())
+ if expiresIn < 0 {
+ expiresIn = 0
+ }
+ tokenResp.ExpiresIn = expiresIn
}
- slog.Debug("HandleCallback: completed successfully", "subject", userInfoDto.Subject)
-
+ slog.Info("HandleCallback: authentication successful", "subject", userInfoDto.Subject, "email", userInfoDto.Email)
return &userInfoDto, tokenResp, nil
}
func (s *OidcService) RefreshToken(ctx context.Context, refreshToken string) (*dto.OidcTokenResponse, error) {
+ if refreshToken == "" {
+ return nil, errors.New("refresh token is required")
+ }
+
cfg, err := s.getEffectiveConfig(ctx)
if err != nil {
- slog.Error("RefreshToken: failed to get effective config", "error", err)
+ slog.Error("RefreshToken: failed to get OIDC config", "error", err)
return nil, err
}
- // 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)
-
- req, err := http.NewRequestWithContext(ctx, http.MethodPost, cfg.TokenEndpoint, strings.NewReader(data.Encode()))
+ provider, err := s.getOrDiscoverProvider(ctx, cfg.IssuerURL)
if err != nil {
- slog.Error("RefreshToken: failed to create request", "error", err)
return nil, err
}
- req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
- req.Header.Set("Accept", "application/json")
- resp, err := s.httpClient.Do(req)
+ scopes := strings.Fields(cfg.Scopes)
+ if len(scopes) == 0 {
+ scopes = []string{"email", "profile"}
+ }
+ scopes = s.ensureOpenIDScope(scopes)
+
+ oauth2Config := oauth2.Config{
+ ClientID: cfg.ClientID,
+ ClientSecret: cfg.ClientSecret,
+ Endpoint: provider.Endpoint(),
+ RedirectURL: s.config.GetOidcRedirectURI(),
+ Scopes: scopes,
+ }
+
+ oldToken := &oauth2.Token{
+ RefreshToken: refreshToken,
+ }
+
+ providerCtx := oidc.ClientContext(ctx, s.httpClient)
+ tokenSource := oauth2Config.TokenSource(providerCtx, oldToken)
+
+ newToken, err := tokenSource.Token()
if err != nil {
- slog.Error("RefreshToken: token endpoint request failed", "token_endpoint", cfg.TokenEndpoint, "error", err)
- return nil, err
+ slog.Error("RefreshToken: token refresh failed", "error", err)
+ return nil, fmt.Errorf("failed to refresh access token: %w", err)
}
- defer resp.Body.Close()
- if resp.StatusCode != http.StatusOK {
- bodyBytes, _ := io.ReadAll(resp.Body)
- 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))
+ tokenType := newToken.TokenType
+ if tokenType == "" {
+ tokenType = "Bearer"
}
- 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
+ var rawIDToken string
+ if idTokenValue := newToken.Extra("id_token"); idTokenValue != nil {
+ if idTokenStr, ok := idTokenValue.(string); ok {
+ rawIDToken = idTokenStr
+ }
}
- slog.Debug("RefreshToken: refresh successful", "has_refresh_token", tokenResponse.RefreshToken != "")
- return &tokenResponse, nil
+
+ tokenResp := &dto.OidcTokenResponse{
+ AccessToken: newToken.AccessToken,
+ TokenType: tokenType,
+ RefreshToken: newToken.RefreshToken,
+ IDToken: rawIDToken,
+ }
+
+ if !newToken.Expiry.IsZero() {
+ expiresIn := int(time.Until(newToken.Expiry).Seconds())
+ if expiresIn < 0 {
+ expiresIn = 0
+ }
+ tokenResp.ExpiresIn = expiresIn
+ }
+
+ if tokenResp.RefreshToken == "" {
+ tokenResp.RefreshToken = refreshToken
+ slog.Debug("RefreshToken: no new refresh token issued, reusing existing")
+ }
+
+ slog.Info("RefreshToken: token refresh successful", "has_new_refresh_token", newToken.RefreshToken != "")
+ return tokenResp, nil
}
func (s *OidcService) decodeState(encodedState string) (*OidcState, error) {