264 lines
8.5 KiB
Go
264 lines
8.5 KiB
Go
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)
|
|
}
|
|
}
|