SMTP-Credentials und E_Mail-Adressen verschlüsselt abgelegt
This commit is contained in:
1 parent
781aa20253
commit
66659d9a23
32 files changed
+3276
-132
No files matched your search
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user