package store import ( "context" "errors" "strings" "sync" "sync/atomic" "testing" "time" "pageswiki/internal/db" ) const cliTestOrigin = "https://wiki.example" func TestCLIAuthTrustedMigrationPreservesExistingRequests(t *testing.T) { s := newSchemaTestStore(t) ctx := context.Background() if err := db.ApplySQLiteMigrations(ctx, s.DB, "cli-auth", cliAuthMigrations[:1]); err != nil { t.Fatal(err) } if _, err := s.DB.Exec(`INSERT INTO auth_cli_requests(id,domain_uuid,origin,device_hash,challenge,code_hash,created_ms,expires_ms) VALUES('old','domain','https://wiki.example','device','challenge','code',1,2)`); err != nil { t.Fatal(err) } for i := 0; i < 2; i++ { if err := db.ApplySQLiteMigrations(ctx, s.DB, "cli-auth", cliAuthMigrations); err != nil { t.Fatal(err) } } var remember int var challenge string if err := s.DB.QueryRow(`SELECT remember,challenge FROM auth_cli_requests WHERE id='old'`).Scan(&remember, &challenge); err != nil || remember != 0 || challenge != "challenge" { t.Fatalf("old grant changed: %d %q %v", remember, challenge, err) } if _, err := s.DB.Exec(`UPDATE auth_cli_requests SET remember=2`); err == nil { t.Fatal("invalid remember flag accepted") } } func TestTOTPLoginBindsTrustedChoice(t *testing.T) { for _, remember := range []bool{false, true} { s, p, _ := cliAuthFixture(t) secret, err := s.BeginTOTPEnrollment(p) if err != nil { t.Fatal(err) } code, err := totpCode(secret, time.Now().Unix()/30) if err != nil { t.Fatal(err) } if err = s.ConfirmTOTPEnrollment(p, code); err != nil { t.Fatal(err) } // Synthetic fixture: permit this time step once for login after enrollment. if _, err = s.DB.Exec(`UPDATE auth_credentials SET parameters_json='{"last_counter":0}' WHERE principal_uuid=? AND kind='totp'`, p); err != nil { t.Fatal(err) } challenge, err := s.CreateTOTPLoginChallengeForLogin("domain", p, remember) if err != nil { t.Fatal(err) } got, choice, err := s.CompleteTOTPLoginChallengeForLogin("domain", challenge, code) if err != nil || got != p || choice != remember { t.Fatalf("bound choice: %q %v %v", got, choice, err) } if _, _, err = s.CompleteTOTPLoginChallengeForLogin("domain", challenge, code); err == nil { t.Fatal("challenge replay accepted") } } } 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) } }