Add OIDC browser approval and PKCE session handoff for pages CLI
Build and publish container images / images (push) Successful in 14m39s
Release container images / release (push) Successful in 25s

This commit is contained in:
Anya Tokugawa committed 2026-11-01 20:26:45 +09:00
1 parent 2af87b4f58
commit 60f5fb1881
18 files changed
+1397 -23

No files matched your search

+253
View File
@@ -0,0 +1,253 @@
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", "new totp"} {
t.Run(mode, func(t *testing.T) {
s, principal, 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`
case "new totp":
_, err = s.DB.Exec(`INSERT INTO auth_credentials(uuid,principal_uuid,kind,identifier,secret_hash,created_at_ms,updated_at_ms,enabled) VALUES('totp',?,'totp',?,'invalid',1,1,1)`, principal, principal)
if err != nil {
t.Fatal(err)
}
}
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 TestCLIAuthRequiresTOTPAndPreservesLevel(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("TOTP bypass")
}
code, err = totpCode(secret, time.Now().Unix()/30+1)
if err != nil {
t.Fatal(err)
}
if err := s.DecideCLIAuth(ctx, "domain", cliTestOrigin, id, browser, userCode, code, 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 != 1 {
t.Fatalf("MFA not preserved: %d %v", level, err)
}
}