Files
pages/internal/server/oidc_verify_test.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
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.
2026-09-27 14:44:43 +09:00

545 lines
21 KiB
Go

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")
}
}