Files
iam/internal/oidc/forgeable_test.go
zeekayandHanzo Dev 386d2b3d49 A cross-site sign-out form is sent back as a GET only at the top level
A form posted into a cross-site frame got the 303 too, and the GET inside
that frame carries no Lax cookie, so the session lived. crossSiteForm now
also requires Sec-Fetch-Dest document.

Co-authored-by: Hanzo Dev <[email protected]>
2026-10-17 21:46:58 -07:00

330 lines
14 KiB
Go

// Copyright 2026 Hanzo AI, Inc.
// SPDX-License-Identifier: MIT OR Apache-2.0
package oidc
// A write the session cookie authorizes is made only on a request no other page
// could have sent (sessions.Forgeable): the issuer's own page, as JSON. The cookie
// is SameSite=Lax, so once the identity host shares a site with other hosts, any
// page on that site can post a form here and the browser attaches it.
import (
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"github.com/hanzoai/iam/internal/sessions"
"github.com/hanzoai/iam/pkg/store"
)
// A device approval needs no answer read, so a form is the whole attack: a page on
// any host of the identity host's site approves the attacker's `hanzo login` code
// and the attacker's terminal is signed in as the victim.
func TestDevice_ApprovalIsMadeOnlyFromTheIssuersOwnPage(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
seedDeviceApp(t, db, "hanzo-app")
_, da := requestDevice(t, app, "hanzo-app", "openid profile")
deviceCode, userCode := da["device_code"].(string), da["user_code"].(string)
cookie := sessionCookieFor(t, app)
form := func() *http.Request {
return formReq("POST", PathLogin, url.Values{"type": {"device"}, "userCode": {userCode}})
}
plain := func() *http.Request {
req := jsonReq("POST", PathLogin, map[string]string{"type": "device", "userCode": userCode})
req.Header.Set("Content-Type", "text/plain")
return req
}
json := func() *http.Request {
return jsonReq("POST", PathLogin, map[string]string{"type": "device", "userCode": userCode})
}
approve := func(req *http.Request, site string) int {
req.Header.Set("Cookie", cookie)
switch {
case strings.HasPrefix(site, "origin "):
req.Header.Set("Origin", strings.TrimPrefix(site, "origin "))
case site != "":
req.Header.Set("Sec-Fetch-Site", site)
}
resp, _ := do(t, app, req)
return resp.StatusCode
}
approver := func() string {
row, err := store.GetTokenByCode(tctx(), db, deviceCode)
if err != nil || row == nil {
t.Fatalf("the pending device code is gone: %v", err)
}
return row.User
}
// A text/plain body is one no binder reads, so it is refused (400) before the
// cookie is reached; every other shape reaches the cookie and is refused 403.
for _, tc := range []struct {
name string
req func() *http.Request
site string
status int
}{
{"a form posted from another site", form, "cross-site", http.StatusForbidden},
{"a form posted from a sibling host", form, "same-site", http.StatusForbidden},
{"a form on the issuer's own page", form, "same-origin", http.StatusForbidden},
{"JSON from a sibling host", json, "same-site", http.StatusForbidden},
{"JSON from a sibling host with no fetch metadata", json, "origin https://chat.hanzo.id", http.StatusForbidden},
{"a form from the issuer's own page with no fetch metadata", form, "origin https://hanzo.id", http.StatusForbidden},
{"a text/plain form carrying JSON", plain, "same-site", http.StatusBadRequest},
{"a text/plain body from the issuer's own page", plain, "same-origin", http.StatusBadRequest},
} {
if status := approve(tc.req(), tc.site); status != tc.status || approver() != "" {
t.Fatalf("%s: status=%d approver=%q, want %d and the device still pending", tc.name, status, approver(), tc.status)
}
}
if status := approve(json(), "same-origin"); status != 200 || approver() != "hanzo/alice" {
t.Fatalf("the approval page: status=%d approver=%q, want 200 and hanzo/alice", status, approver())
}
}
// A browser that sends no Fetch Metadata (Safari before 16.4, Firefox before 90,
// a proxy that strips it) is judged by Origin, so the issuer's own page still
// approves a device.
func TestDevice_ApprovalWithoutFetchMetadata(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
seedDeviceApp(t, db, "hanzo-app")
_, da := requestDevice(t, app, "hanzo-app", "openid profile")
req := jsonReq("POST", PathLogin, map[string]string{"type": "device", "userCode": da["user_code"].(string)})
req.Header.Set("Cookie", sessionCookieFor(t, app))
req.Header.Set("Origin", "https://hanzo.id")
if resp, body := do(t, app, req); resp.StatusCode != 200 {
t.Fatalf("the approval page on an old browser: status=%d %s, want 200", resp.StatusCode, body)
}
if row, _ := store.GetTokenByCode(tctx(), db, da["device_code"].(string)); row == nil || row.User != "hanzo/alice" {
t.Fatalf("the device was not approved: %+v", row)
}
}
// Every other write on the cookie's authority asks the same rule: a sibling host's
// JSON and the issuer's own page's form are both refused, before the handler reads
// anything.
func TestCookieWrites_AllAskTheSameRule(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
cookie := sessionCookieFor(t, app)
for _, w := range []struct{ method, path, body string }{
{"PUT", PathAccount, `{"displayName":"Mallory"}`},
{"PUT", PathPassword, `{"oldPassword":"pw","password":"N3w-passw0rd-long"}`},
{"PUT", PathTerms, `{"terms":"t2","aup":"a2"}`},
{"PUT", PathConsent, `{"insights":true}`},
{"POST", PathPreferences, `{"theme":"dark"}`},
{"POST", PathOnboard, `{"name":"Mallory Inc"}`},
{"POST", PathLink, `{"provider":"provider-github","clientId":"conf","returnUri":"` + testRedirect + `"}`},
{"POST", PathUnlink, `{"providerType":"github","user":{"owner":"hanzo","name":"alice"}}`},
{"POST", PathWebauthnRegisterFinish, `{}`},
{"POST", PathInvitationsAccept, `{"owner":"acme","code":"LINKCODE22"}`},
} {
for _, sent := range []struct{ site, origin, contentType string }{
{"same-site", "", "application/json"},
{"same-origin", "", "application/x-www-form-urlencoded"},
{"", "https://chat.hanzo.id", "application/json"},
{"", "https://hanzo.id", "application/x-www-form-urlencoded"},
} {
req := httptest.NewRequest(w.method, w.path, strings.NewReader(w.body))
req.Host = "hanzo.id"
req.Header.Set("Content-Type", sent.contentType)
req.Header.Set("Cookie", cookie)
if sent.site != "" {
req.Header.Set("Sec-Fetch-Site", sent.site)
}
if sent.origin != "" {
req.Header.Set("Origin", sent.origin)
}
resp, body := do(t, app, req)
if resp.StatusCode != http.StatusForbidden || !strings.Contains(string(body), sessions.ErrForgeable.Error()) {
t.Errorf("%s %s (site %q, origin %q, %s): status=%d %s, want 403", w.method, w.path, sent.site, sent.origin, sent.contentType, resp.StatusCode, body)
}
}
}
// A GET carries no body, so the passkey ceremony's start is judged by the site.
req := formReqNoBody("GET", PathWebauthnRegisterBegin)
req.Header.Set("Cookie", cookie)
req.Header.Set("Sec-Fetch-Site", "same-site")
if resp, body := do(t, app, req); resp.StatusCode != http.StatusForbidden {
t.Errorf("a sibling host began a passkey enrollment: status=%d %s, want 403", resp.StatusCode, body)
}
if u, _ := store.GetUserByName(tctx(), db, "hanzo", "alice"); u == nil || u.DisplayName == "Mallory" {
t.Fatalf("a refused write still changed the account: %+v", u)
}
}
// A client that is not a browser sends no fetch metadata and authenticates with a
// bearer, which no page can make a browser attach. It is untouched — with or
// without a cookie riding along.
func TestCookieWrites_ABearerNeedsNoFetchMetadata(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
access := accessTokenFor(t, app, "openid")
cookie := sessionCookieFor(t, app)
for _, withCookie := range []bool{false, true} {
req := jsonReq("PUT", PathConsent, map[string]any{"insights": withCookie})
req.Header.Set("Authorization", "Bearer "+access)
if withCookie {
req.Header.Set("Cookie", cookie)
}
resp, body := do(t, app, req)
if resp.StatusCode != 200 || decode(t, body)["status"] != "ok" {
t.Fatalf("a bearer client (cookie %v) was refused: status=%d %s", withCookie, resp.StatusCode, body)
}
}
if got := consentOnRow(t, db); !got.Insights {
t.Fatalf("the bearer's consent did not land: %+v", got)
}
}
// Signing out ends sessions, so it is a write too, judged by its own rule: only
// what the browser says another page sent without navigating here — an image, a
// frame, a script's fetch — ends nothing.
func TestLogout_OnlyANavigationOrTheIssuersPageSignsOut(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
cookie := signIn(t, app, "conf")
image := formReqNoBody("GET", PathLogout)
image.Header.Set("Sec-Fetch-Site", "same-site")
image.Header.Set("Sec-Fetch-Mode", "no-cors")
image.Header.Set("Sec-Fetch-Dest", "image")
frame := navigate(formReqNoBody("GET", PathLogout))
frame.Header.Set("Sec-Fetch-Dest", "iframe")
fetch := formReq("POST", PathLogout, url.Values{})
fetch.Header.Set("Sec-Fetch-Site", "same-site")
fetch.Header.Set("Sec-Fetch-Mode", "no-cors")
fetch.Header.Set("Sec-Fetch-Dest", "empty")
for name, req := range map[string]*http.Request{"an image": image, "a frame": frame, "a sibling's fetch": fetch} {
req.Header.Set("Cookie", cookie)
if resp, _ := do(t, app, req); resp.StatusCode != http.StatusForbidden || !sessionLives(t, app, cookie) {
t.Fatalf("%s: status=%d, want 403 and the session alive", name, resp.StatusCode)
}
}
requireSignedOut(t, logout(t, app, cookie, "", ""), "")
if sessionLives(t, app, cookie) {
t.Fatal("a relying party's sign-out navigation left the session alive")
}
}
// Every way a person actually signs out ends the session: the SDKs' sign-out
// (@hanzo/iam end(), iam-sdk logout()) posts a form, or nothing, from the issuer's
// own page; a relying party posts its sign-out form (RP-Initiated Logout 1.0 §2);
// and a browser with no Fetch Metadata cannot say which it is, so it is believed.
func TestLogout_EverySignOutEndsTheSession(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
end := func() *http.Request {
req := formReq("POST", PathLogout, url.Values{"client_id": {"conf"}})
req.Header.Set("Sec-Fetch-Site", "same-origin")
req.Header.Set("Sec-Fetch-Mode", "cors")
req.Header.Set("Sec-Fetch-Dest", "empty")
return req
}
bodyless := func() *http.Request {
req := formReqNoBody("POST", PathLogout)
req.Header.Set("Sec-Fetch-Site", "same-origin")
req.Header.Set("Sec-Fetch-Mode", "cors")
req.Header.Set("Sec-Fetch-Dest", "empty")
return req
}
rpForm := func() *http.Request {
req := formReq("POST", PathLogout, url.Values{"client_id": {"conf"}})
req.Header.Set("Sec-Fetch-Site", "same-site")
req.Header.Set("Sec-Fetch-Mode", "navigate")
req.Header.Set("Sec-Fetch-Dest", "document")
return req
}
oldBrowser := func() *http.Request {
req := formReq("POST", PathLogout, url.Values{"client_id": {"conf"}})
req.Header.Set("Origin", "https://hanzo.id")
return req
}
oldNavigation := func() *http.Request { return formReqNoBody("GET", PathLogout) }
for name, req := range map[string]func() *http.Request{
"@hanzo/iam end()": end,
"a bodyless POST from the page": bodyless,
"a sibling relying party's form": rpForm,
"a browser with no fetch metadata": oldBrowser,
"an old browser's sign-out link": oldNavigation,
} {
t.Run(name, func(t *testing.T) {
cookie := signIn(t, app, "conf")
r := req()
r.Header.Set("Cookie", cookie)
resp, body := do(t, app, r)
if resp.StatusCode >= 400 {
t.Fatalf("status=%d %s, want the session ended", resp.StatusCode, body)
}
if sessionLives(t, app, cookie) {
t.Fatal("the session still authenticates")
}
if sc := resp.Header.Get("Set-Cookie"); !strings.Contains(sc, sessions.CookieName+"=;") {
t.Errorf("the session cookie was not expired: %q", sc)
}
})
}
}
// SameSite=Lax keeps the session cookie off a form another site posts, so a
// relying party's cross-site sign-out form reaches here with no cookie. It is sent
// back as a GET with its parameters, which the cookie rides on, and that GET ends
// the session and returns to the registered address.
func TestLogout_ACrossSiteFormComesBackAsANavigation(t *testing.T) {
app, db := newServer(t)
seedApp(t, db, appOpts{clientID: "conf", secret: "s3cret", redirectURIs: []string{testRedirect}})
seedRichUser(t, db)
cookie := signIn(t, app, "conf")
form := url.Values{"client_id": {"conf"}, "post_logout_redirect_uri": {testRedirect}, "state": {"s1"}}
req := formReq("POST", PathLogout, form)
req.Header.Set("Sec-Fetch-Site", "cross-site")
req.Header.Set("Sec-Fetch-Mode", "navigate")
req.Header.Set("Sec-Fetch-Dest", "document")
resp, _ := do(t, app, req)
loc := resp.Header.Get("Location")
if resp.StatusCode != http.StatusSeeOther || !strings.HasPrefix(loc, PathLogout+"?") {
t.Fatalf("a cookieless cross-site form: status=%d Location=%q, want 303 back to %s", resp.StatusCode, loc, PathLogout)
}
if got, _ := url.Parse(loc); got.Query().Encode() != form.Encode() {
t.Fatalf("the GET dropped parameters: %q, want %q", got.RawQuery, form.Encode())
}
if !sessionLives(t, app, cookie) {
t.Fatal("precondition: nothing is ended before the browser comes back")
}
framed := formReq("POST", PathLogout, form)
framed.Header.Set("Sec-Fetch-Site", "cross-site")
framed.Header.Set("Sec-Fetch-Mode", "navigate")
framed.Header.Set("Sec-Fetch-Dest", "iframe")
if resp, _ := do(t, app, framed); resp.StatusCode == http.StatusSeeOther {
t.Fatal("a form posted into a frame was sent back, where no cookie rides either")
}
again := navigate(formReqNoBody("GET", loc))
again.Header.Set("Cookie", cookie)
resp, _ = do(t, app, again)
if resp.StatusCode != 302 || !strings.HasPrefix(resp.Header.Get("Location"), testRedirect) {
t.Fatalf("the navigation back: status=%d Location=%q, want 302 to %s", resp.StatusCode, resp.Header.Get("Location"), testRedirect)
}
if sessionLives(t, app, cookie) {
t.Fatal("the relying party's sign-out left the session alive")
}
}