Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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.goindex 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 *htfunc (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) (sreturn "", "", 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) (sstateJSON, 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) {