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.
545 lines
21 KiB
Go
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")
|
|
}
|
|
}
|