diff --git a/web/README.md b/web/README.md
index d99ed60..21d2594 100644
--- a/web/README.md
+++ b/web/README.md
@@ -27,6 +27,9 @@ unverändert nutzbar.
Sondergottesdiensten (auch außerhalb der Kirche)
- **Team & Abwesenheiten** mit Rollen, Präferenzen, Monatslimits und
Einsatzhistorie
+- **Eigene Kontaktdaten für Leser:** Wer mit einer Person verknüpft ist, kann
+ die eigene E-Mail-Adresse selbst pflegen; Redakteure können Adressen für alle
+ Personen setzen. Alle Adressen werden verschlüsselt gespeichert
- **Statistik** über Besetzung, Fairness, Monatsverlauf und Kirchenverteilung
- **Austausch** per JSON-Export und zweistufigem Import mit Vorschau
- **Liturgischer Kalender** für das Erzbistum Köln mit Online-Aktualisierung,
@@ -98,8 +101,9 @@ Jedes Konto hat genau eine globale Rolle:
- **Redakteur** bearbeitet die ihm freigegebenen Mandanten.
- **Leser** sieht die ihm freigegebenen Mandanten ausschließlich lesend. Wird
ein Leser-Konto mit einer Person verknüpft, darf es deren Stammdaten,
- Präferenzen und Abwesenheiten selbst bearbeiten und den Plan nach dieser
- Person filtern; ohne Verknüpfung bleiben Teamdaten für Leser unsichtbar.
+ Präferenzen, Abwesenheiten und die eigene E-Mail-Adresse selbst bearbeiten
+ und den Plan nach dieser Person filtern; ohne Verknüpfung bleiben Teamdaten
+ für Leser unsichtbar.
Planungsdaten (Kirchen, Personen, Vorlagen, Gottesdienste, Einteilungen,
Abwesenheiten und Einstellungen) sind immer einem Mandanten zugeordnet.
@@ -107,6 +111,35 @@ Administratoren sehen alle Mandanten; Redakteure und Leser nur die in
`memberships` eingetragenen. Der aktive Mandant wird über die Seitenleiste
gewechselt.
+## Verschlüsselte Kontaktdaten
+
+E-Mail-Adressen und SMTP-Zugangsdaten liegen nicht im Klartext in der
+Datenbank.
+
+- Jedes Konto mit Schlüsselbedarf (Redakteur oder Leser) besitzt ein
+ X25519-Schlüsselpaar. Der private Schlüssel wird mit AES-GCM verschlüsselt
+ gespeichert; den Schlüssel dafür leitet Argon2id aus dem Anmeldepasswort ab.
+- Die E-Mail-Adresse einer Person wird mit einem eigenen Datenschlüssel
+ verschlüsselt. Derselbe Datenschlüssel wird für jeden Redakteur des
+ Mandanten und für den verknüpften Leser mit dessen öffentlichem Schlüssel
+ verpackt. So entschlüsselt jeder Beteiligte die Adresse mit dem aus seinem
+ Login abgeleiteten Schlüssel; Administratoren erhalten bewusst keinen
+ Zugriff.
+- Legt ein Leser seine Adresse selbst an oder ändert er sie, wird sie sofort
+ für alle vorhandenen Redakteure neu verpackt. Wird später ein Redakteur
+ angelegt, erhält er die vorhandenen Datenschlüssel bei der nächsten
+ Anmeldung eines Lesers oder eines bereits entsperrten Redakteurs.
+- Redakteure können Adressen für beliebige Lektoren und Kommunionhelfer
+ setzen. Eine später vom Leser selbst gepflegte Adresse ersetzt diesen Wert.
+- Nach einem Serverneustart sind die Schlüssel nur im Arbeitsspeicher und
+ müssen über „Daten entsperren“ mit dem eigenen Passwort erneut geöffnet
+ werden. Exportdateien enthalten keine Kontaktdaten.
+
+> Ein administrativer Passwort-Reset erzeugt ein temporäres Passwort und
+> schützt damit ein neues Schlüsselpaar, bis der Betroffene ein eigenes
+> Passwort setzt. In dieser kurzen Phase ist der Zugriff auf die
+> verschlüsselten Daten technisch möglich; danach nicht mehr.
+
## Bauen und testen
```bash
diff --git a/web/domain/models.go b/web/domain/models.go
index 0e7bb8a..c87704e 100644
--- a/web/domain/models.go
+++ b/web/domain/models.go
@@ -95,7 +95,7 @@ type Person struct {
LastName string `json:"lastName"`
Roles []Role `json:"roles"`
Email string `json:"email"`
- Phone string `json:"phone"`
+ EmailLocked bool `json:"-"`
PreferredChurchIDs []string `json:"preferredChurchIDs"`
PreferredWeekdays []int `json:"preferredWeekdays"`
PreferredServiceTitles []string `json:"preferredServiceTitles"`
diff --git a/web/store/auth.go b/web/store/auth.go
index d69f38e..8127f76 100644
--- a/web/store/auth.go
+++ b/web/store/auth.go
@@ -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
}
diff --git a/web/store/crypto.go b/web/store/crypto.go
new file mode 100644
index 0000000..1f29122
--- /dev/null
+++ b/web/store/crypto.go
@@ -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
+}
diff --git a/web/store/db.go b/web/store/db.go
index acf8eef..d70c9d6 100644
--- a/web/store/db.go
+++ b/web/store/db.go
@@ -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
}
diff --git a/web/store/demo.go b/web/store/demo.go
index 6208763..4959c12 100644
--- a/web/store/demo.go
+++ b/web/store/demo.go
@@ -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"},
diff --git a/web/store/exchange.go b/web/store/exchange.go
index 032c53f..41f3920 100644
--- a/web/store/exchange.go
+++ b/web/store/exchange.go
@@ -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
}
diff --git a/web/store/keys.go b/web/store/keys.go
new file mode 100644
index 0000000..1397696
--- /dev/null
+++ b/web/store/keys.go
@@ -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
+}
diff --git a/web/store/keys_test.go b/web/store/keys_test.go
new file mode 100644
index 0000000..8119ace
--- /dev/null
+++ b/web/store/keys_test.go
@@ -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)
+ }
+}
diff --git a/web/store/resources.go b/web/store/resources.go
index 511d0be..20d3393 100644
--- a/web/store/resources.go
+++ b/web/store/resources.go
@@ -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
})
diff --git a/web/store/settings.go b/web/store/settings.go
index 67767f7..b5eef5c 100644
--- a/web/store/settings.go
+++ b/web/store/settings.go
@@ -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 {
diff --git a/web/store/tenants.go b/web/store/tenants.go
index 16de807..f028a15 100644
--- a/web/store/tenants.go
+++ b/web/store/tenants.go
@@ -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 {
diff --git a/web/web/admin_handlers.go b/web/web/admin_handlers.go
index e233746..6e9896f 100644
--- a/web/web/admin_handlers.go
+++ b/web/web/admin_handlers.go
@@ -254,6 +254,7 @@ func (s *Server) handleAdminUserSave(w http.ResponseWriter, r *http.Request, use
return
}
}
+ s.grantAccountScopes(r.Context(), s.activeEditorKeyring(r.Context()), tenantIDs)
s.setFlash(w, "Konto „"+created.Username+"“ angelegt. Beim ersten Anmelden muss ein eigenes Passwort gesetzt werden.", "success")
s.redirect(w, r, "/admin/users?edit="+created.ID)
return
@@ -264,6 +265,34 @@ func (s *Server) handleAdminUserSave(w http.ResponseWriter, r *http.Request, use
s.redirect(w, r, "/admin/users?edit="+id)
return
}
+ if err := s.store.PruneUserWrappers(r.Context(), id); err != nil {
+ s.setFlash(w, "Das Konto wurde gespeichert, alte Schlüsselfreigaben konnten aber nicht entfernt werden: "+err.Error(), "error")
+ s.redirect(w, r, "/admin/users?edit="+id)
+ return
+ }
+ if password != "" {
+ // A new password would no longer decrypt the existing keypair.
+ // Editors and readers get a fresh keypair; administrators have none.
+ if role == store.RoleEditor || role == store.RoleReader {
+ _, scopes, err := s.store.ResetUserKeys(r.Context(), id, password)
+ if err != nil {
+ s.setFlash(w, "Das Passwort wurde gespeichert, die Schlüssel konnten aber nicht neu erzeugt werden: "+err.Error(), "error")
+ s.redirect(w, r, "/admin/users?edit="+id)
+ return
+ }
+ s.dropUserKeyrings(id)
+ if actor := s.activeEditorKeyring(r.Context()); actor != nil {
+ if _, err := s.store.RewrapScopes(r.Context(), actor, id, scopes); err != nil {
+ s.setFlash(w, "Das Konto wurde gespeichert, einige verschlüsselte Daten bleiben aber vorerst gesperrt: "+err.Error(), "error")
+ s.redirect(w, r, "/admin/users?edit="+id)
+ return
+ }
+ }
+ } else {
+ _ = s.store.DeleteUserKeys(r.Context(), id)
+ }
+ }
+ s.grantAccountScopes(r.Context(), s.activeEditorKeyring(r.Context()), tenantIDs)
s.setFlash(w, "Konto gespeichert.", "success")
s.redirect(w, r, "/admin/users?edit="+id)
}
@@ -278,6 +307,7 @@ func (s *Server) handleAdminUserDelete(w http.ResponseWriter, r *http.Request, u
if err := s.store.DeleteUser(r.Context(), id); err != nil {
s.setFlash(w, "Das Konto konnte nicht gelöscht werden: "+err.Error(), "error")
} else {
+ s.dropUserKeyrings(id)
s.setFlash(w, "Konto gelöscht.", "success")
}
s.redirect(w, r, "/admin/users")
@@ -307,8 +337,33 @@ func (s *Server) handleAdminUserResetPassword(w http.ResponseWriter, r *http.Req
s.redirect(w, r, "/admin/users?edit="+id)
return
}
+ // The old keypair was protected by the unknown old password. Editors and
+ // readers hold keys for encrypted data; administrators never do.
+ if account.Role != store.RoleEditor && account.Role != store.RoleReader {
+ _ = s.store.DeleteUserKeys(r.Context(), id)
+ s.dropUserKeyrings(id)
+ s.setFlash(w, "Temporäres Passwort für „"+account.Username+"“: "+temporary+
+ " · Beim nächsten Anmelden muss es geändert werden.", "success")
+ s.redirect(w, r, "/admin/users?edit="+id)
+ return
+ }
+ _, scopes, err := s.store.ResetUserKeys(r.Context(), id, temporary)
+ if err != nil {
+ s.setFlash(w, "Das Passwort wurde zurückgesetzt, die Schlüssel konnten aber nicht neu erzeugt werden: "+err.Error(), "error")
+ s.redirect(w, r, "/admin/users?edit="+id)
+ return
+ }
+ s.dropUserKeyrings(id)
+ granted := 0
+ if actor := s.activeEditorKeyring(r.Context()); actor != nil {
+ granted, _ = s.store.RewrapScopes(r.Context(), actor, id, scopes)
+ }
+ note := ""
+ if granted < len(scopes) {
+ note = " Einige Daten bleiben vorerst gesperrt, bis ein entsperrter Redakteur sie erneut freigibt."
+ }
s.setFlash(w, "Temporäres Passwort für „"+account.Username+"“: "+temporary+
- " · Beim nächsten Anmelden muss es geändert werden.", "success")
+ " · Beim nächsten Anmelden muss es geändert werden."+note, "success")
s.redirect(w, r, "/admin/users?edit="+id)
}
diff --git a/web/web/auth_handlers.go b/web/web/auth_handlers.go
index f7046c4..bb01e35 100644
--- a/web/web/auth_handlers.go
+++ b/web/web/auth_handlers.go
@@ -1,6 +1,7 @@
package web
import (
+ "log"
"net/http"
"net/url"
"strings"
@@ -34,12 +35,28 @@ func (s *Server) handleLoginPost(w http.ResponseWriter, r *http.Request) {
s.redirect(w, r, "/login")
return
}
+ if err := s.store.PruneUserWrappers(r.Context(), user.ID); err != nil {
+ log.Printf("login: enforce key policy for %s: %v", user.Username, err)
+ }
+ var keyring *store.Keyring
+ if user.Role == store.RoleEditor || user.Role == store.RoleReader {
+ keyring, err = s.activateKeyring(r.Context(), user, password)
+ if err != nil {
+ log.Printf("login: unlock keys for %s: %v", user.Username, err)
+ s.setFlash(w, "Die verschlüsselten Daten konnten nicht entsperrt werden. Bitte wenden Sie sich an einen Redakteur.", "error")
+ s.redirect(w, r, "/login")
+ return
+ }
+ }
session, token, err := s.store.CreateSession(r.Context(), user.ID, s.sessionTTL)
if err != nil {
s.setFlash(w, "Die Sitzung konnte nicht erstellt werden.", "error")
s.redirect(w, r, "/login")
return
}
+ if keyring != nil {
+ s.cacheKeyring(session.ID, keyring)
+ }
http.SetCookie(w, &http.Cookie{
Name: sessionCookie, Value: token, Path: "/", HttpOnly: true,
SameSite: http.SameSiteLaxMode, Secure: s.opts.SecureCookies,
@@ -57,6 +74,7 @@ func (s *Server) handleLoginPost(w http.ResponseWriter, r *http.Request) {
}
func (s *Server) handleLogout(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
+ s.dropSessionKeyring(session.ID)
if cookie, err := r.Cookie(sessionCookie); err == nil {
_ = s.store.DeleteSessionByToken(r.Context(), cookie.Value)
}
diff --git a/web/web/crypto_web_test.go b/web/web/crypto_web_test.go
new file mode 100644
index 0000000..0a18744
--- /dev/null
+++ b/web/web/crypto_web_test.go
@@ -0,0 +1,538 @@
+package web
+
+import (
+ "context"
+ "encoding/base64"
+ "net/http"
+ "net/http/httptest"
+ "net/url"
+ "regexp"
+ "strings"
+ "testing"
+
+ "lektorenplan/store"
+)
+
+func TestUnlockRequiredAfterServerRestart(t *testing.T) {
+ ts, st := newTestServer(t)
+ client := newClient(t)
+ login(t, client, ts.URL, "editor", "editor123")
+
+ // A fresh server process has an empty keyring cache but the browser still
+ // holds its session cookie.
+ restarted, err := New(st, Options{Version: "test", DemoMode: true})
+ if err != nil {
+ t.Fatalf("new server: %v", err)
+ }
+ ts2 := httptest.NewServer(restarted.Handler())
+ defer ts2.Close()
+
+ req, err := http.NewRequest(http.MethodGet, ts2.URL+"/plan", nil)
+ if err != nil {
+ t.Fatalf("request: %v", err)
+ }
+ resp, err := client.Do(req)
+ if err != nil {
+ t.Fatalf("get plan: %v", err)
+ }
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther || !strings.HasPrefix(resp.Header.Get("Location"), "/unlock") {
+ t.Fatalf("locked request = %d %q, want redirect to /unlock", resp.StatusCode, resp.Header.Get("Location"))
+ }
+
+ body := get(t, client, ts2.URL+"/unlock", http.StatusOK)
+ csrf := extractCSRF(t, body)
+ unlock, err := client.PostForm(ts2.URL+"/unlock", url.Values{
+ "csrf": {csrf},
+ "password": {"editor1231"},
+ })
+ if err != nil {
+ t.Fatalf("unlock: %v", err)
+ }
+ unlock.Body.Close()
+ if unlock.StatusCode != http.StatusSeeOther || unlock.Header.Get("Location") != "/plan" {
+ t.Fatalf("unlock = %d %q", unlock.StatusCode, unlock.Header.Get("Location"))
+ }
+ get(t, client, ts2.URL+"/plan", http.StatusOK)
+}
+
+func TestLinkedReaderUnlocksOwnContactAfterRestart(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenantID, personID, personEmail := demoContact(t, st)
+ reader, err := st.UserByUsername(ctx, "reader")
+ if err != nil {
+ t.Fatalf("reader: %v", err)
+ }
+ if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
+ t.Fatalf("link reader: %v", err)
+ }
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+ readerClient := newClient(t)
+ login(t, readerClient, ts.URL, "reader", "reader123")
+
+ restarted, err := New(st, Options{Version: "test", DemoMode: true})
+ if err != nil {
+ t.Fatalf("new server: %v", err)
+ }
+ ts2 := httptest.NewServer(restarted.Handler())
+ defer ts2.Close()
+
+ req, err := http.NewRequest(http.MethodGet, ts2.URL+"/team", nil)
+ if err != nil {
+ t.Fatalf("request: %v", err)
+ }
+ resp, err := readerClient.Do(req)
+ if err != nil {
+ t.Fatalf("get team: %v", err)
+ }
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther || !strings.HasPrefix(resp.Header.Get("Location"), "/unlock") {
+ t.Fatalf("locked reader request = %d %q, want /unlock", resp.StatusCode, resp.Header.Get("Location"))
+ }
+
+ body := get(t, readerClient, ts2.URL+"/unlock", http.StatusOK)
+ csrf := extractCSRF(t, body)
+ unlock, err := readerClient.PostForm(ts2.URL+"/unlock", url.Values{
+ "csrf": {csrf},
+ "password": {"reader1231"},
+ })
+ if err != nil {
+ t.Fatalf("unlock: %v", err)
+ }
+ unlock.Body.Close()
+ if unlock.StatusCode != http.StatusSeeOther {
+ t.Fatalf("reader unlock = %d, want 303", unlock.StatusCode)
+ }
+ page := get(t, readerClient, ts2.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(page, personEmail) {
+ t.Fatalf("reader cannot decrypt own e-mail after unlock %q", personEmail)
+ }
+}
+
+func TestAdminCannotDecryptSensitiveData(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+ editorPage := get(t, editorClient, ts.URL+"/team", http.StatusOK)
+ if !strings.Contains(editorPage, "anna.berg@example.org") {
+ t.Fatal("editor cannot decrypt the seeded e-mail address")
+ }
+
+ adminClient := newClient(t)
+ login(t, adminClient, ts.URL, "admin", "admin123")
+
+ teamPage := get(t, adminClient, ts.URL+"/team", http.StatusOK)
+ if strings.Contains(teamPage, "@example.org") {
+ t.Fatal("administrator page exposes e-mail addresses")
+ }
+ if !strings.Contains(teamPage, "Kontaktdaten gesperrt") {
+ t.Fatal("administrator page does not mark the contacts as locked")
+ }
+ settingsPage := get(t, adminClient, ts.URL+"/settings", http.StatusOK)
+ if strings.Contains(settingsPage, "E-Mail-Versand (SMTP)") {
+ t.Fatal("administrator settings expose SMTP credentials")
+ }
+ dispatchPage := get(t, adminClient, ts.URL+"/dispatch?"+dispatchRange, http.StatusOK)
+ if strings.Contains(dispatchPage, "@example.org") || strings.Contains(dispatchPage, "data-mailto-link") {
+ t.Fatal("administrator dispatch page exposes recipient addresses")
+ }
+ if !strings.Contains(dispatchPage, "SMTP wird von Redakteuren verwaltet") ||
+ !strings.Contains(dispatchPage, "Direkter E-Mail-Versand ist für dieses Konto nicht verfügbar") {
+ t.Fatal("administrator dispatch page does not explain the restricted SMTP access")
+ }
+ if strings.Contains(dispatchPage, `formaction="/dispatch/send"`) {
+ t.Fatal("administrator dispatch page offers direct sending")
+ }
+
+ admin, err := st.UserByUsername(ctx, "admin")
+ if err != nil {
+ t.Fatalf("admin: %v", err)
+ }
+ if st.HasUserKeys(ctx, admin.ID) {
+ t.Fatal("administrator still holds key material")
+ }
+ scopes, err := st.ScopesForUser(ctx, admin.ID)
+ if err != nil {
+ t.Fatalf("admin scopes: %v", err)
+ }
+ if len(scopes) != 0 {
+ t.Fatalf("administrator holds %d encrypted scopes", len(scopes))
+ }
+}
+
+func TestLinkedReaderManagesOwnContact(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenantID, personID, personEmail := demoContact(t, st)
+ var otherEmail string
+ if err := st.DB().QueryRowContext(ctx,
+ "SELECT email FROM people WHERE tenant_id=? AND id<>? AND email<>'' LIMIT 1",
+ tenantID, personID).Scan(&otherEmail); err != nil {
+ t.Fatalf("other contact: %v", err)
+ }
+ reader, err := st.UserByUsername(ctx, "reader")
+ if err != nil {
+ t.Fatalf("reader: %v", err)
+ }
+ if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
+ t.Fatalf("link reader: %v", err)
+ }
+
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+
+ readerClient := newClient(t)
+ login(t, readerClient, ts.URL, "reader", "reader123")
+ teamPage := get(t, readerClient, ts.URL+"/team", http.StatusOK)
+ if !strings.Contains(teamPage, personEmail) {
+ t.Fatalf("linked reader does not see own e-mail %q", personEmail)
+ }
+ if otherEmail != "" && strings.Contains(teamPage, otherEmail) {
+ t.Fatalf("linked reader sees another person's e-mail %q", otherEmail)
+ }
+
+ personPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ csrf := extractCSRF(t, personPage)
+ updatedEmail := "reader.self@example.org"
+ resp := postForm(t, readerClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
+ "csrf": {csrf},
+ "first_name": {"Anna"},
+ "last_name": {"Berg"},
+ "email": {updatedEmail},
+ })
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther {
+ t.Fatalf("reader save = %d, want 303", resp.StatusCode)
+ }
+
+ var plain string
+ if err := st.DB().QueryRowContext(ctx,
+ "SELECT email FROM people WHERE tenant_id=? AND id=?", tenantID, personID).Scan(&plain); err != nil {
+ t.Fatalf("read person row: %v", err)
+ }
+ if plain != "" {
+ t.Fatalf("reader e-mail stored in plaintext: %q", plain)
+ }
+ if !st.SecretExists(ctx, tenantID, store.ScopePerson, personID, "email") {
+ t.Fatal("reader e-mail was not stored as a secret")
+ }
+
+ editorPage := get(t, editorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(editorPage, updatedEmail) {
+ t.Fatalf("editor does not see the reader-updated e-mail %q", updatedEmail)
+ }
+ if strings.Contains(editorPage, personEmail) {
+ t.Fatalf("editor still sees the old e-mail %q", personEmail)
+ }
+}
+
+func TestNewEditorReceivesReaderAddressAfterReaderLogin(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenantID, personID, _ := demoContact(t, st)
+ reader, err := st.UserByUsername(ctx, "reader")
+ if err != nil {
+ t.Fatalf("reader: %v", err)
+ }
+ if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
+ t.Fatalf("link reader: %v", err)
+ }
+
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+
+ readerClient := newClient(t)
+ login(t, readerClient, ts.URL, "reader", "reader123")
+ personPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ csrf := extractCSRF(t, personPage)
+ updatedEmail := "backfill.self@example.org"
+ resp := postForm(t, readerClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
+ "csrf": {csrf},
+ "first_name": {"Anna"},
+ "last_name": {"Berg"},
+ "email": {updatedEmail},
+ })
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther {
+ t.Fatalf("reader save = %d, want 303", resp.StatusCode)
+ }
+
+ // A new editor is created after the address exists. The reader's next
+ // login must wrap the address for that editor.
+ if _, err := st.CreateUser(ctx, "neueditor", "Neue Redaktion", "neueditor123",
+ store.RoleEditor, true, []string{tenantID}); err != nil {
+ t.Fatalf("create editor: %v", err)
+ }
+ readerAgain := newClient(t)
+ login(t, readerAgain, ts.URL, "reader", "reader1231")
+
+ newEditorClient := newClient(t)
+ login(t, newEditorClient, ts.URL, "neueditor", "neueditor123")
+ page := get(t, newEditorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(page, updatedEmail) {
+ t.Fatalf("new editor cannot decrypt the reader e-mail %q", updatedEmail)
+ }
+}
+
+func TestReaderWithoutScopeCanSaveProfile(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenantID, personID, _ := demoContact(t, st)
+ reader, err := st.UserByUsername(ctx, "reader")
+ if err != nil {
+ t.Fatalf("reader: %v", err)
+ }
+ if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
+ t.Fatalf("link reader: %v", err)
+ }
+
+ // The editor encrypts the tenant and grants the reader access.
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+
+ // Lose the reader's keypair and all wrappers, e.g. after restoring an
+ // older database. The encrypted address remains readable for editors.
+ if err := st.DeleteUserKeys(ctx, reader.ID); err != nil {
+ t.Fatalf("delete reader keys: %v", err)
+ }
+
+ // A fresh process has no unlocked editor keyring, so the reader cannot
+ // receive the person scope on login either.
+ restarted, err := New(st, Options{Version: "test", DemoMode: true})
+ if err != nil {
+ t.Fatalf("new server: %v", err)
+ }
+ ts2 := httptest.NewServer(restarted.Handler())
+ defer ts2.Close()
+
+ readerClient := newClient(t)
+ login(t, readerClient, ts2.URL, "reader", "reader123")
+ if scopes, _ := st.ScopesForUser(ctx, reader.ID); len(scopes) != 0 {
+ t.Fatalf("reader unexpectedly holds %d scopes", len(scopes))
+ }
+
+ page := get(t, readerClient, ts2.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(page, "noch nicht freigegeben") {
+ t.Fatal("reader page does not mark the e-mail as not yet released")
+ }
+ csrf := extractCSRF(t, page)
+ resp := postForm(t, readerClient, ts2.URL+"/team/person/"+personID+"/save", url.Values{
+ "csrf": {csrf},
+ "first_name": {"Anna"},
+ "last_name": {"Berg"},
+ "email": {"should.not.be.saved@example.org"},
+ })
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther {
+ t.Fatalf("reader profile save = %d, want 303", resp.StatusCode)
+ }
+ person, err := st.Person(ctx, tenantID, personID)
+ if err != nil {
+ t.Fatalf("person: %v", err)
+ }
+ if person.LastName != "Berg" {
+ t.Fatalf("reader profile was not saved: last name %q", person.LastName)
+ }
+ var stored string
+ if err := st.DB().QueryRowContext(ctx,
+ "SELECT email FROM people WHERE tenant_id=? AND id=?", tenantID, personID).Scan(&stored); err != nil {
+ t.Fatalf("read person row: %v", err)
+ }
+ if stored != "" {
+ t.Fatalf("reader without scope stored plaintext e-mail %q", stored)
+ }
+}
+
+func TestEditorSetsAddressAndReaderReadsIt(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenantID, personID, _ := demoContact(t, st)
+ reader, err := st.UserByUsername(ctx, "reader")
+ if err != nil {
+ t.Fatalf("reader: %v", err)
+ }
+ if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
+ t.Fatalf("link reader: %v", err)
+ }
+
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+ readerClient := newClient(t)
+ login(t, readerClient, ts.URL, "reader", "reader123")
+
+ editorPage := get(t, editorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ csrf := extractCSRF(t, editorPage)
+ updatedEmail := "editor.set@example.org"
+ resp := postForm(t, editorClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
+ "csrf": {csrf},
+ "first_name": {"Anna"},
+ "last_name": {"Berg"},
+ "role_lector": {"1"},
+ "email": {updatedEmail},
+ })
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther {
+ t.Fatalf("editor save = %d, want 303", resp.StatusCode)
+ }
+
+ var plain string
+ if err := st.DB().QueryRowContext(ctx,
+ "SELECT email FROM people WHERE tenant_id=? AND id=?", tenantID, personID).Scan(&plain); err != nil {
+ t.Fatalf("read person row: %v", err)
+ }
+ if plain != "" {
+ t.Fatalf("editor e-mail stored in plaintext: %q", plain)
+ }
+ readerPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(readerPage, updatedEmail) {
+ t.Fatalf("reader cannot read the editor-set e-mail %q", updatedEmail)
+ }
+}
+
+func TestNewEditorReceivesAllContactsFromUnlockedEditor(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenants, err := st.Tenants(ctx)
+ if err != nil {
+ t.Fatalf("tenants: %v", err)
+ }
+ if len(tenants) == 0 {
+ t.Fatal("demo tenant missing")
+ }
+ tenantID := tenants[0].ID
+ var otherEmail string
+ if err := st.DB().QueryRowContext(ctx,
+ "SELECT email FROM people WHERE tenant_id=? AND email<>'' ORDER BY id LIMIT 1",
+ tenantID).Scan(&otherEmail); err != nil {
+ t.Fatalf("contact: %v", err)
+ }
+
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+
+ newEditor, err := st.CreateUser(ctx, "neueredakteur", "Neue Redaktion", "neueredakteur123",
+ store.RoleEditor, true, []string{tenantID})
+ if err != nil {
+ t.Fatalf("create editor: %v", err)
+ }
+ if scopes, _ := st.ScopesForUser(ctx, newEditor.ID); len(scopes) != 0 {
+ t.Fatalf("new editor already holds %d scopes", len(scopes))
+ }
+
+ newClientSession := newClient(t)
+ login(t, newClientSession, ts.URL, "neueredakteur", "neueredakteur123")
+ teamPage := get(t, newClientSession, ts.URL+"/team", http.StatusOK)
+ if !strings.Contains(teamPage, otherEmail) {
+ t.Fatalf("new editor cannot decrypt team contact %q", otherEmail)
+ }
+ if scopes, _ := st.ScopesForUser(ctx, newEditor.ID); len(scopes) == 0 {
+ t.Fatal("new editor did not receive any scopes")
+ }
+}
+
+func TestAdminResetReaderKeepsAddressForEditor(t *testing.T) {
+ ts, st := newTestServer(t)
+ ctx := context.Background()
+ tenantID, personID, _ := demoContact(t, st)
+ reader, err := st.UserByUsername(ctx, "reader")
+ if err != nil {
+ t.Fatalf("reader: %v", err)
+ }
+ if err := st.SetUserPersonLink(ctx, reader.ID, tenantID, personID); err != nil {
+ t.Fatalf("link reader: %v", err)
+ }
+
+ editorClient := newClient(t)
+ login(t, editorClient, ts.URL, "editor", "editor123")
+ readerClient := newClient(t)
+ login(t, readerClient, ts.URL, "reader", "reader123")
+ personPage := get(t, readerClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ csrf := extractCSRF(t, personPage)
+ updatedEmail := "reset.self@example.org"
+ resp := postForm(t, readerClient, ts.URL+"/team/person/"+personID+"/save", url.Values{
+ "csrf": {csrf},
+ "first_name": {"Anna"},
+ "last_name": {"Berg"},
+ "email": {updatedEmail},
+ })
+ resp.Body.Close()
+ if resp.StatusCode != http.StatusSeeOther {
+ t.Fatalf("reader save = %d, want 303", resp.StatusCode)
+ }
+
+ adminClient := newClient(t)
+ login(t, adminClient, ts.URL, "admin", "admin123")
+ adminPage := get(t, adminClient, ts.URL+"/admin/users", http.StatusOK)
+ adminCSRF := extractCSRF(t, adminPage)
+ reset, err := adminClient.PostForm(ts.URL+"/admin/users/reset-password", url.Values{
+ "csrf": {adminCSRF},
+ "id": {reader.ID},
+ })
+ if err != nil {
+ t.Fatalf("reset reader: %v", err)
+ }
+ reset.Body.Close()
+ temporary := flashPassword(t, reset)
+ if temporary == "" {
+ t.Fatal("no temporary password in reset flash")
+ }
+
+ // The reader signs in with the temporary password, changes it and must
+ // still be able to decrypt the own address.
+ readerAgain := newClient(t)
+ login(t, readerAgain, ts.URL, "reader", temporary)
+ page := get(t, readerAgain, ts.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(page, updatedEmail) {
+ t.Fatalf("reader cannot decrypt own e-mail after reset %q", updatedEmail)
+ }
+ editorPage := get(t, editorClient, ts.URL+"/team/person/"+personID, http.StatusOK)
+ if !strings.Contains(editorPage, updatedEmail) {
+ t.Fatalf("editor lost the reader e-mail after reset %q", updatedEmail)
+ }
+}
+
+// demoContact returns a tenant, a person and that person's plaintext e-mail
+// from the seeded demo data.
+func demoContact(t *testing.T, st *store.Store) (tenantID, personID, email string) {
+ t.Helper()
+ ctx := context.Background()
+ tenants, err := st.Tenants(ctx)
+ if err != nil {
+ t.Fatalf("tenants: %v", err)
+ }
+ for _, tenant := range tenants {
+ if tenant.Slug == "bad-godesberg" {
+ tenantID = tenant.ID
+ }
+ }
+ if tenantID == "" {
+ t.Fatal("demo tenant not found")
+ }
+ if err := st.DB().QueryRowContext(ctx,
+ "SELECT id, email FROM people WHERE tenant_id=? AND email<>'' LIMIT 1",
+ tenantID).Scan(&personID, &email); err != nil {
+ t.Fatalf("contact person: %v", err)
+ }
+ return tenantID, personID, email
+}
+
+var temporaryPasswordPattern = regexp.MustCompile(`lp-[0-9a-f]+`)
+
+func flashPassword(t *testing.T, resp *http.Response) string {
+ t.Helper()
+ for _, cookie := range resp.Cookies() {
+ if cookie.Name != flashCookie || cookie.Value == "" {
+ continue
+ }
+ data, err := base64.RawURLEncoding.DecodeString(cookie.Value)
+ if err != nil {
+ t.Fatalf("decode flash: %v", err)
+ }
+ return temporaryPasswordPattern.FindString(string(data))
+ }
+ return ""
+}
diff --git a/web/web/dispatch_handlers.go b/web/web/dispatch_handlers.go
index c3dad9c..838069c 100644
--- a/web/web/dispatch_handlers.go
+++ b/web/web/dispatch_handlers.go
@@ -5,6 +5,7 @@ import (
"context"
"fmt"
"net/http"
+ "net/url"
"sort"
"strconv"
"strings"
@@ -52,6 +53,9 @@ type dispatchPersonView struct {
Effective string
Assignments []dispatchAssignmentView
AssignmentCount int
+ AssignmentText string
+ MailText string
+ Mailto string
}
type dispatchPageData struct {
@@ -67,14 +71,22 @@ type dispatchPageData struct {
Greeting string
SMTPConfigured bool
SMTPFrom string
- EmailCount int
- PrintCount int
- NoneCount int
- LastEntry *store.DispatchLogEntry
- LastBatch []store.DispatchLogEntry
- History []store.DispatchLogEntry
- OpenSlots int
- ServiceCount int
+ // CanManageSecrets is false for administrators and readers. They can use
+ // the dispatch page, but recipient addresses and SMTP credentials stay
+ // locked because only editors hold the matching keys.
+ CanManageSecrets bool
+ EmailCount int
+ PrintCount int
+ NoneCount int
+ LastEntry *store.DispatchLogEntry
+ LastBatch []store.DispatchLogEntry
+ History []store.DispatchLogEntry
+ OpenSlots int
+ ServiceCount int
+ MailSubject string
+ StartLabel string
+ EndLabel string
+ DefaultIntro string
}
type dispatchSelection struct {
@@ -269,6 +281,14 @@ func (s *Server) handleDispatch(w http.ResponseWriter, r *http.Request, user *st
}
config := s.loadSMTPConfig(r.Context(), tenant.ID)
intro, greeting := s.dispatchTexts(r.Context(), tenant.ID)
+ subject := "Gottesdienstplan " + rng.ShortTitle() + " · " + tenant.Name
+ for index := range people {
+ people[index].AssignmentText = emailAssignmentTable(people[index].Assignments)
+ people[index].MailText = dispatchEmailBody(intro, greeting, rng, people[index].Assignments)
+ if email := strings.TrimSpace(people[index].Person.Email); email != "" {
+ people[index].Mailto = dispatchMailto(email, subject, people[index].MailText)
+ }
+ }
prev := domain.MonthRange(domain.AddingMonths(-1, rng.Start))
next := domain.MonthRange(domain.AddingMonths(1, rng.Start))
page := dispatchPageData{
@@ -276,8 +296,14 @@ func (s *Server) handleDispatch(w http.ResponseWriter, r *http.Request, user *st
PrevStart: domain.Key(prev.Start), PrevEnd: domain.Key(prev.End),
NextStart: domain.Key(next.Start), NextEnd: domain.Key(next.End),
People: people, Intro: intro, Greeting: greeting,
- SMTPConfigured: config.configured(), SMTPFrom: config.FromAddress,
- History: history,
+ SMTPConfigured: config.configured(),
+ SMTPFrom: config.FromAddress,
+ CanManageSecrets: s.store.CanManageSecrets(r.Context(), user, tenant.ID),
+ History: history,
+ MailSubject: subject,
+ StartLabel: dispatchDateLabel(rng.Start),
+ EndLabel: dispatchDateLabel(rng.End),
+ DefaultIntro: defaultDispatchIntro,
}
for _, person := range people {
switch person.Effective {
@@ -435,6 +461,18 @@ func dispatchEmailBody(intro, greeting string, rng domain.DayRange, assignments
return strings.Join(parts, "\n\n")
}
+// dispatchMailto builds a draft link for the local mail client. It is used
+// when no SMTP account has been configured.
+func dispatchMailto(email, subject, body string) string {
+ body = strings.ReplaceAll(body, "\n", "\r\n")
+ return "mailto:" + url.PathEscape(strings.TrimSpace(email)) +
+ "?subject=" + mailtoEscape(subject) + "&body=" + mailtoEscape(body)
+}
+
+func mailtoEscape(value string) string {
+ return strings.ReplaceAll(url.QueryEscape(value), "+", "%20")
+}
+
func (s *Server) handleDispatchSend(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
if tenant == nil {
s.redirect(w, r, "/plan")
@@ -454,7 +492,11 @@ func (s *Server) handleDispatchSend(w http.ResponseWriter, r *http.Request, user
}
config := s.loadSMTPConfig(r.Context(), tenant.ID)
if !config.configured() {
- s.setFlash(w, "Bitte zuerst die SMTP-Parameter in den Einstellungen hinterlegen.", "error")
+ message := "Bitte zuerst die SMTP-Parameter in den Einstellungen hinterlegen."
+ if !s.store.CanManageSecrets(r.Context(), user, tenant.ID) {
+ message = "SMTP-Zugangsdaten können nur Redakteure hinterlegen. Nutzen Sie das E-Mail-Programm oder das Druck-PDF."
+ }
+ s.setFlash(w, message, "error")
s.redirect(w, r, "/dispatch?start="+domain.Key(form.Range.Start)+"&end="+domain.Key(form.Range.End))
return
}
@@ -505,7 +547,7 @@ func (s *Server) handleDispatchSend(w http.ResponseWriter, r *http.Request, user
TenantID: tenant.ID, BatchID: batchID, RangeStart: form.Range.Start,
RangeEnd: form.Range.End, PersonID: person.ID, PersonName: person.FullName(),
Channel: dispatchChannelEmail, Variant: selection.Variant, Cover: false,
- Email: person.Email, CreatedAt: now, CreatedBy: user.DisplayName,
+ CreatedAt: now, CreatedBy: user.DisplayName,
}
if err != nil {
failed++
@@ -634,7 +676,7 @@ func (s *Server) handleDispatchPrint(w http.ResponseWriter, r *http.Request, use
TenantID: tenant.ID, BatchID: batchID, RangeStart: form.Range.Start,
RangeEnd: form.Range.End, PersonID: recipient.Person.ID,
PersonName: recipient.Person.FullName(), Channel: dispatchChannelPrint,
- Variant: recipient.Variant, Cover: recipient.Cover, Email: recipient.Person.Email,
+ Variant: recipient.Variant, Cover: recipient.Cover,
Status: "pdf", Detail: "Druck-PDF erzeugt", CreatedAt: now, CreatedBy: user.DisplayName,
})
}
@@ -665,14 +707,18 @@ func parseTimeLabel(label string) int {
}
func (s *Server) loadSMTPConfig(ctx context.Context, tenantID string) smtpConfig {
- port, _ := strconv.Atoi(strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.port")))
+ value := func(key string) string {
+ raw, _ := s.store.SecretValue(ctx, tenantID, store.ScopeTenant, tenantID, key)
+ return raw
+ }
+ port, _ := strconv.Atoi(strings.TrimSpace(value("smtp.port")))
return smtpConfig{
- Host: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.host")),
+ Host: strings.TrimSpace(value("smtp.host")),
Port: port,
- Username: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.username")),
- Password: s.store.TenantSetting(ctx, tenantID, "smtp.password"),
- FromAddress: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.fromAddress")),
- FromName: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.fromName")),
- Encryption: strings.TrimSpace(s.store.TenantSetting(ctx, tenantID, "smtp.encryption")),
+ Username: strings.TrimSpace(value("smtp.username")),
+ Password: value("smtp.password"),
+ FromAddress: strings.TrimSpace(value("smtp.fromAddress")),
+ FromName: strings.TrimSpace(value("smtp.fromName")),
+ Encryption: strings.TrimSpace(value("smtp.encryption")),
}
}
diff --git a/web/web/dispatch_test.go b/web/web/dispatch_test.go
index d0c3acf..02b6aa8 100644
--- a/web/web/dispatch_test.go
+++ b/web/web/dispatch_test.go
@@ -7,6 +7,8 @@ import (
"net/url"
"strings"
"testing"
+
+ "lektorenplan/store"
)
// dispatchRange is a range with seeded demo services and liturgical days.
@@ -218,18 +220,39 @@ func TestEditorManagesTenantSMTP(t *testing.T) {
tenants, _ := st.Tenants(ctx)
found := false
for _, tenant := range tenants {
- if st.TenantSetting(ctx, tenant.ID, "smtp.host") == "smtp.example.org" {
+ if got := st.TenantSetting(ctx, tenant.ID, "smtp.host"); got == "smtp.example.org" {
+ t.Fatalf("SMTP host was stored as plaintext tenant setting")
+ }
+ if st.SecretExists(ctx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.host") {
found = true
- if got := st.TenantSetting(ctx, tenant.ID, "smtp.port"); got != "587" {
- t.Fatalf("smtp port = %q", got)
+ if !st.SecretIsInitialized(ctx, tenant.ID) {
+ t.Fatal("tenant secrets are not marked as initialized")
}
- if got := st.TenantSetting(ctx, tenant.ID, "smtp.password"); got != "secret" {
- t.Fatalf("smtp password = %q", got)
+ editor, err := st.UserByUsername(ctx, "editor")
+ if err != nil {
+ t.Fatalf("editor account: %v", err)
+ }
+ keyring, err := st.EnsureUserKeys(ctx, editor.ID, "editor1231")
+ if err != nil {
+ t.Fatalf("unlock editor keys: %v", err)
+ }
+ if err := st.UnlockAccessibleKeys(ctx, keyring); err != nil {
+ t.Fatalf("unwrap data keys: %v", err)
+ }
+ secretCtx := store.WithKeyring(ctx, keyring)
+ if got, ok := st.SecretValue(secretCtx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.host"); !ok || got != "smtp.example.org" {
+ t.Fatalf("smtp host = %q, ok=%v", got, ok)
+ }
+ if got, ok := st.SecretValue(secretCtx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.port"); !ok || got != "587" {
+ t.Fatalf("smtp port = %q, ok=%v", got, ok)
+ }
+ if got, ok := st.SecretValue(secretCtx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password"); !ok || got != "secret" {
+ t.Fatalf("smtp password = %q, ok=%v", got, ok)
}
}
}
if !found {
- t.Fatal("SMTP host was not stored as a tenant setting")
+ t.Fatal("SMTP host was not stored as an encrypted secret")
}
// The dispatch page now reports a ready SMTP configuration.
@@ -237,6 +260,12 @@ func TestEditorManagesTenantSMTP(t *testing.T) {
if !strings.Contains(page, "SMTP bereit") {
t.Fatal("dispatch page does not reflect the SMTP configuration")
}
+ if !strings.Contains(page, `formaction="/dispatch/send"`) {
+ t.Fatal("dispatch page does not offer direct sending with SMTP configured")
+ }
+ if strings.Contains(page, "data-mailto-link") {
+ t.Fatal("dispatch page must not offer mailto drafts when SMTP is configured")
+ }
// Readers may not change these settings.
reader := newClient(t)
@@ -247,6 +276,49 @@ func TestEditorManagesTenantSMTP(t *testing.T) {
}
}
+func TestDispatchMailtoEncodesDraft(t *testing.T) {
+ href := dispatchMailto("anna.berg@example.org", "Plan März", "Hallo & Grüße\nZeile 2")
+ if !strings.HasPrefix(href, "mailto:") {
+ t.Fatalf("mailto link = %q", href)
+ }
+ if !strings.Contains(href, "subject=Plan%20M%C3%A4rz") {
+ t.Fatalf("subject is not encoded: %q", href)
+ }
+ body := "body=Hallo%20%26%20Gr%C3%BC%C3%9Fe%0D%0AZeile%202"
+ if !strings.Contains(href, body) {
+ t.Fatalf("body is not encoded: %q", href)
+ }
+ if strings.Contains(href, "+") {
+ t.Fatalf("mailto link must not use plus signs for spaces: %q", href)
+ }
+}
+
+func TestDispatchOffersMailtoAndCopyWithoutSMTP(t *testing.T) {
+ ts, _ := newTestServer(t)
+ client := newClient(t)
+ login(t, client, ts.URL, "editor", "editor123")
+
+ body := get(t, client, ts.URL+"/dispatch?"+dispatchRange, http.StatusOK)
+ if !strings.Contains(body, "Kein SMTP-Konto hinterlegt") {
+ t.Fatal("dispatch page is missing the mailto fallback notice")
+ }
+ if strings.Contains(body, `formaction="/dispatch/send"`) {
+ t.Fatal("dispatch page must not offer direct sending without SMTP")
+ }
+ if !strings.Contains(body, "data-copy-person") {
+ t.Fatal("dispatch page is missing per-person copy controls")
+ }
+ if !strings.Contains(body, "data-copy-shared") {
+ t.Fatal("dispatch page is missing the shared-text copy control")
+ }
+ if !strings.Contains(body, "data-mailto-link") || !strings.Contains(body, `data-mailto-email="anna.berg@example.org"`) {
+ t.Fatal("dispatch page is missing the mailto fallback for recipients")
+ }
+ if !strings.Contains(body, "mailto:anna.berg@example.org?subject=") {
+ t.Fatal("dispatch page is missing a prepared mailto link")
+ }
+}
+
func TestGuestAccessIsReadOnlyAndAnonymous(t *testing.T) {
ts, st := newTestServer(t)
client := newClient(t)
diff --git a/web/web/exchange_handlers.go b/web/web/exchange_handlers.go
index 2f4ecba..db00a06 100644
--- a/web/web/exchange_handlers.go
+++ b/web/web/exchange_handlers.go
@@ -112,6 +112,7 @@ func (s *Server) handleImport(w http.ResponseWriter, r *http.Request, user *stor
return
}
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "lastExchangeImport", time.Now().UTC().Format(time.RFC3339))
+ s.refreshCachedKeyrings(r.Context())
s.setFlash(w, importMessage(summary), "success")
s.redirect(w, r, "/exchange")
return
diff --git a/web/web/keyring_handlers.go b/web/web/keyring_handlers.go
new file mode 100644
index 0000000..2e92fb4
--- /dev/null
+++ b/web/web/keyring_handlers.go
@@ -0,0 +1,268 @@
+package web
+
+import (
+ "context"
+ "log"
+ "net/http"
+ "net/url"
+
+ "lektorenplan/store"
+)
+
+// Keyrings are only kept in memory. A server restart therefore locks all
+// encrypted data until every account unlocks its keys again.
+
+func (s *Server) keyringForSession(sessionID string) *store.Keyring {
+ s.keyMu.Lock()
+ defer s.keyMu.Unlock()
+ return s.keyrings[sessionID]
+}
+
+func (s *Server) cacheKeyring(sessionID string, keyring *store.Keyring) {
+ if keyring == nil {
+ return
+ }
+ s.keyMu.Lock()
+ defer s.keyMu.Unlock()
+ s.keyrings[sessionID] = keyring
+}
+
+func (s *Server) dropSessionKeyring(sessionID string) {
+ s.keyMu.Lock()
+ defer s.keyMu.Unlock()
+ delete(s.keyrings, sessionID)
+}
+
+func (s *Server) dropUserKeyrings(userID string) {
+ s.keyMu.Lock()
+ defer s.keyMu.Unlock()
+ for sessionID, keyring := range s.keyrings {
+ if keyring.UserID == userID {
+ delete(s.keyrings, sessionID)
+ }
+ }
+}
+
+// refreshCachedKeyrings unwraps data keys that were granted while an account
+// was already signed in. It keeps other open sessions usable without forcing
+// them to sign out and in again.
+func (s *Server) refreshCachedKeyrings(ctx context.Context) {
+ s.keyMu.Lock()
+ keyrings := make([]*store.Keyring, 0, len(s.keyrings))
+ for _, keyring := range s.keyrings {
+ if keyring != nil {
+ keyrings = append(keyrings, keyring)
+ }
+ }
+ s.keyMu.Unlock()
+ for _, keyring := range keyrings {
+ if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
+ log.Printf("keyring: refresh session of %s: %v", keyring.UserID, err)
+ }
+ }
+}
+
+// activeEditorKeyring returns any unlocked editor keyring from the in-memory
+// session cache. It lets an administrator trigger a re-grant after a password
+// reset without ever decrypting the data themselves.
+func (s *Server) activeEditorKeyring(ctx context.Context) *store.Keyring {
+ s.keyMu.Lock()
+ candidates := make([]*store.Keyring, 0, len(s.keyrings))
+ for _, keyring := range s.keyrings {
+ if keyring != nil {
+ candidates = append(candidates, keyring)
+ }
+ }
+ s.keyMu.Unlock()
+ for _, keyring := range candidates {
+ user, err := s.store.User(ctx, keyring.UserID)
+ if err != nil || !user.Active || user.Role != store.RoleEditor {
+ continue
+ }
+ return keyring
+ }
+ return nil
+}
+
+// canHoldKeys reports whether an account may have key material. Editors and
+// readers decrypt data with a password-derived key; administrators never do.
+func canHoldKeys(user *store.User) bool {
+ return user != nil && (user.Role == store.RoleEditor || user.Role == store.RoleReader)
+}
+
+// needsUnlock reports whether the session's account has key material but the
+// keyring has not been unlocked since the server started. Editors hold keys
+// for all contacts and SMTP, readers for their own e-mail address.
+func (s *Server) needsUnlock(ctx context.Context, session *store.Session, user *store.User) bool {
+ if user.Role != store.RoleEditor && user.Role != store.RoleReader {
+ return false
+ }
+ if s.keyringForSession(session.ID) != nil {
+ return false
+ }
+ if !s.store.HasUserKeys(ctx, user.ID) {
+ return false
+ }
+ if user.Role == store.RoleReader {
+ // A reader without a granted scope has nothing to decrypt yet.
+ scopes, err := s.store.ScopesForUser(ctx, user.ID)
+ if err != nil || len(scopes) == 0 {
+ return false
+ }
+ }
+ return true
+}
+
+// activateKeyring derives the user's key encryption key from the login
+// password and unwraps all granted data keys. Editors then refresh the tenant
+// scopes; a reader refreshes editor access to their own e-mail address, which
+// also grants addresses to editors created since the last reader login.
+func (s *Server) activateKeyring(ctx context.Context, user *store.User, password string) (*store.Keyring, error) {
+ if user.Role != store.RoleEditor && user.Role != store.RoleReader {
+ return nil, nil
+ }
+ keyring, err := s.store.EnsureUserKeys(ctx, user.ID, password)
+ if err != nil {
+ return nil, err
+ }
+ if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
+ return nil, err
+ }
+ if user.Role == store.RoleEditor {
+ s.syncTenantKeys(ctx, user, keyring)
+ } else {
+ s.syncReaderKeys(ctx, user, keyring)
+ }
+ return keyring, nil
+}
+
+func (s *Server) syncReaderKeys(ctx context.Context, user *store.User, keyring *store.Keyring) {
+ if user.Role != store.RoleReader || keyring == nil {
+ return
+ }
+ if user.LinkedTenantID == "" || user.LinkedPersonID == "" {
+ return
+ }
+ if !s.store.SecretIsInitialized(ctx, user.LinkedTenantID) {
+ return
+ }
+ // A reader can only refresh editor access while holding their own data
+ // key. Without it, an unlocked editor session grants the scope first and
+ // the reader can then unwrap it.
+ if err := s.store.EnsurePersonScope(ctx, keyring, user.LinkedTenantID, user.LinkedPersonID); err != nil {
+ log.Printf("keyring: refresh reader scope %s: %v", user.LinkedPersonID, err)
+ actor := s.activeEditorKeyring(ctx)
+ if actor == nil {
+ return
+ }
+ if err := s.store.EnsurePersonScope(ctx, actor, user.LinkedTenantID, user.LinkedPersonID); err != nil {
+ log.Printf("keyring: editor grant for reader %s: %v", user.LinkedPersonID, err)
+ return
+ }
+ if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
+ log.Printf("keyring: unlock reader after grant %s: %v", user.LinkedPersonID, err)
+ }
+ }
+ s.refreshCachedKeyrings(ctx)
+}
+
+func (s *Server) syncTenantKeys(ctx context.Context, user *store.User, keyring *store.Keyring) {
+ if user.Role != store.RoleEditor || keyring == nil {
+ return
+ }
+ tenants, err := s.store.TenantsForUser(ctx, user)
+ if err != nil {
+ log.Printf("keyring: load tenants: %v", err)
+ return
+ }
+ for _, tenant := range tenants {
+ if !s.store.CanManageSecrets(ctx, user, tenant.ID) {
+ continue
+ }
+ // Reconcile first so a newly created editor receives access to every
+ // person scope before the migration needs to read those scopes.
+ if err := s.store.ReconcileTenant(ctx, keyring, tenant.ID); err != nil {
+ // A newly created editor cannot unwrap the existing data keys.
+ // Another unlocked editor grants them and the new session reloads
+ // the wrappers.
+ actor := s.activeEditorKeyring(ctx)
+ if actor == nil || actor.UserID == keyring.UserID {
+ log.Printf("keyring: reconcile tenant %s: %v", tenant.ID, err)
+ continue
+ }
+ if err := s.store.ReconcileTenant(ctx, actor, tenant.ID); err != nil {
+ log.Printf("keyring: grant tenant %s from editor %s: %v", tenant.ID, actor.UserID, err)
+ continue
+ }
+ if err := s.store.UnlockAccessibleKeys(ctx, keyring); err != nil {
+ log.Printf("keyring: unlock new editor %s: %v", user.ID, err)
+ continue
+ }
+ }
+ if err := s.store.BootstrapTenant(ctx, keyring, tenant.ID); err != nil {
+ log.Printf("keyring: bootstrap tenant %s: %v", tenant.ID, err)
+ }
+ }
+ // Other editors or readers who are already signed in may have received
+ // new wrappers from this reconcile.
+ s.refreshCachedKeyrings(ctx)
+}
+
+// grantAccountScopes grants existing data keys to an account after its role or
+// memberships changed. ReconcileTenant includes the linked reader of every
+// person, so a newly linked reader receives their own scope while other
+// accounts stay excluded.
+func (s *Server) grantAccountScopes(ctx context.Context, actor *store.Keyring, tenantIDs []string) {
+ if actor == nil {
+ return
+ }
+ seen := map[string]bool{}
+ for _, tenantID := range tenantIDs {
+ if tenantID == "" || seen[tenantID] || !s.store.SecretIsInitialized(ctx, tenantID) {
+ continue
+ }
+ seen[tenantID] = true
+ if err := s.store.ReconcileTenant(ctx, actor, tenantID); err != nil {
+ log.Printf("keyring: grant scopes for tenant %s: %v", tenantID, err)
+ }
+ }
+ s.refreshCachedKeyrings(ctx)
+}
+
+type unlockPageData struct {
+ Next string
+}
+
+func (s *Server) handleUnlockGet(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
+ next := safeNext(r.URL.Query().Get("next"))
+ if !canHoldKeys(user) || s.keyringForSession(session.ID) != nil {
+ s.redirect(w, r, next)
+ return
+ }
+ data := s.baseView(w, r, "Daten entsperren", "")
+ data.Data = unlockPageData{Next: next}
+ s.renderPage(w, r, "unlock", data)
+}
+
+func (s *Server) handleUnlockPost(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
+ next := safeNext(r.FormValue("next"))
+ if !canHoldKeys(user) {
+ s.redirect(w, r, next)
+ return
+ }
+ password := r.FormValue("password")
+ if _, err := s.store.Authenticate(r.Context(), user.Username, password); err != nil {
+ s.setFlash(w, "Das Passwort ist nicht korrekt.", "error")
+ s.redirect(w, r, "/unlock?next="+url.QueryEscape(next))
+ return
+ }
+ keyring, err := s.activateKeyring(r.Context(), user, password)
+ if err != nil {
+ s.setFlash(w, "Die gespeicherten Daten konnten nicht entsperrt werden: "+err.Error(), "error")
+ s.redirect(w, r, "/unlock?next="+url.QueryEscape(next))
+ return
+ }
+ s.cacheKeyring(session.ID, keyring)
+ s.setFlash(w, "Die verschlüsselten Daten sind entsperrt.", "success")
+ s.redirect(w, r, next)
+}
diff --git a/web/web/password_handlers.go b/web/web/password_handlers.go
index d0c8c21..278cdfe 100644
--- a/web/web/password_handlers.go
+++ b/web/web/password_handlers.go
@@ -18,57 +18,61 @@ func (s *Server) handlePasswordGet(w http.ResponseWriter, r *http.Request, user
}
func (s *Server) handlePasswordChange(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
- current := r.FormValue("current_password")
- next := r.FormValue("new_password")
- confirm := r.FormValue("confirm_password")
- if _, err := s.store.Authenticate(r.Context(), user.Username, current); err != nil {
- s.setFlash(w, "Das aktuelle Passwort ist nicht korrekt.", "error")
- s.redirect(w, r, "/password")
- return
- }
- if strings.TrimSpace(next) != next || len(next) < 6 {
- s.setFlash(w, "Das neue Passwort muss mindestens 6 Zeichen lang sein.", "error")
- s.redirect(w, r, "/password")
- return
- }
- if next != confirm {
- s.setFlash(w, "Die beiden neuen Passwörter stimmen nicht überein.", "error")
- s.redirect(w, r, "/password")
- return
- }
- if err := s.store.SetUserPassword(r.Context(), user.ID, next, false); err != nil {
- s.setFlash(w, "Das Passwort konnte nicht gespeichert werden: "+err.Error(), "error")
- s.redirect(w, r, "/password")
- return
- }
- s.setFlash(w, "Ihr Passwort wurde geändert.", "success")
- s.redirect(w, r, "/plan")
+ s.changePassword(w, r, user, session, "/password", "/plan")
}
func (s *Server) handleSettingsPassword(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
+ s.changePassword(w, r, user, session, "/settings", "/settings")
+}
+
+// changePassword verifies the current password, rewraps the key material for
+// the new password and finally stores the new bcrypt hash.
+func (s *Server) changePassword(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, back, success string) {
current := r.FormValue("current_password")
next := r.FormValue("new_password")
confirm := r.FormValue("confirm_password")
if _, err := s.store.Authenticate(r.Context(), user.Username, current); err != nil {
s.setFlash(w, "Das aktuelle Passwort ist nicht korrekt.", "error")
- s.redirect(w, r, "/settings")
+ s.redirect(w, r, back)
return
}
- if strings.TrimSpace(next) != next || len(next) < 6 {
- s.setFlash(w, "Das neue Passwort muss mindestens 6 Zeichen lang sein.", "error")
- s.redirect(w, r, "/settings")
+ if strings.TrimSpace(next) != next || len(next) < 6 || len(next) > 72 {
+ s.setFlash(w, "Das neue Passwort muss mindestens 6 und höchstens 72 Zeichen lang sein.", "error")
+ s.redirect(w, r, back)
return
}
if next != confirm {
s.setFlash(w, "Die beiden neuen Passwörter stimmen nicht überein.", "error")
- s.redirect(w, r, "/settings")
+ s.redirect(w, r, back)
+ return
+ }
+ if user.Role != store.RoleEditor && user.Role != store.RoleReader {
+ _ = s.store.DeleteUserKeys(r.Context(), user.ID)
+ if err := s.store.SetUserPassword(r.Context(), user.ID, next, false); err != nil {
+ s.setFlash(w, "Das Passwort konnte nicht gespeichert werden: "+err.Error(), "error")
+ s.redirect(w, r, back)
+ return
+ }
+ s.dropSessionKeyring(session.ID)
+ s.setFlash(w, "Ihr Passwort wurde geändert.", "success")
+ s.redirect(w, r, success)
+ return
+ }
+ keyring, err := s.store.RekeyUserPassword(r.Context(), user.ID, current, next)
+ if err != nil {
+ s.setFlash(w, "Die Schlüssel konnten nicht auf das neue Passwort umgestellt werden: "+err.Error(), "error")
+ s.redirect(w, r, back)
return
}
if err := s.store.SetUserPassword(r.Context(), user.ID, next, false); err != nil {
+ // Keep the key material usable with the old password if the hash
+ // could not be updated.
+ _, _ = s.store.RekeyUserPassword(r.Context(), user.ID, next, current)
s.setFlash(w, "Das Passwort konnte nicht gespeichert werden: "+err.Error(), "error")
- s.redirect(w, r, "/settings")
+ s.redirect(w, r, back)
return
}
+ s.cacheKeyring(session.ID, keyring)
s.setFlash(w, "Ihr Passwort wurde geändert.", "success")
- s.redirect(w, r, "/settings")
+ s.redirect(w, r, success)
}
diff --git a/web/web/render.go b/web/web/render.go
index 7c12a01..b7f2e8b 100644
--- a/web/web/render.go
+++ b/web/web/render.go
@@ -403,6 +403,7 @@ var iconPaths = map[string]string{
"printer": `
Hinterlegen Sie die SMTP-Zugangsdaten in den Einstellungen, damit E-Mails direkt verschickt werden können. Ausdrucke funktionieren bereits ohne SMTP.
+ {{if .Data.CanManageSecrets}} + Kein SMTP-Konto hinterlegt – Versand über Ihr E-Mail-Programm +Ohne SMTP-Zugangsdaten kann die App keine E-Mails direkt versenden. Öffnen Sie je Person das E-Mail-Symbol in der Spalte „Text“, um einen fertigen Entwurf im eigenen E-Mail-Programm zu starten, oder kopieren Sie den Text über das Kopier-Symbol. Das Druck-PDF erzeugen Sie anschließend über „Druck-PDF erzeugen“ und hängen es manuell an. SMTP-Daten lassen sich jederzeit in den Einstellungen hinterlegen.
+ {{icon "settings"}} Zu den Einstellungen + {{else}} + Direkter E-Mail-Versand ist für dieses Konto nicht verfügbar +SMTP-Zugangsdaten und die E-Mail-Adressen der Empfänger werden ausschließlich von Redakteuren verwaltet. Sie können das Druck-PDF mit den gewählten Listen erzeugen und die Empfänger außerhalb der App informieren. Für den Text steht das Kopier-Symbol in der Spalte „Text“ bereit.
+ {{end}}