Files
summercms/modules/wristband/consent_path_test.go
Jakub Zych 1dcc2ed06d fix(32.2): WR-02 refuse a ConsentPath that is not a same-origin path
Add wristband.CheckConsentPath (additive, for hosts to call at boot) and make Authorize answer 500 before storing a pending request while the configured path fails it, so the handoff can never leave the issuer's origin.
2026-11-21 09:08:12 +01:00

301 lines
12 KiB
Go

package wristband
import (
"context"
"net/http"
"net/http/httptest"
"net/url"
"slices"
"strings"
"testing"
)
// consentPathServer builds a server on issuer with one public client "cli"
// at authorizeTestRedirect; mutate may change the options first.
func consentPathServer(t *testing.T, issuer string, mutate func(*Options)) *Server {
t.Helper()
backend := newMemoryBackend()
opts := DefaultOptions()
opts.Issuer = issuer
opts.Resource = issuer + "/mcp"
if mutate != nil {
mutate(&opts)
}
srv := NewServer(opts)
srv.SetBackend(backend)
insertAuthorizeTestClient(backend, "cli", []string{authorizeTestRedirect}, nil)
return srv
}
// consentPathAuthorize runs one authorize request. scope nil sends no scope
// parameter; a non-nil scope (empty included) sends it as given. It answers
// the recorder of a 302.
func consentPathAuthorize(t *testing.T, srv *Server, scope *string) *httptest.ResponseRecorder {
t.Helper()
_, challenge := s256Pair(t)
q := url.Values{}
q.Set("client_id", "cli")
q.Set("redirect_uri", authorizeTestRedirect)
q.Set("response_type", "code")
q.Set("code_challenge", challenge)
q.Set("code_challenge_method", "S256")
if scope != nil {
q.Set("scope", *scope)
}
rec := httptest.NewRecorder()
srv.Authorize(rec, httptest.NewRequest(http.MethodGet, "/oauth/mcp/authorize?"+q.Encode(), nil))
if rec.Code != http.StatusFound {
t.Fatalf("authorize status = %d %s, want 302", rec.Code, rec.Body.String())
}
return rec
}
// handoffRequest answers the request id of a handoff Location that must
// start with prefix and carry nothing but the escaped id after it.
func handoffRequest(t *testing.T, location, prefix string) string {
t.Helper()
if !strings.HasPrefix(location, prefix) {
t.Fatalf("Location = %q, want prefix %q", location, prefix)
}
escaped := strings.TrimPrefix(location, prefix)
id, err := url.QueryUnescape(escaped)
if err != nil || id == "" || strings.ContainsAny(escaped, "?&#/") {
t.Fatalf("Location = %q carries no plain request id", location)
}
if rfc3986Escape(id) != escaped {
t.Fatalf("request id %q is not RFC 3986 escaped in %q", id, location)
}
return id
}
// TestAuthorizeConsentPath locks the authorize handoff (SC-1, D-04): with
// Options.ConsentPath empty the Location is byte for byte the PHP
// {issuer}/connect?request=<RFC 3986 escaped id>, with the PHP headers; a
// set path replaces /connect on the same issuer; an issuer with a path
// segment keeps it in front of the consent path.
func TestAuthorizeConsentPath(t *testing.T) {
read := "read"
cases := []struct {
name, issuer, path, prefix string
}{
{"empty path is the PHP /connect", "https://issuer.example.test", "", "https://issuer.example.test/connect?request="},
{"a set path replaces /connect", "https://issuer.example.test", "/backend/connect", "https://issuer.example.test/backend/connect?request="},
{"an issuer path segment is kept", "https://issuer.example.test/tenant", "", "https://issuer.example.test/tenant/connect?request="},
{"an issuer path segment with a set path", "https://issuer.example.test/tenant", "/gfadmin/connect", "https://issuer.example.test/tenant/gfadmin/connect?request="},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
srv := consentPathServer(t, tc.issuer, func(o *Options) { o.ConsentPath = tc.path })
rec := consentPathAuthorize(t, srv, &read)
location := rec.Header().Get("Location")
id := handoffRequest(t, location, tc.prefix)
if location != tc.issuer+srv.consentPath()+"?request="+rfc3986Escape(id) {
t.Fatalf("Location %q is not issuer + consent path + escaped id", location)
}
if got := rec.Header().Get("Cache-Control"); got != "no-store, private" {
t.Fatalf("Cache-Control = %q, want the PHP no-store, private", got)
}
if _, err := srv.PendingRequest(context.Background(), id, 1); err != nil {
t.Fatalf("the handed-off request is not pending: %v", err)
}
})
}
t.Run("the default options leave the path empty", func(t *testing.T) {
if DefaultOptions().ConsentPath != "" || len(DefaultOptions().DefaultScopes) != 0 {
t.Fatalf("DefaultOptions sets ConsentPath %q DefaultScopes %v", DefaultOptions().ConsentPath, DefaultOptions().DefaultScopes)
}
srv := consentPathServer(t, "https://issuer.example.test", nil)
if srv.consentPath() != "/connect" {
t.Fatalf("consentPath = %q, want /connect", srv.consentPath())
}
})
t.Run("empty and explicit /connect answer the same bytes", func(t *testing.T) {
empty := consentPathServer(t, "https://issuer.example.test", nil)
explicit := consentPathServer(t, "https://issuer.example.test", func(o *Options) { o.ConsentPath = "/connect" })
a := consentPathAuthorize(t, empty, &read)
b := consentPathAuthorize(t, explicit, &read)
idA := handoffRequest(t, a.Header().Get("Location"), "https://issuer.example.test/connect?request=")
idB := handoffRequest(t, b.Header().Get("Location"), "https://issuer.example.test/connect?request=")
bodyA := strings.ReplaceAll(a.Body.String(), rfc3986Escape(idA), "ID")
bodyB := strings.ReplaceAll(b.Body.String(), rfc3986Escape(idB), "ID")
if bodyA != bodyB || !strings.Contains(bodyA, "/connect?request=ID") {
t.Fatalf("redirect bodies differ:\n%s\n%s", bodyA, bodyB)
}
})
}
// TestAuthorizeDefaultScopes locks the scope fallback of an authorize
// request (SC-1, D-04): an absent, empty or identity-only scope value gets
// Options.DefaultScopes; entries outside the accepted set, identity scopes
// and repeats are dropped from it; empty DefaultScopes (or nothing left)
// keeps the PHP read; an explicit data scope is never replaced.
func TestAuthorizeDefaultScopes(t *testing.T) {
const issuer = "https://issuer.example.test"
str := func(s string) *string { return &s }
stored := func(t *testing.T, srv *Server, scope *string) []string {
t.Helper()
rec := consentPathAuthorize(t, srv, scope)
id := handoffRequest(t, rec.Header().Get("Location"), issuer+"/connect?request=")
view, err := srv.PendingRequest(context.Background(), id, 1)
if err != nil {
t.Fatal(err)
}
return view.ScopesRequested
}
withCatalog := func(defaults ...string) func(*Options) {
return func(o *Options) {
o.ScopesSupported = []string{"*", "admin:read", "acme", "acme:read", "offline_access"}
o.DefaultScopes = defaults
}
}
t.Run("absent, empty and identity-only values get the default scopes", func(t *testing.T) {
srv := consentPathServer(t, issuer, withCatalog("*", "admin:read", "acme", "acme:read"))
for name, scope := range map[string]*string{
"absent": nil,
"empty": str(""),
"blank": str(" "),
"identity only": str("openid profile email"),
} {
if got := stored(t, srv, scope); !slices.Equal(got, []string{"*", "admin:read", "acme", "acme:read"}) {
t.Fatalf("%s scope stored %v, want the default scopes in order", name, got)
}
}
})
t.Run("defaults outside the accepted set, identity scopes and repeats are dropped", func(t *testing.T) {
srv := consentPathServer(t, issuer, withCatalog(" acme ", "openid", "unknown", "acme", "", "acme:read"))
if got := stored(t, srv, nil); !slices.Equal(got, []string{"acme", "acme:read"}) {
t.Fatalf("stored %v, want [acme acme:read]", got)
}
})
t.Run("empty default scopes keep read", func(t *testing.T) {
srv := consentPathServer(t, issuer, nil)
for _, scope := range []*string{nil, str(""), str("openid")} {
if got := stored(t, srv, scope); !slices.Equal(got, []string{"read"}) {
t.Fatalf("stored %v, want [read]", got)
}
}
})
t.Run("defaults with nothing accepted keep read", func(t *testing.T) {
srv := consentPathServer(t, issuer, func(o *Options) { o.DefaultScopes = []string{"acme", "openid"} })
if got := stored(t, srv, nil); !slices.Equal(got, []string{"read"}) {
t.Fatalf("stored %v, want [read]", got)
}
})
t.Run("an offline_access-only request gets the default scopes and keeps offline access", func(t *testing.T) {
srv := consentPathServer(t, issuer, withCatalog("*", "admin:read", "offline_access"))
for _, scope := range []string{"offline_access", "openid offline_access", "offline_access offline_access"} {
rec := consentPathAuthorize(t, srv, str(scope))
id := handoffRequest(t, rec.Header().Get("Location"), issuer+"/connect?request=")
view, err := srv.PendingRequest(context.Background(), id, 1)
if err != nil {
t.Fatal(err)
}
if !slices.Equal(view.ScopesRequested, []string{"*", "admin:read"}) {
t.Fatalf("%q stored %v, want the default scopes", scope, view.ScopesRequested)
}
if !view.OfflineAccess {
t.Fatalf("%q lost offline access", scope)
}
}
})
t.Run("without default scopes an offline_access-only request keeps the PHP behaviour", func(t *testing.T) {
srv := consentPathServer(t, issuer, nil)
if got := stored(t, srv, str("offline_access")); len(got) != 0 {
t.Fatalf("stored %v, want no data scope (PHP parity)", got)
}
})
t.Run("a server that does not accept read refuses a request naming no scope", func(t *testing.T) {
srv := consentPathServer(t, issuer, withCatalog())
for _, scope := range []*string{nil, str("openid")} {
rec := consentPathAuthorize(t, srv, scope)
loc, err := url.Parse(rec.Header().Get("Location"))
if err != nil {
t.Fatal(err)
}
if !strings.HasPrefix(loc.String(), authorizeTestRedirect) || loc.Query().Get("error") != "invalid_scope" {
t.Fatalf("Location = %q, want an invalid_scope error redirect", loc)
}
}
})
t.Run("an explicit scope is not replaced", func(t *testing.T) {
srv := consentPathServer(t, issuer, withCatalog("*", "acme"))
if got := stored(t, srv, str("acme:read")); !slices.Equal(got, []string{"acme:read"}) {
t.Fatalf("stored %v, want [acme:read]", got)
}
if got := stored(t, srv, str("openid acme:read")); !slices.Equal(got, []string{"acme:read"}) {
t.Fatalf("identity plus data scope stored %v, want [acme:read]", got)
}
plain := consentPathServer(t, issuer, func(o *Options) { o.DefaultScopes = []string{"write"} })
if got := stored(t, plain, str("read")); !slices.Equal(got, []string{"read"}) {
t.Fatalf("explicit read stored %v, want [read]", got)
}
})
}
// TestCheckConsentPath locks the WR-02 guard: Options.ConsentPath is
// appended to Issuer as given, so only a plain same-origin absolute path is
// accepted, and Authorize answers 500 without storing a pending request or
// sending a Location while the configured path fails it.
func TestCheckConsentPath(t *testing.T) {
for _, ok := range []string{"", "/connect", "/backend/connect", "/gfadmin/mcp/connect", "/a%20b"} {
if err := CheckConsentPath(ok); err != nil {
t.Fatalf("CheckConsentPath(%q) = %v, want nil", ok, err)
}
}
for _, bad := range []string{
"@evil.example/connect",
"backend/connect",
"//evil.example/connect",
"/\\evil.example",
"/connect?x=1",
"/connect#frag",
"/user@evil.example",
"/con nect",
"/connect\n",
"/connect\x7f",
} {
if err := CheckConsentPath(bad); err == nil {
t.Fatalf("CheckConsentPath(%q) = nil, want an error", bad)
}
}
t.Run("authorize refuses an invalid path without a handoff", func(t *testing.T) {
backend := newMemoryBackend()
opts := DefaultOptions()
opts.Issuer = "https://app.example"
opts.Resource = opts.Issuer + "/mcp"
opts.ConsentPath = "@evil.example/connect"
srv := NewServer(opts)
srv.SetBackend(backend)
insertAuthorizeTestClient(backend, "cli", []string{authorizeTestRedirect}, nil)
_, challenge := s256Pair(t)
q := url.Values{}
q.Set("client_id", "cli")
q.Set("redirect_uri", authorizeTestRedirect)
q.Set("response_type", "code")
q.Set("code_challenge", challenge)
q.Set("code_challenge_method", "S256")
q.Set("scope", "read")
rec := httptest.NewRecorder()
srv.Authorize(rec, httptest.NewRequest(http.MethodGet, "/oauth/mcp/authorize?"+q.Encode(), nil))
if rec.Code != http.StatusInternalServerError || rec.Header().Get("Location") != "" {
t.Fatalf("authorize = %d Location %q, want 500 and no Location", rec.Code, rec.Header().Get("Location"))
}
backend.mu.Lock()
defer backend.mu.Unlock()
if len(backend.codes) != 0 {
t.Fatalf("authorize stored %d pending requests, want none", len(backend.codes))
}
})
}