Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
449 lines
15 KiB
Go
449 lines
15 KiB
Go
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:]))
|
|
}
|