Files
zeekay f9a1d15fd5 oidc: hold a sign-in to what its authorize request demanded
The session branch learned prompt from the page, so a page that
forwarded nothing still got a code from an old session: hanzo.ai's
resume for the CLI answered prompt=login and prompt=select_account from
whatever it found, and max_age reached neither the page nor the branch.

Authorize now records what a request it hands to the hosted page
demanded (prompt=login, select_account or several accounts with none
named, max_age) as a LoginChallenge of kind prompt, named by the
request's client, redirect, state and PKCE challenge, for thirty
minutes.  The session branch and a silent re-entry of the same request
both read it: login is met only by a sign-in made after the request,
choose only by a named account, max_age by a sign-in that recent.  A
store fault refuses.  sessions.Open restamps auth_time only when a
credential was just shown; a resume (resumeGrant) keeps the old one.

Review fixes: logout_hint ends every account it names (an address two
orgs share names both, so admin/alice is never the one left signed
in); the sign-out walk's chain is sealed with a MAC, so a crafted link
cannot skip an origin; the issuer is compared in sign-in origin
spelling, so https://hanzo.id:443 is not a second stop; and device
approval binds the account its page named.

TestBindHasOneCaller walked a symlinked root, which WalkDir does not
descend; CI runs the gates from one, so it found no caller there.

Claude-Session: https://claude.ai/code/session_015XYKLnBbrbajqj1GpRydF8
2026-11-07 13:07:35 -08:00

949 lines
35 KiB
Go

// Copyright 2026 Hanzo AI, Inc.
// SPDX-License-Identifier: MIT OR Apache-2.0
package sessions
import (
"context"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/hanzoai/orm"
"github.com/zap-proto/zip"
policy "github.com/hanzoai/authz"
"github.com/hanzoai/iam/internal/keyring"
"github.com/hanzoai/iam/pkg/schema"
)
// certMaterial is what the seeded platform signing cert signs the cookie MAC
// with. SessionKey hashes it, so any non-empty string is a valid key — the value
// only has to be stable across the test.
const certMaterial = "platform-signing-key-material-for-sessions-tests"
// seedSigningCert stages a reserved-owner signing cert so keyFor resolves a key:
// PlatformSigningCert picks the lexically-least admin-owned cert carrying private
// material, and keyring.Set is the one way material enters the process ring.
func seedSigningCert(t *testing.T, db orm.DB) {
t.Helper()
const name = "sess-cert"
keyring.Set(name, certMaterial)
t.Cleanup(func() { keyring.Forget(name) })
c := orm.New[schema.Cert](db)
c.Owner, c.Name, c.CryptoAlgorithm = policy.AdminOrg, name, "RS256"
c.SetId(policy.AdminOrg + "/" + name)
if err := c.CreateCtx(context.Background()); err != nil {
t.Fatalf("seed signing cert: %v", err)
}
}
// key is the MAC key the seeded cert yields — the same one keyFor derives, so a
// test can Issue and Verify cookies the harness will accept.
func key() []byte { return SessionKey(certMaterial) }
// harness wires each resolve.go entry point to a route and returns a driver that
// sends one request, optionally carrying a session cookie, and hands back the
// response so the test can read the result headers and any Set-Cookie.
type harness struct {
app *zip.App
db orm.DB
}
func newHarness(t *testing.T) *harness {
t.Helper()
db := newDB(t)
seedSigningCert(t, db)
app := zip.New(zip.Config{AppName: "sessions-resolve-test", DisableStartupMessage: true})
app.Raw(http.MethodPost, "/open", func(c *zip.Ctx) error {
return report(c, Open(context.Background(), c.Fiber(), db, c.Query("owner"), c.Query("name"), c.Query("app"), c.Query("proved") == "1"))
})
app.Raw(http.MethodPost, "/set", func(c *zip.Ctx) error {
return report(c, Set(context.Background(), c.Fiber(), db, c.Query("owner"), c.Query("name"), c.Query("app")))
})
app.Raw(http.MethodGet, "/current", func(c *zip.Ctx) error {
sc, ok := Current(context.Background(), c.Fiber(), db)
if ok {
c.SetHeader("X-Owner", sc.Owner)
c.SetHeader("X-Name", sc.Name)
c.SetHeader("X-App", sc.Application)
c.SetHeader("X-Sid", sc.SID)
}
c.SetHeader("X-Ok", boolStr(ok))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodGet, "/resolve", func(c *zip.Ctx) error {
owner, name, ok := Resolve(context.Background(), c.Fiber(), db)
c.SetHeader("X-Owner", owner)
c.SetHeader("X-Name", name)
c.SetHeader("X-Ok", boolStr(ok))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodPost, "/clear", func(c *zip.Ctx) error {
ended, err := Clear(context.Background(), c.Fiber(), db)
if err != nil {
return c.String(http.StatusForbidden, err.Error())
}
if len(ended) > 0 {
c.SetHeader("X-Owner", ended[0].Owner)
c.SetHeader("X-Name", ended[0].Name)
c.SetHeader("X-App", ended[0].Application)
}
c.SetHeader("X-People", people(ended))
c.SetHeader("X-Ok", boolStr(len(ended) > 0))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodPost, "/end", func(c *zip.Ctx) error {
ended, err := End(context.Background(), c.Fiber(), db, func(sc Cookie) bool {
return sc.Owner == c.Query("owner") && sc.Name == c.Query("name") || sc.Name == c.Query("also")
})
if err != nil {
return c.String(http.StatusForbidden, err.Error())
}
c.SetHeader("X-Ok", boolStr(len(ended) > 0))
c.SetHeader("X-People", people(ended))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodPost, "/switch", func(c *zip.Ctx) error {
ok, err := Switch(context.Background(), c.Fiber(), db, c.Query("owner"), c.Query("name"))
if err != nil {
return c.String(http.StatusForbidden, err.Error())
}
c.SetHeader("X-Ok", boolStr(ok))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodGet, "/accounts", func(c *zip.Ctx) error {
c.SetHeader("X-People", people(Accounts(context.Background(), c.Fiber(), db)))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodPost, "/rekey", func(c *zip.Ctx) error {
c.SetHeader("X-Ok", boolStr(Rekey(context.Background(), c.Fiber(), db, c.Query("newOwner"))))
return c.String(http.StatusOK, "ok")
})
app.Raw(http.MethodPost, "/revoke-others", func(c *zip.Ctx) error {
RevokeOthers(context.Background(), c.Fiber(), db, c.Query("owner"), c.Query("name"))
return c.String(http.StatusOK, "ok")
})
return &harness{app: app, db: db}
}
// page is what the issuer's own pages send with a write: the browser's
// same-origin fetch metadata and a JSON body.
var page = []string{"Sec-Fetch-Site", "same-origin", "Content-Type", "application/json"}
// do sends method+target, carrying cookie as the session cookie when non-empty.
func (h *harness) do(t *testing.T, method, target, cookie string, headers ...string) *http.Response {
t.Helper()
req := httptest.NewRequest(method, target, nil)
if cookie != "" {
req.AddCookie(&http.Cookie{Name: CookieName, Value: cookie})
}
for i := 0; i+1 < len(headers); i += 2 {
req.Header.Set(headers[i], headers[i+1])
}
res, err := h.app.Test(req, zip.TestConfig{Timeout: 0, FailOnTimeout: false})
if err != nil {
t.Fatalf("%s %s: %v", method, target, err)
}
return res
}
func report(c *zip.Ctx, err error) error {
if err != nil {
c.SetHeader("X-Err", err.Error())
return c.String(http.StatusInternalServerError, "err")
}
return c.String(http.StatusOK, "ok")
}
// people renders a session list as "owner/name,owner/name" in order.
func people(list []Cookie) string {
out := make([]string, len(list))
for i, sc := range list {
out[i] = sc.Owner + "/" + sc.Name
}
return strings.Join(out, ",")
}
func boolStr(b bool) string {
if b {
return "true"
}
return "false"
}
// cookieOf returns the session cookie a response set, or nil when none was
// written.
func cookieOf(res *http.Response) *http.Cookie {
for _, ck := range res.Cookies() {
if ck.Name == CookieName {
return ck
}
}
return nil
}
// mint drives one /set and returns the issued cookie value.
func (h *harness) mint(t *testing.T, owner, name, application string) string {
t.Helper()
res := h.do(t, http.MethodPost, "/set?owner="+owner+"&name="+name+"&app="+application, "")
ck := cookieOf(res)
if ck == nil || ck.Value == "" {
t.Fatal("Set issued no session cookie")
}
return ck.Value
}
func TestSet_IssuesResolvableSession(t *testing.T) {
h := newHarness(t)
value := h.mint(t, "hanzo", "alice", "cloud")
res := h.do(t, http.MethodGet, "/resolve", value)
if res.Header.Get("X-Ok") != "true" {
t.Fatal("a freshly set session must resolve")
}
if res.Header.Get("X-Owner") != "hanzo" || res.Header.Get("X-Name") != "alice" {
t.Fatalf("resolve = %s/%s, want hanzo/alice", res.Header.Get("X-Owner"), res.Header.Get("X-Name"))
}
cur := h.do(t, http.MethodGet, "/current", value)
sid := cur.Header.Get("X-Sid")
if sid == "" || cur.Header.Get("X-App") != "cloud" {
t.Fatalf("current = app %q sid %q, want cloud and a non-empty sid", cur.Header.Get("X-App"), sid)
}
// Set registered the sid server-side, which is what makes the session revocable.
if !sidActive(h.db, "hanzo", "alice", "cloud", sid) {
t.Fatal("Set did not register the sid on the session row")
}
}
// A deployment with no platform signing cert cannot mint a session: set fails at
// keyFor and the error propagates, so no cookie ever ships under no key.
func TestSet_NoSigningCertErrors(t *testing.T) {
db := newDB(t) // deliberately NO cert seeded
app := zip.New(zip.Config{AppName: "sessions-nocert-test", DisableStartupMessage: true})
app.Raw(http.MethodPost, "/set", func(c *zip.Ctx) error {
return report(c, Set(context.Background(), c.Fiber(), db, "hanzo", "alice", "cloud"))
})
res, err := app.Test(httptest.NewRequest(http.MethodPost, "/set", nil), zip.TestConfig{Timeout: 0, FailOnTimeout: false})
if err != nil {
t.Fatal(err)
}
if res.Header.Get("X-Err") == "" {
t.Fatal("Set with no signing cert must error rather than mint an unkeyed session")
}
if cookieOf(res) != nil {
t.Fatal("no cookie may ship when there is no key to sign it")
}
}
func TestCurrentAndResolve_NoCookie(t *testing.T) {
h := newHarness(t)
if res := h.do(t, http.MethodGet, "/current", ""); res.Header.Get("X-Ok") != "false" {
t.Fatal("a request with no cookie carries no current session")
}
if res := h.do(t, http.MethodGet, "/resolve", ""); res.Header.Get("X-Ok") != "false" {
t.Fatal("a request with no cookie resolves to not-signed-in")
}
}
// A tampered cookie fails the signature check, so Current reads no session — the
// server-side half of fail-closed resolution.
func TestCurrent_ForgedCookieRejected(t *testing.T) {
h := newHarness(t)
value := h.mint(t, "maxpower", "dave", "cloud")
sc, err := Verify(value, key())
if err != nil {
t.Fatal(err)
}
sc.Owner = "admin" // the privilege-escalation attempt
if res := h.do(t, http.MethodGet, "/current", forge(t, value, *sc)); res.Header.Get("X-Ok") != "false" {
t.Fatal("a cookie with a rewritten owner must not resolve")
}
}
// A signature that verifies but whose sid was never registered (or was revoked)
// is dead: resolution checks the sid against the row, not just the MAC.
func TestCurrent_UnregisteredSidRejected(t *testing.T) {
h := newHarness(t)
orphan := Issue(Cookie{Owner: "hanzo", Name: "alice", Application: "cloud", SID: NewSID()}, key(), sessionTTL)
if res := h.do(t, http.MethodGet, "/current", orphan); res.Header.Get("X-Ok") != "false" {
t.Fatal("a validly-signed cookie whose sid is not on the row must not resolve")
}
}
func TestOpen_MintsOnceThenKeepsLive(t *testing.T) {
h := newHarness(t)
first := h.do(t, http.MethodPost, "/open?owner=hanzo&name=bob&app=cloud", "")
ck := cookieOf(first)
if ck == nil || ck.Value == "" {
t.Fatal("Open with no live session must mint one")
}
// A browser that already carries a live session for this person keeps it — no
// second sid is minted for a silent hop.
second := h.do(t, http.MethodPost, "/open?owner=hanzo&name=bob&app=cloud", ck.Value)
if cookieOf(second) != nil {
t.Fatal("Open must not re-issue a cookie for a person already signed in first")
}
}
// open drives one /open carrying cookie and returns the cookie the browser holds
// afterwards: the one written, or the one it sent when nothing was written.
func (h *harness) open(t *testing.T, owner, name, cookie string) string {
t.Helper()
res := h.do(t, http.MethodPost, "/open?owner="+owner+"&name="+name+"&app=cloud", cookie)
if e := res.Header.Get("X-Err"); e != "" {
t.Fatalf("open %s/%s: %s", owner, name, e)
}
if ck := cookieOf(res); ck != nil {
return ck.Value
}
return cookie
}
func (h *harness) people(t *testing.T, cookie string) string {
t.Helper()
return h.do(t, http.MethodGet, "/accounts", cookie).Header.Get("X-People")
}
// A second person signing in on the same browser is added in front; the first
// stays signed in.
func TestOpen_AddsASecondPersonInFront(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
value = h.open(t, "acme", "bob", value)
if got := h.people(t, value); got != "acme/bob,hanzo/alice" {
t.Fatalf("accounts = %q, want acme/bob,hanzo/alice", got)
}
if r := h.do(t, http.MethodGet, "/resolve", value); r.Header.Get("X-Name") != "bob" {
t.Fatalf("current = %s, want the most recent sign-in, bob", r.Header.Get("X-Name"))
}
}
// Signing in again as someone the browser already holds moves them to the front
// with the session they had: same sid, same auth_time.
func TestOpen_PromotesAPersonAlreadyHeld(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
aliceSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
value = h.open(t, "acme", "bob", value)
value = h.open(t, "hanzo", "alice", value)
if got := h.people(t, value); got != "hanzo/alice,acme/bob" {
t.Fatalf("accounts = %q, want hanzo/alice,acme/bob", got)
}
if sid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid"); sid != aliceSid {
t.Fatal("promoting a held person must keep their session, not mint a new one")
}
}
// Set replaces the session the named person held and keeps everyone else.
func TestSet_ReplacesOnlyThatPerson(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
oldSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
value = h.open(t, "acme", "bob", value)
res := h.do(t, http.MethodPost, "/set?owner=hanzo&name=alice&app=cloud", value)
value = cookieOf(res).Value
if got := h.people(t, value); got != "hanzo/alice,acme/bob" {
t.Fatalf("accounts = %q, want hanzo/alice,acme/bob", got)
}
if sidActive(h.db, "hanzo", "alice", "cloud", oldSid) {
t.Fatal("the session Set replaced must be revoked")
}
}
// A session revoked elsewhere drops out of the list and the next person becomes
// current; nobody else is signed out with it.
func TestAccounts_SkipsARevokedSession(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
value = h.open(t, "acme", "bob", value)
bobSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
revokeSID(h.db, "acme", "bob", "cloud", bobSid)
if got := h.people(t, value); got != "hanzo/alice" {
t.Fatalf("accounts = %q, want only hanzo/alice", got)
}
if r := h.do(t, http.MethodGet, "/resolve", value); r.Header.Get("X-Name") != "alice" {
t.Fatalf("current = %q, want alice", r.Header.Get("X-Name"))
}
}
// A browser holding more people than one cookie can store signs the least recent
// out rather than writing a cookie the browser would refuse.
func TestWrite_DropsTheOldestPastTheLimit(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "person-0", "")
firstSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
for i := 1; i < 40; i++ {
value = h.open(t, "hanzo", "person-"+itoa(i), value)
}
if len(value) > maxValue {
t.Fatalf("cookie value is %d bytes, over the %d a browser stores", len(value), maxValue)
}
held := strings.Split(h.people(t, value), ",")
if held[0] != "hanzo/person-39" || len(held) < 2 {
t.Fatalf("accounts = %v, want the most recent first and more than one", held)
}
if sidActive(h.db, "hanzo", "person-0", "cloud", firstSid) {
t.Fatal("a session dropped from the cookie must be revoked")
}
}
func TestClear_RevokesAndReportsIdentity(t *testing.T) {
h := newHarness(t)
value := h.mint(t, "hanzo", "alice", "cloud")
sid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
res := h.do(t, http.MethodPost, "/clear", value, page...)
if res.Header.Get("X-Ok") != "true" {
t.Fatal("clearing a live session must report it ended")
}
if res.Header.Get("X-Owner") != "hanzo" || res.Header.Get("X-Name") != "alice" || res.Header.Get("X-App") != "cloud" {
t.Fatalf("Clear reported %s/%s/%s, want the signed-out identity hanzo/alice/cloud",
res.Header.Get("X-Owner"), res.Header.Get("X-Name"), res.Header.Get("X-App"))
}
if cookieOf(res) == nil {
t.Fatal("Clear must write an expiring cookie on the response")
}
// The load-bearing half: the sid is dead server-side, so a captured copy of
// the cookie no longer resolves.
if sidActive(h.db, "hanzo", "alice", "cloud", sid) {
t.Fatal("Clear did not revoke the sid")
}
if h.do(t, http.MethodGet, "/resolve", value).Header.Get("X-Ok") != "false" {
t.Fatal("a cleared session must no longer resolve even with the same cookie value")
}
}
// Only the issuer's own pages, a person-started request, a top-level GET
// navigation, or a client with no fetch metadata may change who a browser holds.
// A form posted from another site or a sibling host signs nobody in.
func TestSet_OnlyFromTheIssuer(t *testing.T) {
cases := []struct {
name string
method string
headers []string
writes bool
}{
{"no fetch metadata", http.MethodPost, nil, true},
{"same-origin", http.MethodPost, []string{"Sec-Fetch-Site", "same-origin"}, true},
{"person-started", http.MethodPost, []string{"Sec-Fetch-Site", "none"}, true},
{"cross-site form post", http.MethodPost, []string{"Sec-Fetch-Site", "cross-site", "Sec-Fetch-Mode", "navigate"}, false},
{"sibling host", http.MethodPost, []string{"Sec-Fetch-Site", "same-site"}, false},
{"cross-site fetch", http.MethodPost, []string{"Sec-Fetch-Site", "cross-site", "Sec-Fetch-Mode", "cors"}, false},
{"top-level navigation back from an identity provider", http.MethodGet, []string{"Sec-Fetch-Site", "cross-site", "Sec-Fetch-Mode", "navigate"}, true},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
h := newHarness(t)
h.app.Raw(http.MethodGet, "/set", func(c *zip.Ctx) error {
return report(c, Set(context.Background(), c.Fiber(), h.db, "hanzo", "mallory", "cloud"))
})
res := h.do(t, tc.method, "/set?owner=hanzo&name=mallory&app=cloud", "", tc.headers...)
if got := cookieOf(res) != nil; got != tc.writes {
t.Fatalf("session written = %v, want %v", got, tc.writes)
}
row, _ := orm.Get[schema.Session](h.db, sessionID("hanzo", "mallory", "cloud"))
if registered := row != nil && len(row.SessionId) > 0; registered != tc.writes {
t.Fatalf("sid registered = %v, want %v", registered, tc.writes)
}
})
}
}
// A sibling host cannot reorder who a browser holds either.
func TestOpen_SiblingHostCannotPromote(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
value = h.open(t, "acme", "bob", value)
res := h.do(t, http.MethodPost, "/open?owner=hanzo&name=alice&app=cloud", value, "Sec-Fetch-Site", "same-site")
if cookieOf(res) != nil {
t.Fatal("a sibling host re-ordered the browser's accounts")
}
if got := h.people(t, value); got != "acme/bob,hanzo/alice" {
t.Fatalf("accounts = %q, want acme/bob,hanzo/alice unchanged", got)
}
}
func TestClear_EndsEveryPerson(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
aliceSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
value = h.open(t, "acme", "bob", value)
bobSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
res := h.do(t, http.MethodPost, "/clear", value, page...)
if got := res.Header.Get("X-People"); got != "acme/bob,hanzo/alice" {
t.Fatalf("Clear ended %q, want acme/bob,hanzo/alice", got)
}
if sidActive(h.db, "hanzo", "alice", "cloud", aliceSid) || sidActive(h.db, "acme", "bob", "cloud", bobSid) {
t.Fatal("Clear must revoke every session the browser held")
}
if got := h.people(t, value); got != "" {
t.Fatalf("after Clear the old cookie still resolves %q", got)
}
}
func TestClear_NoLiveSessionStillExpiresCookie(t *testing.T) {
h := newHarness(t)
// No cookie at all: nothing to end, but the cookie is expired unconditionally.
res := h.do(t, http.MethodPost, "/clear", "")
if res.Header.Get("X-Ok") != "false" {
t.Fatal("clearing with no cookie is an idempotent no-op")
}
if cookieOf(res) == nil {
t.Fatal("Clear expires the cookie even when there was no session to end")
}
// A cookie that no longer verifies: still expired first, then reported as no
// live session.
res = h.do(t, http.MethodPost, "/clear", "garbage.notacookie", page...)
if res.Header.Get("X-Ok") != "false" {
t.Fatal("an unverifiable cookie clears to no live session")
}
if cookieOf(res) == nil {
t.Fatal("Clear must expire even an unverifiable cookie")
}
}
func TestRekey_MovesSessionToNewOwner(t *testing.T) {
h := newHarness(t)
value := h.mint(t, "hanzo", "carol", "cloud")
oldSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
authTime := mustVerify(t, value).AuthTime
res := h.do(t, http.MethodPost, "/rekey?newOwner=newco", value)
if res.Header.Get("X-Ok") != "true" {
t.Fatal("re-keying a live session to a new owner must succeed")
}
moved := cookieOf(res)
if moved == nil || moved.Value == "" {
t.Fatal("Rekey must re-issue the cookie under the new owner")
}
// The old sid is revoked so the stale cookie cannot be replayed.
if sidActive(h.db, "hanzo", "carol", "cloud", oldSid) {
t.Fatal("Rekey did not revoke the old-owner sid")
}
// The re-issued cookie resolves under the new owner.
r := h.do(t, http.MethodGet, "/resolve", moved.Value)
if r.Header.Get("X-Owner") != "newco" || r.Header.Get("X-Name") != "carol" || r.Header.Get("X-Ok") != "true" {
t.Fatalf("moved session resolves to %s/%s, want newco/carol", r.Header.Get("X-Owner"), r.Header.Get("X-Name"))
}
// A change of address, not a re-authentication: the original auth_time carries across.
if got := mustVerify(t, moved.Value).AuthTime; got != authTime {
t.Fatalf("auth_time = %d after rekey, want the carried %d", got, authTime)
}
}
// Rekey moves the most recent person and leaves everyone else signed in.
func TestRekey_KeepsTheOthers(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "dave", "")
value = h.open(t, "hanzo", "carol", value)
res := h.do(t, http.MethodPost, "/rekey?newOwner=newco", value)
if res.Header.Get("X-Ok") != "true" {
t.Fatal("re-keying must succeed")
}
if got := h.people(t, cookieOf(res).Value); got != "newco/carol,hanzo/dave" {
t.Fatalf("accounts = %q, want newco/carol,hanzo/dave", got)
}
}
func TestRekey_Noops(t *testing.T) {
h := newHarness(t)
value := h.mint(t, "hanzo", "carol", "cloud")
cases := []struct {
name string
newOwner string
cookie string
}{
{"empty new owner", "", value},
{"no session", "newco", ""},
{"already under that owner", "hanzo", value},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
res := h.do(t, http.MethodPost, "/rekey?newOwner="+tc.newOwner, tc.cookie)
if res.Header.Get("X-Ok") != "false" {
t.Fatalf("Rekey(%s) must be a no-op", tc.name)
}
if cookieOf(res) != nil {
t.Fatalf("Rekey(%s) must not re-issue a cookie", tc.name)
}
})
}
}
func TestRevokeOthers_KeepsOnlyThisRequestsSid(t *testing.T) {
h := newHarness(t)
value := h.mint(t, "hanzo", "dave", "cloud")
keep := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
// A second cookie on the same app, a session on another app, and a third app
// whose only sid IS the one being kept (the unchanged branch).
if err := registerSID(h.db, "hanzo", "dave", "cloud", "other-cloud"); err != nil {
t.Fatal(err)
}
if err := registerSID(h.db, "hanzo", "dave", "console", "other-console"); err != nil {
t.Fatal(err)
}
if err := registerSID(h.db, "hanzo", "dave", "extra", keep); err != nil {
t.Fatal(err)
}
h.do(t, http.MethodPost, "/revoke-others?owner=hanzo&name=dave", value)
if !sidActive(h.db, "hanzo", "dave", "cloud", keep) {
t.Fatal("RevokeOthers dropped the request's own sid")
}
if sidActive(h.db, "hanzo", "dave", "cloud", "other-cloud") {
t.Fatal("RevokeOthers kept a sibling sid on the same app")
}
if sidActive(h.db, "hanzo", "dave", "console", "other-console") {
t.Fatal("RevokeOthers kept a session on another app")
}
if !sidActive(h.db, "hanzo", "dave", "extra", keep) {
t.Fatal("a row already holding only the kept sid must be left untouched")
}
}
// The kept sid is the one this browser holds for that person, wherever they sit in
// the list.
func TestRevokeOthers_KeepsThePersonsSidWhenNotFirst(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "dave", "")
keep := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
value = h.open(t, "acme", "erin", value)
if err := registerSID(h.db, "hanzo", "dave", "cloud", "other-cloud"); err != nil {
t.Fatal(err)
}
h.do(t, http.MethodPost, "/revoke-others?owner=hanzo&name=dave", value)
if !sidActive(h.db, "hanzo", "dave", "cloud", keep) {
t.Fatal("RevokeOthers dropped the sid this browser holds for dave")
}
if sidActive(h.db, "hanzo", "dave", "cloud", "other-cloud") {
t.Fatal("RevokeOthers kept another browser's sid")
}
}
// With no session on the request, keep is empty and every sid is revoked — what a
// second-factor change owes when the caller has no live cookie of its own.
func TestRevokeOthers_NoCurrentSessionRevokesAll(t *testing.T) {
h := newHarness(t)
if err := registerSID(h.db, "acme", "zoe", "cloud", "s1"); err != nil {
t.Fatal(err)
}
h.do(t, http.MethodPost, "/revoke-others?owner=acme&name=zoe", "")
if sidActive(h.db, "acme", "zoe", "cloud", "s1") {
t.Fatal("with no session to keep, every sid must be revoked")
}
}
func TestCurrentValue_DirectChecks(t *testing.T) {
db := newDB(t)
seedSigningCert(t, db)
ctx := context.Background()
// Empty value is not signed-in.
if _, ok := CurrentValue(ctx, "", db); ok {
t.Fatal("an empty cookie value must not resolve")
}
// A signed cookie whose sid is registered resolves to its claims.
sid := NewSID()
if err := registerSID(db, "hanzo", "alice", "cloud", sid); err != nil {
t.Fatal(err)
}
value := Issue(Cookie{Owner: "hanzo", Name: "alice", Application: "cloud", SID: sid}, key(), sessionTTL)
sc, ok := CurrentValue(ctx, value, db)
if !ok || sc.Owner != "hanzo" || sc.SID != sid {
t.Fatalf("CurrentValue = %+v ok=%v, want the hanzo/alice claims", sc, ok)
}
// Revoke the sid and the same value stops resolving.
revokeSID(db, "hanzo", "alice", "cloud", sid)
if _, ok := CurrentValue(ctx, value, db); ok {
t.Fatal("a revoked sid must make the cookie stop resolving")
}
// A malformed value never resolves.
if _, ok := CurrentValue(ctx, "not-a-cookie", db); ok {
t.Fatal("a malformed value must not resolve")
}
}
// With no signing cert seeded, keyFor fails and every resolution reads
// not-signed-in rather than erroring — a misconfigured deployment fails closed.
func TestCurrentValue_NoSigningCertFailsClosed(t *testing.T) {
db := newDB(t) // deliberately NO cert seeded
value := Issue(Cookie{Owner: "hanzo", Name: "alice", Application: "cloud", SID: NewSID()}, key(), sessionTTL)
if _, ok := CurrentValue(context.Background(), value, db); ok {
t.Fatal("with no platform signing cert, no cookie can resolve")
}
}
func TestRegisterSID_CreatesThenAppendsAndCaps(t *testing.T) {
db := newDB(t)
if err := registerSID(db, "hanzo", "alice", "cloud", "s1"); err != nil {
t.Fatal(err)
}
if !sidActive(db, "hanzo", "alice", "cloud", "s1") {
t.Fatal("registerSID did not create the row with the sid")
}
if err := registerSID(db, "hanzo", "alice", "cloud", "s2"); err != nil {
t.Fatal(err)
}
if !sidActive(db, "hanzo", "alice", "cloud", "s1") || !sidActive(db, "hanzo", "alice", "cloud", "s2") {
t.Fatal("registerSID must append, keeping earlier sids live")
}
// Overflowing the row keeps the cap and drops the oldest.
for i := 0; i < maxSessionIds+5; i++ {
if err := registerSID(db, "hanzo", "alice", "cloud", "bulk"+itoa(i)); err != nil {
t.Fatal(err)
}
}
row, err := orm.Get[schema.Session](db, sessionID("hanzo", "alice", "cloud"))
if err != nil {
t.Fatal(err)
}
if len(row.SessionId) != maxSessionIds {
t.Fatalf("row holds %d sids, want the cap %d", len(row.SessionId), maxSessionIds)
}
if sidActive(db, "hanzo", "alice", "cloud", "s1") {
t.Fatal("the oldest sid must be dropped once the row overflows")
}
}
func TestRevokeSID_DropsThenNoops(t *testing.T) {
db := newDB(t)
if err := registerSID(db, "hanzo", "alice", "cloud", "s1"); err != nil {
t.Fatal(err)
}
if err := registerSID(db, "hanzo", "alice", "cloud", "s2"); err != nil {
t.Fatal(err)
}
revokeSID(db, "hanzo", "alice", "cloud", "s1")
if sidActive(db, "hanzo", "alice", "cloud", "s1") {
t.Fatal("revokeSID did not drop the sid")
}
if !sidActive(db, "hanzo", "alice", "cloud", "s2") {
t.Fatal("revokeSID dropped a sibling it should have kept")
}
// A sid not on the row leaves it untouched (the length-unchanged branch).
revokeSID(db, "hanzo", "alice", "cloud", "never-there")
if !sidActive(db, "hanzo", "alice", "cloud", "s2") {
t.Fatal("revoking an absent sid must not disturb the row")
}
// A missing row is already revoked — no panic, no error.
revokeSID(db, "ghost", "nobody", "cloud", "s1")
}
func TestSidActive_MissingRowAndAbsentSid(t *testing.T) {
db := newDB(t)
if sidActive(db, "ghost", "nobody", "cloud", "s1") {
t.Fatal("a missing row has no active sid")
}
if err := registerSID(db, "hanzo", "alice", "cloud", "s1"); err != nil {
t.Fatal(err)
}
if sidActive(db, "hanzo", "alice", "cloud", "absent") {
t.Fatal("a sid not on the row must read inactive")
}
}
// mustVerify decodes a cookie value with the seeded cert's key, failing the test
// if it does not verify.
func mustVerify(t *testing.T, value string) *Cookie {
t.Helper()
c, err := Verify(value, key())
if err != nil {
t.Fatalf("verify %q: %v", value, err)
}
return c
}
// Ending one person signs out exactly that person: their sid is dead server-side,
// the cookie is rewritten without them, and everyone else stays signed in.
func TestEnd_SignsOutOnlyThatPerson(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
aliceSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
value = h.open(t, "acme", "bob", value)
bobSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
res := h.do(t, http.MethodPost, "/end?owner=hanzo&name=alice", value, page...)
if res.Header.Get("X-Ok") != "true" {
t.Fatal("ending a person the browser holds must report it ended")
}
if sidActive(h.db, "hanzo", "alice", "cloud", aliceSid) {
t.Fatal("the ended person's sid must be revoked")
}
if !sidActive(h.db, "acme", "bob", "cloud", bobSid) {
t.Fatal("ending alice revoked bob's session")
}
ck := cookieOf(res)
if ck == nil || ck.MaxAge <= 0 {
t.Fatal("End must rewrite the cookie with the people left, not expire it")
}
if got := h.people(t, ck.Value); got != "acme/bob" {
t.Fatalf("accounts after End = %q, want acme/bob", got)
}
// The captured old cookie no longer carries alice either.
if got := h.people(t, value); got != "acme/bob" {
t.Fatalf("the old cookie still resolves %q", got)
}
}
// Ending the last person expires the cookie; ending someone the browser does not
// hold signs nobody out.
func TestEnd_LastPersonAndStranger(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
res := h.do(t, http.MethodPost, "/end?owner=acme&name=mallory", value, page...)
if res.Header.Get("X-Ok") != "false" || cookieOf(res) != nil {
t.Fatal("ending a person the browser does not hold must change nothing")
}
if got := h.people(t, value); got != "hanzo/alice" {
t.Fatalf("accounts = %q, want hanzo/alice untouched", got)
}
res = h.do(t, http.MethodPost, "/end?owner=hanzo&name=alice", value, page...)
if ck := cookieOf(res); res.Header.Get("X-Ok") != "true" || ck == nil || ck.MaxAge >= 0 {
t.Fatal("ending the last person must expire the cookie")
}
if got := h.people(t, value); got != "" {
t.Fatalf("accounts after ending the last person = %q, want none", got)
}
}
// A fetch another page sent ends nobody (the same rule Clear keeps).
func TestEnd_RefusesAForgedRequest(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
res := h.do(t, http.MethodPost, "/end?owner=hanzo&name=alice", value, "Sec-Fetch-Site", "cross-site", "Sec-Fetch-Mode", "cors", "Sec-Fetch-Dest", "empty")
if res.StatusCode != http.StatusForbidden {
t.Fatalf("status = %d, want 403", res.StatusCode)
}
if got := h.people(t, value); got != "hanzo/alice" {
t.Fatalf("a forged end signed out %q", got)
}
}
// Switching moves a held person to the front with the session they had; nobody is
// signed in or out, and the current reader answers with them.
func TestSwitch_MakesAHeldPersonCurrent(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
aliceSid := h.do(t, http.MethodGet, "/current", value).Header.Get("X-Sid")
value = h.open(t, "acme", "bob", value)
res := h.do(t, http.MethodPost, "/switch?owner=hanzo&name=alice", value, page...)
if res.Header.Get("X-Ok") != "true" {
t.Fatal("switching to a held person must report it")
}
ck := cookieOf(res)
if ck == nil {
t.Fatal("switching must rewrite the cookie in the new order")
}
if got := h.people(t, ck.Value); got != "hanzo/alice,acme/bob" {
t.Fatalf("accounts = %q, want hanzo/alice,acme/bob", got)
}
cur := h.do(t, http.MethodGet, "/current", ck.Value)
if cur.Header.Get("X-Name") != "alice" || cur.Header.Get("X-Sid") != aliceSid {
t.Fatal("the current session after a switch must be alice's own, same sid")
}
}
// A person the browser does not hold cannot be switched to, the current person is
// a no-op, and a request another page could have sent changes nothing.
func TestSwitch_RefusesStrangersAndForgery(t *testing.T) {
h := newHarness(t)
value := h.open(t, "hanzo", "alice", "")
value = h.open(t, "acme", "bob", value)
if res := h.do(t, http.MethodPost, "/switch?owner=admin&name=root", value, page...); res.Header.Get("X-Ok") != "false" || cookieOf(res) != nil {
t.Fatal("switching to someone not signed in here must change nothing")
}
if res := h.do(t, http.MethodPost, "/switch?owner=acme&name=bob", value, page...); res.Header.Get("X-Ok") != "true" || cookieOf(res) != nil {
t.Fatal("switching to the current person is a no-op that writes nothing")
}
for _, forged := range [][]string{
{"Sec-Fetch-Site", "same-site", "Content-Type", "application/json"},
{"Sec-Fetch-Site", "same-origin", "Content-Type", "application/x-www-form-urlencoded"},
} {
res := h.do(t, http.MethodPost, "/switch?owner=hanzo&name=alice", value, forged...)
if res.StatusCode != http.StatusForbidden || cookieOf(res) != nil {
t.Fatalf("%v: status=%d, want 403 and no cookie", forged, res.StatusCode)
}
}
if got := h.people(t, value); got != "acme/bob,hanzo/alice" {
t.Fatalf("accounts = %q, want acme/bob,hanzo/alice unchanged", got)
}
}
// End takes every session its predicate names, and only those.
func TestEnd_EveryPersonNamed(t *testing.T) {
h := newHarness(t)
value := h.open(t, "admin", "alice", "")
value = h.open(t, "hanzo", "alice", value)
value = h.open(t, "hanzo", "bob", value)
res := h.do(t, http.MethodPost, "/end?also=alice", value, page...)
if got := res.Header.Get("X-People"); got != "hanzo/alice,admin/alice" {
t.Fatalf("End ended %q, want both alices", got)
}
if got := h.people(t, cookieOf(res).Value); got != "hanzo/bob" {
t.Fatalf("accounts after End = %q, want hanzo/bob", got)
}
}
// A credential shown again for a person already held is a new sign-in: same sid,
// and its auth_time is now. A resume from the session is not, and keeps the old one.
func TestOpen_ProvedRefreshesAuthTime(t *testing.T) {
h := newHarness(t)
old := Issue(Cookie{Owner: "hanzo", Name: "alice", Application: "cloud", SID: NewSID(), AuthTime: time.Now().Add(-2 * time.Hour).Unix()}, key(), sessionTTL)
sc, _ := Verify(old, key())
if err := registerSID(h.db, "hanzo", "alice", "cloud", sc.SID); err != nil {
t.Fatal(err)
}
if res := h.do(t, http.MethodPost, "/open?owner=hanzo&name=alice&app=cloud", old); cookieOf(res) != nil {
t.Fatal("a resume must not re-issue the session")
}
res := h.do(t, http.MethodPost, "/open?owner=hanzo&name=alice&app=cloud&proved=1", old)
ck := cookieOf(res)
if ck == nil {
t.Fatal("a proved sign-in must re-issue the session with its new auth_time")
}
got, err := Verify(ck.Value, key())
if err != nil || got.SID != sc.SID {
t.Fatalf("the proved sign-in must keep the sid: %v", err)
}
if got.AuthTime <= sc.AuthTime || got.AuthTime < time.Now().Add(-time.Minute).Unix() {
t.Fatalf("auth_time = %d, want now (was %d)", got.AuthTime, sc.AuthTime)
}
}