Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming. Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
343 lines
12 KiB
Go
343 lines
12 KiB
Go
package store
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"testing"
|
|
"time"
|
|
|
|
_ "modernc.org/sqlite"
|
|
)
|
|
|
|
func TestAuthorizeUsesDomainScopedPositiveRoleGrant(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
now := time.Now().UnixMilli()
|
|
statements := []string{
|
|
`INSERT INTO principals(uuid,state,created_at_ms,updated_at_ms) VALUES('p','active',?,?)`,
|
|
`INSERT INTO domain_memberships(uuid,domain_uuid,principal_uuid,state,created_at_ms) VALUES('m','d','p','active',?)`,
|
|
`INSERT INTO auth_roles(uuid,domain_uuid,name,created_at_ms) VALUES('r','d','editor',?)`,
|
|
`INSERT INTO auth_role_bindings(membership_uuid,role_uuid,created_at_ms) VALUES('m','r',?)`,
|
|
`INSERT INTO auth_capability_grants(uuid,role_uuid,capability,target_type,target_id,created_at_ms) VALUES('g','r','write','spot','auth-api',?)`,
|
|
}
|
|
for index, statement := range statements {
|
|
args := []any{now}
|
|
if index == 0 {
|
|
args = []any{now, now}
|
|
}
|
|
if _, err := st.DB.Exec(statement, args...); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := st.Authorize(AuthorizationRequest{DomainUUID: "d", PrincipalUUID: "p", Capability: "write", TargetType: "spot", TargetID: "auth-api"}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
denied := []AuthorizationRequest{
|
|
{DomainUUID: "other", PrincipalUUID: "p", Capability: "write", TargetType: "spot", TargetID: "auth-api"},
|
|
{DomainUUID: "d", PrincipalUUID: "p", Capability: "delete", TargetType: "spot", TargetID: "auth-api"},
|
|
{DomainUUID: "d", PrincipalUUID: "p", Capability: "write", TargetType: "spot", TargetID: "other"},
|
|
}
|
|
for _, request := range denied {
|
|
if err := st.Authorize(request); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("request %#v: %v", request, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPasswordBootstrapSessionAndRevocation(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
principal, err := st.BootstrapOwner("domain-1", "Owner", "correct horse battery staple", "Owner", "owner@example.test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := st.AuthenticatePassword("owner", "wrong password value"); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("wrong password: %v", err)
|
|
}
|
|
authenticated, err := st.AuthenticatePassword("owner", "correct horse battery staple")
|
|
if err != nil || authenticated.UUID != principal.UUID {
|
|
t.Fatalf("authentication = %#v, %v", authenticated, err)
|
|
}
|
|
token, err := st.CreateAuthSession("domain-1", principal.UUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if loaded, err := st.PrincipalForSession("domain-1", token); err != nil || loaded.UUID != principal.UUID {
|
|
t.Fatalf("session = %#v, %v", loaded, err)
|
|
}
|
|
if _, err := st.PrincipalForSession("domain-2", token); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("cross-domain session: %v", err)
|
|
}
|
|
if err := st.RevokeAuthSession(token); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := st.PrincipalForSession("domain-1", token); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("revoked session: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestUsernameRejectsDotAndAvatarIsMutableMetadata(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := st.BootstrapOwner("d", "alice.example", "correct horse battery staple", "Alice", ""); err == nil {
|
|
t.Fatal("username containing a dot was accepted")
|
|
}
|
|
principal, err := st.BootstrapOwner("d", "alice", "correct horse battery staple", "Alice", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
avatar := []byte{0x89, 'P', 'N', 'G'}
|
|
if err := st.SetPrincipalAvatar(principal.UUID, "image/png", avatar); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
contentType, loaded, err := st.PrincipalAvatar(principal.UUID)
|
|
if err != nil || contentType != "image/png" || string(loaded) != string(avatar) {
|
|
t.Fatalf("avatar = %q %v %v", contentType, loaded, err)
|
|
}
|
|
}
|
|
|
|
func TestTOTPEnrollmentEncryptionAndReplayProtection(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database, authKey: make([]byte, 32)}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
principal, err := st.BootstrapOwner("d", "alice", "correct horse battery staple", "Alice", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
secret, err := st.BeginTOTPEnrollment(principal.UUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var stored string
|
|
if err := database.QueryRow(`SELECT secret_hash FROM auth_credentials WHERE kind='totp-pending'`).Scan(&stored); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if stored == secret {
|
|
t.Fatal("TOTP seed was stored in plaintext")
|
|
}
|
|
code, err := totpCode(secret, time.Now().Unix()/30)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := st.ConfirmTOTPEnrollment(principal.UUID, code); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !st.HasTOTP(principal.UUID) {
|
|
t.Fatal("TOTP was not enabled")
|
|
}
|
|
if err := st.VerifyTOTP(principal.UUID, code); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("replayed code = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestTOTPLoginChallengeExpiresAfterFiveInvalidAttempts(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database, authKey: make([]byte, 32)}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
principal, err := st.BootstrapOwner("d", "alice", "correct horse battery staple", "Alice", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
secret, err := st.BeginTOTPEnrollment(principal.UUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
code, err := totpCode(secret, time.Now().Unix()/30)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := st.ConfirmTOTPEnrollment(principal.UUID, code); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
challenge, err := st.CreateTOTPLoginChallenge("d", principal.UUID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for attempt := 1; attempt <= 5; attempt++ {
|
|
if _, err := st.CompleteTOTPLoginChallenge("d", challenge, "invalid"); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("attempt %d = %v", attempt, err)
|
|
}
|
|
}
|
|
var attempts int
|
|
var consumedAt int64
|
|
if err := database.QueryRow(`SELECT attempt_count,consumed_at_ms FROM auth_challenges WHERE kind='totp-login'`).Scan(&attempts, &consumedAt); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if attempts != 5 || consumedAt == 0 {
|
|
t.Fatalf("challenge state = attempts %d, consumed_at_ms %d", attempts, consumedAt)
|
|
}
|
|
}
|
|
|
|
func TestExternalProviderSecretsAndMagicChallenge(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database, authKey: make([]byte, 32)}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
config := AuthProviderConfig{Kind: "oidc", Enabled: true, Issuer: "https://id.example.test", ClientID: "pages", ClientSecret: "not-plaintext"}
|
|
if err := st.SetAuthProviderConfig("d", config); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var encrypted string
|
|
if err := database.QueryRow(`SELECT secret_encrypted FROM auth_providers WHERE domain_uuid='d' AND kind='oidc'`).Scan(&encrypted); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if encrypted == "" || encrypted == config.ClientSecret {
|
|
t.Fatal("provider secret was not encrypted")
|
|
}
|
|
loaded, err := st.AuthProviderConfig("d", "oidc")
|
|
if err != nil || loaded.ClientSecret != config.ClientSecret || !loaded.Enabled || loaded.OIDCMatchBy != "email" {
|
|
t.Fatalf("provider = %#v, %v", loaded, err)
|
|
}
|
|
config.ClientSecret = ""
|
|
config.OIDCMatchBy = "display_name"
|
|
if err := st.SetAuthProviderConfig("d", config); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
loaded, err = st.AuthProviderConfig("d", "oidc")
|
|
if err != nil || loaded.OIDCMatchBy != "display_name" || loaded.ClientSecret != "not-plaintext" {
|
|
t.Fatalf("display-name provider = %#v, %v", loaded, err)
|
|
}
|
|
config.OIDCMatchBy = "username"
|
|
if err := st.SetAuthProviderConfig("d", config); err == nil {
|
|
t.Fatal("unsupported OIDC matching field was accepted")
|
|
}
|
|
token, err := st.CreateAuthChallenge("d", "principal", "magic-link", map[string]string{"return": "/docs"}, time.Minute)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var payload map[string]string
|
|
principal, err := st.ConsumeAuthChallenge("d", "magic-link", token, &payload)
|
|
if err != nil || principal != "principal" || payload["return"] != "/docs" {
|
|
t.Fatalf("challenge = %q %#v, %v", principal, payload, err)
|
|
}
|
|
if _, err := st.ConsumeAuthChallenge("d", "magic-link", token, nil); !errors.Is(err, ErrAccessDenied) {
|
|
t.Fatalf("reused challenge = %v", err)
|
|
}
|
|
}
|
|
|
|
func TestGroupPermissionProfilesAndAdministrationRoles(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
st := &Store{DB: database, authKey: make([]byte, 32)}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
owner, err := st.BootstrapOwner("d", "owner", "correct horse battery staple", "Owner", "owner@example.test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
member, err := st.CreatePasswordAccount("d", "member", "correct horse battery staple", "Member", "member@example.test")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := database.Exec(`DELETE FROM auth_role_bindings WHERE membership_uuid IN (SELECT uuid FROM domain_memberships WHERE domain_uuid='d' AND principal_uuid=?)`, member.UUID); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
group, err := st.CreateGroup("d", owner.UUID, "writers", "Writers", "", "members")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := st.AddGroupMemberByUsername("d", group.UUID, "member", "member"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if role := st.GroupMemberRole(group.UUID, owner.UUID); role != "owner" {
|
|
t.Fatalf("owner role = %q", role)
|
|
}
|
|
if role := st.GroupMemberRole(group.UUID, member.UUID); role != "member" {
|
|
t.Fatalf("member role = %q", role)
|
|
}
|
|
if err := st.SetGroupPermission(group.UUID, "/drop", "upload_only"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
allowed := func(capability, path string) bool {
|
|
return st.Authorize(AuthorizationRequest{DomainUUID: "d", PrincipalUUID: member.UUID, Capability: capability, TargetType: "path", TargetID: path}) == nil
|
|
}
|
|
if !allowed("upload", "/drop/file.txt") || allowed("read", "/drop/file.txt") || allowed("write", "/drop/file.txt") {
|
|
t.Fatal("upload-only permission did not remain upload-only")
|
|
}
|
|
if err := st.SetGroupPermission(group.UUID, "/once", "read_write_once"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !allowed("read", "/once/a") || !allowed("create", "/once/a") || !allowed("upload", "/once/a") || allowed("write", "/once/a") || allowed("delete", "/once/a") {
|
|
t.Fatal("read/write-once permission capabilities are incorrect")
|
|
}
|
|
if err := st.SetGroupPermission(group.UUID, "/work", "read_write"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !allowed("read", "/work/a") || !allowed("write", "/work/a") || !allowed("rename", "/work/a") || allowed("delete", "/work/a") {
|
|
t.Fatal("read/write permission capabilities are incorrect")
|
|
}
|
|
}
|
|
|
|
func TestBuiltinCampusAndDomainAdminProjection(t *testing.T) {
|
|
database, err := sql.Open("sqlite", ":memory:")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = database.Close() })
|
|
if _, err := database.Exec(`CREATE TABLE domains(uuid TEXT PRIMARY KEY,campus_uuid TEXT,enabled INTEGER NOT NULL DEFAULT 1); INSERT INTO domains(uuid,campus_uuid) VALUES('d1','c1'),('d2','c1')`); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
st := &Store{DB: database, authKey: make([]byte, 32)}
|
|
if err := st.EnsureAuthSchema(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := st.EnsureBuiltinAdminGroups(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
owner, err := st.BootstrapOwner("d1", "owner", "correct horse battery staple", "Owner", "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !st.IsBuiltinGroupAdmin("d1", owner.UUID, "domain_admin") {
|
|
t.Fatal("bootstrap owner was not migrated to domain_admin")
|
|
}
|
|
if !st.IsCampusAdmin("c1", owner.UUID) || !st.IsBuiltinGroupAdmin("d2", owner.UUID, "campus_admin") {
|
|
t.Fatal("campus_admin was not projected to the sibling Domain")
|
|
}
|
|
if st.IsBuiltinGroupAdmin("d2", owner.UUID, "domain_admin") {
|
|
t.Fatal("domain_admin was unexpectedly inherited")
|
|
}
|
|
}
|