SMTP-Credentials und E_Mail-Adressen verschlüsselt abgelegt

This commit is contained in:
concierge committed 2026-11-16 15:43:51 +01:00
1 parent 781aa20253
commit 66659d9a23
32 files changed
+3276 -132

No files matched your search

+586
View File
@@ -0,0 +1,586 @@
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)
}
}