package store import ( "context" "testing" ) // openDemoStore returns an in-memory store with the demo tenant. func openDemoStore(t *testing.T) *Store { t.Helper() st, err := Open(":memory:") if err != nil { t.Fatalf("open store: %v", err) } t.Cleanup(func() { st.Close() }) if err := st.SeedDemo(context.Background()); err != nil { t.Fatalf("seed demo: %v", err) } return st } type secretFixture struct { tenantID string personID string email string editor *User reader *User } func prepareSecretFixture(t *testing.T, st *Store) secretFixture { t.Helper() ctx := context.Background() var fixture secretFixture if err := st.db.QueryRowContext(ctx, "SELECT tenant_id, id, email FROM people WHERE email<>'' LIMIT 1"). Scan(&fixture.tenantID, &fixture.personID, &fixture.email); err != nil { t.Fatalf("contact person: %v", err) } editor, err := st.UserByUsername(ctx, "editor") if err != nil { t.Fatalf("editor: %v", err) } reader, err := st.UserByUsername(ctx, "reader") if err != nil { t.Fatalf("reader: %v", err) } fixture.editor = editor fixture.reader = reader return fixture } func TestSecretsEncryptContactsAndSMTP(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) if err := st.SetTenantSetting(ctx, fixture.tenantID, "smtp.host", "smtp.example.org"); err != nil { t.Fatalf("legacy smtp host: %v", err) } if err := st.SetTenantSetting(ctx, fixture.tenantID, "smtp.password", "secret"); err != nil { t.Fatalf("legacy smtp password: %v", err) } editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } if !st.SecretIsInitialized(ctx, fixture.tenantID) { t.Fatal("tenant is not marked as encrypted") } var plainEmail string if err := st.db.QueryRowContext(ctx, "SELECT email FROM people WHERE tenant_id=? AND id=?", fixture.tenantID, fixture.personID).Scan(&plainEmail); err != nil { t.Fatalf("read person row: %v", err) } if plainEmail != "" { t.Fatalf("plaintext contact remains: email=%q", plainEmail) } if got := st.TenantSetting(ctx, fixture.tenantID, "smtp.password"); got != "" { t.Fatalf("SMTP password remains as tenant setting %q", got) } keyCtx := WithKeyring(ctx, editorKey) if got, ok := st.SecretValue(keyCtx, fixture.tenantID, ScopeTenant, fixture.tenantID, "smtp.host"); !ok || got != "smtp.example.org" { t.Fatalf("smtp host = %q, ok=%v", got, ok) } if got, ok := st.SecretValue(keyCtx, fixture.tenantID, ScopeTenant, fixture.tenantID, "smtp.password"); !ok || got != "secret" { t.Fatalf("smtp password = %q, ok=%v", got, ok) } person, err := st.Person(keyCtx, fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person with keyring: %v", err) } if person.Email != fixture.email || person.EmailLocked { t.Fatalf("decrypted e-mail = %q locked=%v, want %q", person.Email, person.EmailLocked, fixture.email) } locked, err := st.Person(ctx, fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person without keyring: %v", err) } if locked.Email != "" || !locked.EmailLocked { t.Fatalf("locked e-mail = %q locked=%v", locked.Email, locked.EmailLocked) } } func TestWrongPasswordDoesNotUnlockKeys(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err != nil { t.Fatalf("create keys: %v", err) } if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "falsch"); err == nil { t.Fatal("wrong password unlocked the keypair") } } func TestScopeWrappersFollowRolePolicy(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil { t.Fatalf("link reader: %v", err) } if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("reconcile: %v", err) } readerScopes, err := st.ScopesForUser(ctx, fixture.reader.ID) if err != nil { t.Fatalf("reader scopes: %v", err) } if len(readerScopes) != 1 || readerScopes[0].Type != ScopePerson || readerScopes[0].TenantID != fixture.tenantID || readerScopes[0].ID != fixture.personID { t.Fatalf("reader scopes = %+v, want only own person scope", readerScopes) } // Administrators must not receive wrappers, even if stale key material // exists for them. admin, err := st.UserByUsername(ctx, "admin") if err != nil { t.Fatalf("admin: %v", err) } if _, err := st.EnsureUserKeys(ctx, admin.ID, "temporary"); err != nil { t.Fatalf("legacy admin keys: %v", err) } if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("reconcile after admin keys: %v", err) } if adminScopes, _ := st.ScopesForUser(ctx, admin.ID); len(adminScopes) != 0 { t.Fatalf("administrator received %d encrypted scopes", len(adminScopes)) } // A reader has access to the own address only. readerKey, err := st.EnsureUserKeys(ctx, fixture.reader.ID, "reader123") if err != nil { t.Fatalf("reader keys: %v", err) } if err := st.UnlockAccessibleKeys(ctx, readerKey); err != nil { t.Fatalf("unwrap reader keys: %v", err) } own, err := st.Person(WithKeyring(ctx, readerKey), fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("own person: %v", err) } if own.Email != fixture.email { t.Fatalf("reader e-mail = %q, want %q", own.Email, fixture.email) } var otherID string if err := st.db.QueryRowContext(ctx, "SELECT id FROM people WHERE tenant_id=? AND id<>? LIMIT 1", fixture.tenantID, fixture.personID).Scan(&otherID); err != nil { t.Fatalf("other person: %v", err) } other, err := st.Person(WithKeyring(ctx, readerKey), fixture.tenantID, otherID) if err != nil { t.Fatalf("other person: %v", err) } if other.Email != "" { t.Fatalf("reader decrypted another person's e-mail %q", other.Email) } } func TestPasswordChangeKeepsDataKeys(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } if _, err := st.RekeyUserPassword(ctx, fixture.editor.ID, "editor123", "neues-passwort"); err != nil { t.Fatalf("rekey: %v", err) } if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err == nil { t.Fatal("old password still unlocks the keypair") } rekeyed, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "neues-passwort") if err != nil { t.Fatalf("new password: %v", err) } if err := st.UnlockAccessibleKeys(ctx, rekeyed); err != nil { t.Fatalf("unlock rekeyed: %v", err) } person, err := st.Person(WithKeyring(ctx, rekeyed), fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person after rekey: %v", err) } if person.Email != fixture.email { t.Fatalf("e-mail after rekey = %q, want %q", person.Email, fixture.email) } } func TestAdminResetRewrapsEditorScopes(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } _, scopes, err := st.ResetUserKeys(ctx, fixture.editor.ID, "temp-passwort") if err != nil { t.Fatalf("reset editor keys: %v", err) } if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err == nil { t.Fatal("old password still unlocks after reset") } // Another unlocked editor can restore the scopes without ever exposing // the data to an administrator. granted, err := st.RewrapScopes(ctx, editorKey, fixture.editor.ID, scopes) if err != nil { t.Fatalf("rewrap: %v", err) } if granted == 0 { t.Fatal("no scopes were granted again") } resetKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "temp-passwort") if err != nil { t.Fatalf("temporary password: %v", err) } if err := st.UnlockAccessibleKeys(ctx, resetKey); err != nil { t.Fatalf("unlock reset keys: %v", err) } person, err := st.Person(WithKeyring(ctx, resetKey), fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person after reset: %v", err) } if person.Email != fixture.email { t.Fatalf("e-mail after reset = %q, want %q", person.Email, fixture.email) } } func TestExchangeExportOmitsContacts(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } exchange, err := st.ExportResources(WithKeyring(ctx, editorKey), fixture.tenantID) if err != nil { t.Fatalf("export: %v", err) } for _, person := range exchange.Resources.People { if person.Email != "" { t.Fatalf("export contains contact data for %s", person.ID) } } } func TestPruneUserWrappersRestrictsReaderToOwnScope(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil { t.Fatalf("link reader: %v", err) } tenantScope := KeyScope{Type: ScopeTenant, TenantID: fixture.tenantID, ID: fixture.tenantID} tenantDEK, err := st.ensureScope(ctx, editorKey, tenantScope) if err != nil { t.Fatalf("tenant scope: %v", err) } ownScope := KeyScope{Type: ScopePerson, TenantID: fixture.tenantID, ID: fixture.personID} ownDEK, err := st.ensureScope(ctx, editorKey, ownScope) if err != nil { t.Fatalf("own scope: %v", err) } // Simulate stale grants from older versions. if err := st.grantScopeDEK(ctx, editorKey, tenantScope, tenantDEK, []string{fixture.reader.ID}); err != nil { t.Fatalf("legacy tenant grant: %v", err) } if err := st.grantScopeDEK(ctx, editorKey, ownScope, ownDEK, []string{fixture.reader.ID}); err != nil { t.Fatalf("legacy person grant: %v", err) } if err := st.PruneUserWrappers(ctx, fixture.reader.ID); err != nil { t.Fatalf("prune reader: %v", err) } scopes, err := st.ScopesForUser(ctx, fixture.reader.ID) if err != nil { t.Fatalf("reader scopes: %v", err) } if len(scopes) != 1 || scopes[0].String() != ownScope.String() { t.Fatalf("reader scopes = %+v, want only %s", scopes, ownScope.String()) } if !st.HasUserKeys(ctx, fixture.reader.ID) { t.Fatal("reader lost key material") } // Administrators lose both wrappers and key material. admin, err := st.UserByUsername(ctx, "admin") if err != nil { t.Fatalf("admin: %v", err) } if _, err := st.EnsureUserKeys(ctx, admin.ID, "temporary"); err != nil { t.Fatalf("legacy admin keys: %v", err) } if err := st.grantScopeDEK(ctx, editorKey, tenantScope, tenantDEK, []string{admin.ID}); err != nil { t.Fatalf("legacy admin grant: %v", err) } if err := st.PruneUserWrappers(ctx, admin.ID); err != nil { t.Fatalf("prune admin: %v", err) } if adminScopes, _ := st.ScopesForUser(ctx, admin.ID); len(adminScopes) != 0 { t.Fatalf("administrator still holds %d wrappers", len(adminScopes)) } if st.HasUserKeys(ctx, admin.ID) { t.Fatal("administrator still holds key material") } } func TestReaderRefreshesAccessForNewEditors(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil { t.Fatalf("link reader: %v", err) } if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("reconcile: %v", err) } readerKey, err := st.EnsureUserKeys(ctx, fixture.reader.ID, "reader123") if err != nil { t.Fatalf("reader keys: %v", err) } if err := st.UnlockAccessibleKeys(ctx, readerKey); err != nil { t.Fatalf("unwrap reader keys: %v", err) } ownScope := KeyScope{Type: ScopePerson, TenantID: fixture.tenantID, ID: fixture.personID} newEditor, err := st.CreateUser(ctx, "editor-neu", "Neue Redaktion", "editor-neu-123", RoleEditor, true, []string{fixture.tenantID}) if err != nil { t.Fatalf("create editor: %v", err) } if st.HasScopeAccess(ctx, newEditor.ID, ownScope) { t.Fatal("new editor already has the person scope") } // The next login of the reader wraps the address for the new editor. if err := st.EnsurePersonScope(ctx, readerKey, fixture.tenantID, fixture.personID); err != nil { t.Fatalf("reader refresh: %v", err) } if !st.HasScopeAccess(ctx, newEditor.ID, ownScope) { t.Fatal("new editor did not receive the person scope") } newKey, err := st.EnsureUserKeys(ctx, newEditor.ID, "editor-neu-123") if err != nil { t.Fatalf("new editor keys: %v", err) } if err := st.UnlockAccessibleKeys(ctx, newKey); err != nil { t.Fatalf("unlock new editor: %v", err) } person, err := st.Person(WithKeyring(ctx, newKey), fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person as new editor: %v", err) } if person.Email != fixture.email { t.Fatalf("new editor e-mail = %q, want %q", person.Email, fixture.email) } } func TestPruneUserWrappersKeepsEditorMembershipScopes(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } before, err := st.ScopesForUser(ctx, fixture.editor.ID) if err != nil { t.Fatalf("editor scopes: %v", err) } if len(before) == 0 { t.Fatal("editor received no scopes") } if err := st.PruneUserWrappers(ctx, fixture.editor.ID); err != nil { t.Fatalf("prune editor: %v", err) } after, err := st.ScopesForUser(ctx, fixture.editor.ID) if err != nil { t.Fatalf("editor scopes after prune: %v", err) } if len(after) != len(before) { t.Fatalf("editor scopes changed from %d to %d", len(before), len(after)) } } func TestBootstrapMigratesPlaintextCreatedAfterInitialization(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123") if err != nil { t.Fatalf("editor keys: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("bootstrap: %v", err) } // Simulate a seeding or restore run without a keyring that writes a // plaintext address after the tenant was already migrated and its // encrypted value was removed together with the planning data. lateEmail := "nachzuegler@example.org" if _, err := st.db.ExecContext(ctx, "DELETE FROM secrets WHERE tenant_id=? AND scope_type='person' AND scope_id=? AND secret_key='email'", fixture.tenantID, fixture.personID); err != nil { t.Fatalf("delete old secret: %v", err) } if _, err := st.db.ExecContext(ctx, "UPDATE people SET email=? WHERE tenant_id=? AND id=?", lateEmail, fixture.tenantID, fixture.personID); err != nil { t.Fatalf("late plaintext: %v", err) } if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil { t.Fatalf("second bootstrap: %v", err) } var plain string if err := st.db.QueryRowContext(ctx, "SELECT email FROM people WHERE tenant_id=? AND id=?", fixture.tenantID, fixture.personID).Scan(&plain); err != nil { t.Fatalf("read person: %v", err) } if plain != "" { t.Fatalf("late plaintext remains: %q", plain) } person, err := st.Person(WithKeyring(ctx, editorKey), fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person: %v", err) } if person.Email != lateEmail { t.Fatalf("migrated e-mail = %q, want %q", person.Email, lateEmail) } } func TestLockedLegacyContactSurvivesKeylessUpdate(t *testing.T) { st := openDemoStore(t) ctx := context.Background() fixture := prepareSecretFixture(t, st) // Before the first editor login the tenant is not migrated. An // administrator session has no keyring, so the plaintext address is // hidden and marked as locked. person, err := st.Person(ctx, fixture.tenantID, fixture.personID) if err != nil { t.Fatalf("person: %v", err) } if person.Email != "" || !person.EmailLocked { t.Fatalf("keyless contact = %q locked=%v", person.Email, person.EmailLocked) } person.Notes = "geändert ohne Kontaktschlüssel" if err := st.UpsertPerson(ctx, fixture.tenantID, *person); err != nil { t.Fatalf("update: %v", err) } var plain string if err := st.db.QueryRowContext(ctx, "SELECT email FROM people WHERE tenant_id=? AND id=?", fixture.tenantID, fixture.personID).Scan(&plain); err != nil { t.Fatalf("read person: %v", err) } if plain != fixture.email { t.Fatalf("legacy e-mail was changed from %q to %q", fixture.email, plain) } } func TestMigrationRemovesPhoneNumbers(t *testing.T) { path := t.TempDir() + "/lektorenplan.db" st, err := Open(path) if err != nil { t.Fatalf("open store: %v", err) } ctx := context.Background() if err := st.SeedDemo(ctx); err != nil { t.Fatalf("seed demo: %v", err) } var tenantID string if err := st.db.QueryRowContext(ctx, "SELECT tenant_id FROM people WHERE id='p-anna'").Scan(&tenantID); err != nil { t.Fatalf("tenant: %v", err) } // Recreate the legacy column and a matching encrypted value. if _, err := st.db.ExecContext(ctx, "ALTER TABLE people ADD COLUMN phone TEXT NOT NULL DEFAULT ''"); err != nil { t.Fatalf("add legacy column: %v", err) } if _, err := st.db.ExecContext(ctx, "UPDATE people SET phone='0228 555 0101' WHERE tenant_id=? AND id='p-anna'", tenantID); err != nil { t.Fatalf("legacy phone: %v", err) } if _, err := st.db.ExecContext(ctx, ` INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at) VALUES(?, 'person', 'p-anna', 'phone', X'00', ?)`, tenantID, nowText()); err != nil { t.Fatalf("legacy secret: %v", err) } st.Close() reopened, err := Open(path) if err != nil { t.Fatalf("reopen store: %v", err) } defer reopened.Close() hasPhone, err := reopened.hasColumn(ctx, "people", "phone") if err != nil { t.Fatalf("inspect people: %v", err) } if hasPhone { t.Fatal("phone column still exists after migration") } var count int if err := reopened.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM secrets WHERE secret_key='phone'").Scan(&count); err != nil { t.Fatalf("count phone secrets: %v", err) } if count != 0 { t.Fatalf("%d phone secrets remain after migration", count) } }