package server import ( "bytes" "context" "crypto" "crypto/ecdsa" "crypto/elliptic" "crypto/rsa" "crypto/sha256" "crypto/subtle" "encoding/base64" "encoding/json" "errors" "fmt" "io" "math/big" "net/http" "net/url" "slices" "strings" "sync" "time" ) const ( oidcMaxResponse = 1 << 20 oidcMaxToken = 64 << 10 oidcCacheTTL = 5 * time.Minute oidcRefreshInterval = 30 * time.Second oidcMaxIssuers = 64 oidcMaxKeys = 128 ) type oidcMetadata struct { Issuer string `json:"issuer"` AuthorizationEndpoint string `json:"authorization_endpoint"` TokenEndpoint string `json:"token_endpoint"` UserinfoEndpoint string `json:"userinfo_endpoint"` JWKSURI string `json:"jwks_uri"` SigningAlgorithms []string `json:"id_token_signing_alg_values_supported"` } type oidcIDClaims struct { Issuer string `json:"iss"` Sub string `json:"sub"` Aud json.RawMessage `json:"aud"` AuthorizedParty string `json:"azp"` Nonce string `json:"nonce"` Expiry int64 `json:"exp"` IssuedAt int64 `json:"iat"` NotBefore int64 `json:"nbf"` AccessTokenHash string `json:"at_hash"` } type oidcJWK struct { Kty string `json:"kty"` Kid string `json:"kid"` Alg string `json:"alg"` Use string `json:"use"` KeyOps []string `json:"key_ops"` N string `json:"n"` E string `json:"e"` Crv string `json:"crv"` X string `json:"x"` Y string `json:"y"` } type oidcProviderCache struct { mu sync.Mutex metadata oidcMetadata metadataExpires time.Time metadataAttempt time.Time keys []oidcJWK keysExpires time.Time keysAttempt time.Time keysRefreshAttempt time.Time used time.Time // guarded by oidcProviderVerifier.mu } type oidcProviderVerifier struct { client *http.Client now func() time.Time mu sync.Mutex providers map[string]*oidcProviderCache slots chan struct{} } type oidcProviderRequestError struct{ cause error } func (e *oidcProviderRequestError) Error() string { return "OIDC provider request failed" } func (e *oidcProviderRequestError) Unwrap() error { return e.cause } // This cache contains public issuer metadata and public keys only. Trust is // always scoped by the exact configured issuer, never by a token-supplied URL. var oidcVerifier = newOIDCProviderVerifier(nil) const oidcBrowserCookieName = "pageswiki_oidc_state" func oidcBrowserCookieForRequest(r *http.Request) string { if requestIsHTTPS(r) { return "__Host-" + oidcBrowserCookieName } return oidcBrowserCookieName } func setOIDCBrowserCookie(w http.ResponseWriter, r *http.Request, value string, maxAge int) { http.SetCookie(w, &http.Cookie{Name: oidcBrowserCookieForRequest(r), Value: value, Path: "/", HttpOnly: true, Secure: requestIsHTTPS(r), SameSite: http.SameSiteLaxMode, MaxAge: maxAge}) } func oidcBrowserCookie(r *http.Request) string { var value string count := 0 for _, cookie := range r.Cookies() { if cookie.Name == oidcBrowserCookieForRequest(r) { value = cookie.Value count++ } } if count != 1 { return "" } return value } func validOIDCBrowserChallenge(value, expected string) bool { if len(value) != 43 || expected == "" { return false } digest := sha256.Sum256([]byte(value)) return subtle.ConstantTimeCompare([]byte(base64.RawURLEncoding.EncodeToString(digest[:])), []byte(expected)) == 1 } func newOIDCProviderVerifier(client *http.Client) *oidcProviderVerifier { if client == nil { transport := http.DefaultTransport.(*http.Transport).Clone() transport.MaxResponseHeaderBytes = 64 << 10 transport.MaxConnsPerHost = 8 transport.MaxIdleConns = 16 transport.MaxIdleConnsPerHost = 2 transport.ResponseHeaderTimeout = 5 * time.Second client = &http.Client{Transport: transport} } copyClient := *client copyClient.Timeout = 5 * time.Second // In particular, never redirect a token POST carrying a client secret, or a // UserInfo request carrying an access token, to another endpoint. copyClient.CheckRedirect = func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse } return &oidcProviderVerifier{client: ©Client, now: time.Now, providers: make(map[string]*oidcProviderCache), slots: make(chan struct{}, 8)} } func validateOIDCURL(raw string, issuer bool) error { u, err := url.Parse(raw) if err != nil || u.Scheme != "https" || u.Hostname() == "" || u.User != nil || u.Fragment != "" || (issuer && (u.RawQuery != "" || u.ForceQuery)) { return errors.New("OIDC endpoints must be absolute HTTPS URLs without credentials or fragments") } return nil } func (v *oidcProviderVerifier) provider(issuer string) *oidcProviderCache { v.mu.Lock() defer v.mu.Unlock() entry := v.providers[issuer] if entry == nil { if len(v.providers) >= oidcMaxIssuers { var oldest string for key, cached := range v.providers { if oldest == "" || cached.used.Before(v.providers[oldest].used) { oldest = key } } delete(v.providers, oldest) } entry = &oidcProviderCache{} v.providers[issuer] = entry } entry.used = v.now() return entry } // requestJSON bounds the entire response read, not just the time to headers. func (v *oidcProviderVerifier) requestJSON(ctx context.Context, method, endpoint string, form url.Values, accessToken string, target any) error { if err := validateOIDCURL(endpoint, false); err != nil { return err } select { case v.slots <- struct{}{}: defer func() { <-v.slots }() case <-ctx.Done(): return ctx.Err() } var body io.Reader if form != nil { body = strings.NewReader(form.Encode()) } req, err := http.NewRequestWithContext(ctx, method, endpoint, body) if err != nil { return errors.New("invalid OIDC endpoint") } req.Header.Set("Accept", "application/json") if form != nil { req.Header.Set("Content-Type", "application/x-www-form-urlencoded") } if accessToken != "" { req.Header.Set("Authorization", "Bearer "+accessToken) } response, err := v.client.Do(req) if err != nil { return &oidcProviderRequestError{cause: err} } defer response.Body.Close() if response.StatusCode != http.StatusOK { return fmt.Errorf("OIDC provider returned HTTP %d", response.StatusCode) } raw, err := io.ReadAll(io.LimitReader(response.Body, oidcMaxResponse+1)) if err != nil || len(raw) > oidcMaxResponse { return errors.New("OIDC response is too large or incomplete") } return decodeOIDCObject(raw, target) } // Reject duplicate top-level members and trailing JSON; authentication data // must not depend on which JSON decoder happens to select a duplicate claim. func decodeOIDCObject(raw []byte, target any) error { d := json.NewDecoder(bytes.NewReader(raw)) first, err := d.Token() if err != nil || first != json.Delim('{') { return errors.New("invalid OIDC JSON object") } seen := make(map[string]bool) for d.More() { token, err := d.Token() key, ok := token.(string) if err != nil || !ok || seen[strings.ToLower(key)] { return errors.New("duplicate or invalid OIDC JSON member") } seen[strings.ToLower(key)] = true var value json.RawMessage if err := d.Decode(&value); err != nil { return errors.New("invalid OIDC JSON value") } } if _, err := d.Token(); err != nil { return errors.New("invalid OIDC JSON object") } if _, err := d.Token(); err != io.EOF { return errors.New("trailing OIDC JSON data") } return json.Unmarshal(raw, target) } func fetchOIDCMetadata(ctx context.Context, issuer string) (oidcMetadata, error) { return oidcVerifier.metadata(ctx, issuer) } func (v *oidcProviderVerifier) metadata(ctx context.Context, issuer string) (oidcMetadata, error) { var metadata oidcMetadata if err := validateOIDCURL(issuer, true); err != nil { return metadata, err } entry := v.provider(issuer) entry.mu.Lock() defer entry.mu.Unlock() now := v.now() if now.Before(entry.metadataExpires) { return entry.metadata, nil } if !entry.metadataAttempt.IsZero() && now.Sub(entry.metadataAttempt) < oidcRefreshInterval { return metadata, errors.New("OIDC discovery retry is temporarily limited") } entry.metadataAttempt = now if err := v.requestJSON(ctx, http.MethodGet, strings.TrimRight(issuer, "/")+"/.well-known/openid-configuration", nil, "", &metadata); err != nil { return metadata, err } if metadata.Issuer != issuer { return oidcMetadata{}, errors.New("OIDC discovery issuer mismatch") } for _, endpoint := range []string{metadata.AuthorizationEndpoint, metadata.TokenEndpoint, metadata.UserinfoEndpoint, metadata.JWKSURI} { if err := validateOIDCURL(endpoint, false); err != nil { return oidcMetadata{}, err } } if !slices.Contains(metadata.SigningAlgorithms, "RS256") && !slices.Contains(metadata.SigningAlgorithms, "ES256") { return oidcMetadata{}, errors.New("OIDC provider has no supported ID-token signing algorithm") } if entry.metadata.JWKSURI != metadata.JWKSURI { entry.keys, entry.keysExpires, entry.keysAttempt, entry.keysRefreshAttempt = nil, time.Time{}, time.Time{}, time.Time{} } entry.metadata, entry.metadataExpires = metadata, now.Add(oidcCacheTTL) return metadata, nil } func (v *oidcProviderVerifier) keys(ctx context.Context, metadata oidcMetadata, force bool) ([]oidcJWK, error) { entry := v.provider(metadata.Issuer) entry.mu.Lock() defer entry.mu.Unlock() now := v.now() if entry.metadata.JWKSURI != metadata.JWKSURI { return nil, errors.New("OIDC provider metadata changed; restart login") } if !force && now.Before(entry.keysExpires) { return entry.keys, nil } lastAttempt := entry.keysAttempt if force { lastAttempt = entry.keysRefreshAttempt } if !lastAttempt.IsZero() && now.Sub(lastAttempt) < oidcRefreshInterval { if now.Before(entry.keysExpires) { return entry.keys, nil } return nil, errors.New("OIDC signing-key retry is temporarily limited") } entry.keysAttempt = now if force { entry.keysRefreshAttempt = now } var set struct { Keys []oidcJWK `json:"keys"` } if err := v.requestJSON(ctx, http.MethodGet, metadata.JWKSURI, nil, "", &set); err != nil { return nil, err } if len(set.Keys) == 0 || len(set.Keys) > oidcMaxKeys { return nil, errors.New("OIDC signing-key set has an invalid size") } entry.keys, entry.keysExpires = set.Keys, now.Add(oidcCacheTTL) return entry.keys, nil } func (v *oidcProviderVerifier) verify(ctx context.Context, metadata oidcMetadata, token, clientID, nonce, accessToken string) (oidcIDClaims, error) { var claims oidcIDClaims if len(token) == 0 || len(token) > oidcMaxToken || clientID == "" || nonce == "" { return claims, errors.New("invalid OIDC ID token") } parts := strings.Split(token, ".") if len(parts) != 3 { return claims, errors.New("OIDC requires a signed compact ID token") } var header struct { Alg string `json:"alg"` Kid string `json:"kid"` Crit json.RawMessage `json:"crit"` B64 json.RawMessage `json:"b64"` } head, err := base64.RawURLEncoding.Strict().DecodeString(parts[0]) if err != nil || decodeOIDCObject(head, &header) != nil || len(header.Kid) > 256 || len(header.Crit) != 0 || len(header.B64) != 0 || (header.Alg != "RS256" && header.Alg != "ES256") || !slices.Contains(metadata.SigningAlgorithms, header.Alg) { return claims, errors.New("unsupported OIDC signature header") } signature, err := base64.RawURLEncoding.Strict().DecodeString(parts[2]) if err != nil { return claims, errors.New("invalid OIDC signature encoding") } keys, err := v.keys(ctx, metadata, false) if err != nil { return claims, err } digest := sha256.Sum256([]byte(parts[0] + "." + parts[1])) if !verifyOIDCSignature(keys, header.Alg, header.Kid, digest[:], signature) { // At most one refresh, globally limited per issuer, handles both a new // kid and providers that replace the public key while retaining a kid. keys, err = v.keys(ctx, metadata, true) if err != nil || !verifyOIDCSignature(keys, header.Alg, header.Kid, digest[:], signature) { return claims, errors.New("OIDC ID-token signature is invalid") } } payload, err := base64.RawURLEncoding.Strict().DecodeString(parts[1]) if err != nil || decodeOIDCObject(payload, &claims) != nil { return oidcIDClaims{}, errors.New("invalid OIDC ID-token claims") } now := v.now().Unix() if claims.Issuer != metadata.Issuer || claims.Sub == "" || len(claims.Sub) > 255 || !oidcAudienceContains(claims.Aud, clientID) || (claims.AuthorizedParty != "" && claims.AuthorizedParty != clientID) || subtle.ConstantTimeCompare([]byte(claims.Nonce), []byte(nonce)) != 1 || claims.Expiry <= now || claims.IssuedAt <= 0 || claims.IssuedAt > now+60 || claims.IssuedAt >= claims.Expiry || claims.NotBefore < 0 || claims.NotBefore > now+60 || (claims.NotBefore != 0 && claims.NotBefore >= claims.Expiry) { return oidcIDClaims{}, errors.New("OIDC ID-token claims are invalid") } if claims.AccessTokenHash != "" { digest := sha256.Sum256([]byte(accessToken)) expected := base64.RawURLEncoding.EncodeToString(digest[:16]) if accessToken == "" || subtle.ConstantTimeCompare([]byte(claims.AccessTokenHash), []byte(expected)) != 1 { return oidcIDClaims{}, errors.New("OIDC access-token hash mismatch") } } return claims, nil } func oidcAudienceContains(raw json.RawMessage, clientID string) bool { var single string if json.Unmarshal(raw, &single) == nil { return single != "" && single == clientID } var many []string // No other client audiences are configured as trusted. Do not silently // trust additional audiences just because an azp claim is present. return json.Unmarshal(raw, &many) == nil && len(many) == 1 && many[0] == clientID && clientID != "" } func verifyOIDCSignature(keys []oidcJWK, alg, kid string, digest, signature []byte) bool { var candidate *oidcJWK for i := range keys { key := &keys[i] if (kid != "" && key.Kid != kid) || (key.Alg != "" && key.Alg != alg) || (key.Use != "" && key.Use != "sig") || (key.KeyOps != nil && !slices.Contains(key.KeyOps, "verify")) || (alg == "RS256" && key.Kty != "RSA") || (alg == "ES256" && key.Kty != "EC") { continue } if candidate != nil { return false } // Ambiguous key selection fails closed. candidate = key } if candidate == nil { return false } decode := base64.RawURLEncoding.Strict().DecodeString if alg == "RS256" { n, err := decode(candidate.N) if err != nil || len(n) < 256 || len(n) > 1024 { return false } e, err := decode(candidate.E) if err != nil || len(e) == 0 || len(e) > 4 { return false } exponent := new(big.Int).SetBytes(e).Int64() modulus := new(big.Int).SetBytes(n) if exponent < 3 || exponent > 1<<31-1 || exponent%2 == 0 || modulus.BitLen() < 2048 || modulus.Bit(0) == 0 { return false } return rsa.VerifyPKCS1v15(&rsa.PublicKey{N: modulus, E: int(exponent)}, crypto.SHA256, digest, signature) == nil } x, err := decode(candidate.X) if err != nil || len(x) != 32 || candidate.Crv != "P-256" { return false } y, err := decode(candidate.Y) if err != nil || len(y) != 32 || len(signature) != 64 { return false } key := &ecdsa.PublicKey{Curve: elliptic.P256(), X: new(big.Int).SetBytes(x), Y: new(big.Int).SetBytes(y)} if !key.Curve.IsOnCurve(key.X, key.Y) { return false } return ecdsa.Verify(key, digest, new(big.Int).SetBytes(signature[:32]), new(big.Int).SetBytes(signature[32:])) }