package store import ( "database/sql" "errors" "strings" "testing" ) func externalBindingFixture(t *testing.T) *Store { t.Helper() database, err := sql.Open("sqlite", ":memory:") if err != nil { t.Fatal(err) } database.SetMaxOpenConns(1) t.Cleanup(func() { database.Close() }) st := &Store{DB: database, authKey: make([]byte, 32)} if err := st.EnsureAuthSchema(); err != nil { t.Fatal(err) } if _, err := database.Exec(`INSERT INTO principals(uuid,display_name,email,state,created_at_ms,updated_at_ms) VALUES('first','First User','same@example.test','active',1,1),('second','Second User','SAME@example.test','readonly',1,1); INSERT INTO principal_identities(uuid,principal_uuid,provider_type,subject,created_at_ms) VALUES('i1','first','password','first',1),('i2','second','password','second',1); INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES('m1','domain','first','active',1),('m2','domain','second','suspended',1),('m3','other','second','active',1)`); err != nil { t.Fatal(err) } return st } func TestExternalUsernameLookupRequiresActiveAccountAndMembership(t *testing.T) { st := externalBindingFixture(t) principal, err := st.PrincipalByExternalUsername("domain", " FIRST ") if err != nil || principal.UUID != "first" || principal.Username != "first" { t.Fatalf("active username: %#v %v", principal, err) } if _, err := st.PrincipalByExternalUsername("domain", "second"); !errors.Is(err, ErrAccessDenied) { t.Fatalf("suspended membership resolved username: %v", err) } if _, err := st.DB.Exec(`UPDATE principals SET state='quarantined' WHERE uuid='second'`); err != nil { t.Fatal(err) } if _, err := st.PrincipalByExternalUsername("other", "second"); !errors.Is(err, ErrAccessDenied) { t.Fatalf("quarantined account resolved username: %v", err) } if _, err := st.PrincipalByExternalUsername("domain", " "); !errors.Is(err, ErrAccessDenied) { t.Fatal("empty username resolved account") } } func TestExternalDisplayNameLookupRequiresExactUniqueActiveMembership(t *testing.T) { st := externalBindingFixture(t) principal, err := st.PrincipalByDisplayName("domain", " First User ") if err != nil || principal.UUID != "first" { t.Fatalf("unique active display name: %#v %v", principal, err) } if _, err := st.PrincipalByDisplayName("domain", "first user"); !errors.Is(err, ErrAccessDenied) { t.Fatalf("case-insensitive display name unexpectedly matched: %v", err) } if _, err := st.DB.Exec(`UPDATE principals SET display_name='First User' WHERE uuid='second'; UPDATE domain_memberships SET state='active' WHERE uuid='m2'`); err != nil { t.Fatal(err) } if principal, err := st.PrincipalByDisplayName("domain", "First User"); !errors.Is(err, ErrAccessDenied) || principal != nil { t.Fatalf("ambiguous display name selected an arbitrary account: %#v %v", principal, err) } if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE uuid='m2'`); err != nil { t.Fatal(err) } if principal, err := st.PrincipalByDisplayName("domain", "First User"); err != nil || principal.UUID != "first" { t.Fatalf("inactive duplicate blocked unique active account: %#v %v", principal, err) } if _, err := st.PrincipalByDisplayName("domain", " "); !errors.Is(err, ErrAccessDenied) { t.Fatal("empty display name resolved account") } } func TestExternalEmailLookupRequiresUniqueActiveMembership(t *testing.T) { st := externalBindingFixture(t) principal, err := st.PrincipalByVerifiedEmail("domain", " SAME@example.test ") if err != nil || principal.UUID != "first" { t.Fatalf("unique active account: %#v %v", principal, err) } if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='active' WHERE uuid='m2'`); err != nil { t.Fatal(err) } if principal, err := st.PrincipalByVerifiedEmail("domain", "same@example.test"); !errors.Is(err, ErrAccessDenied) || principal != nil { t.Fatalf("ambiguous email selected an arbitrary account: %#v %v", principal, err) } if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE domain_uuid='domain'`); err != nil { t.Fatal(err) } if _, err := st.PrincipalByVerifiedEmail("domain", "same@example.test"); !errors.Is(err, ErrAccessDenied) { t.Fatalf("suspended membership resolved email: %v", err) } if _, err := st.PrincipalByVerifiedEmail("other", "same@example.test"); err != nil { t.Fatalf("readonly active member rejected: %v", err) } if _, err := st.DB.Exec(`UPDATE principals SET state='quarantined' WHERE uuid='second'`); err != nil { t.Fatal(err) } if _, err := st.PrincipalByVerifiedEmail("other", "same@example.test"); !errors.Is(err, ErrAccessDenied) { t.Fatal("quarantined account resolved email") } if _, err := st.PrincipalByVerifiedEmail("domain", " "); !errors.Is(err, ErrAccessDenied) { t.Fatal("empty email resolved account") } } func TestExternalIdentityConflictCannotRebindPrincipal(t *testing.T) { st := externalBindingFixture(t) bind := func(principal, marker string) error { return st.BindExternalIdentity(principal, "oidc", "provider", "https://issuer.example.test", "subject", map[string]string{"marker": marker}) } if err := bind("first", "initial"); err != nil { t.Fatal(err) } if err := bind("second", "attacker"); !errors.Is(err, ErrAccessDenied) { t.Fatalf("different principal rebind succeeded: %v", err) } var owner, attributes string if err := st.DB.QueryRow(`SELECT principal_uuid,attributes_json FROM principal_identities WHERE provider_type='oidc'`).Scan(&owner, &attributes); err != nil { t.Fatal(err) } if owner != "first" || strings.Contains(attributes, "attacker") { t.Fatal("rejected rebind changed owner or attributes") } if err := bind("first", "refreshed"); err != nil { t.Fatalf("same principal refresh rejected: %v", err) } principal, err := st.PrincipalByExternalIdentity("domain", "oidc", "provider", "https://issuer.example.test", "subject") if err != nil || principal.UUID != "first" { t.Fatalf("bound principal: %#v %v", principal, err) } if _, err := st.DB.Exec(`UPDATE domain_memberships SET state='suspended' WHERE uuid='m1'`); err != nil { t.Fatal(err) } if _, err := st.PrincipalByExternalIdentity("domain", "oidc", "provider", "https://issuer.example.test", "subject"); err == nil { t.Fatal("suspended membership resolved external identity") } } func TestExternalIdentityConcurrentBindingHasOneWinner(t *testing.T) { st := externalBindingFixture(t) start := make(chan struct{}) type result struct { principal string err error } results := make(chan result, 2) for _, principal := range []string{"first", "second"} { go func(principal string) { <-start results <- result{principal, st.BindExternalIdentity(principal, "oidc", "provider", "https://issuer.example.test", "race", map[string]string{"principal": principal})} }(principal) } close(start) winner, failures := "", 0 for range 2 { result := <-results if result.err == nil { if winner != "" { t.Fatal("two accounts accepted the same external subject") } winner = result.principal } else if errors.Is(result.err, ErrAccessDenied) { failures++ } else { t.Fatal(result.err) } } if winner == "" || failures != 1 { t.Fatal("binding did not have exactly one accepted owner") } var actual string if err := st.DB.QueryRow(`SELECT principal_uuid FROM principal_identities WHERE subject='race'`).Scan(&actual); err != nil || actual != winner { t.Fatalf("binding winner was not persisted: %q %v", actual, err) } }