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") } }