oidc.go 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193
  1. // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
  2. // SPDX-License-Identifier: Apache-2.0
  3. package oauth2 // import "miniflux.app/v2/internal/oauth2"
  4. import (
  5. "context"
  6. "errors"
  7. "fmt"
  8. "log/slog"
  9. "slices"
  10. "miniflux.app/v2/internal/config"
  11. "miniflux.app/v2/internal/model"
  12. "github.com/coreos/go-oidc/v3/oidc"
  13. "golang.org/x/oauth2"
  14. )
  15. // ErrEmptyUsername is returned when the OIDC user profile has no username.
  16. var ErrEmptyUsername = errors.New("oidc: username is empty")
  17. type userClaims struct {
  18. Email string `json:"email"`
  19. Profile string `json:"profile"`
  20. Name string `json:"name"`
  21. PreferredUsername string `json:"preferred_username"`
  22. }
  23. type oidcProvider struct {
  24. clientID string
  25. clientSecret string
  26. redirectURL string
  27. provider *oidc.Provider
  28. }
  29. // NewOidcProvider returns a Provider that authenticates users via OpenID Connect.
  30. // It discovers the OIDC endpoints from the given discovery URL.
  31. func NewOidcProvider(ctx context.Context, clientID, clientSecret, redirectURL, discoveryEndpoint string) (Provider, error) {
  32. provider, err := oidc.NewProvider(ctx, discoveryEndpoint)
  33. if err != nil {
  34. return nil, fmt.Errorf(`oidc: failed to initialize provider %q: %w`, discoveryEndpoint, err)
  35. }
  36. return &oidcProvider{
  37. clientID: clientID,
  38. clientSecret: clientSecret,
  39. redirectURL: redirectURL,
  40. provider: provider,
  41. }, nil
  42. }
  43. func (o *oidcProvider) UserExtraKey() string {
  44. return "openid_connect_id"
  45. }
  46. func (o *oidcProvider) Config() *oauth2.Config {
  47. return &oauth2.Config{
  48. RedirectURL: o.redirectURL,
  49. ClientID: o.clientID,
  50. ClientSecret: o.clientSecret,
  51. Scopes: slices.Concat([]string{oidc.ScopeOpenID, "profile", "email"}, config.Opts.Oauth2AdditionalScopes()),
  52. Endpoint: o.provider.Endpoint(),
  53. }
  54. }
  55. func (o *oidcProvider) Profile(ctx context.Context, code, codeVerifier string) (*UserProfile, error) {
  56. conf := o.Config()
  57. token, err := conf.Exchange(ctx, code, oauth2.SetAuthURLParam("code_verifier", codeVerifier))
  58. if err != nil {
  59. return nil, fmt.Errorf(`oidc: failed to exchange token: %w`, err)
  60. }
  61. rawIDToken, ok := token.Extra("id_token").(string)
  62. if !ok {
  63. return nil, errors.New(`oidc: no id_token in token response`)
  64. }
  65. verifier := o.provider.Verifier(&oidc.Config{ClientID: o.clientID})
  66. idToken, err := verifier.Verify(ctx, rawIDToken)
  67. if err != nil {
  68. return nil, fmt.Errorf(`oidc: failed to verify id token: %w`, err)
  69. }
  70. userInfo, err := o.provider.UserInfo(ctx, oauth2.StaticTokenSource(token))
  71. if err != nil {
  72. return nil, fmt.Errorf(`oidc: failed to get user info: %w`, err)
  73. }
  74. if idToken.Subject != userInfo.Subject {
  75. return nil, fmt.Errorf(`oidc: id token subject %q does not match userinfo subject %q`, idToken.Subject, userInfo.Subject)
  76. }
  77. profile := &UserProfile{
  78. Key: o.UserExtraKey(),
  79. ID: userInfo.Subject,
  80. }
  81. var userClaims userClaims
  82. if err := userInfo.Claims(&userClaims); err != nil {
  83. return nil, fmt.Errorf(`oidc: failed to parse user claims: %w`, err)
  84. }
  85. // Use the first non-empty value from the claims to set the username.
  86. // The order of preference is: preferred_username, email, name, profile.
  87. for _, value := range []string{userClaims.PreferredUsername, userClaims.Email, userClaims.Name, userClaims.Profile} {
  88. if value != "" {
  89. profile.Username = value
  90. break
  91. }
  92. }
  93. if profile.Username == "" {
  94. return nil, ErrEmptyUsername
  95. }
  96. if groupClaim := config.Opts.Oauth2GroupClaim(); groupClaim != "" {
  97. var rawUserClaims map[string]any
  98. if err := userInfo.Claims(&rawUserClaims); err != nil {
  99. return nil, fmt.Errorf(`oidc: failed to parse user claims: %w`, err)
  100. }
  101. groups, found, err := groupsFromClaims(rawUserClaims, groupClaim)
  102. if err != nil {
  103. return nil, err
  104. }
  105. // Some providers only include the groups in the ID token.
  106. if !found {
  107. var rawIDTokenClaims map[string]any
  108. if err := idToken.Claims(&rawIDTokenClaims); err != nil {
  109. return nil, fmt.Errorf(`oidc: failed to parse id token claims: %w`, err)
  110. }
  111. groups, found, err = groupsFromClaims(rawIDTokenClaims, groupClaim)
  112. if err != nil {
  113. return nil, err
  114. }
  115. }
  116. if !found {
  117. slog.Warn("[OIDC] Group claim not found in the ID token or user info",
  118. slog.String("claim", groupClaim),
  119. slog.String("username", profile.Username),
  120. )
  121. }
  122. profile.Groups = groups
  123. }
  124. return profile, nil
  125. }
  126. func (o *oidcProvider) PopulateUserCreationWithProfileID(user *model.UserCreationRequest, profile *UserProfile) {
  127. user.OpenIDConnectID = profile.ID
  128. }
  129. func (o *oidcProvider) PopulateUserWithProfileID(user *model.User, profile *UserProfile) {
  130. user.OpenIDConnectID = profile.ID
  131. }
  132. func (o *oidcProvider) UserProfileID(user *model.User) string {
  133. return user.OpenIDConnectID
  134. }
  135. func (o *oidcProvider) UnsetUserProfileID(user *model.User) {
  136. user.OpenIDConnectID = ""
  137. }
  138. // groupsFromClaims returns the groups stored in the given claim, and whether the claim is present.
  139. func groupsFromClaims(claims map[string]any, claimName string) ([]string, bool, error) {
  140. rawValue, found := claims[claimName]
  141. if !found {
  142. return nil, false, nil
  143. }
  144. switch value := rawValue.(type) {
  145. case string:
  146. return []string{value}, true, nil
  147. case []any:
  148. groups := make([]string, 0, len(value))
  149. for _, rawEntry := range value {
  150. entry, ok := rawEntry.(string)
  151. if !ok {
  152. return nil, true, fmt.Errorf(`oidc: failed to parse user claims: %q must only contain strings`, claimName)
  153. }
  154. groups = append(groups, entry)
  155. }
  156. return groups, true, nil
  157. default:
  158. return nil, true, fmt.Errorf(`oidc: failed to parse user claims: %q must be a string or a list of strings`, claimName)
  159. }
  160. }