package store import ( "context" "errors" "strings" "sync" "sync/atomic" "testing" "time" ) const cliTestOrigin = "https://wiki.example" func cliAuthFixture(t *testing.T) (*Store, string, string) { t.Helper() s := newSchemaTestStore(t) s.authKey = make([]byte, 32) // synthetic key; no on-disk or production secrets if err := s.EnsureAuthSchema(); err != nil { t.Fatal(err) } if err := s.ensureSchemaComponent("cli-auth"); err != nil { t.Fatal(err) } p, err := s.BootstrapOwner("domain", "owner", "correct horse battery staple", "Owner", "") if err != nil { t.Fatal(err) } browser, err := s.CreateBrowserAuthSession("domain", p.UUID, 0) if err != nil { t.Fatal(err) } return s, p.UUID, browser } func TestCLIAuthExchangeIsAtomicAndSingleUse(t *testing.T) { s, _, browser := cliAuthFixture(t) ctx := context.Background() verifier := strings.Repeat("a", 43) id, device, code, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, hashAuthToken(verifier)) if err != nil { t.Fatal(err) } if _, _, _, err := s.ExchangeCLIAuth(ctx, "domain", cliTestOrigin, device, verifier); !errors.Is(err, ErrCLIPending) { t.Fatalf("pending: %v", err) } if _, _, _, err := s.ExchangeCLIAuth(ctx, "domain", cliTestOrigin, device, verifier); !errors.Is(err, ErrCLISlowDown) { t.Fatalf("poll rate: %v", err) } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, browser); err != nil { t.Fatal(err) } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, browser); err == nil { t.Fatal("request rebound") } if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, code, "", true); err != nil { t.Fatal(err) } if _, err := s.DB.Exec(`UPDATE auth_cli_requests SET next_poll_ms=0`); err != nil { t.Fatal(err) } var wg sync.WaitGroup var successes atomic.Int32 for range 12 { wg.Add(1) go func() { defer wg.Done() token, name, expires, err := s.ExchangeCLIAuth(ctx, "domain", cliTestOrigin, device, verifier) if err == nil { if !strings.HasPrefix(token, "pw_api_") || name != "owner" || expires <= time.Now().UnixMilli() { t.Errorf("bad issued session") } if _, err := s.PrincipalForSession("domain", token); err != nil { t.Error(err) } successes.Add(1) } }() } wg.Wait() if successes.Load() != 1 { t.Fatalf("issued %d sessions", successes.Load()) } var count int if err := s.DB.QueryRow(`SELECT count(*) FROM auth_sessions`).Scan(&count); err != nil || count != 2 { t.Fatalf("sessions=%d %v", count, err) } } func TestCLIAuthBoundariesAndRevocation(t *testing.T) { for _, mode := range []string{"domain", "origin", "verifier", "device", "expired", "denied", "suspended", "membership", "browser revoked"} { t.Run(mode, func(t *testing.T) { s, _, browser := cliAuthFixture(t) ctx := context.Background() verifier := strings.Repeat("b", 43) id, device, code, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, hashAuthToken(verifier)) if err != nil { t.Fatal(err) } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, browser); err != nil { t.Fatal(err) } if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, code, "", mode != "denied"); err != nil { t.Fatal(err) } domain, origin := "domain", cliTestOrigin var query string switch mode { case "domain": domain = "other" case "origin": origin = "https://alias.example" case "verifier": verifier = strings.Repeat("c", 43) case "device": device = strings.Repeat("d", 43) case "expired": query = `UPDATE auth_cli_requests SET expires_ms=1` case "suspended": query = `UPDATE principals SET state='suspended'` case "membership": query = `UPDATE domain_memberships SET state='suspended'` case "browser revoked": query = `UPDATE auth_sessions SET revoked_at_ms=1` } if query != "" { if _, err := s.DB.Exec(query); err != nil { t.Fatal(err) } } if token, _, _, err := s.ExchangeCLIAuth(ctx, domain, origin, device, verifier); err == nil || token != "" { t.Fatalf("bypass %s", mode) } var count int if err := s.DB.QueryRow(`SELECT count(*) FROM auth_sessions`).Scan(&count); err != nil || count != 1 { t.Fatalf("session leaked %d %v", count, err) } }) } } func TestCLIAuthApprovalAttemptsAndIssuanceCap(t *testing.T) { s, _, browser := cliAuthFixture(t) ctx := context.Background() id, _, code, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, strings.Repeat("c", 43)) if err != nil { t.Fatal(err) } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, browser); err != nil { t.Fatal(err) } for range 5 { if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, "wrong", "", true); err == nil { t.Fatal("wrong code accepted") } } if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, code, "", true); err == nil { t.Fatal("attempt limit bypassed") } for range 63 { if _, _, _, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, strings.Repeat("c", 43)); err != nil { t.Fatal(err) } } if _, _, _, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, strings.Repeat("c", 43)); !errors.Is(err, ErrCLILimit) { t.Fatalf("cap: %v", err) } s.ReadOnly = true if _, _, _, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, strings.Repeat("c", 43)); !errors.Is(err, ErrReadOnly) { t.Fatalf("readonly: %v", err) } } func TestCLIAuthSessionFailureRollsBackConsumption(t *testing.T) { s, _, browser := cliAuthFixture(t) ctx := context.Background() verifier := strings.Repeat("e", 43) id, device, code, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, hashAuthToken(verifier)) if err != nil { t.Fatal(err) } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, browser); err != nil { t.Fatal(err) } if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, code, "", true); err != nil { t.Fatal(err) } if _, err := s.DB.Exec(`CREATE TRIGGER reject_cli_session BEFORE INSERT ON auth_sessions BEGIN SELECT RAISE(ABORT,'synthetic failure'); END`); err != nil { t.Fatal(err) } if token, _, _, err := s.ExchangeCLIAuth(ctx, "domain", cliTestOrigin, device, verifier); err == nil || token != "" { t.Fatal("failed write accepted") } grant, err := s.CLIAuthRequest(ctx, "domain", cliTestOrigin, id) if err != nil || grant.State != "approved" { t.Fatalf("consumed without session: %+v %v", grant, err) } } func TestCLIAuthOIDCDoesNotRepeatLocalTOTPOrInventMFA(t *testing.T) { s, principal, browser := cliAuthFixture(t) ctx := context.Background() verifier := strings.Repeat("t", 43) secret, err := s.BeginTOTPEnrollment(principal) if err != nil { t.Fatal(err) } code, err := totpCode(secret, time.Now().Unix()/30) if err != nil { t.Fatal(err) } if err := s.ConfirmTOTPEnrollment(principal, code); err != nil { t.Fatal(err) } id, device, userCode, err := s.StartCLIAuth(ctx, "domain", cliTestOrigin, hashAuthToken(verifier)) if err != nil { t.Fatal(err) } for range 3 { if err := s.BeginCLIAuth(ctx, "domain", cliTestOrigin, id); err != nil { t.Fatal(err) } } if err := s.BeginCLIAuth(ctx, "domain", cliTestOrigin, id); err == nil { t.Fatal("OIDC challenge amplification allowed") } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, browser); err != nil { t.Fatal(err) } if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, userCode, "", true); err != nil { t.Fatal(err) } token, _, _, err := s.ExchangeCLIAuth(ctx, "domain", cliTestOrigin, device, verifier) if err != nil { t.Fatal(err) } var level int if err := s.DB.QueryRow(`SELECT mfa_level FROM auth_sessions WHERE token_hash=?`, hashAuthToken(token)).Scan(&level); err != nil || level != 0 { t.Fatalf("OIDC must not invent local MFA: %d %v", level, err) } // Preserve an actually verified level from the bound browser session. strongBrowser, err := s.CreateBrowserAuthSession("domain", principal, 1) if err != nil { t.Fatal(err) } id, device, userCode, err = s.StartCLIAuth(ctx, "domain", cliTestOrigin, hashAuthToken(verifier)) if err != nil { t.Fatal(err) } if err := s.BindCLIAuth(ctx, "domain", cliTestOrigin, id, strongBrowser); err != nil { t.Fatal(err) } if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, strongBrowser, userCode, "", true); err != nil { t.Fatal(err) } token, _, _, err = s.ExchangeCLIAuth(ctx, "domain", cliTestOrigin, device, verifier) if err != nil { t.Fatal(err) } if err := s.DB.QueryRow(`SELECT mfa_level FROM auth_sessions WHERE token_hash=?`, hashAuthToken(token)).Scan(&level); err != nil || level != 1 { t.Fatalf("verified MFA level lost: %d %v", level, err) } }