package server import ( "context" "crypto" "crypto/ecdsa" "crypto/elliptic" "crypto/rand" "crypto/rsa" "crypto/sha256" "encoding/base64" "encoding/json" "math/big" "net/http" "net/http/httptest" "net/url" "strings" "sync" "testing" "time" "pageswiki/internal/store" ) type oidcTestProvider struct { server *httptest.Server verifier *oidcProviderVerifier key *rsa.PrivateKey mu sync.Mutex keys []oidcJWK counts map[string]int metadataOverride func(*oidcMetadata) broken, oversized, redirect string idToken, userinfoSub string userinfoName, userinfoDisplayName, userinfoPreferredName string } func newOIDCTestProvider(t *testing.T) *oidcTestProvider { t.Helper() key, err := rsa.GenerateKey(rand.Reader, 2048) if err != nil { t.Fatal(err) } p := &oidcTestProvider{key: key, keys: []oidcJWK{oidcTestRSAJWK(key, "one")}, counts: make(map[string]int), userinfoSub: "subject", userinfoName: "Test Admin", userinfoPreferredName: "admin"} p.server = httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { p.mu.Lock() defer p.mu.Unlock() p.counts[r.URL.Path]++ if r.URL.Path == p.broken { http.Error(w, "unavailable", http.StatusServiceUnavailable) return } if r.URL.Path == p.oversized { _, _ = w.Write([]byte(strings.Repeat(" ", oidcMaxResponse) + "{}")) return } if r.URL.Path == p.redirect { http.Redirect(w, r, p.server.URL+"/redirect-target", http.StatusTemporaryRedirect) return } w.Header().Set("Content-Type", "application/json") switch r.URL.Path { case "/.well-known/openid-configuration": metadata := oidcMetadata{Issuer: p.server.URL, AuthorizationEndpoint: p.server.URL + "/authorize?provider=value", TokenEndpoint: p.server.URL + "/token", UserinfoEndpoint: p.server.URL + "/userinfo", JWKSURI: p.server.URL + "/keys", SigningAlgorithms: []string{"RS256", "ES256"}} if p.metadataOverride != nil { p.metadataOverride(&metadata) } _ = json.NewEncoder(w).Encode(metadata) case "/keys": _ = json.NewEncoder(w).Encode(map[string]any{"keys": p.keys}) case "/token": _ = json.NewEncoder(w).Encode(map[string]string{"access_token": "access", "id_token": p.idToken, "token_type": "Bearer"}) case "/userinfo": _ = json.NewEncoder(w).Encode(map[string]any{"sub": p.userinfoSub, "name": p.userinfoName, "display_name": p.userinfoDisplayName, "preferred_username": p.userinfoPreferredName, "email": "admin@example.test", "email_verified": true}) default: http.NotFound(w, r) } })) t.Cleanup(p.server.Close) p.verifier = newOIDCProviderVerifier(p.server.Client()) return p } func oidcTestRSAJWK(key *rsa.PrivateKey, kid string) oidcJWK { return oidcJWK{Kty: "RSA", Kid: kid, Alg: "RS256", Use: "sig", N: base64.RawURLEncoding.EncodeToString(key.N.Bytes()), E: base64.RawURLEncoding.EncodeToString(big.NewInt(int64(key.E)).Bytes())} } func oidcTestClaims(issuer string) map[string]any { now := time.Now().Unix() return map[string]any{"iss": issuer, "sub": "subject", "aud": "client", "nonce": "nonce", "iat": now, "exp": now + 600} } func oidcTestToken(t *testing.T, key any, header, claims any) string { t.Helper() encode := func(value any) []byte { if raw, ok := value.(json.RawMessage); ok { return raw } data, err := json.Marshal(value) if err != nil { t.Fatal(err) } return data } input := base64.RawURLEncoding.EncodeToString(encode(header)) + "." + base64.RawURLEncoding.EncodeToString(encode(claims)) digest := sha256.Sum256([]byte(input)) var signature []byte switch key := key.(type) { case *rsa.PrivateKey: var err error signature, err = rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, digest[:]) if err != nil { t.Fatal(err) } case *ecdsa.PrivateKey: r, s, err := ecdsa.Sign(rand.Reader, key, digest[:]) if err != nil { t.Fatal(err) } signature = append(r.FillBytes(make([]byte, 32)), s.FillBytes(make([]byte, 32))...) default: t.Fatal("unsupported test key") } return input + "." + base64.RawURLEncoding.EncodeToString(signature) } func TestOIDCSignatureAndClaims(t *testing.T) { p := newOIDCTestProvider(t) metadata, err := p.verifier.metadata(context.Background(), p.server.URL) if err != nil { t.Fatal(err) } header := map[string]any{"alg": "RS256", "kid": "one"} verify := func(token string) error { _, err := p.verifier.verify(context.Background(), metadata, token, "client", "nonce", "access") return err } valid := oidcTestToken(t, p.key, header, oidcTestClaims(p.server.URL)) if err := verify(valid); err != nil { t.Fatalf("valid RS256: %v", err) } for name, mutate := range map[string]func(map[string]any){ "issuer": func(c map[string]any) { c["iss"] = p.server.URL + "/" }, "audience": func(c map[string]any) { c["aud"] = "other" }, "untrusted additional audience": func(c map[string]any) { c["aud"] = []string{"client", "other"}; c["azp"] = "client" }, "authorized party": func(c map[string]any) { c["azp"] = "other" }, "nonce": func(c map[string]any) { c["nonce"] = "other" }, "missing nonce": func(c map[string]any) { delete(c, "nonce") }, "missing subject": func(c map[string]any) { delete(c, "sub") }, "expired": func(c map[string]any) { c["exp"] = time.Now().Unix() }, "future issued": func(c map[string]any) { c["iat"] = time.Now().Unix() + 120 }, "missing issued": func(c map[string]any) { delete(c, "iat") }, "future not before": func(c map[string]any) { c["nbf"] = time.Now().Unix() + 120 }, "string expiry": func(c map[string]any) { c["exp"] = "9999999999" }, "access token hash": func(c map[string]any) { c["at_hash"] = "wrong" }, } { t.Run(name, func(t *testing.T) { claims := oidcTestClaims(p.server.URL) mutate(claims) if verify(oidcTestToken(t, p.key, header, claims)) == nil { t.Fatal("invalid claims accepted") } }) } for _, alg := range []string{"none", "HS256", "RS512", "ES256"} { t.Run("wrong algorithm "+alg, func(t *testing.T) { if verify(oidcTestToken(t, p.key, map[string]any{"alg": alg, "kid": "one"}, oidcTestClaims(p.server.URL))) == nil { t.Fatal("wrong algorithm accepted") } }) } for name, head := range map[string]any{ "critical extension": map[string]any{"alg": "RS256", "kid": "one", "crit": []string{"custom"}}, "unencoded payload": map[string]any{"alg": "RS256", "kid": "one", "b64": false}, "duplicate algorithm": json.RawMessage(`{"alg":"none","alg":"RS256","kid":"one"}`), } { t.Run(name, func(t *testing.T) { if verify(oidcTestToken(t, p.key, head, oidcTestClaims(p.server.URL))) == nil { t.Fatal("invalid header accepted") } }) } parts := strings.Split(valid, ".") signature, _ := base64.RawURLEncoding.DecodeString(parts[2]) signature[0] ^= 1 parts[2] = base64.RawURLEncoding.EncodeToString(signature) if verify(strings.Join(parts, ".")) == nil { t.Fatal("forged signature accepted") } if verify(strings.Repeat("a", oidcMaxToken+1)) == nil { t.Fatal("oversized token accepted") } claims := oidcTestClaims(p.server.URL) claims["aud"] = []string{"client"} claims["azp"] = "client" digest := sha256.Sum256([]byte("access")) claims["at_hash"] = base64.RawURLEncoding.EncodeToString(digest[:16]) if err := verify(oidcTestToken(t, p.key, header, claims)); err != nil { t.Fatalf("valid optional claims: %v", err) } if err := verify(oidcTestToken(t, p.key, map[string]string{"alg": "RS256"}, claims)); err != nil { t.Fatalf("unambiguous missing kid: %v", err) } } func TestOIDCES256AndKeyConstraints(t *testing.T) { p := newOIDCTestProvider(t) ec, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader) if err != nil { t.Fatal(err) } key := oidcJWK{Kty: "EC", Kid: "ec", Alg: "ES256", Use: "sig", Crv: "P-256", X: base64.RawURLEncoding.EncodeToString(ec.X.FillBytes(make([]byte, 32))), Y: base64.RawURLEncoding.EncodeToString(ec.Y.FillBytes(make([]byte, 32)))} p.mu.Lock() p.keys = []oidcJWK{key} p.mu.Unlock() metadata, err := p.verifier.metadata(context.Background(), p.server.URL) if err != nil { t.Fatal(err) } token := oidcTestToken(t, ec, map[string]string{"alg": "ES256", "kid": "ec"}, oidcTestClaims(p.server.URL)) if _, err := p.verifier.verify(context.Background(), metadata, token, "client", "nonce", "access"); err != nil { t.Fatalf("valid ES256: %v", err) } parts := strings.Split(token, ".") signature, _ := base64.RawURLEncoding.DecodeString(parts[2]) digest := sha256.Sum256([]byte(parts[0] + "." + parts[1])) for name, change := range map[string]func(*oidcJWK){ "encryption key": func(k *oidcJWK) { k.Use = "enc" }, "sign only": func(k *oidcJWK) { k.KeyOps = []string{"sign"} }, "no operations": func(k *oidcJWK) { k.KeyOps = []string{} }, "wrong curve": func(k *oidcJWK) { k.Crv = "P-384" }, "wrong algorithm": func(k *oidcJWK) { k.Alg = "RS256" }, "invalid point": func(k *oidcJWK) { k.X = base64.RawURLEncoding.EncodeToString(make([]byte, 32)) }, } { t.Run(name, func(t *testing.T) { changed := key change(&changed) if verifyOIDCSignature([]oidcJWK{changed}, "ES256", "ec", digest[:], signature) { t.Fatal("invalid key accepted") } }) } if verifyOIDCSignature([]oidcJWK{key, key}, "ES256", "ec", digest[:], signature) { t.Fatal("ambiguous keys accepted") } } func TestOIDCCacheRotationAndBounds(t *testing.T) { p := newOIDCTestProvider(t) now := time.Now() p.verifier.now = func() time.Time { return now } metadata, err := p.verifier.metadata(context.Background(), p.server.URL) if err != nil { t.Fatal(err) } _, _ = p.verifier.metadata(context.Background(), p.server.URL) valid := oidcTestToken(t, p.key, map[string]string{"alg": "RS256", "kid": "one"}, oidcTestClaims(p.server.URL)) var wg sync.WaitGroup for range 16 { wg.Add(1) go func() { defer wg.Done() if _, err := p.verifier.verify(context.Background(), metadata, valid, "client", "nonce", "access"); err != nil { t.Errorf("concurrent verification: %v", err) } }() } wg.Wait() p.mu.Lock() discovery, initialKeys := p.counts["/.well-known/openid-configuration"], p.counts["/keys"] p.mu.Unlock() if discovery != 1 || initialKeys != 1 { t.Fatalf("cache did not coalesce requests: discovery=%d keys=%d", discovery, initialKeys) } rotated, _ := rsa.GenerateKey(rand.Reader, 2048) p.mu.Lock() p.keys = []oidcJWK{oidcTestRSAJWK(rotated, "two")} p.mu.Unlock() rotatedToken := oidcTestToken(t, rotated, map[string]string{"alg": "RS256", "kid": "two"}, oidcTestClaims(p.server.URL)) if _, err := p.verifier.verify(context.Background(), metadata, rotatedToken, "client", "nonce", "access"); err != nil { t.Fatalf("new signing key not refreshed: %v", err) } for range 10 { if _, err := p.verifier.verify(context.Background(), metadata, valid, "client", "nonce", "access"); err == nil { t.Fatal("removed signing key accepted") } } p.mu.Lock() afterRotation := p.counts["/keys"] p.mu.Unlock() if afterRotation != 2 { t.Fatalf("unbounded invalid-key refreshes: %d", afterRotation) } now = now.Add(31 * time.Second) p.mu.Lock() p.broken = "/keys" p.mu.Unlock() if _, err := p.verifier.verify(context.Background(), metadata, valid, "client", "nonce", "access"); err == nil { t.Fatal("failed refresh authenticated token") } if _, err := p.verifier.verify(context.Background(), metadata, rotatedToken, "client", "nonce", "access"); err != nil { t.Fatalf("still-fresh cached key failed during provider outage: %v", err) } now = now.Add(oidcCacheTTL) if _, err := p.verifier.verify(context.Background(), metadata, rotatedToken, "client", "nonce", "access"); err == nil { t.Fatal("expired cached key accepted during provider outage") } for i := range oidcMaxIssuers + 10 { now = now.Add(time.Second) p.verifier.provider(string(rune(i + 64))) } if len(p.verifier.providers) != oidcMaxIssuers { t.Fatalf("cache exceeded issuer limit: %d", len(p.verifier.providers)) } } func TestOIDCDiscoveryAndTransportDenials(t *testing.T) { p := newOIDCTestProvider(t) for _, issuer := range []string{"http://id.test", "https://user:pass@id.test", "https://id.test/?query", "https://id.test/#fragment", "/relative"} { if _, err := p.verifier.metadata(context.Background(), issuer); err == nil { t.Fatalf("unsafe issuer accepted: %s", issuer) } } for name, change := range map[string]func(*oidcMetadata){ "issuer mismatch": func(m *oidcMetadata) { m.Issuer += "/" }, "HTTP token endpoint": func(m *oidcMetadata) { m.TokenEndpoint = "http://id.test/token" }, "credentials in JWKS": func(m *oidcMetadata) { m.JWKSURI = "https://user:pass@id.test/keys" }, "missing JWKS": func(m *oidcMetadata) { m.JWKSURI = "" }, "unsupported algorithm": func(m *oidcMetadata) { m.SigningAlgorithms = []string{"none", "HS256"} }, } { t.Run(name, func(t *testing.T) { p.mu.Lock() p.metadataOverride = change p.mu.Unlock() verifier := newOIDCProviderVerifier(p.server.Client()) if _, err := verifier.metadata(context.Background(), p.server.URL); err == nil { t.Fatal("invalid discovery accepted") } }) } p.mu.Lock() p.metadataOverride = nil p.oversized = "/oversized" p.redirect = "/token" p.mu.Unlock() var response map[string]any if p.verifier.requestJSON(context.Background(), http.MethodGet, p.server.URL+"/oversized", nil, "", &response) == nil { t.Fatal("oversized response accepted") } if p.verifier.requestJSON(context.Background(), http.MethodPost, p.server.URL+"/token", url.Values{"client_secret": {"secret"}}, "", &response) == nil { t.Fatal("token redirect accepted") } p.mu.Lock() redirectRequests := p.counts["/redirect-target"] p.mu.Unlock() if redirectRequests != 0 { t.Fatal("credentials were sent to a redirect target") } for _, raw := range []string{`{"sub":"first","sub":"second"}`, `{"sub":"first","SUB":"second"}`, `{} {}`, `null`, `[]`} { if decodeOIDCObject([]byte(raw), &response) == nil { t.Fatalf("ambiguous JSON accepted: %s", raw) } } ctx, cancel := context.WithCancel(context.Background()) cancel() if p.verifier.requestJSON(ctx, http.MethodGet, p.server.URL+"/keys", nil, "", &response) == nil { t.Fatal("canceled fetch succeeded") } } func TestOIDCCallbackBindingAndVerification(t *testing.T) { for _, mode := range []string{"valid", "preferred username", "display name", "ambiguous display name", "forged", "wrong browser", "missing browser", "duplicate browser", "subject mismatch", "provider changed"} { t.Run(mode, func(t *testing.T) { s, _, domain := configFixture(t) p := newOIDCTestProvider(t) previous := oidcVerifier oidcVerifier = p.verifier t.Cleanup(func() { oidcVerifier = previous }) if _, err := s.store.DB.Exec(`UPDATE principals SET email='admin@example.test'`); err != nil { t.Fatal(err) } config := store.AuthProviderConfig{Kind: "oidc", Enabled: true, Issuer: p.server.URL, ClientID: "client", ClientSecret: "secret"} if strings.Contains(mode, "display name") { config.OIDCMatchBy = "display_name" p.userinfoName = "Test Admin" p.userinfoDisplayName = "A different provider display name" if _, err := s.store.DB.Exec(`UPDATE principals SET email='not-the-oidc-address@example.test'`); err != nil { t.Fatal(err) } } if mode == "preferred username" { config.OIDCMatchBy = "preferred_username" if _, err := s.store.DB.Exec(`UPDATE principals SET email='not-the-oidc-address@example.test',display_name='Not an OIDC display name'`); err != nil { t.Fatal(err) } } if mode == "ambiguous display name" { if _, err := s.store.CreatePasswordAccount(domain, "another", "another long test password", "Test Admin", "another@example.test"); err != nil { t.Fatal(err) } } if err := s.store.SetAuthProviderConfig(domain, config); err != nil { t.Fatal(err) } begin := httptest.NewRecorder() s.beginOIDC(begin, httptest.NewRequest(http.MethodGet, "https://localhost/_/auth/oidc?return=/destination", nil)) if begin.Code != http.StatusFound { t.Fatalf("begin: %d %s", begin.Code, begin.Body.String()) } location, _ := url.Parse(begin.Header().Get("Location")) if location.Query().Get("provider") != "value" || location.Query().Get("code_challenge_method") != "S256" { t.Fatal("authorization query or PKCE lost") } cookies := begin.Result().Cookies() if len(cookies) != 1 || !cookies[0].Secure || !cookies[0].HttpOnly || cookies[0].SameSite != http.SameSiteLaxMode || !strings.HasPrefix(cookies[0].Name, "__Host-") { t.Fatalf("unsafe browser state cookie: %+v", cookies) } claims := oidcTestClaims(p.server.URL) claims["nonce"] = location.Query().Get("nonce") token := oidcTestToken(t, p.key, map[string]string{"alg": "RS256", "kid": "one"}, claims) if mode == "forged" { parts := strings.Split(token, ".") signature, _ := base64.RawURLEncoding.DecodeString(parts[2]) signature[0] ^= 1 parts[2] = base64.RawURLEncoding.EncodeToString(signature) token = strings.Join(parts, ".") } p.mu.Lock() p.idToken = token if mode == "subject mismatch" { p.userinfoSub = "other" } p.mu.Unlock() callbackURL := "https://localhost/_/auth/callback/oidc?code=code&state=" + url.QueryEscape(location.Query().Get("state")) request := httptest.NewRequest(http.MethodGet, callbackURL, nil) if mode == "wrong browser" { cookies[0].Value = randomURLToken(32) } if mode != "missing browser" { request.AddCookie(cookies[0]) } if mode == "duplicate browser" { request.AddCookie(cookies[0]) } if mode == "provider changed" { config.ClientID = "new-client" if err := s.store.SetAuthProviderConfig(domain, config); err != nil { t.Fatal(err) } } response := httptest.NewRecorder() s.completeOIDC(response, request) var count int if err := s.store.DB.QueryRow(`SELECT COUNT(*) FROM principal_identities WHERE provider_type='oidc'`).Scan(&count); err != nil { t.Fatal(err) } if mode == "valid" || mode == "display name" || mode == "preferred username" { if response.Code != http.StatusSeeOther || response.Header().Get("Location") != "/destination" || count != 1 { t.Fatalf("valid callback: status=%d identities=%d body=%s", response.Code, count, response.Body.String()) } var session string for _, cookie := range response.Result().Cookies() { if cookie.Name == authCookieName { session = cookie.Value } } if _, err := s.store.PrincipalForSession(domain, session); err != nil { t.Fatalf("session not issued: %v", err) } } else { if response.Code < 400 || count != 0 { t.Fatalf("invalid callback authenticated: status=%d identities=%d", response.Code, count) } for _, cookie := range response.Result().Cookies() { if cookie.Name == authCookieName && cookie.Value != "" { t.Fatal("invalid callback issued session") } } p.mu.Lock() userinfo, exchange := p.counts["/userinfo"], p.counts["/token"] p.mu.Unlock() if mode == "forged" && userinfo != 0 { t.Fatal("unverified claims reached UserInfo") } if strings.Contains(mode, "browser") && exchange != 0 { t.Fatal("unbound browser reached token exchange") } } replay := httptest.NewRecorder() s.completeOIDC(replay, request) if replay.Code != http.StatusBadRequest { t.Fatalf("state replay not rejected: %d", replay.Code) } }) } } func TestOIDCFlowMethods(t *testing.T) { s := &Server{} for _, method := range []string{http.MethodPost, http.MethodPut, http.MethodHead, http.MethodDelete} { for _, handler := range []http.HandlerFunc{s.beginOIDC, s.completeOIDC} { response := httptest.NewRecorder() handler(response, httptest.NewRequest(method, "https://localhost/_/auth/oidc", nil)) if response.Code != http.StatusMethodNotAllowed || response.Header().Get("Allow") != "GET" { t.Fatalf("OIDC accepted %s: %d", method, response.Code) } } } } func TestOIDCFetchTimeoutAndKeySetLimit(t *testing.T) { slow := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"pending":`)) w.(http.Flusher).Flush() <-r.Context().Done() })) defer slow.Close() verifier := newOIDCProviderVerifier(slow.Client()) ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) defer cancel() var response map[string]any started := time.Now() if verifier.requestJSON(ctx, http.MethodGet, slow.URL, nil, "", &response) == nil { t.Fatal("incomplete body accepted") } if time.Since(started) > time.Second { t.Fatal("body read did not honor the request deadline") } if len(verifier.slots) != 0 { t.Fatal("failed fetch leaked its admission slot") } p := newOIDCTestProvider(t) p.mu.Lock() p.keys = make([]oidcJWK, oidcMaxKeys+1) p.mu.Unlock() metadata, err := p.verifier.metadata(context.Background(), p.server.URL) if err != nil { t.Fatal(err) } if _, err := p.verifier.keys(context.Background(), metadata, false); err == nil { t.Fatal("unbounded key set accepted") } }