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

+9
View File
@@ -247,6 +247,15 @@ func (s *Store) CreateUser(ctx context.Context, username, displayName, password
return nil, err
}
user.TenantIDs = tenantIDs
// Editors need keys for SMTP and all contacts, readers for their own
// e-mail address. Administrators deliberately receive no key material.
// The keypair is protected by the initial password; the first login
// replaces that protection with the account holder's own password.
if role == RoleEditor || role == RoleReader {
if _, err := s.createUserKeys(ctx, user.ID, password); err != nil {
return nil, err
}
}
return user, nil
}
+155
View File
@@ -0,0 +1,155 @@
package store
import (
"crypto/aes"
"crypto/cipher"
"crypto/ecdh"
"crypto/rand"
"crypto/sha256"
"errors"
"fmt"
"io"
"golang.org/x/crypto/argon2"
"golang.org/x/crypto/hkdf"
)
// Key derivation parameters. The version string is stored with every user key
// so the parameters can be changed later without breaking existing data.
const (
kdfVersion = "argon2id-v1"
kdfSaltBytes = 16
keyBytes = 32
)
var (
errKeyLocked = errors.New("Verschlüsselung ist gesperrt")
errNoKeyAccess = errors.New("kein Zugriff auf diesen Datenschlüssel")
)
func deriveUserKEK(password string, salt []byte) []byte {
return argon2.IDKey([]byte(password), salt, 3, 64*1024, 2, keyBytes)
}
func newSalt() ([]byte, error) {
salt := make([]byte, kdfSaltBytes)
if _, err := io.ReadFull(rand.Reader, salt); err != nil {
return nil, err
}
return salt, nil
}
func newDEK() ([]byte, error) {
key := make([]byte, keyBytes)
if _, err := io.ReadFull(rand.Reader, key); err != nil {
return nil, err
}
return key, nil
}
func sealAESGCM(key, plaintext, additionalData []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
return nil, err
}
return gcm.Seal(nonce, nonce, plaintext, additionalData), nil
}
func openAESGCM(key, sealed, additionalData []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
if len(sealed) < gcm.NonceSize() {
return nil, errors.New("verschlüsselter Wert ist unvollständig")
}
nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
return gcm.Open(nil, nonce, ciphertext, additionalData)
}
// wrapDEK encrypts a data key for the recipient's X25519 public key using an
// ephemeral key and HKDF. The scope is bound as additional data so a wrapper
// cannot be moved to a different tenant or person.
func wrapDEK(recipientPublic, dek []byte, scope string) (ephemeralPublic, wrapped []byte, err error) {
curve := ecdh.X25519()
publicKey, err := curve.NewPublicKey(recipientPublic)
if err != nil {
return nil, nil, err
}
ephemeral, err := curve.GenerateKey(rand.Reader)
if err != nil {
return nil, nil, err
}
shared, err := ephemeral.ECDH(publicKey)
if err != nil {
return nil, nil, err
}
salt := append(append([]byte{}, ephemeral.PublicKey().Bytes()...), recipientPublic...)
wrappingKey, err := hkdfKey(shared, salt, "lektorenplan-dek-wrap-v1")
if err != nil {
return nil, nil, err
}
wrapped, err = sealAESGCM(wrappingKey, dek, []byte(scope))
if err != nil {
return nil, nil, err
}
return ephemeral.PublicKey().Bytes(), wrapped, nil
}
func unwrapDEK(privateKey, ephemeralPublic, wrapped []byte, scope string) ([]byte, error) {
curve := ecdh.X25519()
private, err := curve.NewPrivateKey(privateKey)
if err != nil {
return nil, err
}
ephemeral, err := curve.NewPublicKey(ephemeralPublic)
if err != nil {
return nil, err
}
shared, err := private.ECDH(ephemeral)
if err != nil {
return nil, err
}
salt := append(append([]byte{}, ephemeralPublic...), private.PublicKey().Bytes()...)
wrappingKey, err := hkdfKey(shared, salt, "lektorenplan-dek-wrap-v1")
if err != nil {
return nil, err
}
return openAESGCM(wrappingKey, wrapped, []byte(scope))
}
func hkdfKey(secret, salt []byte, info string) ([]byte, error) {
reader := hkdf.New(sha256.New, secret, salt, []byte(info))
key := make([]byte, keyBytes)
if _, err := io.ReadFull(reader, key); err != nil {
return nil, err
}
return key, nil
}
func keyAAD(parts ...string) []byte {
return []byte(fmt.Sprintf("lektorenplan-secret-v1|%s", joinKeyParts(parts)))
}
func joinKeyParts(parts []string) string {
out := ""
for index, part := range parts {
if index > 0 {
out += "\x00"
}
out += part
}
return out
}
+81 -2
View File
@@ -139,7 +139,6 @@ CREATE TABLE IF NOT EXISTS people (
last_name TEXT NOT NULL,
roles TEXT NOT NULL,
email TEXT NOT NULL DEFAULT '',
phone TEXT NOT NULL DEFAULT '',
preferred_church_ids TEXT NOT NULL DEFAULT '[]',
preferred_weekdays TEXT NOT NULL DEFAULT '[]',
preferred_service_titles TEXT NOT NULL DEFAULT '[]',
@@ -279,6 +278,43 @@ CREATE TABLE IF NOT EXISTS dispatch_log (
created_by TEXT NOT NULL DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_dispatch_log_tenant ON dispatch_log(tenant_id, created_at);
CREATE TABLE IF NOT EXISTS user_keys (
user_id TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
kdf_salt BLOB NOT NULL,
kdf_version TEXT NOT NULL,
public_key BLOB NOT NULL,
wrapped_private BLOB NOT NULL,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS key_wrappers (
scope_type TEXT NOT NULL,
tenant_id TEXT NOT NULL,
scope_id TEXT NOT NULL,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
ephemeral_public BLOB NOT NULL,
wrapped_dek BLOB NOT NULL,
created_at TEXT NOT NULL,
PRIMARY KEY (scope_type, tenant_id, scope_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_key_wrappers_user ON key_wrappers(user_id);
CREATE TABLE IF NOT EXISTS secrets (
tenant_id TEXT NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
scope_type TEXT NOT NULL,
scope_id TEXT NOT NULL,
secret_key TEXT NOT NULL,
ciphertext BLOB NOT NULL,
updated_at TEXT NOT NULL,
PRIMARY KEY (tenant_id, scope_type, scope_id, secret_key)
);
CREATE TABLE IF NOT EXISTS secret_state (
tenant_id TEXT PRIMARY KEY REFERENCES tenants(id) ON DELETE CASCADE,
initialized_at TEXT NOT NULL
);
`
func (s *Store) migrate(ctx context.Context) error {
@@ -309,10 +345,53 @@ func (s *Store) migrate(ctx context.Context) error {
}
}
if _, err := s.db.ExecContext(ctx,
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '3') "+
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '5') "+
"ON CONFLICT(key) DO UPDATE SET value=excluded.value"); err != nil {
return fmt.Errorf("record schema version: %w", err)
}
// Phone numbers are no longer stored anywhere in the web app. Remove both
// the encrypted values and the legacy plaintext column.
if _, err := s.db.ExecContext(ctx,
"DELETE FROM secrets WHERE secret_key='phone'"); err != nil {
return fmt.Errorf("remove encrypted phone numbers: %w", err)
}
hasPhone, err := s.hasColumn(ctx, "people", "phone")
if err != nil {
return fmt.Errorf("inspect people table: %w", err)
}
if hasPhone {
if _, err := s.db.ExecContext(ctx, "ALTER TABLE people DROP COLUMN phone"); err != nil {
return fmt.Errorf("drop people.phone: %w", err)
}
}
// Editors and linked readers hold key material; administrators never do.
// Readers may only keep the scope of their linked person.
if _, err := s.db.ExecContext(ctx,
"DELETE FROM key_wrappers WHERE user_id IN (SELECT id FROM users WHERE role='admin')"); err != nil {
return fmt.Errorf("prune administrator key wrappers: %w", err)
}
if _, err := s.db.ExecContext(ctx,
"DELETE FROM user_keys WHERE user_id IN (SELECT id FROM users WHERE role='admin')"); err != nil {
return fmt.Errorf("prune administrator keys: %w", err)
}
if _, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE user_id IN (
SELECT u.id FROM users u WHERE u.role='reader' AND (
u.linked_tenant_id='' OR u.linked_person_id='' OR NOT (
key_wrappers.scope_type='person'
AND key_wrappers.tenant_id=u.linked_tenant_id
AND key_wrappers.scope_id=u.linked_person_id
)
)
)`); err != nil {
return fmt.Errorf("prune unlinked reader key wrappers: %w", err)
}
// Dispatch logs used to contain the full recipient address. Remove that
// plaintext now that addresses are stored encrypted.
if _, err := s.db.ExecContext(ctx,
"UPDATE dispatch_log SET email='' WHERE email<>''"); err != nil {
return fmt.Errorf("redact dispatch log: %w", err)
}
return nil
}
+4 -4
View File
@@ -73,17 +73,17 @@ func badGodesbergSpec() demoTenantSpec {
people := []domain.Person{
{ID: "p-anna", FirstName: "Anna", LastName: "Berg", Roles: []domain.Role{domain.RoleLector},
Email: "anna.berg@example.org", Phone: "0228 555 0101",
Email: "anna.berg@example.org",
PreferredChurchIDs: []string{"c-andreas"}, PreferredWeekdays: []int{1},
PreferredServiceTitles: []string{"Hochamt"}, MaxPerMonth: 7, Active: true,
Notes: "Liest besonders gerne die Sonntagslesungen."},
{ID: "p-markus", FirstName: "Markus", LastName: "Weber", Roles: []domain.Role{domain.RoleLector},
Email: "markus.weber@example.org", Phone: "0228 555 0102",
Email: "markus.weber@example.org",
PreferredChurchIDs: []string{"c-herzjesu"}, PreferredWeekdays: []int{1, 7},
PreferredServiceTitles: []string{"Vorabendmesse"}, MaxPerMonth: 8, Active: true},
{ID: "p-elisabeth", FirstName: "Elisabeth", LastName: "Klein",
Roles: []domain.Role{domain.RoleLector, domain.RoleHelper},
Email: "elisabeth.klein@example.org", Phone: "0228 555 0103",
Roles: []domain.Role{domain.RoleLector, domain.RoleHelper},
Email: "elisabeth.klein@example.org",
MaxPerMonth: 9, Active: true, Notes: "Flexibel einsetzbar, auch kurzfristig."},
{ID: "p-johannes", FirstName: "Johannes", LastName: "Schmitz", Roles: []domain.Role{domain.RoleLector},
Email: "johannes.schmitz@example.org", PreferredChurchIDs: []string{"c-evergislus"},
+12
View File
@@ -5,6 +5,7 @@ import (
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"lektorenplan/domain"
@@ -92,6 +93,12 @@ func (s *Store) ExportResources(ctx context.Context, tenantID string) (PlanExcha
if err != nil {
return PlanExchange{}, err
}
// Contact details are only stored encrypted and tied to accounts. They are
// deliberately left out of exchange files.
for index := range people {
people[index].Email = ""
people[index].EmailLocked = false
}
absences, err := s.Absences(ctx, tenantID)
if err != nil {
return PlanExchange{}, err
@@ -198,6 +205,11 @@ func (s *Store) ApplyExchange(ctx context.Context, tenantID string, exchange Pla
}
}
for _, person := range exchange.Resources.People {
// Exchange files never carry contact details. Keep any encrypted
// values that already exist instead of deleting them on import.
if strings.TrimSpace(person.Email) == "" {
person.EmailLocked = true
}
if err := s.UpsertPerson(ctx, tenantID, person); err != nil {
return ExchangeSummary{}, err
}
+912
View File
@@ -0,0 +1,912 @@
package store
import (
"context"
"crypto/ecdh"
"crypto/rand"
"database/sql"
"errors"
"fmt"
"strings"
"sync"
"time"
)
// KeyScope identifies one encrypted data scope. Tenant scopes hold the SMTP
// credentials, person scopes hold e-mail addresses. Editors hold the person
// scopes of their tenants; a reader only holds the scope of the person linked
// to their account.
type KeyScope struct {
Type string
TenantID string
ID string
}
func (s KeyScope) String() string {
return s.Type + "|" + s.TenantID + "|" + s.ID
}
const (
ScopeTenant = "tenant"
ScopePerson = "person"
)
// Keyring holds the decrypted private key of one user and the data keys that
// were unlocked during this login. It is only kept in memory.
type Keyring struct {
UserID string
privateKey []byte
mu sync.RWMutex
deks map[string][]byte
}
func newKeyring(userID string, privateKey []byte) *Keyring {
return &Keyring{
UserID: userID,
privateKey: privateKey,
deks: map[string][]byte{},
}
}
// DEK returns a cached data key.
func (k *Keyring) DEK(scope KeyScope) ([]byte, bool) {
k.mu.RLock()
defer k.mu.RUnlock()
value, ok := k.deks[scope.String()]
return value, ok
}
func (k *Keyring) remember(scope KeyScope, dek []byte) {
k.mu.Lock()
defer k.mu.Unlock()
k.deks[scope.String()] = append([]byte{}, dek...)
}
type keyringContextKey struct{}
// WithKeyring attaches an unlocked keyring to a request context.
func WithKeyring(ctx context.Context, keyring *Keyring) context.Context {
return context.WithValue(ctx, keyringContextKey{}, keyring)
}
// KeyringFrom returns the request's keyring, or nil when the session is locked.
func KeyringFrom(ctx context.Context) *Keyring {
keyring, _ := ctx.Value(keyringContextKey{}).(*Keyring)
return keyring
}
// EnsureUserKeys creates the user's X25519 keypair on first login and returns
// an unlocked keyring. The private key is protected by a KEK derived from the
// login password.
func (s *Store) EnsureUserKeys(ctx context.Context, userID, password string) (*Keyring, error) {
var salt, publicKey, wrappedPrivate []byte
var version string
err := s.db.QueryRowContext(ctx,
"SELECT kdf_salt, kdf_version, public_key, wrapped_private FROM user_keys WHERE user_id=?",
userID).Scan(&salt, &version, &publicKey, &wrappedPrivate)
switch {
case errors.Is(err, sql.ErrNoRows):
return s.createUserKeys(ctx, userID, password)
case err != nil:
return nil, err
}
if version != kdfVersion {
return nil, fmt.Errorf("unbekannte Schlüsselversion %q", version)
}
kek := deriveUserKEK(password, salt)
privateKey, err := openAESGCM(kek, wrappedPrivate, keyAAD("user-private", userID))
if err != nil {
return nil, errors.New("das Passwort konnte die gespeicherten Schlüssel nicht entsperren")
}
return newKeyring(userID, privateKey), nil
}
func (s *Store) createUserKeys(ctx context.Context, userID, password string) (*Keyring, error) {
salt, err := newSalt()
if err != nil {
return nil, err
}
curve := ecdh.X25519()
private, err := curve.GenerateKey(rand.Reader)
if err != nil {
return nil, err
}
privateKey := private.Bytes()
kek := deriveUserKEK(password, salt)
wrapped, err := sealAESGCM(kek, privateKey, keyAAD("user-private", userID))
if err != nil {
return nil, err
}
now := time.Now().UTC().Format(time.RFC3339)
_, err = s.db.ExecContext(ctx, `
INSERT INTO user_keys(user_id, kdf_salt, kdf_version, public_key, wrapped_private, created_at, updated_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(user_id) DO UPDATE SET
kdf_salt=excluded.kdf_salt, kdf_version=excluded.kdf_version,
public_key=excluded.public_key, wrapped_private=excluded.wrapped_private,
updated_at=excluded.updated_at`,
userID, salt, kdfVersion, private.PublicKey().Bytes(), wrapped, now, now)
if err != nil {
return nil, err
}
return newKeyring(userID, privateKey), nil
}
// HasUserKeys reports whether an account already has key material.
func (s *Store) HasUserKeys(ctx context.Context, userID string) bool {
var count int
err := s.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM user_keys WHERE user_id=?", userID).Scan(&count)
return err == nil && count > 0
}
// UnlockAccessibleKeys unwraps every data key that has been granted to this
// user. Missing wrappers are skipped; the affected pages report locked data.
func (s *Store) UnlockAccessibleKeys(ctx context.Context, keyring *Keyring) error {
if keyring == nil {
return errKeyLocked
}
type wrapperRow struct {
scope KeyScope
ephemeral []byte
wrapped []byte
}
rows, err := s.db.QueryContext(ctx, `
SELECT scope_type, tenant_id, scope_id, ephemeral_public, wrapped_dek
FROM key_wrappers WHERE user_id=?`, keyring.UserID)
if err != nil {
return err
}
var wrappers []wrapperRow
for rows.Next() {
var row wrapperRow
if err := rows.Scan(&row.scope.Type, &row.scope.TenantID, &row.scope.ID,
&row.ephemeral, &row.wrapped); err != nil {
rows.Close()
return err
}
wrappers = append(wrappers, row)
}
if err := rows.Err(); err != nil {
rows.Close()
return err
}
rows.Close()
for _, row := range wrappers {
dek, err := unwrapDEK(keyring.privateKey, row.ephemeral, row.wrapped, row.scope.String())
if err != nil {
continue
}
keyring.remember(row.scope, dek)
}
return nil
}
// SecretIsInitialized reports whether a tenant has been migrated to encrypted
// secrets. Until then the legacy plaintext columns remain readable.
func (s *Store) SecretIsInitialized(ctx context.Context, tenantID string) bool {
var count int
err := s.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM secret_state WHERE tenant_id=?", tenantID).Scan(&count)
return err == nil && count > 0
}
// BootstrapTenant encrypts the legacy plaintext values of one tenant and
// grants the first key holder access. It is idempotent and also migrates
// plaintext that reached the database after the initial migration, for
// example demo data restored by a command-line seeding run.
func (s *Store) BootstrapTenant(ctx context.Context, keyring *Keyring, tenantID string) error {
if s.SecretIsInitialized(ctx, tenantID) {
var legacy int
if err := s.db.QueryRowContext(ctx, `
SELECT (SELECT COUNT(*) FROM people WHERE tenant_id=? AND email<>'')
+ (SELECT COUNT(*) FROM tenant_settings
WHERE tenant_id=? AND key LIKE 'smtp.%')`, tenantID, tenantID).Scan(&legacy); err != nil {
return err
}
if legacy == 0 {
return nil
}
}
tenantScope := KeyScope{Type: ScopeTenant, TenantID: tenantID, ID: tenantID}
if _, err := s.ensureScope(ctx, keyring, tenantScope); err != nil {
return err
}
// Prepare every person scope first so the migration transaction only has
// to write data.
peopleRows, err := s.db.QueryContext(ctx, "SELECT id FROM people WHERE tenant_id=?", tenantID)
if err != nil {
return err
}
var peopleIDs []string
for peopleRows.Next() {
var id string
if err := peopleRows.Scan(&id); err != nil {
peopleRows.Close()
return err
}
peopleIDs = append(peopleIDs, id)
}
if err := peopleRows.Err(); err != nil {
peopleRows.Close()
return err
}
peopleRows.Close()
for _, id := range peopleIDs {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: id}
if _, err := s.ensureScope(ctx, keyring, scope); err != nil {
return err
}
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
settingsRows, err := tx.QueryContext(ctx,
"SELECT key, value FROM tenant_settings WHERE tenant_id=? AND key LIKE 'smtp.%'", tenantID)
if err != nil {
return err
}
type legacySecret struct {
key string
value string
}
var legacy []legacySecret
for settingsRows.Next() {
var item legacySecret
if err := settingsRows.Scan(&item.key, &item.value); err != nil {
settingsRows.Close()
return err
}
legacy = append(legacy, item)
}
if err := settingsRows.Err(); err != nil {
settingsRows.Close()
return err
}
settingsRows.Close()
tenantDEK, _ := keyring.DEK(tenantScope)
for _, item := range legacy {
if strings.TrimSpace(item.value) != "" {
sealed, err := sealAESGCM(tenantDEK, []byte(item.value),
keyAAD(ScopeTenant, tenantID, tenantID, item.key))
if err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO NOTHING`,
tenantID, ScopeTenant, tenantID, item.key, sealed,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
}
if _, err := tx.ExecContext(ctx,
"DELETE FROM tenant_settings WHERE tenant_id=? AND key=?", tenantID, item.key); err != nil {
return err
}
}
type legacyContact struct {
id, email string
}
contactRows, err := tx.QueryContext(ctx,
"SELECT id, email FROM people WHERE tenant_id=? AND email<>''", tenantID)
if err != nil {
return err
}
var contacts []legacyContact
for contactRows.Next() {
var item legacyContact
if err := contactRows.Scan(&item.id, &item.email); err != nil {
contactRows.Close()
return err
}
contacts = append(contacts, item)
}
if err := contactRows.Err(); err != nil {
contactRows.Close()
return err
}
contactRows.Close()
for _, item := range contacts {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: item.id}
dek, ok := keyring.DEK(scope)
if !ok {
continue
}
if strings.TrimSpace(item.email) == "" {
continue
}
sealed, err := sealAESGCM(dek, []byte(item.email), keyAAD(ScopePerson, tenantID, item.id, "email"))
if err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO NOTHING`,
tenantID, ScopePerson, item.id, "email", sealed,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"UPDATE people SET email='' WHERE tenant_id=? AND id=?", tenantID, item.id); err != nil {
return err
}
}
if _, err := tx.ExecContext(ctx,
"INSERT INTO secret_state(tenant_id, initialized_at) VALUES(?, ?) ON CONFLICT(tenant_id) DO NOTHING",
tenantID, time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
if err := tx.Commit(); err != nil {
return err
}
return s.ReconcileTenant(ctx, keyring, tenantID)
}
// ReconcileTenant creates missing data scopes and grants them to all eligible
// accounts that already have key material. It requires an unlocked key holder
// for this tenant.
func (s *Store) ReconcileTenant(ctx context.Context, keyring *Keyring, tenantID string) error {
if keyring == nil {
return errKeyLocked
}
editors, err := s.tenantKeyRecipients(ctx, tenantID)
if err != nil {
return err
}
// Grant what this key holder can reach and report the first inaccessible
// scope afterwards. A new editor can then receive the remaining scopes
// from another unlocked editor without losing partial access.
var firstErr error
rememberError := func(err error) {
if err != nil && firstErr == nil {
firstErr = err
}
}
tenantScope := KeyScope{Type: ScopeTenant, TenantID: tenantID, ID: tenantID}
if _, err := s.ensureScope(ctx, keyring, tenantScope); err != nil {
rememberError(err)
} else if err := s.grantScope(ctx, keyring, tenantScope, editors); err != nil {
rememberError(err)
}
rows, err := s.db.QueryContext(ctx, "SELECT id FROM people WHERE tenant_id=?", tenantID)
if err != nil {
return err
}
var peopleIDs []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return err
}
peopleIDs = append(peopleIDs, id)
}
if err := rows.Err(); err != nil {
rows.Close()
return err
}
rows.Close()
for _, personID := range peopleIDs {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: personID}
if _, err := s.ensureScope(ctx, keyring, scope); err != nil {
rememberError(err)
continue
}
recipients := append([]string{}, editors...)
if linked := s.linkedReaderForPerson(ctx, tenantID, personID); linked != "" {
recipients = append(recipients, linked)
}
if err := s.grantScope(ctx, keyring, scope, recipients); err != nil {
rememberError(err)
}
}
return firstErr
}
// linkedReaderForPerson returns the active reader account that is linked to
// the given person. Only that account may decrypt the person's own e-mail
// address; administrators and unlinked readers stay excluded.
func (s *Store) linkedReaderForPerson(ctx context.Context, tenantID, personID string) string {
var id string
err := s.db.QueryRowContext(ctx, `
SELECT id FROM users
WHERE active=1 AND role='reader' AND linked_tenant_id=? AND linked_person_id=?
ORDER BY id LIMIT 1`, tenantID, personID).Scan(&id)
if err != nil {
return ""
}
return id
}
func (s *Store) tenantKeyRecipients(ctx context.Context, tenantID string) ([]string, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id FROM users
WHERE active=1 AND role='editor' AND id IN (
SELECT user_id FROM memberships WHERE tenant_id=?
)
ORDER BY id`, tenantID)
if err != nil {
return nil, err
}
defer rows.Close()
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}
// ensureScope returns the DEK for a scope, creating it and wrapping it for the
// keyring user when the scope is new. If the scope exists but the user has no
// wrapper, errNoKeyAccess is returned.
func (s *Store) ensureScope(ctx context.Context, keyring *Keyring, scope KeyScope) ([]byte, error) {
if keyring == nil {
return nil, errKeyLocked
}
if dek, ok := keyring.DEK(scope); ok {
return dek, nil
}
dek, err := s.scopeDEK(ctx, keyring, scope)
if err == nil {
return dek, nil
}
if !errors.Is(err, errNoKeyAccess) {
return nil, err
}
// A scope exists only when at least one wrapper is present.
var count int
if err := s.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?",
scope.Type, scope.TenantID, scope.ID).Scan(&count); err != nil {
return nil, err
}
if count > 0 {
return nil, errNoKeyAccess
}
// A scope without wrappers but with stored secrets has lost its data key.
// Never silently replace it, otherwise the old data would be unreadable.
var secrets int
if err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=?`,
scope.TenantID, scope.Type, scope.ID).Scan(&secrets); err != nil {
return nil, err
}
if secrets > 0 {
return nil, errNoKeyAccess
}
dek, err = newDEK()
if err != nil {
return nil, err
}
if err := s.grantScopeDEK(ctx, keyring, scope, dek, []string{keyring.UserID}); err != nil {
return nil, err
}
keyring.remember(scope, dek)
return dek, nil
}
// scopeDEK unwraps the data key for the keyring user.
func (s *Store) scopeDEK(ctx context.Context, keyring *Keyring, scope KeyScope) ([]byte, error) {
if keyring == nil {
return nil, errKeyLocked
}
if dek, ok := keyring.DEK(scope); ok {
return dek, nil
}
var ephemeral, wrapped []byte
err := s.db.QueryRowContext(ctx, `
SELECT ephemeral_public, wrapped_dek FROM key_wrappers
WHERE scope_type=? AND tenant_id=? AND scope_id=? AND user_id=?`,
scope.Type, scope.TenantID, scope.ID, keyring.UserID).Scan(&ephemeral, &wrapped)
if errors.Is(err, sql.ErrNoRows) {
return nil, errNoKeyAccess
}
if err != nil {
return nil, err
}
dek, err := unwrapDEK(keyring.privateKey, ephemeral, wrapped, scope.String())
if err != nil {
return nil, err
}
keyring.remember(scope, dek)
return dek, nil
}
func (s *Store) grantScope(ctx context.Context, keyring *Keyring, scope KeyScope, userIDs []string) error {
dek, err := s.ensureScope(ctx, keyring, scope)
if err != nil {
return err
}
return s.grantScopeDEK(ctx, keyring, scope, dek, userIDs)
}
func (s *Store) grantScopeDEK(ctx context.Context, keyring *Keyring, scope KeyScope, dek []byte, userIDs []string) error {
seen := map[string]bool{}
for _, userID := range userIDs {
if userID == "" || seen[userID] {
continue
}
seen[userID] = true
publicKey, err := s.userPublicKey(ctx, userID)
if err != nil || len(publicKey) == 0 {
continue
}
ephemeral, wrapped, err := wrapDEK(publicKey, dek, scope.String())
if err != nil {
return err
}
if _, err := s.db.ExecContext(ctx, `
INSERT INTO key_wrappers(scope_type, tenant_id, scope_id, user_id,
ephemeral_public, wrapped_dek, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(scope_type, tenant_id, scope_id, user_id) DO UPDATE SET
ephemeral_public=excluded.ephemeral_public, wrapped_dek=excluded.wrapped_dek,
created_at=excluded.created_at`,
scope.Type, scope.TenantID, scope.ID, userID, ephemeral, wrapped,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
}
return nil
}
func (s *Store) userPublicKey(ctx context.Context, userID string) ([]byte, error) {
var publicKey []byte
err := s.db.QueryRowContext(ctx, "SELECT public_key FROM user_keys WHERE user_id=?", userID).Scan(&publicKey)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
return publicKey, err
}
// SecretValue decrypts one stored secret. When the tenant has not been
// initialized yet, legacy tenant settings are only readable with an unlocked
// editor keyring.
func (s *Store) SecretValue(ctx context.Context, tenantID, scopeType, scopeID, key string) (string, bool) {
if !s.SecretIsInitialized(ctx, tenantID) {
if scopeType == ScopeTenant && KeyringFrom(ctx) != nil {
value := s.TenantSetting(ctx, tenantID, key)
return value, value != ""
}
return "", false
}
keyring := KeyringFrom(ctx)
if keyring == nil {
return "", false
}
scope := KeyScope{Type: scopeType, TenantID: tenantID, ID: scopeID}
dek, err := s.scopeDEK(ctx, keyring, scope)
if err != nil {
return "", false
}
var sealed []byte
err = s.db.QueryRowContext(ctx, `
SELECT ciphertext FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, scopeType, scopeID, key).Scan(&sealed)
if err != nil {
return "", false
}
plaintext, err := openAESGCM(dek, sealed, keyAAD(scopeType, tenantID, scopeID, key))
if err != nil {
return "", false
}
return string(plaintext), true
}
// SecretExists reports whether an encrypted value is present.
func (s *Store) SecretExists(ctx context.Context, tenantID, scopeType, scopeID, key string) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, scopeType, scopeID, key).Scan(&count)
return err == nil && count > 0
}
// SetSecret encrypts and stores one value. An empty value removes it. Before
// a tenant is initialized, legacy tenant settings may only be written with an
// unlocked editor keyring present.
func (s *Store) SetSecret(ctx context.Context, tenantID, scopeType, scopeID, key, value string) error {
if !s.SecretIsInitialized(ctx, tenantID) {
if scopeType == ScopeTenant && KeyringFrom(ctx) != nil {
return s.SetTenantSetting(ctx, tenantID, key, value)
}
if scopeType == ScopeTenant {
return errKeyLocked
}
return nil
}
keyring := KeyringFrom(ctx)
if keyring == nil {
return errKeyLocked
}
scope := KeyScope{Type: scopeType, TenantID: tenantID, ID: scopeID}
dek, err := s.scopeDEK(ctx, keyring, scope)
if err != nil {
return err
}
if strings.TrimSpace(value) == "" {
_, err := s.db.ExecContext(ctx, `
DELETE FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, scopeType, scopeID, key)
return err
}
sealed, err := sealAESGCM(dek, []byte(value), keyAAD(scopeType, tenantID, scopeID, key))
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO UPDATE SET
ciphertext=excluded.ciphertext, updated_at=excluded.updated_at`,
tenantID, scopeType, scopeID, key, sealed, time.Now().UTC().Format(time.RFC3339))
return err
}
// EnsurePersonScope creates the person scope if needed and grants it to all
// active editors plus the linked reader. It works with an editor keyring and
// with a reader keyring that already holds the person's data key; the latter
// lets a reader refresh editor access after a new editor was created.
func (s *Store) EnsurePersonScope(ctx context.Context, keyring *Keyring, tenantID, personID string) error {
if keyring == nil || !s.SecretIsInitialized(ctx, tenantID) {
return nil
}
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: personID}
if _, err := s.ensureScope(ctx, keyring, scope); err != nil {
return err
}
recipients, err := s.tenantKeyRecipients(ctx, tenantID)
if err != nil {
return err
}
if linked := s.linkedReaderForPerson(ctx, tenantID, personID); linked != "" {
recipients = append(recipients, linked)
}
return s.grantScope(ctx, keyring, scope, recipients)
}
// PersonContactSecrets loads and decrypts the e-mail address of one person.
// Values that exist but cannot be decrypted are reported as locked.
func (s *Store) PersonContactSecrets(ctx context.Context, tenantID, personID string) (email string, emailLocked bool) {
if !s.SecretIsInitialized(ctx, tenantID) {
return "", false
}
rows, err := s.db.QueryContext(ctx, `
SELECT ciphertext FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key='email'`,
tenantID, ScopePerson, personID)
if err != nil {
return "", false
}
var sealedValues [][]byte
for rows.Next() {
var sealed []byte
if err := rows.Scan(&sealed); err != nil {
rows.Close()
return "", false
}
sealedValues = append(sealedValues, sealed)
}
rows.Close()
keyring := KeyringFrom(ctx)
var dek []byte
if keyring != nil {
dek, _ = s.scopeDEK(ctx, keyring, KeyScope{Type: ScopePerson, TenantID: tenantID, ID: personID})
}
for _, sealed := range sealedValues {
if dek != nil {
plaintext, err := openAESGCM(dek, sealed, keyAAD(ScopePerson, tenantID, personID, "email"))
if err == nil {
return string(plaintext), false
}
}
emailLocked = true
}
return "", emailLocked
}
// DeletePersonSecrets removes all encrypted values and wrappers of a person.
func (s *Store) DeletePersonSecrets(ctx context.Context, tenantID, personID string) error {
if _, err := s.db.ExecContext(ctx, `
DELETE FROM secrets WHERE tenant_id=? AND scope_type=? AND scope_id=?`,
tenantID, ScopePerson, personID); err != nil {
return err
}
_, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?`,
ScopePerson, tenantID, personID)
return err
}
// ScopesForUser lists the scopes whose DEKs are wrapped for one account.
func (s *Store) ScopesForUser(ctx context.Context, userID string) ([]KeyScope, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT scope_type, tenant_id, scope_id FROM key_wrappers WHERE user_id=?`, userID)
if err != nil {
return nil, err
}
defer rows.Close()
var scopes []KeyScope
for rows.Next() {
var scope KeyScope
if err := rows.Scan(&scope.Type, &scope.TenantID, &scope.ID); err != nil {
return nil, err
}
scopes = append(scopes, scope)
}
return scopes, rows.Err()
}
// ResetUserKeys replaces an account's keypair, e.g. after an administrator set
// a new temporary password. Existing wrappers become invalid and are returned
// so an unlocked administrator can grant them again.
func (s *Store) ResetUserKeys(ctx context.Context, userID, newPassword string) (*Keyring, []KeyScope, error) {
scopes, err := s.ScopesForUser(ctx, userID)
if err != nil {
return nil, nil, err
}
if err := s.DeleteUserKeys(ctx, userID); err != nil {
return nil, nil, err
}
keyring, err := s.createUserKeys(ctx, userID, newPassword)
if err != nil {
return nil, nil, err
}
return keyring, scopes, nil
}
// DeleteUserKeys removes the key material and all wrappers of an account.
func (s *Store) DeleteUserKeys(ctx context.Context, userID string) error {
if _, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID); err != nil {
return err
}
_, err := s.db.ExecContext(ctx, "DELETE FROM user_keys WHERE user_id=?", userID)
return err
}
// PruneUserWrappers enforces the key access policy. Editors keep the scopes of
// their tenant memberships. A reader may hold exactly one wrapper: the person
// scope of the account they are linked to. Administrators never hold key
// material.
func (s *Store) PruneUserWrappers(ctx context.Context, userID string) error {
var role, linkedTenantID, linkedPersonID string
var active int
err := s.db.QueryRowContext(ctx, `
SELECT role, active, linked_tenant_id, linked_person_id
FROM users WHERE id=?`, userID).
Scan(&role, &active, &linkedTenantID, &linkedPersonID)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
return err
}
userRole := UserRole(role)
if userRole == RoleAdmin {
if _, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID); err != nil {
return err
}
_, err := s.db.ExecContext(ctx, "DELETE FROM user_keys WHERE user_id=?", userID)
return err
}
if active == 0 {
_, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID)
return err
}
if userRole == RoleEditor {
_, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE user_id=? AND tenant_id NOT IN (
SELECT tenant_id FROM memberships WHERE user_id=?
)`, userID, userID)
return err
}
if linkedTenantID == "" || linkedPersonID == "" {
_, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID)
return err
}
_, err = s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE user_id=? AND NOT (
scope_type='person' AND tenant_id=? AND scope_id=?
)`, userID, linkedTenantID, linkedPersonID)
return err
}
// HasScopeAccess reports whether a data key for the scope is wrapped for the
// account. It is used to decide whether a reader may edit their own contact.
func (s *Store) HasScopeAccess(ctx context.Context, userID string, scope KeyScope) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM key_wrappers
WHERE scope_type=? AND tenant_id=? AND scope_id=? AND user_id=?`,
scope.Type, scope.TenantID, scope.ID, userID).Scan(&count)
return err == nil && count > 0
}
// RewrapScopes grants the given scopes to a user from an unlocked keyring.
func (s *Store) RewrapScopes(ctx context.Context, keyring *Keyring, userID string, scopes []KeyScope) (int, error) {
if keyring == nil {
return 0, errKeyLocked
}
publicKey, err := s.userPublicKey(ctx, userID)
if err != nil || len(publicKey) == 0 {
return 0, err
}
granted := 0
for _, scope := range scopes {
dek, err := s.scopeDEK(ctx, keyring, scope)
if err != nil {
continue
}
ephemeral, wrapped, err := wrapDEK(publicKey, dek, scope.String())
if err != nil {
return granted, err
}
if _, err := s.db.ExecContext(ctx, `
INSERT INTO key_wrappers(scope_type, tenant_id, scope_id, user_id,
ephemeral_public, wrapped_dek, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(scope_type, tenant_id, scope_id, user_id) DO UPDATE SET
ephemeral_public=excluded.ephemeral_public, wrapped_dek=excluded.wrapped_dek,
created_at=excluded.created_at`,
scope.Type, scope.TenantID, scope.ID, userID, ephemeral, wrapped,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return granted, err
}
granted++
}
return granted, nil
}
// RekeyUserPassword keeps the same keypair but protects it with a new KEK.
func (s *Store) RekeyUserPassword(ctx context.Context, userID, currentPassword, newPassword string) (*Keyring, error) {
var salt, publicKey, wrappedPrivate []byte
err := s.db.QueryRowContext(ctx,
"SELECT kdf_salt, public_key, wrapped_private FROM user_keys WHERE user_id=?", userID).
Scan(&salt, &publicKey, &wrappedPrivate)
if errors.Is(err, sql.ErrNoRows) {
return s.EnsureUserKeys(ctx, userID, newPassword)
}
if err != nil {
return nil, err
}
privateKey, err := openAESGCM(deriveUserKEK(currentPassword, salt), wrappedPrivate,
keyAAD("user-private", userID))
if err != nil {
return nil, err
}
newSalt, err := newSalt()
if err != nil {
return nil, err
}
wrapped, err := sealAESGCM(deriveUserKEK(newPassword, newSalt), privateKey,
keyAAD("user-private", userID))
if err != nil {
return nil, err
}
if _, err := s.db.ExecContext(ctx, `
UPDATE user_keys SET kdf_salt=?, wrapped_private=?, updated_at=? WHERE user_id=?`,
newSalt, wrapped, time.Now().UTC().Format(time.RFC3339), userID); err != nil {
return nil, err
}
return newKeyring(userID, privateKey), nil
}
+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)
}
}
+132 -24
View File
@@ -6,6 +6,7 @@ import (
"encoding/json"
"errors"
"strings"
"time"
"lektorenplan/domain"
)
@@ -151,35 +152,68 @@ func (s *Store) DeleteChurch(ctx context.Context, tenantID, id string) error {
// People lists a tenant's volunteers.
func (s *Store) People(ctx context.Context, tenantID string) ([]domain.Person, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id, first_name, last_name, roles, email, phone, preferred_church_ids,
SELECT id, first_name, last_name, roles, email, preferred_church_ids,
preferred_weekdays, preferred_service_titles, max_per_month, active, notes
FROM people WHERE tenant_id=? ORDER BY last_name COLLATE NOCASE, first_name COLLATE NOCASE`, tenantID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []domain.Person
for rows.Next() {
person, err := scanPerson(rows)
if err != nil {
rows.Close()
return nil, err
}
out = append(out, *person)
}
return out, rows.Err()
if err := rows.Err(); err != nil {
rows.Close()
return nil, err
}
rows.Close()
// The connection pool has a single connection, so the rows must be closed
// before the encrypted contacts are loaded.
for index := range out {
s.hydratePersonContacts(ctx, tenantID, &out[index])
}
return out, nil
}
// Person loads one volunteer.
func (s *Store) Person(ctx context.Context, tenantID, id string) (*domain.Person, error) {
row := s.db.QueryRowContext(ctx, `
SELECT id, first_name, last_name, roles, email, phone, preferred_church_ids,
SELECT id, first_name, last_name, roles, email, preferred_church_ids,
preferred_weekdays, preferred_service_titles, max_per_month, active, notes
FROM people WHERE tenant_id=? AND id=?`, tenantID, id)
person, err := scanPerson(row)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return person, err
if err != nil {
return nil, err
}
s.hydratePersonContacts(ctx, tenantID, person)
return person, nil
}
// hydratePersonContacts fills the e-mail address from the encrypted store.
// Values that exist but cannot be decrypted stay empty and are marked as
// locked so the UI can explain the situation. Before a tenant has been
// migrated, plaintext contacts are only exposed to key-holding editors.
func (s *Store) hydratePersonContacts(ctx context.Context, tenantID string, person *domain.Person) {
if !s.SecretIsInitialized(ctx, tenantID) {
if KeyringFrom(ctx) == nil && strings.TrimSpace(person.Email) != "" {
person.Email = ""
person.EmailLocked = true
}
return
}
email, emailLocked := s.PersonContactSecrets(ctx, tenantID, person.ID)
if person.Email == "" {
person.Email = email
person.EmailLocked = emailLocked
}
}
func scanPerson(row rowScanner) (*domain.Person, error) {
@@ -187,7 +221,7 @@ func scanPerson(row rowScanner) (*domain.Person, error) {
var roles, churches, weekdays, titles string
var active int
if err := row.Scan(&person.ID, &person.FirstName, &person.LastName, &roles,
&person.Email, &person.Phone, &churches, &weekdays, &titles,
&person.Email, &churches, &weekdays, &titles,
&person.MaxPerMonth, &active, &person.Notes); err != nil {
return nil, err
}
@@ -221,24 +255,88 @@ func (s *Store) UpsertPerson(ctx context.Context, tenantID string, person domain
if person.MaxPerMonth < 0 {
person.MaxPerMonth = 0
}
_, err := s.db.ExecContext(ctx, `
INSERT INTO people(tenant_id, id, first_name, last_name, roles, email, phone,
preferred_church_ids, preferred_weekdays, preferred_service_titles,
max_per_month, active, notes)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, id) DO UPDATE SET
first_name=excluded.first_name, last_name=excluded.last_name, roles=excluded.roles,
email=excluded.email, phone=excluded.phone,
preferred_church_ids=excluded.preferred_church_ids,
preferred_weekdays=excluded.preferred_weekdays,
preferred_service_titles=excluded.preferred_service_titles,
max_per_month=excluded.max_per_month, active=excluded.active, notes=excluded.notes`,
tenantID, person.ID, person.FirstName, person.LastName, encodeStrings(roleStrings),
person.Email, person.Phone, encodeStrings(person.PreferredChurchIDs),
encodeInts(person.PreferredWeekdays),
encodeStrings(person.PreferredServiceTitles), person.MaxPerMonth,
boolInt(person.Active), person.Notes)
return err
initialized := s.SecretIsInitialized(ctx, tenantID)
keyring := KeyringFrom(ctx)
// Plaintext contact writes are only a migration fallback for callers
// without key material. A reader who is logged in never stores an address
// in the legacy column.
manageContacts := !initialized && keyring == nil
// A locked field that was left empty must keep its existing value. This
// also lets readers without their own data key update their profile and
// prevents an administrator who cannot see plaintext contacts from
// clearing them before the tenant has been migrated.
preserveContact := person.EmailLocked && strings.TrimSpace(person.Email) == ""
updateLegacyContact := manageContacts && !preserveContact
var dek []byte
if initialized && keyring != nil && !preserveContact {
if err := s.EnsurePersonScope(ctx, keyring, tenantID, person.ID); err != nil {
return err
}
var err error
dek, err = s.scopeDEK(ctx, keyring, KeyScope{Type: ScopePerson, TenantID: tenantID, ID: person.ID})
if err != nil {
return err
}
}
return s.transaction(ctx, func(tx *sql.Tx) error {
email := person.Email
if initialized || !manageContacts {
// Contact details only live in the encrypted secrets table.
email = ""
}
_, err := tx.ExecContext(ctx, `
INSERT INTO people(tenant_id, id, first_name, last_name, roles, email,
preferred_church_ids, preferred_weekdays, preferred_service_titles,
max_per_month, active, notes)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, id) DO UPDATE SET
first_name=excluded.first_name, last_name=excluded.last_name, roles=excluded.roles,
email=CASE WHEN ? THEN excluded.email ELSE people.email END,
preferred_church_ids=excluded.preferred_church_ids,
preferred_weekdays=excluded.preferred_weekdays,
preferred_service_titles=excluded.preferred_service_titles,
max_per_month=excluded.max_per_month, active=excluded.active, notes=excluded.notes`,
tenantID, person.ID, person.FirstName, person.LastName, encodeStrings(roleStrings),
email, encodeStrings(person.PreferredChurchIDs),
encodeInts(person.PreferredWeekdays),
encodeStrings(person.PreferredServiceTitles), person.MaxPerMonth,
boolInt(person.Active), person.Notes, boolInt(updateLegacyContact))
if err != nil {
return err
}
if !initialized || keyring == nil {
return nil
}
setSecret := func(key, value string) error {
if strings.TrimSpace(value) == "" {
_, err := tx.ExecContext(ctx, `
DELETE FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, ScopePerson, person.ID, key)
return err
}
sealed, err := sealAESGCM(dek, []byte(value),
keyAAD(ScopePerson, tenantID, person.ID, key))
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO UPDATE SET
ciphertext=excluded.ciphertext, updated_at=excluded.updated_at`,
tenantID, ScopePerson, person.ID, key, sealed,
time.Now().UTC().Format(time.RFC3339))
return err
}
// A locked field that was left empty must keep its existing secret.
if !(person.EmailLocked && strings.TrimSpace(person.Email) == "") {
if err := setSecret("email", person.Email); err != nil {
return err
}
}
return nil
})
}
// DeletePerson removes a volunteer with assignments and absences.
@@ -252,6 +350,16 @@ func (s *Store) DeletePerson(ctx context.Context, tenantID, id string) error {
"DELETE FROM absences WHERE tenant_id=? AND person_id=?", tenantID, id); err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"DELETE FROM secrets WHERE tenant_id=? AND scope_type=? AND scope_id=?",
tenantID, ScopePerson, id); err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"DELETE FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?",
ScopePerson, tenantID, id); err != nil {
return err
}
_, err := tx.ExecContext(ctx, "DELETE FROM people WHERE tenant_id=? AND id=?", tenantID, id)
return err
})
+2
View File
@@ -102,6 +102,8 @@ func (s *Store) DeleteAllTenantData(ctx context.Context, tenantID string) error
"DELETE FROM dispatch_preferences WHERE tenant_id=?",
"DELETE FROM dispatch_log WHERE tenant_id=?",
"DELETE FROM tenant_settings WHERE tenant_id=?",
"DELETE FROM secrets WHERE tenant_id=?",
"DELETE FROM key_wrappers WHERE tenant_id=? AND scope_type='person'",
}
for _, statement := range statements {
if _, err := tx.ExecContext(ctx, statement, tenantID); err != nil {
+17 -2
View File
@@ -123,8 +123,13 @@ func (s *Store) UpdateTenant(ctx context.Context, tenant *Tenant) error {
// DeleteTenant removes a tenant and, through cascades, its planning data.
func (s *Store) DeleteTenant(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM tenants WHERE id=?", id)
return err
return s.transaction(ctx, func(tx *sql.Tx) error {
if _, err := tx.ExecContext(ctx, "DELETE FROM key_wrappers WHERE tenant_id=?", id); err != nil {
return err
}
_, err := tx.ExecContext(ctx, "DELETE FROM tenants WHERE id=?", id)
return err
})
}
func slugify(value string) string {
@@ -236,6 +241,16 @@ func (s *Store) CanAccessTenant(ctx context.Context, user *User, tenantID string
return count > 0
}
// CanManageSecrets reports whether the user may manage encrypted contacts and
// SMTP credentials. Administrators are deliberately excluded: only editors
// hold the keys for these scopes.
func (s *Store) CanManageSecrets(ctx context.Context, user *User, tenantID string) bool {
if user == nil || !user.Active || user.Role != RoleEditor {
return false
}
return s.CanAccessTenant(ctx, user, tenantID)
}
// CanEditTenant reports whether the user may change planning data.
func (s *Store) CanEditTenant(ctx context.Context, user *User, tenantID string) bool {
if user == nil || !user.Active {