Repository Public
1/**2 * =============================================================================3 * SP BOUCHER | INFRASTRUCTURE & AUTOMATION4 * ARTIFICIAL INTELLIGENCE • FINANCE • ENGINEERING5 * =============================================================================6 *7 * Project : MacLustr Command Center (MCC)8 * File : services/internal/identity/identity_test.go9 * Module : services10 * Repository : https://git.spboucher.ai/maclustr-command-center11 * Project Website : https://clustr.spboucher.ai12 * Created : 2026-11-1813 * Last Modified : 2026-11-1814 *15 * Author : Simon-Pierre Boucher16 * Position : Professor of Finance17 * Institution : Université du Québec en Outaouais (UQO)18 * Organization : SP Boucher19 * Website : https://spboucher.ai20 * Git : https://git.spboucher.ai21 *22 * Preferred Contact: admin@spboucher.ai23 * Technical Contact: dev@spboucher.ai24 * Security/Admin : admin@spboucher.ai25 *26 * Copyright (c) 202627 * Simon-Pierre Boucher28 * All rights reserved where applicable. This file is governed by the29 * applicable project license, copyright notices and relevant law.30 * Existing third-party rights and notices remain unaffected.31 *32 * License : None specified (no license file in this repository)33 *34 * Do not embed credentials, private keys, access tokens,35 * certificates or confidential personal information.36 *37 * =============================================================================38 * END OF SP BOUCHER SOURCE HEADER39 * =============================================================================40 */4142package identity_test4344import (45 "context"46 "encoding/json"47 "errors"48 "sync"49 "sync/atomic"50 "testing"51 "time"5253 "github.com/google/uuid"5455 "clustr.spboucher.ai/mcc/internal/authz"56 "clustr.spboucher.ai/mcc/internal/config"57 "clustr.spboucher.ai/mcc/internal/httpx"58 "clustr.spboucher.ai/mcc/internal/identity"59 "clustr.spboucher.ai/mcc/internal/identity/vauth"60 "clustr.spboucher.ai/mcc/internal/testdb"61)6263const origin = "https://clustr.example.test"6465type env struct {66 t *testing.T67 svc *identity.Service68 clock *time.Time69 ctx context.Context70 db interface {71 Exec(context.Context, string, ...any) (interface{ RowsAffected() int64 }, error)72 }73 q func(dst any, sql string, args ...any)74}7576func setup(t *testing.T) *env {77 t.Helper()78 pool, _ := testdb.New(t)79 cfg := &config.Config{Env: config.Test, PublicOrigin: origin, RPID: "clustr.example.test", SecretsDir: t.TempDir(),80 SessionIdle: 30 * time.Minute, SessionAbsolute: 12 * time.Hour, AccessTTL: 10 * time.Minute,81 RefreshTTL: 30 * 24 * time.Hour, StepUpWindow: 5 * time.Minute}82 svc, err := identity.New(pool, cfg)83 if err != nil {84 t.Fatal(err)85 }86 now := time.Now().UTC().Truncate(time.Second)87 e := &env{t: t, svc: svc, clock: &now, ctx: context.Background()}88 svc.SetClock(func() time.Time { return *e.clock })89 e.q = func(dst any, sql string, args ...any) {90 t.Helper()91 if err := pool.QueryRow(e.ctx, sql, args...).Scan(dst); err != nil {92 t.Fatalf("query %q: %v", sql, err)93 }94 }95 return e96}9798func (e *env) advance(d time.Duration) { *e.clock = e.clock.Add(d) }99100func meta() identity.ReqMeta { return identity.ReqMeta{Correlation: uuid.New(), UserAgent: "test"} }101102func code(err error) string {103 var he *httpx.Error104 if errors.As(err, &he) {105 return he.Code106 }107 if err == nil {108 return ""109 }110 return "internal:" + err.Error()111}112113func (e *env) want(err error, c string) {114 e.t.Helper()115 if code(err) != c {116 e.t.Fatalf("got error %q, want %q", code(err), c)117 }118}119120func js(v any) []byte { b, _ := json.Marshal(v); return b }121122// register drives a full setup: exchange → registration ceremony → first session.123func (e *env) register(token string, a *vauth.Authenticator, kind string) *identity.AuthResult {124 e.t.Helper()125 _, txTok, err := e.svc.ExchangeInvitation(e.ctx, token, meta())126 if err != nil {127 e.t.Fatalf("exchange: %v", err)128 }129 chID, opts, err := e.svc.BeginSetupRegistration(e.ctx, txTok)130 if err != nil {131 e.t.Fatalf("begin registration: %v", err)132 }133 cred, err := a.Create(js(opts))134 if err != nil {135 e.t.Fatal(err)136 }137 res, err := e.svc.FinishSetupRegistration(e.ctx, txTok, chID, cred, identity.ClientInfo{Kind: kind, Label: "test device"}, "first", meta())138 if err != nil {139 e.t.Fatalf("finish registration: %v", err)140 }141 return res142}143144func (e *env) owner() (*identity.AuthResult, *vauth.Authenticator) {145 e.t.Helper()146 _, token, err := e.svc.BootstrapOwner(e.ctx, "root", "Root Owner", 15*time.Minute)147 if err != nil {148 e.t.Fatal(err)149 }150 a := vauth.New(origin)151 return e.register(token, a, "web"), a152}153154func (e *env) invite(actor *identity.Session, role authz.Role, handle string) string {155 e.t.Helper()156 _, token, err := e.svc.CreateInvitation(e.ctx, actor, identity.InvitationParams{Role: role, Handle: handle, DisplayName: "User " + handle}, meta())157 if err != nil {158 e.t.Fatalf("invite %s: %v", handle, err)159 }160 return token161}162163func (e *env) login(a *vauth.Authenticator, kind string) (*identity.AuthResult, error) {164 chID, opts, err := e.svc.BeginAuthentication(e.ctx)165 if err != nil {166 e.t.Fatal(err)167 }168 assertion, err := a.Get(js(opts))169 if err != nil {170 e.t.Fatal(err)171 }172 return e.svc.FinishAuthentication(e.ctx, chID, assertion, identity.ClientInfo{Kind: kind}, meta())173}174175func (e *env) session(res *identity.AuthResult) *identity.Session {176 e.t.Helper()177 tok, kind := res.SessionToken, "cookie"178 if tok == "" {179 tok, kind = res.AccessToken, "bearer"180 }181 s, err := e.svc.Authenticate(e.ctx, tok, kind)182 if err != nil {183 e.t.Fatalf("authenticate: %v", err)184 }185 return s186}187188func (e *env) stepUp(sess *identity.Session, a *vauth.Authenticator) {189 e.t.Helper()190 chID, opts, err := e.svc.BeginStepUp(e.ctx, sess)191 if err != nil {192 e.t.Fatal(err)193 }194 as, _ := a.Get(js(opts))195 if _, err := e.svc.FinishStepUp(e.ctx, sess, chID, as, meta()); err != nil {196 e.t.Fatalf("step-up: %v", err)197 }198}199200func TestBootstrapRegisterLoginAndCSRF(t *testing.T) {201 e := setup(t)202 res, a := e.owner()203 if res.User.Role != authz.Owner || res.SessionToken == "" || res.AccessToken != "" {204 t.Fatalf("unexpected first session: %+v", res)205 }206 // A second bootstrap is refused once an owner can sign in.207 _, _, err := e.svc.BootstrapOwner(e.ctx, "root2", "Second", time.Minute)208 e.want(err, "owner_exists")209210 login, err := e.login(a, "web")211 if err != nil {212 t.Fatal(err)213 }214 sess := e.session(login)215 if sess.User.Handle != "root" {216 t.Fatalf("wrong user %q", sess.User.Handle)217 }218 csrf := e.svc.CSRFToken(login.SessionToken)219 if !e.svc.CheckCSRF(login.SessionToken, csrf) || e.svc.CheckCSRF(login.SessionToken, "") ||220 e.svc.CheckCSRF(login.SessionToken, e.svc.CSRFToken(res.SessionToken)) {221 t.Fatal("CSRF token must be bound to its own session")222 }223 // Tokens are stored hashed only.224 var leaked int225 e.q(&leaked, `select count(*) from sessions where encode(token_hash,'escape') = $1`, login.SessionToken)226 if leaked != 0 {227 t.Fatal("clear token stored")228 }229}230231func TestInvitationSingleUse(t *testing.T) {232 e := setup(t)233 own, _ := e.owner()234 actor := e.session(own)235236 t.Run("reuse after exchange", func(t *testing.T) {237 tok := e.invite(actor, authz.Viewer, "v1")238 if _, _, err := e.svc.ExchangeInvitation(e.ctx, tok, meta()); err != nil {239 t.Fatal(err)240 }241 _, _, err := e.svc.ExchangeInvitation(e.ctx, tok, meta())242 e.want(err, "invitation_invalid")243 })244 t.Run("concurrent exchange has exactly one winner", func(t *testing.T) {245 tok := e.invite(actor, authz.Viewer, "v2")246 var wins atomic.Int32247 var wg sync.WaitGroup248 for i := 0; i < 24; i++ {249 wg.Add(1)250 go func() {251 defer wg.Done()252 if _, _, err := e.svc.ExchangeInvitation(e.ctx, tok, meta()); err == nil {253 wins.Add(1)254 }255 }()256 }257 wg.Wait()258 if wins.Load() != 1 {259 t.Fatalf("%d exchanges succeeded, want exactly 1", wins.Load())260 }261 })262 t.Run("expired", func(t *testing.T) {263 tok := e.invite(actor, authz.Viewer, "v3")264 e.advance(16 * time.Minute)265 _, _, err := e.svc.ExchangeInvitation(e.ctx, tok, meta())266 e.want(err, "invitation_invalid")267 })268 t.Run("revoked", func(t *testing.T) {269 actor := e.session(e.mustLogin(t))270 inv, tok, _ := e.svc.CreateInvitation(e.ctx, actor, identity.InvitationParams{Role: authz.Viewer, Handle: "v4", DisplayName: "V4"}, meta())271 if err := e.svc.RevokeInvitation(e.ctx, actor, inv.ID, meta()); err != nil {272 t.Fatal(err)273 }274 _, _, err := e.svc.ExchangeInvitation(e.ctx, tok, meta())275 e.want(err, "invitation_invalid")276 })277 t.Run("garbage and unknown tokens", func(t *testing.T) {278 for _, tok := range []string{"", "short", "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"} {279 _, _, err := e.svc.ExchangeInvitation(e.ctx, tok, meta())280 e.want(err, "invitation_invalid")281 }282 })283 t.Run("completed invitation and its transaction are dead", func(t *testing.T) {284 actor := e.session(e.mustLogin(t))285 tok := e.invite(actor, authz.Operator, "op1")286 _, txTok, _ := e.svc.ExchangeInvitation(e.ctx, tok, meta())287 chID, opts, _ := e.svc.BeginSetupRegistration(e.ctx, txTok)288 a := vauth.New(origin)289 cred, _ := a.Create(js(opts))290 if _, err := e.svc.FinishSetupRegistration(e.ctx, txTok, chID, cred, identity.ClientInfo{Kind: "web"}, "", meta()); err != nil {291 t.Fatal(err)292 }293 // Same transaction cannot mint a second passkey or account.294 _, _, err := e.svc.BeginSetupRegistration(e.ctx, txTok)295 e.want(err, "setup_transaction_invalid")296 _, err = e.svc.FinishSetupRegistration(e.ctx, txTok, chID, cred, identity.ClientInfo{Kind: "web"}, "", meta())297 e.want(err, "setup_transaction_invalid")298 _, _, err = e.svc.ExchangeInvitation(e.ctx, tok, meta())299 e.want(err, "invitation_invalid")300 })301 t.Run("setup transaction expires", func(t *testing.T) {302 actor := e.session(e.mustLogin(t))303 tok := e.invite(actor, authz.Viewer, "v5")304 _, txTok, _ := e.svc.ExchangeInvitation(e.ctx, tok, meta())305 e.advance(11 * time.Minute)306 _, _, err := e.svc.BeginSetupRegistration(e.ctx, txTok)307 e.want(err, "setup_transaction_invalid")308 })309}310311var ownerAuth *vauth.Authenticator312313func (e *env) mustLogin(t *testing.T) *identity.AuthResult {314 t.Helper()315 // Sessions created earlier in the test may have expired after clock jumps: bootstrap a fresh admin path.316 var n int317 e.q(&n, `select count(*) from users where handle='helper'`)318 if n == 0 {319 // Create a helper owner directly through a recovery of root is overkill; insert via invitation from DB-side bootstrap instead.320 _, tok, err := e.svc.RecoveryInvitation(e.ctx, "root", 15*time.Minute)321 if err != nil {322 t.Fatal(err)323 }324 ownerAuth = vauth.New(origin)325 res := e.register(tok, ownerAuth, "web")326 actor := e.session(res)327 htok := e.invite(actor, authz.Owner, "helper")328 ownerAuth = vauth.New(origin)329 return e.register(htok, ownerAuth, "web")330 }331 res, err := e.login(ownerAuth, "web")332 if err != nil {333 t.Fatal(err)334 }335 return res336}337338func TestChallengeAndAssertionAbuse(t *testing.T) {339 e := setup(t)340 _, a := e.owner()341342 t.Run("challenge replay", func(t *testing.T) {343 chID, opts, _ := e.svc.BeginAuthentication(e.ctx)344 as, _ := a.Get(js(opts))345 if _, err := e.svc.FinishAuthentication(e.ctx, chID, as, identity.ClientInfo{Kind: "web"}, meta()); err != nil {346 t.Fatal(err)347 }348 _, err := e.svc.FinishAuthentication(e.ctx, chID, as, identity.ClientInfo{Kind: "web"}, meta())349 e.want(err, "challenge_invalid")350 })351 t.Run("assertion for another challenge", func(t *testing.T) {352 _, opts1, _ := e.svc.BeginAuthentication(e.ctx)353 ch2, _, _ := e.svc.BeginAuthentication(e.ctx)354 as, _ := a.Get(js(opts1))355 _, err := e.svc.FinishAuthentication(e.ctx, ch2, as, identity.ClientInfo{Kind: "web"}, meta())356 e.want(err, "credential_rejected")357 })358 t.Run("a failed attempt burns the challenge", func(t *testing.T) {359 chID, opts, _ := e.svc.BeginAuthentication(e.ctx)360 _, err := e.svc.FinishAuthentication(e.ctx, chID, []byte(`{"id":"x"}`), identity.ClientInfo{Kind: "web"}, meta())361 e.want(err, "credential_rejected")362 as, _ := a.Get(js(opts))363 _, err = e.svc.FinishAuthentication(e.ctx, chID, as, identity.ClientInfo{Kind: "web"}, meta())364 e.want(err, "challenge_invalid")365 })366 t.Run("expired challenge", func(t *testing.T) {367 chID, opts, _ := e.svc.BeginAuthentication(e.ctx)368 as, _ := a.Get(js(opts))369 e.advance(6 * time.Minute)370 _, err := e.svc.FinishAuthentication(e.ctx, chID, as, identity.ClientInfo{Kind: "web"}, meta())371 e.want(err, "challenge_invalid")372 })373 t.Run("phishing origin", func(t *testing.T) {374 a.Origin = "https://clustr.example.test.evil.example"375 _, err := e.login(a, "web")376 e.want(err, "credential_rejected")377 a.Origin = origin378 })379 t.Run("wrong RP ID", func(t *testing.T) {380 a.RPIDOverride = "evil.example"381 _, err := e.login(a, "web")382 e.want(err, "credential_rejected")383 a.RPIDOverride = ""384 })385 t.Run("no user verification", func(t *testing.T) {386 a.NoUserVerification = true387 _, err := e.login(a, "web")388 e.want(err, "credential_rejected")389 a.NoUserVerification = false390 })391 t.Run("unknown credential", func(t *testing.T) {392 stranger := vauth.New(origin)393 // A credential minted for this RP by an authenticator the server never saw.394 _, tok, _ := e.svc.RecoveryInvitation(e.ctx, "root", time.Minute)395 _, txTok, _ := e.svc.ExchangeInvitation(e.ctx, tok, meta())396 _, opts, _ := e.svc.BeginSetupRegistration(e.ctx, txTok)397 stranger.Create(js(opts)) // created locally, never finished server-side398 _, err := e.login(stranger, "web")399 e.want(err, "credential_rejected")400 e.svc.AbandonSetup(e.ctx, txTok, meta())401 })402 t.Run("still works after all rejections", func(t *testing.T) {403 if _, err := e.login(a, "web"); err != nil {404 t.Fatal(err)405 }406 })407 t.Run("denials are audited", func(t *testing.T) {408 var n int409 e.q(&n, `select count(*) from audit_log where action='auth.login' and outcome='denied'`)410 if n < 5 {411 t.Fatalf("only %d denied logins audited", n)412 }413 })414}415416func TestClonedAuthenticatorDetected(t *testing.T) {417 e := setup(t)418 _, tok, _ := e.svc.BootstrapOwner(e.ctx, "root", "Root", time.Minute)419 a := vauth.New(origin)420 a.UseCounter = true421 e.register(tok, a, "web")422 for i := 0; i < 3; i++ {423 if _, err := e.login(a, "web"); err != nil {424 t.Fatal(err)425 }426 }427 a.RewindCounter(3) // a clone replays an older counter428 _, err := e.login(a, "web")429 e.want(err, "credential_rejected")430}431432func TestSessionLifetimesAndRevocation(t *testing.T) {433 e := setup(t)434 res, a := e.owner()435436 // Idle expiry.437 e.advance(29 * time.Minute)438 e.session(res) // touches439 e.advance(29 * time.Minute)440 e.session(res) // still alive thanks to the sliding window441 e.advance(31 * time.Minute)442 _, err := e.svc.Authenticate(e.ctx, res.SessionToken, "cookie")443 e.want(err, "unauthenticated")444445 // Absolute expiry even with constant activity.446 res, _ = e.login(a, "web")447 for i := 0; i < 25; i++ {448 e.advance(29 * time.Minute)449 if _, err := e.svc.Authenticate(e.ctx, res.SessionToken, "cookie"); err != nil {450 if i < 23 {451 t.Fatalf("session died early at step %d", i)452 }453 break454 }455 if i == 24 {456 t.Fatal("session outlived its absolute lifetime")457 }458 }459460 // A cookie token is not accepted as a bearer token and vice versa.461 res, _ = e.login(a, "web")462 _, err = e.svc.Authenticate(e.ctx, res.SessionToken, "bearer")463 e.want(err, "unauthenticated")464465 // Explicit revocation.466 sess := e.session(res)467 if err := e.svc.RevokeSession(e.ctx, sess, sess.ID, "logout", meta()); err != nil {468 t.Fatal(err)469 }470 _, err = e.svc.Authenticate(e.ctx, res.SessionToken, "cookie")471 e.want(err, "unauthenticated")472473 // Device revocation kills every session of that device, and only those.474 web, _ := e.login(a, "web")475 phone, _ := e.login(a, "ios")476 phone2, err := e.svc.FinishAuthentication(e.ctx, func() uuid.UUID { id, _, _ := e.svc.BeginAuthentication(e.ctx); return id }(), nil, identity.ClientInfo{Kind: "ios"}, meta())477 _ = phone2478 e.want(err, "credential_rejected")479 if err := e.svc.RevokeDevice(e.ctx, e.session(web), phone.Device.ID, meta()); err != nil {480 t.Fatal(err)481 }482 _, err = e.svc.Authenticate(e.ctx, phone.AccessToken, "bearer")483 e.want(err, "unauthenticated")484 _, err = e.svc.Refresh(e.ctx, phone.RefreshToken, meta())485 e.want(err, "refresh_rejected")486 e.session(web) // unaffected487488 // A revoked device id cannot be resurrected by presenting it again at login.489 chID, opts, _ := e.svc.BeginAuthentication(e.ctx)490 as, _ := a.Get(js(opts))491 again, err := e.svc.FinishAuthentication(e.ctx, chID, as, identity.ClientInfo{Kind: "ios", DeviceID: &phone.Device.ID}, meta())492 if err != nil {493 t.Fatal(err)494 }495 if again.Device.ID == phone.Device.ID {496 t.Fatal("revoked device was reused")497 }498}499500func TestRefreshRotationAndReuseDetection(t *testing.T) {501 e := setup(t)502 _, a := e.owner()503 native, err := e.login(a, "macos")504 if err != nil || native.AccessToken == "" || native.RefreshToken == "" || native.SessionToken != "" {505 t.Fatalf("native login: %+v err=%v", native, err)506 }507 e.session(native)508509 // Access token expires; refresh rotates both tokens.510 e.advance(11 * time.Minute)511 _, err = e.svc.Authenticate(e.ctx, native.AccessToken, "bearer")512 e.want(err, "unauthenticated")513 r1, err := e.svc.Refresh(e.ctx, native.RefreshToken, meta())514 if err != nil {515 t.Fatal(err)516 }517 if r1.RefreshToken == native.RefreshToken || r1.AccessToken == native.AccessToken {518 t.Fatal("tokens must rotate")519 }520 if _, err := e.svc.Authenticate(e.ctx, r1.AccessToken, "bearer"); err != nil {521 t.Fatal(err)522 }523 // The old access token is dead even though its hash was replaced.524 _, err = e.svc.Authenticate(e.ctx, native.AccessToken, "bearer")525 e.want(err, "unauthenticated")526527 // Replaying the rotated refresh token revokes the whole session, including the legitimate new tokens.528 _, err = e.svc.Refresh(e.ctx, native.RefreshToken, meta())529 e.want(err, "refresh_rejected")530 _, err = e.svc.Authenticate(e.ctx, r1.AccessToken, "bearer")531 e.want(err, "unauthenticated")532 _, err = e.svc.Refresh(e.ctx, r1.RefreshToken, meta())533 e.want(err, "refresh_rejected")534 var n int535 e.q(&n, `select count(*) from audit_log where action='session.refresh_reuse_detected'`)536 if n != 1 {537 t.Fatalf("reuse audited %d times", n)538 }539540 // Concurrent refresh with the same token: one winner, and the loser triggers reuse handling.541 native, _ = e.login(a, "macos")542 var ok atomic.Int32543 var wg sync.WaitGroup544 for i := 0; i < 8; i++ {545 wg.Add(1)546 go func() {547 defer wg.Done()548 if _, err := e.svc.Refresh(e.ctx, native.RefreshToken, meta()); err == nil {549 ok.Add(1)550 }551 }()552 }553 wg.Wait()554 if ok.Load() != 1 {555 t.Fatalf("%d concurrent refreshes succeeded", ok.Load())556 }557558 // Refresh tokens expire.559 native, _ = e.login(a, "ios")560 e.advance(31 * 24 * time.Hour)561 _, err = e.svc.Refresh(e.ctx, native.RefreshToken, meta())562 e.want(err, "refresh_rejected")563}564565func TestStepUp(t *testing.T) {566 e := setup(t)567 res, a := e.owner()568 sess := e.session(res)569 if !e.svc.StepUpFresh(sess) {570 t.Fatal("a session is fresh right after sign-in")571 }572 e.advance(6 * time.Minute)573 sess = e.session(res)574 if e.svc.StepUpFresh(sess) {575 t.Fatal("step-up must go stale")576 }577 // A step-up challenge issued to another session of the same user is not accepted.578 other, _ := e.login(a, "web")579 otherSess := e.session(other)580 chID, opts, _ := e.svc.BeginStepUp(e.ctx, otherSess)581 as, _ := a.Get(js(opts))582 _, err := e.svc.FinishStepUp(e.ctx, sess, chID, as, meta())583 e.want(err, "credential_rejected")584585 e.stepUp(sess, a)586 if !e.svc.StepUpFresh(e.session(res)) {587 t.Fatal("step-up not recorded")588 }589 // Another user's passkey cannot step up this session.590 tok := e.invite(sess, authz.Viewer, "mallory")591 m := vauth.New(origin)592 e.register(tok, m, "web")593 e.advance(6 * time.Minute)594 sess = e.session(res)595 chID, opts, _ = e.svc.BeginStepUp(e.ctx, sess)596 chAuth, optsAuth, _ := e.svc.BeginAuthentication(e.ctx)597 _ = chAuth598 mAs, _ := m.Get(js(optsAuth)) // mallory signs a different challenge with her own key599 _, err = e.svc.FinishStepUp(e.ctx, sess, chID, mAs, meta())600 e.want(err, "credential_rejected")601 _ = opts602 if e.svc.StepUpFresh(e.session(res)) {603 t.Fatal("failed step-up must not refresh the session")604 }605}606607func TestPasskeyManagement(t *testing.T) {608 e := setup(t)609 res, a := e.owner()610 sess := e.session(res)611 keys, _ := e.svc.ListPasskeys(e.ctx, sess.User.ID)612 if len(keys) != 1 {613 t.Fatalf("want 1 passkey, got %d", len(keys))614 }615 e.want(e.svc.RevokePasskey(e.ctx, sess, sess.User.ID, keys[0].ID, false, meta()), "last_passkey")616617 // Add a second passkey on another authenticator.618 b := vauth.New(origin)619 chID, opts, err := e.svc.BeginAddPasskey(e.ctx, sess)620 if err != nil {621 t.Fatal(err)622 }623 // The same authenticator is excluded.624 if _, err := a.Create(js(opts)); err == nil {625 t.Fatal("existing authenticator should be excluded")626 }627 cred, _ := b.Create(js(opts))628 pk, err := e.svc.FinishAddPasskey(e.ctx, sess, chID, cred, "backup key", meta())629 if err != nil {630 t.Fatal(err)631 }632 // Registration challenge is single-use too.633 _, err = e.svc.FinishAddPasskey(e.ctx, sess, chID, cred, "again", meta())634 e.want(err, "challenge_invalid")635636 viaB, err := e.login(b, "web")637 if err != nil {638 t.Fatal(err)639 }640 // Revoking passkey B ends the sessions opened with it; passkey A keeps working.641 if err := e.svc.RevokePasskey(e.ctx, sess, sess.User.ID, pk.ID, false, meta()); err != nil {642 t.Fatal(err)643 }644 _, err = e.svc.Authenticate(e.ctx, viaB.SessionToken, "cookie")645 e.want(err, "unauthenticated")646 _, err = e.login(b, "web")647 e.want(err, "credential_rejected")648 if _, err := e.login(a, "web"); err != nil {649 t.Fatal(err)650 }651 // The administration view keeps the revoked passkey; the user's own list does not.652 all, err := e.svc.ListAllPasskeys(e.ctx, sess.User.ID)653 if err != nil || len(all) != 2 || all[0].RevokedAt != nil || all[1].ID != pk.ID || all[1].RevokedAt == nil {654 t.Fatalf("ListAllPasskeys: %+v (%v)", all, err)655 }656 if active, _ := e.svc.ListPasskeys(e.ctx, sess.User.ID); len(active) != 1 {657 t.Fatalf("want 1 active passkey, got %d", len(active))658 }659}660661func TestRolesAndTakeoverProtection(t *testing.T) {662 e := setup(t)663 own, ownA := e.owner()664 owner := e.session(own)665666 adminA := vauth.New(origin)667 admin := e.session(e.register(e.invite(owner, authz.Admin, "alice"), adminA, "web"))668 opA := vauth.New(origin)669 op := e.session(e.register(e.invite(admin, authz.Operator, "bob"), opA, "web"))670671 // Admin cannot mint an owner; operator cannot invite at all (service-level defence in depth).672 _, _, err := e.svc.CreateInvitation(e.ctx, admin, identity.InvitationParams{Role: authz.Owner, Handle: "eve", DisplayName: "Eve"}, meta())673 e.want(err, "forbidden")674 _, _, err = e.svc.CreateInvitation(e.ctx, op, identity.InvitationParams{Role: authz.Viewer, Handle: "eve", DisplayName: "Eve"}, meta())675 e.want(err, "forbidden")676677 // An invitation can never name an existing handle (no implicit merge / takeover).678 _, _, err = e.svc.CreateInvitation(e.ctx, owner, identity.InvitationParams{Role: authz.Owner, Handle: "alice", DisplayName: "Alice 2"}, meta())679 e.want(err, "handle_taken")680 // …nor can an invitee pick one during setup.681 _, open, _ := e.svc.CreateInvitation(e.ctx, owner, identity.InvitationParams{Role: authz.Viewer}, meta())682 _, txTok, _ := e.svc.ExchangeInvitation(e.ctx, open, meta())683 _, _, err = e.svc.BeginSetupRegistration(e.ctx, txTok)684 e.want(err, "profile_required")685 _, err = e.svc.SetSetupProfile(e.ctx, txTok, "root", "Fake Root")686 e.want(err, "handle_taken")687 if _, err = e.svc.SetSetupProfile(e.ctx, txTok, "Carol", "Carol C."); err != nil {688 t.Fatal(err)689 }690 // Race: the handle gets taken between profile choice and finish → no account is created.691 chID, opts, _ := e.svc.BeginSetupRegistration(e.ctx, txTok)692 e.register(e.invite(owner, authz.Viewer, "carol"), vauth.New(origin), "web")693 ca := vauth.New(origin)694 cred, _ := ca.Create(js(opts))695 _, err = e.svc.FinishSetupRegistration(e.ctx, txTok, chID, cred, identity.ClientInfo{Kind: "web"}, "", meta())696 e.want(err, "handle_taken")697698 // Role changes.699 viewer := authz.Viewer700 ownerRole := authz.Owner701 yes := true702 _, err = e.svc.UpdateUser(e.ctx, admin, admin.User.ID, &ownerRole, nil, meta())703 e.want(err, "self_modification")704 _, err = e.svc.UpdateUser(e.ctx, admin, op.User.ID, &ownerRole, nil, meta())705 e.want(err, "forbidden")706 _, err = e.svc.UpdateUser(e.ctx, admin, owner.User.ID, &viewer, nil, meta())707 e.want(err, "forbidden")708 _, err = e.svc.UpdateUser(e.ctx, admin, owner.User.ID, nil, &yes, meta())709 e.want(err, "forbidden")710711 // Promote alice to owner, then she cannot demote the only other… wait: two owners exist, demotion of one is fine,712 // but the last one standing is protected.713 if _, err = e.svc.UpdateUser(e.ctx, owner, admin.User.ID, &ownerRole, nil, meta()); err != nil {714 t.Fatal(err)715 }716 alice, _ := e.login(adminA, "web")717 aliceSess := e.session(alice)718 if _, err = e.svc.UpdateUser(e.ctx, aliceSess, owner.User.ID, &viewer, nil, meta()); err != nil {719 t.Fatal(err)720 }721 rootAgain, _ := e.login(ownA, "web")722 _, err = e.svc.UpdateUser(e.ctx, e.session(rootAgain), aliceSess.User.ID, &viewer, nil, meta())723 e.want(err, "forbidden") // root is now a viewer724 // Disabling a user revokes their sessions immediately.725 if _, err = e.svc.UpdateUser(e.ctx, aliceSess, op.User.ID, nil, &yes, meta()); err != nil {726 t.Fatal(err)727 }728 _, err = e.login(opA, "web")729 e.want(err, "credential_rejected")730}731732func TestLastOwnerProtected(t *testing.T) {733 e := setup(t)734 own, _ := e.owner()735 owner := e.session(own)736 // A second owner WITHOUT a usable passkey does not count as an active owner.737 a2 := vauth.New(origin)738 second := e.session(e.register(e.invite(owner, authz.Owner, "second"), a2, "web"))739 keys, _ := e.svc.ListPasskeys(e.ctx, second.User.ID)740 if err := e.svc.RevokePasskey(e.ctx, owner, second.User.ID, keys[0].ID, true, meta()); err != nil {741 t.Fatal(err)742 }743 viewer := authz.Viewer744 yes := true745 // "second" still has role owner but cannot sign in: demoting/disabling root would lock the cluster out.746 // second's session was not opened by owner, so it may still be valid: use it as the actor.747 _, err := e.svc.UpdateUser(e.ctx, second, owner.User.ID, &viewer, nil, meta())748 e.want(err, "last_owner")749 _, err = e.svc.UpdateUser(e.ctx, second, owner.User.ID, nil, &yes, meta())750 e.want(err, "last_owner")751}752753func TestLinkInvitationRequiresTheRightAccountAndStepUp(t *testing.T) {754 e := setup(t)755 own, _ := e.owner()756 owner := e.session(own)757 bobA, eveA := vauth.New(origin), vauth.New(origin)758 bob := e.register(e.invite(owner, authz.Viewer, "bob"), bobA, "web")759 eve := e.register(e.invite(owner, authz.Viewer, "eve"), eveA, "web")760 bobID := bob.User.ID761762 _, tok, err := e.svc.CreateInvitation(e.ctx, owner, identity.InvitationParams{Purpose: "link", Role: authz.Admin, TargetUserID: &bobID}, meta())763 if err != nil {764 t.Fatal(err)765 }766 _, txTok, _ := e.svc.ExchangeInvitation(e.ctx, tok, meta())767 // A link invitation can never register a passkey (that would be an account takeover vector).768 _, _, err = e.svc.BeginSetupRegistration(e.ctx, txTok)769 e.want(err, "link_required")770 // Unauthenticated, or signed in as someone else: refused.771 _, err = e.svc.LinkSetup(e.ctx, txTok, nil, true, meta())772 e.want(err, "unauthenticated")773 _, err = e.svc.LinkSetup(e.ctx, txTok, e.session(eve), true, meta())774 e.want(err, "wrong_account")775 // The right account, but with a stale step-up, or without explicit confirmation.776 e.advance(6 * time.Minute)777 bobSess := e.session(bob)778 _, err = e.svc.LinkSetup(e.ctx, txTok, bobSess, true, meta())779 e.want(err, "step_up_required")780 e.stepUp(bobSess, bobA)781 _, err = e.svc.LinkSetup(e.ctx, txTok, bobSess, false, meta())782 e.want(err, "validation_failed")783 u, err := e.svc.LinkSetup(e.ctx, txTok, bobSess, true, meta())784 if err != nil || u.Role != authz.Admin {785 t.Fatalf("link: role=%s err=%v", u.Role, err)786 }787 _, err = e.svc.LinkSetup(e.ctx, txTok, bobSess, true, meta())788 e.want(err, "setup_transaction_invalid")789 var eveRole string790 e.q(&eveRole, `select role::text from users where handle='eve'`)791 if eveRole != "viewer" {792 t.Fatal("eve must be untouched")793 }794}795796func TestRecoveryIsOutOfBandAndRevokesOldCredentials(t *testing.T) {797 e := setup(t)798 own, oldA := e.owner()799 owner := e.session(own)800 rootID := owner.User.ID801 // Through the API (any actor), recovery invitations cannot be created.802 _, _, err := e.svc.CreateInvitation(e.ctx, owner, identity.InvitationParams{Purpose: "recovery", Role: authz.Owner, TargetUserID: &rootID}, meta())803 e.want(err, "forbidden")804805 _, tok, err := e.svc.RecoveryInvitation(e.ctx, "root", 15*time.Minute)806 if err != nil {807 t.Fatal(err)808 }809 _, _, err = e.svc.RecoveryInvitation(e.ctx, "root", 15*time.Minute)810 e.want(err, "recovery_pending")811 newA := vauth.New(origin)812 res := e.register(tok, newA, "macos")813 if res.User.ID != rootID || res.User.Role != authz.Owner {814 t.Fatal("recovery must return the same account with the same role")815 }816 // Old session and old passkey are dead; the new passkey works.817 _, err = e.svc.Authenticate(e.ctx, own.SessionToken, "cookie")818 e.want(err, "unauthenticated")819 _, err = e.login(oldA, "web")820 e.want(err, "credential_rejected")821 if _, err := e.login(newA, "web"); err != nil {822 t.Fatal(err)823 }824 var cli int825 e.q(&cli, `select count(*) from audit_log where action='invitation.create' and actor_kind='cli'`)826 if cli < 2 {827 t.Fatal("out-of-band operations must be audited as cli")828 }829}830831func TestSetupAttemptLimit(t *testing.T) {832 e := setup(t)833 own, _ := e.owner()834 tok := e.invite(e.session(own), authz.Viewer, "victim")835 _, txTok, _ := e.svc.ExchangeInvitation(e.ctx, tok, meta())836 bad := vauth.New("https://evil.example") // wrong origin: every attestation is rejected837 for i := 0; i < 5; i++ {838 chID, opts, err := e.svc.BeginSetupRegistration(e.ctx, txTok)839 if err != nil {840 t.Fatalf("attempt %d: begin: %v", i, err)841 }842 cred, _ := bad.Create(js(opts))843 _, err = e.svc.FinishSetupRegistration(e.ctx, txTok, chID, cred, identity.ClientInfo{Kind: "web"}, "", meta())844 e.want(err, "credential_rejected")845 }846 _, _, err := e.svc.BeginSetupRegistration(e.ctx, txTok)847 e.want(err, "setup_transaction_invalid")848 var users int849 e.q(&users, `select count(*) from users where handle='victim'`)850 if users != 0 {851 t.Fatal("no account may exist after failed setups")852 }853}854855func TestCleanupExpiredRuns(t *testing.T) {856 e := setup(t)857 e.owner()858 if err := e.svc.CleanupExpired(e.ctx); err != nil {859 t.Fatal(err)860 }861 e.advance(48 * time.Hour)862 if err := e.svc.CleanupExpired(e.ctx); err != nil {863 t.Fatal(err)864 }865 var n int866 e.q(&n, `select count(*) from webauthn_challenges`)867 if n != 0 {868 t.Fatalf("%d expired challenges left", n)869 }870}871