SMTP-Credentials und E_Mail-Adressen verschlüsselt abgelegt

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

No files matched your search

+35 -2
View File
@@ -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
+1 -1
View File
@@ -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"`
+9
View File
@@ -247,6 +247,15 @@ func (s *Store) CreateUser(ctx context.Context, username, displayName, password
return nil, err
}
user.TenantIDs = tenantIDs
// Editors need keys for SMTP and all contacts, readers for their own
// e-mail address. Administrators deliberately receive no key material.
// The keypair is protected by the initial password; the first login
// replaces that protection with the account holder's own password.
if role == RoleEditor || role == RoleReader {
if _, err := s.createUserKeys(ctx, user.ID, password); err != nil {
return nil, err
}
}
return user, nil
}
+155
View File
@@ -0,0 +1,155 @@
package store
import (
"crypto/aes"
"crypto/cipher"
"crypto/ecdh"
"crypto/rand"
"crypto/sha256"
"errors"
"fmt"
"io"
"golang.org/x/crypto/argon2"
"golang.org/x/crypto/hkdf"
)
// Key derivation parameters. The version string is stored with every user key
// so the parameters can be changed later without breaking existing data.
const (
kdfVersion = "argon2id-v1"
kdfSaltBytes = 16
keyBytes = 32
)
var (
errKeyLocked = errors.New("Verschlüsselung ist gesperrt")
errNoKeyAccess = errors.New("kein Zugriff auf diesen Datenschlüssel")
)
func deriveUserKEK(password string, salt []byte) []byte {
return argon2.IDKey([]byte(password), salt, 3, 64*1024, 2, keyBytes)
}
func newSalt() ([]byte, error) {
salt := make([]byte, kdfSaltBytes)
if _, err := io.ReadFull(rand.Reader, salt); err != nil {
return nil, err
}
return salt, nil
}
func newDEK() ([]byte, error) {
key := make([]byte, keyBytes)
if _, err := io.ReadFull(rand.Reader, key); err != nil {
return nil, err
}
return key, nil
}
func sealAESGCM(key, plaintext, additionalData []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
return nil, err
}
return gcm.Seal(nonce, nonce, plaintext, additionalData), nil
}
func openAESGCM(key, sealed, additionalData []byte) ([]byte, error) {
block, err := aes.NewCipher(key)
if err != nil {
return nil, err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, err
}
if len(sealed) < gcm.NonceSize() {
return nil, errors.New("verschlüsselter Wert ist unvollständig")
}
nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
return gcm.Open(nil, nonce, ciphertext, additionalData)
}
// wrapDEK encrypts a data key for the recipient's X25519 public key using an
// ephemeral key and HKDF. The scope is bound as additional data so a wrapper
// cannot be moved to a different tenant or person.
func wrapDEK(recipientPublic, dek []byte, scope string) (ephemeralPublic, wrapped []byte, err error) {
curve := ecdh.X25519()
publicKey, err := curve.NewPublicKey(recipientPublic)
if err != nil {
return nil, nil, err
}
ephemeral, err := curve.GenerateKey(rand.Reader)
if err != nil {
return nil, nil, err
}
shared, err := ephemeral.ECDH(publicKey)
if err != nil {
return nil, nil, err
}
salt := append(append([]byte{}, ephemeral.PublicKey().Bytes()...), recipientPublic...)
wrappingKey, err := hkdfKey(shared, salt, "lektorenplan-dek-wrap-v1")
if err != nil {
return nil, nil, err
}
wrapped, err = sealAESGCM(wrappingKey, dek, []byte(scope))
if err != nil {
return nil, nil, err
}
return ephemeral.PublicKey().Bytes(), wrapped, nil
}
func unwrapDEK(privateKey, ephemeralPublic, wrapped []byte, scope string) ([]byte, error) {
curve := ecdh.X25519()
private, err := curve.NewPrivateKey(privateKey)
if err != nil {
return nil, err
}
ephemeral, err := curve.NewPublicKey(ephemeralPublic)
if err != nil {
return nil, err
}
shared, err := private.ECDH(ephemeral)
if err != nil {
return nil, err
}
salt := append(append([]byte{}, ephemeralPublic...), private.PublicKey().Bytes()...)
wrappingKey, err := hkdfKey(shared, salt, "lektorenplan-dek-wrap-v1")
if err != nil {
return nil, err
}
return openAESGCM(wrappingKey, wrapped, []byte(scope))
}
func hkdfKey(secret, salt []byte, info string) ([]byte, error) {
reader := hkdf.New(sha256.New, secret, salt, []byte(info))
key := make([]byte, keyBytes)
if _, err := io.ReadFull(reader, key); err != nil {
return nil, err
}
return key, nil
}
func keyAAD(parts ...string) []byte {
return []byte(fmt.Sprintf("lektorenplan-secret-v1|%s", joinKeyParts(parts)))
}
func joinKeyParts(parts []string) string {
out := ""
for index, part := range parts {
if index > 0 {
out += "\x00"
}
out += part
}
return out
}
+81 -2
View File
@@ -139,7 +139,6 @@ CREATE TABLE IF NOT EXISTS people (
last_name TEXT NOT NULL,
roles TEXT NOT NULL,
email TEXT NOT NULL DEFAULT '',
phone TEXT NOT NULL DEFAULT '',
preferred_church_ids TEXT NOT NULL DEFAULT '[]',
preferred_weekdays TEXT NOT NULL DEFAULT '[]',
preferred_service_titles TEXT NOT NULL DEFAULT '[]',
@@ -279,6 +278,43 @@ CREATE TABLE IF NOT EXISTS dispatch_log (
created_by TEXT NOT NULL DEFAULT ''
);
CREATE INDEX IF NOT EXISTS idx_dispatch_log_tenant ON dispatch_log(tenant_id, created_at);
CREATE TABLE IF NOT EXISTS user_keys (
user_id TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
kdf_salt BLOB NOT NULL,
kdf_version TEXT NOT NULL,
public_key BLOB NOT NULL,
wrapped_private BLOB NOT NULL,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS key_wrappers (
scope_type TEXT NOT NULL,
tenant_id TEXT NOT NULL,
scope_id TEXT NOT NULL,
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
ephemeral_public BLOB NOT NULL,
wrapped_dek BLOB NOT NULL,
created_at TEXT NOT NULL,
PRIMARY KEY (scope_type, tenant_id, scope_id, user_id)
);
CREATE INDEX IF NOT EXISTS idx_key_wrappers_user ON key_wrappers(user_id);
CREATE TABLE IF NOT EXISTS secrets (
tenant_id TEXT NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
scope_type TEXT NOT NULL,
scope_id TEXT NOT NULL,
secret_key TEXT NOT NULL,
ciphertext BLOB NOT NULL,
updated_at TEXT NOT NULL,
PRIMARY KEY (tenant_id, scope_type, scope_id, secret_key)
);
CREATE TABLE IF NOT EXISTS secret_state (
tenant_id TEXT PRIMARY KEY REFERENCES tenants(id) ON DELETE CASCADE,
initialized_at TEXT NOT NULL
);
`
func (s *Store) migrate(ctx context.Context) error {
@@ -309,10 +345,53 @@ func (s *Store) migrate(ctx context.Context) error {
}
}
if _, err := s.db.ExecContext(ctx,
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '3') "+
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '5') "+
"ON CONFLICT(key) DO UPDATE SET value=excluded.value"); err != nil {
return fmt.Errorf("record schema version: %w", err)
}
// Phone numbers are no longer stored anywhere in the web app. Remove both
// the encrypted values and the legacy plaintext column.
if _, err := s.db.ExecContext(ctx,
"DELETE FROM secrets WHERE secret_key='phone'"); err != nil {
return fmt.Errorf("remove encrypted phone numbers: %w", err)
}
hasPhone, err := s.hasColumn(ctx, "people", "phone")
if err != nil {
return fmt.Errorf("inspect people table: %w", err)
}
if hasPhone {
if _, err := s.db.ExecContext(ctx, "ALTER TABLE people DROP COLUMN phone"); err != nil {
return fmt.Errorf("drop people.phone: %w", err)
}
}
// Editors and linked readers hold key material; administrators never do.
// Readers may only keep the scope of their linked person.
if _, err := s.db.ExecContext(ctx,
"DELETE FROM key_wrappers WHERE user_id IN (SELECT id FROM users WHERE role='admin')"); err != nil {
return fmt.Errorf("prune administrator key wrappers: %w", err)
}
if _, err := s.db.ExecContext(ctx,
"DELETE FROM user_keys WHERE user_id IN (SELECT id FROM users WHERE role='admin')"); err != nil {
return fmt.Errorf("prune administrator keys: %w", err)
}
if _, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE user_id IN (
SELECT u.id FROM users u WHERE u.role='reader' AND (
u.linked_tenant_id='' OR u.linked_person_id='' OR NOT (
key_wrappers.scope_type='person'
AND key_wrappers.tenant_id=u.linked_tenant_id
AND key_wrappers.scope_id=u.linked_person_id
)
)
)`); err != nil {
return fmt.Errorf("prune unlinked reader key wrappers: %w", err)
}
// Dispatch logs used to contain the full recipient address. Remove that
// plaintext now that addresses are stored encrypted.
if _, err := s.db.ExecContext(ctx,
"UPDATE dispatch_log SET email='' WHERE email<>''"); err != nil {
return fmt.Errorf("redact dispatch log: %w", err)
}
return nil
}
+3 -3
View File
@@ -73,17 +73,17 @@ func badGodesbergSpec() demoTenantSpec {
people := []domain.Person{
{ID: "p-anna", FirstName: "Anna", LastName: "Berg", Roles: []domain.Role{domain.RoleLector},
Email: "anna.berg@example.org", Phone: "0228 555 0101",
Email: "anna.berg@example.org",
PreferredChurchIDs: []string{"c-andreas"}, PreferredWeekdays: []int{1},
PreferredServiceTitles: []string{"Hochamt"}, MaxPerMonth: 7, Active: true,
Notes: "Liest besonders gerne die Sonntagslesungen."},
{ID: "p-markus", FirstName: "Markus", LastName: "Weber", Roles: []domain.Role{domain.RoleLector},
Email: "markus.weber@example.org", Phone: "0228 555 0102",
Email: "markus.weber@example.org",
PreferredChurchIDs: []string{"c-herzjesu"}, PreferredWeekdays: []int{1, 7},
PreferredServiceTitles: []string{"Vorabendmesse"}, MaxPerMonth: 8, Active: true},
{ID: "p-elisabeth", FirstName: "Elisabeth", LastName: "Klein",
Roles: []domain.Role{domain.RoleLector, domain.RoleHelper},
Email: "elisabeth.klein@example.org", Phone: "0228 555 0103",
Email: "elisabeth.klein@example.org",
MaxPerMonth: 9, Active: true, Notes: "Flexibel einsetzbar, auch kurzfristig."},
{ID: "p-johannes", FirstName: "Johannes", LastName: "Schmitz", Roles: []domain.Role{domain.RoleLector},
Email: "johannes.schmitz@example.org", PreferredChurchIDs: []string{"c-evergislus"},
+12
View File
@@ -5,6 +5,7 @@ import (
"encoding/json"
"errors"
"fmt"
"strings"
"time"
"lektorenplan/domain"
@@ -92,6 +93,12 @@ func (s *Store) ExportResources(ctx context.Context, tenantID string) (PlanExcha
if err != nil {
return PlanExchange{}, err
}
// Contact details are only stored encrypted and tied to accounts. They are
// deliberately left out of exchange files.
for index := range people {
people[index].Email = ""
people[index].EmailLocked = false
}
absences, err := s.Absences(ctx, tenantID)
if err != nil {
return PlanExchange{}, err
@@ -198,6 +205,11 @@ func (s *Store) ApplyExchange(ctx context.Context, tenantID string, exchange Pla
}
}
for _, person := range exchange.Resources.People {
// Exchange files never carry contact details. Keep any encrypted
// values that already exist instead of deleting them on import.
if strings.TrimSpace(person.Email) == "" {
person.EmailLocked = true
}
if err := s.UpsertPerson(ctx, tenantID, person); err != nil {
return ExchangeSummary{}, err
}
+912
View File
@@ -0,0 +1,912 @@
package store
import (
"context"
"crypto/ecdh"
"crypto/rand"
"database/sql"
"errors"
"fmt"
"strings"
"sync"
"time"
)
// KeyScope identifies one encrypted data scope. Tenant scopes hold the SMTP
// credentials, person scopes hold e-mail addresses. Editors hold the person
// scopes of their tenants; a reader only holds the scope of the person linked
// to their account.
type KeyScope struct {
Type string
TenantID string
ID string
}
func (s KeyScope) String() string {
return s.Type + "|" + s.TenantID + "|" + s.ID
}
const (
ScopeTenant = "tenant"
ScopePerson = "person"
)
// Keyring holds the decrypted private key of one user and the data keys that
// were unlocked during this login. It is only kept in memory.
type Keyring struct {
UserID string
privateKey []byte
mu sync.RWMutex
deks map[string][]byte
}
func newKeyring(userID string, privateKey []byte) *Keyring {
return &Keyring{
UserID: userID,
privateKey: privateKey,
deks: map[string][]byte{},
}
}
// DEK returns a cached data key.
func (k *Keyring) DEK(scope KeyScope) ([]byte, bool) {
k.mu.RLock()
defer k.mu.RUnlock()
value, ok := k.deks[scope.String()]
return value, ok
}
func (k *Keyring) remember(scope KeyScope, dek []byte) {
k.mu.Lock()
defer k.mu.Unlock()
k.deks[scope.String()] = append([]byte{}, dek...)
}
type keyringContextKey struct{}
// WithKeyring attaches an unlocked keyring to a request context.
func WithKeyring(ctx context.Context, keyring *Keyring) context.Context {
return context.WithValue(ctx, keyringContextKey{}, keyring)
}
// KeyringFrom returns the request's keyring, or nil when the session is locked.
func KeyringFrom(ctx context.Context) *Keyring {
keyring, _ := ctx.Value(keyringContextKey{}).(*Keyring)
return keyring
}
// EnsureUserKeys creates the user's X25519 keypair on first login and returns
// an unlocked keyring. The private key is protected by a KEK derived from the
// login password.
func (s *Store) EnsureUserKeys(ctx context.Context, userID, password string) (*Keyring, error) {
var salt, publicKey, wrappedPrivate []byte
var version string
err := s.db.QueryRowContext(ctx,
"SELECT kdf_salt, kdf_version, public_key, wrapped_private FROM user_keys WHERE user_id=?",
userID).Scan(&salt, &version, &publicKey, &wrappedPrivate)
switch {
case errors.Is(err, sql.ErrNoRows):
return s.createUserKeys(ctx, userID, password)
case err != nil:
return nil, err
}
if version != kdfVersion {
return nil, fmt.Errorf("unbekannte Schlüsselversion %q", version)
}
kek := deriveUserKEK(password, salt)
privateKey, err := openAESGCM(kek, wrappedPrivate, keyAAD("user-private", userID))
if err != nil {
return nil, errors.New("das Passwort konnte die gespeicherten Schlüssel nicht entsperren")
}
return newKeyring(userID, privateKey), nil
}
func (s *Store) createUserKeys(ctx context.Context, userID, password string) (*Keyring, error) {
salt, err := newSalt()
if err != nil {
return nil, err
}
curve := ecdh.X25519()
private, err := curve.GenerateKey(rand.Reader)
if err != nil {
return nil, err
}
privateKey := private.Bytes()
kek := deriveUserKEK(password, salt)
wrapped, err := sealAESGCM(kek, privateKey, keyAAD("user-private", userID))
if err != nil {
return nil, err
}
now := time.Now().UTC().Format(time.RFC3339)
_, err = s.db.ExecContext(ctx, `
INSERT INTO user_keys(user_id, kdf_salt, kdf_version, public_key, wrapped_private, created_at, updated_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(user_id) DO UPDATE SET
kdf_salt=excluded.kdf_salt, kdf_version=excluded.kdf_version,
public_key=excluded.public_key, wrapped_private=excluded.wrapped_private,
updated_at=excluded.updated_at`,
userID, salt, kdfVersion, private.PublicKey().Bytes(), wrapped, now, now)
if err != nil {
return nil, err
}
return newKeyring(userID, privateKey), nil
}
// HasUserKeys reports whether an account already has key material.
func (s *Store) HasUserKeys(ctx context.Context, userID string) bool {
var count int
err := s.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM user_keys WHERE user_id=?", userID).Scan(&count)
return err == nil && count > 0
}
// UnlockAccessibleKeys unwraps every data key that has been granted to this
// user. Missing wrappers are skipped; the affected pages report locked data.
func (s *Store) UnlockAccessibleKeys(ctx context.Context, keyring *Keyring) error {
if keyring == nil {
return errKeyLocked
}
type wrapperRow struct {
scope KeyScope
ephemeral []byte
wrapped []byte
}
rows, err := s.db.QueryContext(ctx, `
SELECT scope_type, tenant_id, scope_id, ephemeral_public, wrapped_dek
FROM key_wrappers WHERE user_id=?`, keyring.UserID)
if err != nil {
return err
}
var wrappers []wrapperRow
for rows.Next() {
var row wrapperRow
if err := rows.Scan(&row.scope.Type, &row.scope.TenantID, &row.scope.ID,
&row.ephemeral, &row.wrapped); err != nil {
rows.Close()
return err
}
wrappers = append(wrappers, row)
}
if err := rows.Err(); err != nil {
rows.Close()
return err
}
rows.Close()
for _, row := range wrappers {
dek, err := unwrapDEK(keyring.privateKey, row.ephemeral, row.wrapped, row.scope.String())
if err != nil {
continue
}
keyring.remember(row.scope, dek)
}
return nil
}
// SecretIsInitialized reports whether a tenant has been migrated to encrypted
// secrets. Until then the legacy plaintext columns remain readable.
func (s *Store) SecretIsInitialized(ctx context.Context, tenantID string) bool {
var count int
err := s.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM secret_state WHERE tenant_id=?", tenantID).Scan(&count)
return err == nil && count > 0
}
// BootstrapTenant encrypts the legacy plaintext values of one tenant and
// grants the first key holder access. It is idempotent and also migrates
// plaintext that reached the database after the initial migration, for
// example demo data restored by a command-line seeding run.
func (s *Store) BootstrapTenant(ctx context.Context, keyring *Keyring, tenantID string) error {
if s.SecretIsInitialized(ctx, tenantID) {
var legacy int
if err := s.db.QueryRowContext(ctx, `
SELECT (SELECT COUNT(*) FROM people WHERE tenant_id=? AND email<>'')
+ (SELECT COUNT(*) FROM tenant_settings
WHERE tenant_id=? AND key LIKE 'smtp.%')`, tenantID, tenantID).Scan(&legacy); err != nil {
return err
}
if legacy == 0 {
return nil
}
}
tenantScope := KeyScope{Type: ScopeTenant, TenantID: tenantID, ID: tenantID}
if _, err := s.ensureScope(ctx, keyring, tenantScope); err != nil {
return err
}
// Prepare every person scope first so the migration transaction only has
// to write data.
peopleRows, err := s.db.QueryContext(ctx, "SELECT id FROM people WHERE tenant_id=?", tenantID)
if err != nil {
return err
}
var peopleIDs []string
for peopleRows.Next() {
var id string
if err := peopleRows.Scan(&id); err != nil {
peopleRows.Close()
return err
}
peopleIDs = append(peopleIDs, id)
}
if err := peopleRows.Err(); err != nil {
peopleRows.Close()
return err
}
peopleRows.Close()
for _, id := range peopleIDs {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: id}
if _, err := s.ensureScope(ctx, keyring, scope); err != nil {
return err
}
}
tx, err := s.db.BeginTx(ctx, nil)
if err != nil {
return err
}
defer tx.Rollback()
settingsRows, err := tx.QueryContext(ctx,
"SELECT key, value FROM tenant_settings WHERE tenant_id=? AND key LIKE 'smtp.%'", tenantID)
if err != nil {
return err
}
type legacySecret struct {
key string
value string
}
var legacy []legacySecret
for settingsRows.Next() {
var item legacySecret
if err := settingsRows.Scan(&item.key, &item.value); err != nil {
settingsRows.Close()
return err
}
legacy = append(legacy, item)
}
if err := settingsRows.Err(); err != nil {
settingsRows.Close()
return err
}
settingsRows.Close()
tenantDEK, _ := keyring.DEK(tenantScope)
for _, item := range legacy {
if strings.TrimSpace(item.value) != "" {
sealed, err := sealAESGCM(tenantDEK, []byte(item.value),
keyAAD(ScopeTenant, tenantID, tenantID, item.key))
if err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO NOTHING`,
tenantID, ScopeTenant, tenantID, item.key, sealed,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
}
if _, err := tx.ExecContext(ctx,
"DELETE FROM tenant_settings WHERE tenant_id=? AND key=?", tenantID, item.key); err != nil {
return err
}
}
type legacyContact struct {
id, email string
}
contactRows, err := tx.QueryContext(ctx,
"SELECT id, email FROM people WHERE tenant_id=? AND email<>''", tenantID)
if err != nil {
return err
}
var contacts []legacyContact
for contactRows.Next() {
var item legacyContact
if err := contactRows.Scan(&item.id, &item.email); err != nil {
contactRows.Close()
return err
}
contacts = append(contacts, item)
}
if err := contactRows.Err(); err != nil {
contactRows.Close()
return err
}
contactRows.Close()
for _, item := range contacts {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: item.id}
dek, ok := keyring.DEK(scope)
if !ok {
continue
}
if strings.TrimSpace(item.email) == "" {
continue
}
sealed, err := sealAESGCM(dek, []byte(item.email), keyAAD(ScopePerson, tenantID, item.id, "email"))
if err != nil {
return err
}
if _, err := tx.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO NOTHING`,
tenantID, ScopePerson, item.id, "email", sealed,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"UPDATE people SET email='' WHERE tenant_id=? AND id=?", tenantID, item.id); err != nil {
return err
}
}
if _, err := tx.ExecContext(ctx,
"INSERT INTO secret_state(tenant_id, initialized_at) VALUES(?, ?) ON CONFLICT(tenant_id) DO NOTHING",
tenantID, time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
if err := tx.Commit(); err != nil {
return err
}
return s.ReconcileTenant(ctx, keyring, tenantID)
}
// ReconcileTenant creates missing data scopes and grants them to all eligible
// accounts that already have key material. It requires an unlocked key holder
// for this tenant.
func (s *Store) ReconcileTenant(ctx context.Context, keyring *Keyring, tenantID string) error {
if keyring == nil {
return errKeyLocked
}
editors, err := s.tenantKeyRecipients(ctx, tenantID)
if err != nil {
return err
}
// Grant what this key holder can reach and report the first inaccessible
// scope afterwards. A new editor can then receive the remaining scopes
// from another unlocked editor without losing partial access.
var firstErr error
rememberError := func(err error) {
if err != nil && firstErr == nil {
firstErr = err
}
}
tenantScope := KeyScope{Type: ScopeTenant, TenantID: tenantID, ID: tenantID}
if _, err := s.ensureScope(ctx, keyring, tenantScope); err != nil {
rememberError(err)
} else if err := s.grantScope(ctx, keyring, tenantScope, editors); err != nil {
rememberError(err)
}
rows, err := s.db.QueryContext(ctx, "SELECT id FROM people WHERE tenant_id=?", tenantID)
if err != nil {
return err
}
var peopleIDs []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
rows.Close()
return err
}
peopleIDs = append(peopleIDs, id)
}
if err := rows.Err(); err != nil {
rows.Close()
return err
}
rows.Close()
for _, personID := range peopleIDs {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: personID}
if _, err := s.ensureScope(ctx, keyring, scope); err != nil {
rememberError(err)
continue
}
recipients := append([]string{}, editors...)
if linked := s.linkedReaderForPerson(ctx, tenantID, personID); linked != "" {
recipients = append(recipients, linked)
}
if err := s.grantScope(ctx, keyring, scope, recipients); err != nil {
rememberError(err)
}
}
return firstErr
}
// linkedReaderForPerson returns the active reader account that is linked to
// the given person. Only that account may decrypt the person's own e-mail
// address; administrators and unlinked readers stay excluded.
func (s *Store) linkedReaderForPerson(ctx context.Context, tenantID, personID string) string {
var id string
err := s.db.QueryRowContext(ctx, `
SELECT id FROM users
WHERE active=1 AND role='reader' AND linked_tenant_id=? AND linked_person_id=?
ORDER BY id LIMIT 1`, tenantID, personID).Scan(&id)
if err != nil {
return ""
}
return id
}
func (s *Store) tenantKeyRecipients(ctx context.Context, tenantID string) ([]string, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id FROM users
WHERE active=1 AND role='editor' AND id IN (
SELECT user_id FROM memberships WHERE tenant_id=?
)
ORDER BY id`, tenantID)
if err != nil {
return nil, err
}
defer rows.Close()
var ids []string
for rows.Next() {
var id string
if err := rows.Scan(&id); err != nil {
return nil, err
}
ids = append(ids, id)
}
return ids, rows.Err()
}
// ensureScope returns the DEK for a scope, creating it and wrapping it for the
// keyring user when the scope is new. If the scope exists but the user has no
// wrapper, errNoKeyAccess is returned.
func (s *Store) ensureScope(ctx context.Context, keyring *Keyring, scope KeyScope) ([]byte, error) {
if keyring == nil {
return nil, errKeyLocked
}
if dek, ok := keyring.DEK(scope); ok {
return dek, nil
}
dek, err := s.scopeDEK(ctx, keyring, scope)
if err == nil {
return dek, nil
}
if !errors.Is(err, errNoKeyAccess) {
return nil, err
}
// A scope exists only when at least one wrapper is present.
var count int
if err := s.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?",
scope.Type, scope.TenantID, scope.ID).Scan(&count); err != nil {
return nil, err
}
if count > 0 {
return nil, errNoKeyAccess
}
// A scope without wrappers but with stored secrets has lost its data key.
// Never silently replace it, otherwise the old data would be unreadable.
var secrets int
if err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=?`,
scope.TenantID, scope.Type, scope.ID).Scan(&secrets); err != nil {
return nil, err
}
if secrets > 0 {
return nil, errNoKeyAccess
}
dek, err = newDEK()
if err != nil {
return nil, err
}
if err := s.grantScopeDEK(ctx, keyring, scope, dek, []string{keyring.UserID}); err != nil {
return nil, err
}
keyring.remember(scope, dek)
return dek, nil
}
// scopeDEK unwraps the data key for the keyring user.
func (s *Store) scopeDEK(ctx context.Context, keyring *Keyring, scope KeyScope) ([]byte, error) {
if keyring == nil {
return nil, errKeyLocked
}
if dek, ok := keyring.DEK(scope); ok {
return dek, nil
}
var ephemeral, wrapped []byte
err := s.db.QueryRowContext(ctx, `
SELECT ephemeral_public, wrapped_dek FROM key_wrappers
WHERE scope_type=? AND tenant_id=? AND scope_id=? AND user_id=?`,
scope.Type, scope.TenantID, scope.ID, keyring.UserID).Scan(&ephemeral, &wrapped)
if errors.Is(err, sql.ErrNoRows) {
return nil, errNoKeyAccess
}
if err != nil {
return nil, err
}
dek, err := unwrapDEK(keyring.privateKey, ephemeral, wrapped, scope.String())
if err != nil {
return nil, err
}
keyring.remember(scope, dek)
return dek, nil
}
func (s *Store) grantScope(ctx context.Context, keyring *Keyring, scope KeyScope, userIDs []string) error {
dek, err := s.ensureScope(ctx, keyring, scope)
if err != nil {
return err
}
return s.grantScopeDEK(ctx, keyring, scope, dek, userIDs)
}
func (s *Store) grantScopeDEK(ctx context.Context, keyring *Keyring, scope KeyScope, dek []byte, userIDs []string) error {
seen := map[string]bool{}
for _, userID := range userIDs {
if userID == "" || seen[userID] {
continue
}
seen[userID] = true
publicKey, err := s.userPublicKey(ctx, userID)
if err != nil || len(publicKey) == 0 {
continue
}
ephemeral, wrapped, err := wrapDEK(publicKey, dek, scope.String())
if err != nil {
return err
}
if _, err := s.db.ExecContext(ctx, `
INSERT INTO key_wrappers(scope_type, tenant_id, scope_id, user_id,
ephemeral_public, wrapped_dek, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(scope_type, tenant_id, scope_id, user_id) DO UPDATE SET
ephemeral_public=excluded.ephemeral_public, wrapped_dek=excluded.wrapped_dek,
created_at=excluded.created_at`,
scope.Type, scope.TenantID, scope.ID, userID, ephemeral, wrapped,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
}
return nil
}
func (s *Store) userPublicKey(ctx context.Context, userID string) ([]byte, error) {
var publicKey []byte
err := s.db.QueryRowContext(ctx, "SELECT public_key FROM user_keys WHERE user_id=?", userID).Scan(&publicKey)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil
}
return publicKey, err
}
// SecretValue decrypts one stored secret. When the tenant has not been
// initialized yet, legacy tenant settings are only readable with an unlocked
// editor keyring.
func (s *Store) SecretValue(ctx context.Context, tenantID, scopeType, scopeID, key string) (string, bool) {
if !s.SecretIsInitialized(ctx, tenantID) {
if scopeType == ScopeTenant && KeyringFrom(ctx) != nil {
value := s.TenantSetting(ctx, tenantID, key)
return value, value != ""
}
return "", false
}
keyring := KeyringFrom(ctx)
if keyring == nil {
return "", false
}
scope := KeyScope{Type: scopeType, TenantID: tenantID, ID: scopeID}
dek, err := s.scopeDEK(ctx, keyring, scope)
if err != nil {
return "", false
}
var sealed []byte
err = s.db.QueryRowContext(ctx, `
SELECT ciphertext FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, scopeType, scopeID, key).Scan(&sealed)
if err != nil {
return "", false
}
plaintext, err := openAESGCM(dek, sealed, keyAAD(scopeType, tenantID, scopeID, key))
if err != nil {
return "", false
}
return string(plaintext), true
}
// SecretExists reports whether an encrypted value is present.
func (s *Store) SecretExists(ctx context.Context, tenantID, scopeType, scopeID, key string) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, scopeType, scopeID, key).Scan(&count)
return err == nil && count > 0
}
// SetSecret encrypts and stores one value. An empty value removes it. Before
// a tenant is initialized, legacy tenant settings may only be written with an
// unlocked editor keyring present.
func (s *Store) SetSecret(ctx context.Context, tenantID, scopeType, scopeID, key, value string) error {
if !s.SecretIsInitialized(ctx, tenantID) {
if scopeType == ScopeTenant && KeyringFrom(ctx) != nil {
return s.SetTenantSetting(ctx, tenantID, key, value)
}
if scopeType == ScopeTenant {
return errKeyLocked
}
return nil
}
keyring := KeyringFrom(ctx)
if keyring == nil {
return errKeyLocked
}
scope := KeyScope{Type: scopeType, TenantID: tenantID, ID: scopeID}
dek, err := s.scopeDEK(ctx, keyring, scope)
if err != nil {
return err
}
if strings.TrimSpace(value) == "" {
_, err := s.db.ExecContext(ctx, `
DELETE FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, scopeType, scopeID, key)
return err
}
sealed, err := sealAESGCM(dek, []byte(value), keyAAD(scopeType, tenantID, scopeID, key))
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO UPDATE SET
ciphertext=excluded.ciphertext, updated_at=excluded.updated_at`,
tenantID, scopeType, scopeID, key, sealed, time.Now().UTC().Format(time.RFC3339))
return err
}
// EnsurePersonScope creates the person scope if needed and grants it to all
// active editors plus the linked reader. It works with an editor keyring and
// with a reader keyring that already holds the person's data key; the latter
// lets a reader refresh editor access after a new editor was created.
func (s *Store) EnsurePersonScope(ctx context.Context, keyring *Keyring, tenantID, personID string) error {
if keyring == nil || !s.SecretIsInitialized(ctx, tenantID) {
return nil
}
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: personID}
if _, err := s.ensureScope(ctx, keyring, scope); err != nil {
return err
}
recipients, err := s.tenantKeyRecipients(ctx, tenantID)
if err != nil {
return err
}
if linked := s.linkedReaderForPerson(ctx, tenantID, personID); linked != "" {
recipients = append(recipients, linked)
}
return s.grantScope(ctx, keyring, scope, recipients)
}
// PersonContactSecrets loads and decrypts the e-mail address of one person.
// Values that exist but cannot be decrypted are reported as locked.
func (s *Store) PersonContactSecrets(ctx context.Context, tenantID, personID string) (email string, emailLocked bool) {
if !s.SecretIsInitialized(ctx, tenantID) {
return "", false
}
rows, err := s.db.QueryContext(ctx, `
SELECT ciphertext FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key='email'`,
tenantID, ScopePerson, personID)
if err != nil {
return "", false
}
var sealedValues [][]byte
for rows.Next() {
var sealed []byte
if err := rows.Scan(&sealed); err != nil {
rows.Close()
return "", false
}
sealedValues = append(sealedValues, sealed)
}
rows.Close()
keyring := KeyringFrom(ctx)
var dek []byte
if keyring != nil {
dek, _ = s.scopeDEK(ctx, keyring, KeyScope{Type: ScopePerson, TenantID: tenantID, ID: personID})
}
for _, sealed := range sealedValues {
if dek != nil {
plaintext, err := openAESGCM(dek, sealed, keyAAD(ScopePerson, tenantID, personID, "email"))
if err == nil {
return string(plaintext), false
}
}
emailLocked = true
}
return "", emailLocked
}
// DeletePersonSecrets removes all encrypted values and wrappers of a person.
func (s *Store) DeletePersonSecrets(ctx context.Context, tenantID, personID string) error {
if _, err := s.db.ExecContext(ctx, `
DELETE FROM secrets WHERE tenant_id=? AND scope_type=? AND scope_id=?`,
tenantID, ScopePerson, personID); err != nil {
return err
}
_, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?`,
ScopePerson, tenantID, personID)
return err
}
// ScopesForUser lists the scopes whose DEKs are wrapped for one account.
func (s *Store) ScopesForUser(ctx context.Context, userID string) ([]KeyScope, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT scope_type, tenant_id, scope_id FROM key_wrappers WHERE user_id=?`, userID)
if err != nil {
return nil, err
}
defer rows.Close()
var scopes []KeyScope
for rows.Next() {
var scope KeyScope
if err := rows.Scan(&scope.Type, &scope.TenantID, &scope.ID); err != nil {
return nil, err
}
scopes = append(scopes, scope)
}
return scopes, rows.Err()
}
// ResetUserKeys replaces an account's keypair, e.g. after an administrator set
// a new temporary password. Existing wrappers become invalid and are returned
// so an unlocked administrator can grant them again.
func (s *Store) ResetUserKeys(ctx context.Context, userID, newPassword string) (*Keyring, []KeyScope, error) {
scopes, err := s.ScopesForUser(ctx, userID)
if err != nil {
return nil, nil, err
}
if err := s.DeleteUserKeys(ctx, userID); err != nil {
return nil, nil, err
}
keyring, err := s.createUserKeys(ctx, userID, newPassword)
if err != nil {
return nil, nil, err
}
return keyring, scopes, nil
}
// DeleteUserKeys removes the key material and all wrappers of an account.
func (s *Store) DeleteUserKeys(ctx context.Context, userID string) error {
if _, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID); err != nil {
return err
}
_, err := s.db.ExecContext(ctx, "DELETE FROM user_keys WHERE user_id=?", userID)
return err
}
// PruneUserWrappers enforces the key access policy. Editors keep the scopes of
// their tenant memberships. A reader may hold exactly one wrapper: the person
// scope of the account they are linked to. Administrators never hold key
// material.
func (s *Store) PruneUserWrappers(ctx context.Context, userID string) error {
var role, linkedTenantID, linkedPersonID string
var active int
err := s.db.QueryRowContext(ctx, `
SELECT role, active, linked_tenant_id, linked_person_id
FROM users WHERE id=?`, userID).
Scan(&role, &active, &linkedTenantID, &linkedPersonID)
if errors.Is(err, sql.ErrNoRows) {
return nil
}
if err != nil {
return err
}
userRole := UserRole(role)
if userRole == RoleAdmin {
if _, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID); err != nil {
return err
}
_, err := s.db.ExecContext(ctx, "DELETE FROM user_keys WHERE user_id=?", userID)
return err
}
if active == 0 {
_, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID)
return err
}
if userRole == RoleEditor {
_, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE user_id=? AND tenant_id NOT IN (
SELECT tenant_id FROM memberships WHERE user_id=?
)`, userID, userID)
return err
}
if linkedTenantID == "" || linkedPersonID == "" {
_, err := s.db.ExecContext(ctx, "DELETE FROM key_wrappers WHERE user_id=?", userID)
return err
}
_, err = s.db.ExecContext(ctx, `
DELETE FROM key_wrappers WHERE user_id=? AND NOT (
scope_type='person' AND tenant_id=? AND scope_id=?
)`, userID, linkedTenantID, linkedPersonID)
return err
}
// HasScopeAccess reports whether a data key for the scope is wrapped for the
// account. It is used to decide whether a reader may edit their own contact.
func (s *Store) HasScopeAccess(ctx context.Context, userID string, scope KeyScope) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM key_wrappers
WHERE scope_type=? AND tenant_id=? AND scope_id=? AND user_id=?`,
scope.Type, scope.TenantID, scope.ID, userID).Scan(&count)
return err == nil && count > 0
}
// RewrapScopes grants the given scopes to a user from an unlocked keyring.
func (s *Store) RewrapScopes(ctx context.Context, keyring *Keyring, userID string, scopes []KeyScope) (int, error) {
if keyring == nil {
return 0, errKeyLocked
}
publicKey, err := s.userPublicKey(ctx, userID)
if err != nil || len(publicKey) == 0 {
return 0, err
}
granted := 0
for _, scope := range scopes {
dek, err := s.scopeDEK(ctx, keyring, scope)
if err != nil {
continue
}
ephemeral, wrapped, err := wrapDEK(publicKey, dek, scope.String())
if err != nil {
return granted, err
}
if _, err := s.db.ExecContext(ctx, `
INSERT INTO key_wrappers(scope_type, tenant_id, scope_id, user_id,
ephemeral_public, wrapped_dek, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(scope_type, tenant_id, scope_id, user_id) DO UPDATE SET
ephemeral_public=excluded.ephemeral_public, wrapped_dek=excluded.wrapped_dek,
created_at=excluded.created_at`,
scope.Type, scope.TenantID, scope.ID, userID, ephemeral, wrapped,
time.Now().UTC().Format(time.RFC3339)); err != nil {
return granted, err
}
granted++
}
return granted, nil
}
// RekeyUserPassword keeps the same keypair but protects it with a new KEK.
func (s *Store) RekeyUserPassword(ctx context.Context, userID, currentPassword, newPassword string) (*Keyring, error) {
var salt, publicKey, wrappedPrivate []byte
err := s.db.QueryRowContext(ctx,
"SELECT kdf_salt, public_key, wrapped_private FROM user_keys WHERE user_id=?", userID).
Scan(&salt, &publicKey, &wrappedPrivate)
if errors.Is(err, sql.ErrNoRows) {
return s.EnsureUserKeys(ctx, userID, newPassword)
}
if err != nil {
return nil, err
}
privateKey, err := openAESGCM(deriveUserKEK(currentPassword, salt), wrappedPrivate,
keyAAD("user-private", userID))
if err != nil {
return nil, err
}
newSalt, err := newSalt()
if err != nil {
return nil, err
}
wrapped, err := sealAESGCM(deriveUserKEK(newPassword, newSalt), privateKey,
keyAAD("user-private", userID))
if err != nil {
return nil, err
}
if _, err := s.db.ExecContext(ctx, `
UPDATE user_keys SET kdf_salt=?, wrapped_private=?, updated_at=? WHERE user_id=?`,
newSalt, wrapped, time.Now().UTC().Format(time.RFC3339), userID); err != nil {
return nil, err
}
return newKeyring(userID, privateKey), nil
}
+586
View File
@@ -0,0 +1,586 @@
package store
import (
"context"
"testing"
)
// openDemoStore returns an in-memory store with the demo tenant.
func openDemoStore(t *testing.T) *Store {
t.Helper()
st, err := Open(":memory:")
if err != nil {
t.Fatalf("open store: %v", err)
}
t.Cleanup(func() { st.Close() })
if err := st.SeedDemo(context.Background()); err != nil {
t.Fatalf("seed demo: %v", err)
}
return st
}
type secretFixture struct {
tenantID string
personID string
email string
editor *User
reader *User
}
func prepareSecretFixture(t *testing.T, st *Store) secretFixture {
t.Helper()
ctx := context.Background()
var fixture secretFixture
if err := st.db.QueryRowContext(ctx,
"SELECT tenant_id, id, email FROM people WHERE email<>'' LIMIT 1").
Scan(&fixture.tenantID, &fixture.personID, &fixture.email); err != nil {
t.Fatalf("contact person: %v", err)
}
editor, err := st.UserByUsername(ctx, "editor")
if err != nil {
t.Fatalf("editor: %v", err)
}
reader, err := st.UserByUsername(ctx, "reader")
if err != nil {
t.Fatalf("reader: %v", err)
}
fixture.editor = editor
fixture.reader = reader
return fixture
}
func TestSecretsEncryptContactsAndSMTP(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
if err := st.SetTenantSetting(ctx, fixture.tenantID, "smtp.host", "smtp.example.org"); err != nil {
t.Fatalf("legacy smtp host: %v", err)
}
if err := st.SetTenantSetting(ctx, fixture.tenantID, "smtp.password", "secret"); err != nil {
t.Fatalf("legacy smtp password: %v", err)
}
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
if !st.SecretIsInitialized(ctx, fixture.tenantID) {
t.Fatal("tenant is not marked as encrypted")
}
var plainEmail string
if err := st.db.QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id=?",
fixture.tenantID, fixture.personID).Scan(&plainEmail); err != nil {
t.Fatalf("read person row: %v", err)
}
if plainEmail != "" {
t.Fatalf("plaintext contact remains: email=%q", plainEmail)
}
if got := st.TenantSetting(ctx, fixture.tenantID, "smtp.password"); got != "" {
t.Fatalf("SMTP password remains as tenant setting %q", got)
}
keyCtx := WithKeyring(ctx, editorKey)
if got, ok := st.SecretValue(keyCtx, fixture.tenantID, ScopeTenant, fixture.tenantID, "smtp.host"); !ok || got != "smtp.example.org" {
t.Fatalf("smtp host = %q, ok=%v", got, ok)
}
if got, ok := st.SecretValue(keyCtx, fixture.tenantID, ScopeTenant, fixture.tenantID, "smtp.password"); !ok || got != "secret" {
t.Fatalf("smtp password = %q, ok=%v", got, ok)
}
person, err := st.Person(keyCtx, fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person with keyring: %v", err)
}
if person.Email != fixture.email || person.EmailLocked {
t.Fatalf("decrypted e-mail = %q locked=%v, want %q", person.Email, person.EmailLocked, fixture.email)
}
locked, err := st.Person(ctx, fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person without keyring: %v", err)
}
if locked.Email != "" || !locked.EmailLocked {
t.Fatalf("locked e-mail = %q locked=%v", locked.Email, locked.EmailLocked)
}
}
func TestWrongPasswordDoesNotUnlockKeys(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err != nil {
t.Fatalf("create keys: %v", err)
}
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "falsch"); err == nil {
t.Fatal("wrong password unlocked the keypair")
}
}
func TestScopeWrappersFollowRolePolicy(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil {
t.Fatalf("link reader: %v", err)
}
if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("reconcile: %v", err)
}
readerScopes, err := st.ScopesForUser(ctx, fixture.reader.ID)
if err != nil {
t.Fatalf("reader scopes: %v", err)
}
if len(readerScopes) != 1 || readerScopes[0].Type != ScopePerson ||
readerScopes[0].TenantID != fixture.tenantID || readerScopes[0].ID != fixture.personID {
t.Fatalf("reader scopes = %+v, want only own person scope", readerScopes)
}
// Administrators must not receive wrappers, even if stale key material
// exists for them.
admin, err := st.UserByUsername(ctx, "admin")
if err != nil {
t.Fatalf("admin: %v", err)
}
if _, err := st.EnsureUserKeys(ctx, admin.ID, "temporary"); err != nil {
t.Fatalf("legacy admin keys: %v", err)
}
if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("reconcile after admin keys: %v", err)
}
if adminScopes, _ := st.ScopesForUser(ctx, admin.ID); len(adminScopes) != 0 {
t.Fatalf("administrator received %d encrypted scopes", len(adminScopes))
}
// A reader has access to the own address only.
readerKey, err := st.EnsureUserKeys(ctx, fixture.reader.ID, "reader123")
if err != nil {
t.Fatalf("reader keys: %v", err)
}
if err := st.UnlockAccessibleKeys(ctx, readerKey); err != nil {
t.Fatalf("unwrap reader keys: %v", err)
}
own, err := st.Person(WithKeyring(ctx, readerKey), fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("own person: %v", err)
}
if own.Email != fixture.email {
t.Fatalf("reader e-mail = %q, want %q", own.Email, fixture.email)
}
var otherID string
if err := st.db.QueryRowContext(ctx,
"SELECT id FROM people WHERE tenant_id=? AND id<>? LIMIT 1",
fixture.tenantID, fixture.personID).Scan(&otherID); err != nil {
t.Fatalf("other person: %v", err)
}
other, err := st.Person(WithKeyring(ctx, readerKey), fixture.tenantID, otherID)
if err != nil {
t.Fatalf("other person: %v", err)
}
if other.Email != "" {
t.Fatalf("reader decrypted another person's e-mail %q", other.Email)
}
}
func TestPasswordChangeKeepsDataKeys(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
if _, err := st.RekeyUserPassword(ctx, fixture.editor.ID, "editor123", "neues-passwort"); err != nil {
t.Fatalf("rekey: %v", err)
}
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err == nil {
t.Fatal("old password still unlocks the keypair")
}
rekeyed, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "neues-passwort")
if err != nil {
t.Fatalf("new password: %v", err)
}
if err := st.UnlockAccessibleKeys(ctx, rekeyed); err != nil {
t.Fatalf("unlock rekeyed: %v", err)
}
person, err := st.Person(WithKeyring(ctx, rekeyed), fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person after rekey: %v", err)
}
if person.Email != fixture.email {
t.Fatalf("e-mail after rekey = %q, want %q", person.Email, fixture.email)
}
}
func TestAdminResetRewrapsEditorScopes(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
_, scopes, err := st.ResetUserKeys(ctx, fixture.editor.ID, "temp-passwort")
if err != nil {
t.Fatalf("reset editor keys: %v", err)
}
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err == nil {
t.Fatal("old password still unlocks after reset")
}
// Another unlocked editor can restore the scopes without ever exposing
// the data to an administrator.
granted, err := st.RewrapScopes(ctx, editorKey, fixture.editor.ID, scopes)
if err != nil {
t.Fatalf("rewrap: %v", err)
}
if granted == 0 {
t.Fatal("no scopes were granted again")
}
resetKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "temp-passwort")
if err != nil {
t.Fatalf("temporary password: %v", err)
}
if err := st.UnlockAccessibleKeys(ctx, resetKey); err != nil {
t.Fatalf("unlock reset keys: %v", err)
}
person, err := st.Person(WithKeyring(ctx, resetKey), fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person after reset: %v", err)
}
if person.Email != fixture.email {
t.Fatalf("e-mail after reset = %q, want %q", person.Email, fixture.email)
}
}
func TestExchangeExportOmitsContacts(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
exchange, err := st.ExportResources(WithKeyring(ctx, editorKey), fixture.tenantID)
if err != nil {
t.Fatalf("export: %v", err)
}
for _, person := range exchange.Resources.People {
if person.Email != "" {
t.Fatalf("export contains contact data for %s", person.ID)
}
}
}
func TestPruneUserWrappersRestrictsReaderToOwnScope(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil {
t.Fatalf("link reader: %v", err)
}
tenantScope := KeyScope{Type: ScopeTenant, TenantID: fixture.tenantID, ID: fixture.tenantID}
tenantDEK, err := st.ensureScope(ctx, editorKey, tenantScope)
if err != nil {
t.Fatalf("tenant scope: %v", err)
}
ownScope := KeyScope{Type: ScopePerson, TenantID: fixture.tenantID, ID: fixture.personID}
ownDEK, err := st.ensureScope(ctx, editorKey, ownScope)
if err != nil {
t.Fatalf("own scope: %v", err)
}
// Simulate stale grants from older versions.
if err := st.grantScopeDEK(ctx, editorKey, tenantScope, tenantDEK, []string{fixture.reader.ID}); err != nil {
t.Fatalf("legacy tenant grant: %v", err)
}
if err := st.grantScopeDEK(ctx, editorKey, ownScope, ownDEK, []string{fixture.reader.ID}); err != nil {
t.Fatalf("legacy person grant: %v", err)
}
if err := st.PruneUserWrappers(ctx, fixture.reader.ID); err != nil {
t.Fatalf("prune reader: %v", err)
}
scopes, err := st.ScopesForUser(ctx, fixture.reader.ID)
if err != nil {
t.Fatalf("reader scopes: %v", err)
}
if len(scopes) != 1 || scopes[0].String() != ownScope.String() {
t.Fatalf("reader scopes = %+v, want only %s", scopes, ownScope.String())
}
if !st.HasUserKeys(ctx, fixture.reader.ID) {
t.Fatal("reader lost key material")
}
// Administrators lose both wrappers and key material.
admin, err := st.UserByUsername(ctx, "admin")
if err != nil {
t.Fatalf("admin: %v", err)
}
if _, err := st.EnsureUserKeys(ctx, admin.ID, "temporary"); err != nil {
t.Fatalf("legacy admin keys: %v", err)
}
if err := st.grantScopeDEK(ctx, editorKey, tenantScope, tenantDEK, []string{admin.ID}); err != nil {
t.Fatalf("legacy admin grant: %v", err)
}
if err := st.PruneUserWrappers(ctx, admin.ID); err != nil {
t.Fatalf("prune admin: %v", err)
}
if adminScopes, _ := st.ScopesForUser(ctx, admin.ID); len(adminScopes) != 0 {
t.Fatalf("administrator still holds %d wrappers", len(adminScopes))
}
if st.HasUserKeys(ctx, admin.ID) {
t.Fatal("administrator still holds key material")
}
}
func TestReaderRefreshesAccessForNewEditors(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil {
t.Fatalf("link reader: %v", err)
}
if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("reconcile: %v", err)
}
readerKey, err := st.EnsureUserKeys(ctx, fixture.reader.ID, "reader123")
if err != nil {
t.Fatalf("reader keys: %v", err)
}
if err := st.UnlockAccessibleKeys(ctx, readerKey); err != nil {
t.Fatalf("unwrap reader keys: %v", err)
}
ownScope := KeyScope{Type: ScopePerson, TenantID: fixture.tenantID, ID: fixture.personID}
newEditor, err := st.CreateUser(ctx, "editor-neu", "Neue Redaktion", "editor-neu-123",
RoleEditor, true, []string{fixture.tenantID})
if err != nil {
t.Fatalf("create editor: %v", err)
}
if st.HasScopeAccess(ctx, newEditor.ID, ownScope) {
t.Fatal("new editor already has the person scope")
}
// The next login of the reader wraps the address for the new editor.
if err := st.EnsurePersonScope(ctx, readerKey, fixture.tenantID, fixture.personID); err != nil {
t.Fatalf("reader refresh: %v", err)
}
if !st.HasScopeAccess(ctx, newEditor.ID, ownScope) {
t.Fatal("new editor did not receive the person scope")
}
newKey, err := st.EnsureUserKeys(ctx, newEditor.ID, "editor-neu-123")
if err != nil {
t.Fatalf("new editor keys: %v", err)
}
if err := st.UnlockAccessibleKeys(ctx, newKey); err != nil {
t.Fatalf("unlock new editor: %v", err)
}
person, err := st.Person(WithKeyring(ctx, newKey), fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person as new editor: %v", err)
}
if person.Email != fixture.email {
t.Fatalf("new editor e-mail = %q, want %q", person.Email, fixture.email)
}
}
func TestPruneUserWrappersKeepsEditorMembershipScopes(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
before, err := st.ScopesForUser(ctx, fixture.editor.ID)
if err != nil {
t.Fatalf("editor scopes: %v", err)
}
if len(before) == 0 {
t.Fatal("editor received no scopes")
}
if err := st.PruneUserWrappers(ctx, fixture.editor.ID); err != nil {
t.Fatalf("prune editor: %v", err)
}
after, err := st.ScopesForUser(ctx, fixture.editor.ID)
if err != nil {
t.Fatalf("editor scopes after prune: %v", err)
}
if len(after) != len(before) {
t.Fatalf("editor scopes changed from %d to %d", len(before), len(after))
}
}
func TestBootstrapMigratesPlaintextCreatedAfterInitialization(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
if err != nil {
t.Fatalf("editor keys: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("bootstrap: %v", err)
}
// Simulate a seeding or restore run without a keyring that writes a
// plaintext address after the tenant was already migrated and its
// encrypted value was removed together with the planning data.
lateEmail := "nachzuegler@example.org"
if _, err := st.db.ExecContext(ctx,
"DELETE FROM secrets WHERE tenant_id=? AND scope_type='person' AND scope_id=? AND secret_key='email'",
fixture.tenantID, fixture.personID); err != nil {
t.Fatalf("delete old secret: %v", err)
}
if _, err := st.db.ExecContext(ctx,
"UPDATE people SET email=? WHERE tenant_id=? AND id=?",
lateEmail, fixture.tenantID, fixture.personID); err != nil {
t.Fatalf("late plaintext: %v", err)
}
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
t.Fatalf("second bootstrap: %v", err)
}
var plain string
if err := st.db.QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id=?",
fixture.tenantID, fixture.personID).Scan(&plain); err != nil {
t.Fatalf("read person: %v", err)
}
if plain != "" {
t.Fatalf("late plaintext remains: %q", plain)
}
person, err := st.Person(WithKeyring(ctx, editorKey), fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person: %v", err)
}
if person.Email != lateEmail {
t.Fatalf("migrated e-mail = %q, want %q", person.Email, lateEmail)
}
}
func TestLockedLegacyContactSurvivesKeylessUpdate(t *testing.T) {
st := openDemoStore(t)
ctx := context.Background()
fixture := prepareSecretFixture(t, st)
// Before the first editor login the tenant is not migrated. An
// administrator session has no keyring, so the plaintext address is
// hidden and marked as locked.
person, err := st.Person(ctx, fixture.tenantID, fixture.personID)
if err != nil {
t.Fatalf("person: %v", err)
}
if person.Email != "" || !person.EmailLocked {
t.Fatalf("keyless contact = %q locked=%v", person.Email, person.EmailLocked)
}
person.Notes = "geändert ohne Kontaktschlüssel"
if err := st.UpsertPerson(ctx, fixture.tenantID, *person); err != nil {
t.Fatalf("update: %v", err)
}
var plain string
if err := st.db.QueryRowContext(ctx,
"SELECT email FROM people WHERE tenant_id=? AND id=?",
fixture.tenantID, fixture.personID).Scan(&plain); err != nil {
t.Fatalf("read person: %v", err)
}
if plain != fixture.email {
t.Fatalf("legacy e-mail was changed from %q to %q", fixture.email, plain)
}
}
func TestMigrationRemovesPhoneNumbers(t *testing.T) {
path := t.TempDir() + "/lektorenplan.db"
st, err := Open(path)
if err != nil {
t.Fatalf("open store: %v", err)
}
ctx := context.Background()
if err := st.SeedDemo(ctx); err != nil {
t.Fatalf("seed demo: %v", err)
}
var tenantID string
if err := st.db.QueryRowContext(ctx,
"SELECT tenant_id FROM people WHERE id='p-anna'").Scan(&tenantID); err != nil {
t.Fatalf("tenant: %v", err)
}
// Recreate the legacy column and a matching encrypted value.
if _, err := st.db.ExecContext(ctx,
"ALTER TABLE people ADD COLUMN phone TEXT NOT NULL DEFAULT ''"); err != nil {
t.Fatalf("add legacy column: %v", err)
}
if _, err := st.db.ExecContext(ctx,
"UPDATE people SET phone='0228 555 0101' WHERE tenant_id=? AND id='p-anna'", tenantID); err != nil {
t.Fatalf("legacy phone: %v", err)
}
if _, err := st.db.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, 'person', 'p-anna', 'phone', X'00', ?)`,
tenantID, nowText()); err != nil {
t.Fatalf("legacy secret: %v", err)
}
st.Close()
reopened, err := Open(path)
if err != nil {
t.Fatalf("reopen store: %v", err)
}
defer reopened.Close()
hasPhone, err := reopened.hasColumn(ctx, "people", "phone")
if err != nil {
t.Fatalf("inspect people: %v", err)
}
if hasPhone {
t.Fatal("phone column still exists after migration")
}
var count int
if err := reopened.db.QueryRowContext(ctx,
"SELECT COUNT(*) FROM secrets WHERE secret_key='phone'").Scan(&count); err != nil {
t.Fatalf("count phone secrets: %v", err)
}
if count != 0 {
t.Fatalf("%d phone secrets remain after migration", count)
}
}
+120 -12
View File
@@ -6,6 +6,7 @@ import (
"encoding/json"
"errors"
"strings"
"time"
"lektorenplan/domain"
)
@@ -151,35 +152,68 @@ func (s *Store) DeleteChurch(ctx context.Context, tenantID, id string) error {
// People lists a tenant's volunteers.
func (s *Store) People(ctx context.Context, tenantID string) ([]domain.Person, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id, first_name, last_name, roles, email, phone, preferred_church_ids,
SELECT id, first_name, last_name, roles, email, preferred_church_ids,
preferred_weekdays, preferred_service_titles, max_per_month, active, notes
FROM people WHERE tenant_id=? ORDER BY last_name COLLATE NOCASE, first_name COLLATE NOCASE`, tenantID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []domain.Person
for rows.Next() {
person, err := scanPerson(rows)
if err != nil {
rows.Close()
return nil, err
}
out = append(out, *person)
}
return out, rows.Err()
if err := rows.Err(); err != nil {
rows.Close()
return nil, err
}
rows.Close()
// The connection pool has a single connection, so the rows must be closed
// before the encrypted contacts are loaded.
for index := range out {
s.hydratePersonContacts(ctx, tenantID, &out[index])
}
return out, nil
}
// Person loads one volunteer.
func (s *Store) Person(ctx context.Context, tenantID, id string) (*domain.Person, error) {
row := s.db.QueryRowContext(ctx, `
SELECT id, first_name, last_name, roles, email, phone, preferred_church_ids,
SELECT id, first_name, last_name, roles, email, preferred_church_ids,
preferred_weekdays, preferred_service_titles, max_per_month, active, notes
FROM people WHERE tenant_id=? AND id=?`, tenantID, id)
person, err := scanPerson(row)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
return person, err
if err != nil {
return nil, err
}
s.hydratePersonContacts(ctx, tenantID, person)
return person, nil
}
// hydratePersonContacts fills the e-mail address from the encrypted store.
// Values that exist but cannot be decrypted stay empty and are marked as
// locked so the UI can explain the situation. Before a tenant has been
// migrated, plaintext contacts are only exposed to key-holding editors.
func (s *Store) hydratePersonContacts(ctx context.Context, tenantID string, person *domain.Person) {
if !s.SecretIsInitialized(ctx, tenantID) {
if KeyringFrom(ctx) == nil && strings.TrimSpace(person.Email) != "" {
person.Email = ""
person.EmailLocked = true
}
return
}
email, emailLocked := s.PersonContactSecrets(ctx, tenantID, person.ID)
if person.Email == "" {
person.Email = email
person.EmailLocked = emailLocked
}
}
func scanPerson(row rowScanner) (*domain.Person, error) {
@@ -187,7 +221,7 @@ func scanPerson(row rowScanner) (*domain.Person, error) {
var roles, churches, weekdays, titles string
var active int
if err := row.Scan(&person.ID, &person.FirstName, &person.LastName, &roles,
&person.Email, &person.Phone, &churches, &weekdays, &titles,
&person.Email, &churches, &weekdays, &titles,
&person.MaxPerMonth, &active, &person.Notes); err != nil {
return nil, err
}
@@ -221,24 +255,88 @@ func (s *Store) UpsertPerson(ctx context.Context, tenantID string, person domain
if person.MaxPerMonth < 0 {
person.MaxPerMonth = 0
}
_, err := s.db.ExecContext(ctx, `
INSERT INTO people(tenant_id, id, first_name, last_name, roles, email, phone,
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(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
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,
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),
person.Email, person.Phone, encodeStrings(person.PreferredChurchIDs),
email, encodeStrings(person.PreferredChurchIDs),
encodeInts(person.PreferredWeekdays),
encodeStrings(person.PreferredServiceTitles), person.MaxPerMonth,
boolInt(person.Active), person.Notes)
boolInt(person.Active), person.Notes, boolInt(updateLegacyContact))
if err != nil {
return err
}
if !initialized || keyring == nil {
return nil
}
setSecret := func(key, value string) error {
if strings.TrimSpace(value) == "" {
_, err := tx.ExecContext(ctx, `
DELETE FROM secrets
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
tenantID, ScopePerson, person.ID, key)
return err
}
sealed, err := sealAESGCM(dek, []byte(value),
keyAAD(ScopePerson, tenantID, person.ID, key))
if err != nil {
return err
}
_, err = tx.ExecContext(ctx, `
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
VALUES(?, ?, ?, ?, ?, ?)
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO UPDATE SET
ciphertext=excluded.ciphertext, updated_at=excluded.updated_at`,
tenantID, ScopePerson, person.ID, key, sealed,
time.Now().UTC().Format(time.RFC3339))
return err
}
// A locked field that was left empty must keep its existing secret.
if !(person.EmailLocked && strings.TrimSpace(person.Email) == "") {
if err := setSecret("email", person.Email); err != nil {
return err
}
}
return nil
})
}
// DeletePerson removes a volunteer with assignments and absences.
@@ -252,6 +350,16 @@ func (s *Store) DeletePerson(ctx context.Context, tenantID, id string) error {
"DELETE FROM absences WHERE tenant_id=? AND person_id=?", tenantID, id); err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"DELETE FROM secrets WHERE tenant_id=? AND scope_type=? AND scope_id=?",
tenantID, ScopePerson, id); err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"DELETE FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?",
ScopePerson, tenantID, id); err != nil {
return err
}
_, err := tx.ExecContext(ctx, "DELETE FROM people WHERE tenant_id=? AND id=?", tenantID, id)
return err
})
+2
View File
@@ -102,6 +102,8 @@ func (s *Store) DeleteAllTenantData(ctx context.Context, tenantID string) error
"DELETE FROM dispatch_preferences WHERE tenant_id=?",
"DELETE FROM dispatch_log WHERE tenant_id=?",
"DELETE FROM tenant_settings WHERE tenant_id=?",
"DELETE FROM secrets WHERE tenant_id=?",
"DELETE FROM key_wrappers WHERE tenant_id=? AND scope_type='person'",
}
for _, statement := range statements {
if _, err := tx.ExecContext(ctx, statement, tenantID); err != nil {
+16 -1
View File
@@ -123,8 +123,13 @@ func (s *Store) UpdateTenant(ctx context.Context, tenant *Tenant) error {
// DeleteTenant removes a tenant and, through cascades, its planning data.
func (s *Store) DeleteTenant(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM tenants WHERE id=?", id)
return 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 {
+55
View File
@@ -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,9 +337,34 @@ 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."+note, "success")
s.redirect(w, r, "/admin/users?edit="+id)
}
func parseLinkedPerson(value string) (string, string) {
+18
View File
@@ -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)
}
+538
View File
@@ -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 ""
}
+57 -11
View File
@@ -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,6 +71,10 @@ type dispatchPageData struct {
Greeting string
SMTPConfigured bool
SMTPFrom string
// 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
@@ -75,6 +83,10 @@ type dispatchPageData struct {
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,
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")),
}
}
+79 -7
View File
@@ -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" {
found = true
if got := st.TenantSetting(ctx, tenant.ID, "smtp.port"); got != "587" {
t.Fatalf("smtp port = %q", got)
if got := st.TenantSetting(ctx, tenant.ID, "smtp.host"); got == "smtp.example.org" {
t.Fatalf("SMTP host was stored as plaintext tenant setting")
}
if got := st.TenantSetting(ctx, tenant.ID, "smtp.password"); got != "secret" {
t.Fatalf("smtp password = %q", got)
if st.SecretExists(ctx, tenant.ID, store.ScopeTenant, tenant.ID, "smtp.host") {
found = true
if !st.SecretIsInitialized(ctx, tenant.ID) {
t.Fatal("tenant secrets are not marked as initialized")
}
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)
+1
View File
@@ -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
+268
View File
@@ -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)
}
+36 -32
View File
@@ -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)
}
+1
View File
@@ -403,6 +403,7 @@ var iconPaths = map[string]string{
"printer": `<path d="M6 9V2h12v7M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"/><rect x="6" y="14" width="12" height="8"/>`,
"send": `<path d="M22 2L11 13M22 2l-7 20-4-9-9-4z"/>`,
"mail": `<rect x="2" y="4" width="20" height="16" rx="2"/><path d="M3 6l9 7 9-7"/>`,
"copy": `<rect x="9" y="9" width="12" height="12" rx="2"/><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"/>`,
"plus": `<path d="M12 5v14M5 12h14"/>`,
"left": `<path d="M15 18l-6-6 6-6"/>`,
"right": `<path d="M9 18l6-6-6-6"/>`,
+17 -1
View File
@@ -14,6 +14,7 @@ import (
"net/http"
"net/url"
"strings"
"sync"
"time"
"lektorenplan/domain"
@@ -39,6 +40,9 @@ type Server struct {
static http.Handler
opts Options
sessionTTL time.Duration
keyMu sync.Mutex
keyrings map[string]*store.Keyring
}
const (
@@ -63,7 +67,7 @@ func New(st *store.Store, opts Options) (*Server, error) {
names := []string{
"login", "plan", "service", "services", "team", "person", "statistics",
"exchange", "settings", "liturgy", "dispatch", "guest", "admin_tenants", "admin_users",
"admin_churches", "password", "error", "no_tenant",
"admin_churches", "password", "unlock", "error", "no_tenant",
}
views := make(map[string]*template.Template, len(names))
for _, name := range names {
@@ -81,6 +85,7 @@ func New(st *store.Store, opts Options) (*Server, error) {
return &Server{
store: st, views: views, opts: opts, sessionTTL: opts.SessionTTL,
static: http.StripPrefix("/static/", http.FileServer(http.FS(staticFS))),
keyrings: map[string]*store.Keyring{},
}, nil
}
@@ -124,6 +129,8 @@ func (s *Server) Handler() http.Handler {
mux.HandleFunc("POST /login", s.handleLoginPost)
mux.HandleFunc("GET /guest", s.handleGuest)
mux.HandleFunc("POST /logout", s.auth(s.handleLogout))
mux.HandleFunc("GET /unlock", s.auth(s.handleUnlockGet))
mux.HandleFunc("POST /unlock", s.auth(s.handleUnlockPost))
mux.HandleFunc("GET /password", s.auth(s.handlePasswordGet))
mux.HandleFunc("POST /password", s.auth(s.handlePasswordChange))
mux.HandleFunc("GET /switch", s.auth(s.handleSwitchTenant))
@@ -211,6 +218,10 @@ func (s *Server) withSession(next http.Handler) http.Handler {
if err == nil {
ctx := context.WithValue(r.Context(), userContext, user)
ctx = context.WithValue(ctx, sessionContext, session)
if keyring := s.keyringForSession(session.ID); keyring != nil &&
(user.Role == store.RoleEditor || user.Role == store.RoleReader) {
ctx = store.WithKeyring(ctx, keyring)
}
r = r.WithContext(ctx)
tenant, fromQuery := s.resolveTenant(w, r, user)
@@ -300,6 +311,11 @@ func (s *Server) auth(next authedHandler) http.HandlerFunc {
s.redirect(w, r, "/password")
return
}
if r.URL.Path != "/unlock" && r.URL.Path != "/password" && r.URL.Path != "/logout" &&
s.needsUnlock(r.Context(), session, user) {
s.redirect(w, r, "/unlock?next="+url.QueryEscape(r.URL.RequestURI()))
return
}
next(w, r, user, session, tenantFrom(r))
}
}
+7 -5
View File
@@ -16,6 +16,7 @@ type settingsPageData struct {
Counts map[string]int
ChurchCount int
CanEdit bool
CanManageSecrets bool
IsAdmin bool
Database string
DemoReset bool
@@ -103,13 +104,14 @@ func (s *Server) handleSettings(w http.ResponseWriter, r *http.Request, user *st
LastSync: s.store.Setting(r.Context(), "lastLiturgicalSync"),
Counts: counts,
CanEdit: s.store.CanEditTenant(r.Context(), user, tenant.ID),
CanManageSecrets: s.store.CanManageSecrets(r.Context(), user, tenant.ID),
IsAdmin: user.Role.IsAdmin(),
Database: s.store.Path(),
DemoReset: tenant.Slug == "bad-godesberg" || tenant.Slug == "rheinaue",
LoginQuote: s.loginQuote(r),
LoginQuoteSource: s.loginQuoteSource(r),
}
if page.CanEdit {
if page.CanManageSecrets {
config := s.loadSMTPConfig(r.Context(), tenant.ID)
page.SMTPHost = config.Host
if config.Port > 0 {
@@ -165,7 +167,7 @@ func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user
// SMTP settings for dispatch e-mails are administered per tenant by the
// editors. The password is only replaced when a new value is entered so
// it never has to be echoed back.
if s.store.CanEditTenant(r.Context(), user, tenant.ID) {
if s.store.CanManageSecrets(r.Context(), user, tenant.ID) {
smtpValues := map[string]string{
"smtp.host": strings.TrimSpace(r.FormValue("smtp_host")),
"smtp.username": strings.TrimSpace(r.FormValue("smtp_username")),
@@ -179,7 +181,7 @@ func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user
smtpValues["smtp.port"] = ""
}
for key, value := range smtpValues {
if err := s.store.SetTenantSetting(r.Context(), tenant.ID, key, value); err != nil {
if err := s.store.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, tenant.ID, key, value); err != nil {
s.setFlash(w, "Die SMTP-Einstellungen konnten nicht gespeichert werden: "+err.Error(), "error")
s.redirect(w, r, "/settings")
return
@@ -187,9 +189,9 @@ func (s *Server) handleSettingsSave(w http.ResponseWriter, r *http.Request, user
}
switch {
case r.FormValue("smtp_clear_password") == "1":
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "smtp.password", "")
_ = s.store.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password", "")
case strings.TrimSpace(r.FormValue("smtp_password")) != "":
_ = s.store.SetTenantSetting(r.Context(), tenant.ID, "smtp.password", r.FormValue("smtp_password"))
_ = s.store.SetSecret(r.Context(), tenant.ID, store.ScopeTenant, tenant.ID, "smtp.password", r.FormValue("smtp_password"))
}
}
+116
View File
@@ -197,6 +197,121 @@
});
}
/* Texte kopieren und mailto-Entwürfe aktuell halten ------------------- */
function initDispatchCopy() {
var form = document.querySelector("[data-dispatch-form]");
if (!form) return;
var intro = form.querySelector("[data-dispatch-intro]");
var greeting = form.querySelector("[data-dispatch-greeting]");
var startLabel = form.getAttribute("data-range-start") || "{start}";
var endLabel = form.getAttribute("data-range-end") || "{end}";
var defaultIntro = form.getAttribute("data-default-intro") || "";
var subject = form.getAttribute("data-mail-subject") || "";
function resolve(value) {
return String(value == null ? "" : value)
.split("{start}").join(startLabel)
.split("{end}").join(endLabel)
.trim();
}
function compose(assignments) {
var parts = [];
var rawIntro = intro ? intro.value : "";
if (!String(rawIntro).trim()) rawIntro = defaultIntro;
var lead = resolve(rawIntro);
var tail = resolve(greeting ? greeting.value : "");
if (lead) parts.push(lead);
var table = String(assignments == null ? "" : assignments).trim();
if (table) parts.push("Ihre Einsätze im Zeitraum:\n\n" + table);
if (tail) parts.push(tail);
return parts.join("\n\n");
}
function mailtoHref(button, body) {
var email = button.getAttribute("data-mailto-email") || "";
return "mailto:" + encodeURIComponent(email) +
"?subject=" + encodeURIComponent(subject) +
"&body=" + encodeURIComponent(body.replace(/\n/g, "\r\n"));
}
function markCopied(button) {
if (!button) return;
var original = button.getAttribute("data-copy-title");
if (original == null) {
original = button.getAttribute("title") || "";
button.setAttribute("data-copy-title", original);
}
button.classList.add("is-copied");
button.setAttribute("title", "In die Zwischenablage kopiert");
window.clearTimeout(button.copyTimer);
button.copyTimer = window.setTimeout(function () {
button.classList.remove("is-copied");
if (original) button.setAttribute("title", original);
}, 1600);
}
function fallbackCopy(text, button) {
var area = document.createElement("textarea");
area.value = text;
area.setAttribute("readonly", "");
area.style.position = "fixed";
area.style.top = "-1000px";
area.style.opacity = "0";
document.body.appendChild(area);
area.select();
var ok = false;
try { ok = document.execCommand("copy"); } catch (err) { ok = false; }
document.body.removeChild(area);
if (ok) {
markCopied(button);
} else {
window.prompt("Text in die Zwischenablage kopieren:", text);
}
}
function copy(text, button) {
if (!text) return;
if (navigator.clipboard && navigator.clipboard.writeText) {
navigator.clipboard.writeText(text).then(function () {
markCopied(button);
}, function () {
fallbackCopy(text, button);
});
} else {
fallbackCopy(text, button);
}
}
form.querySelectorAll("[data-copy-shared]").forEach(function (button) {
button.addEventListener("click", function () {
copy(compose(""), button);
});
});
form.querySelectorAll("[data-copy-person]").forEach(function (button) {
button.addEventListener("click", function () {
copy(compose(button.getAttribute("data-mail-assignments")), button);
});
});
var mailtoLinks = Array.prototype.slice.call(form.querySelectorAll("[data-mailto-link]"));
function refreshMailto() {
mailtoLinks.forEach(function (link) {
link.setAttribute("href", mailtoHref(link, compose(link.getAttribute("data-mail-assignments"))));
});
}
if (mailtoLinks.length) {
[intro, greeting].forEach(function (field) {
if (field) field.addEventListener("input", refreshMailto);
});
refreshMailto();
}
}
/* Formular-Doppelversand verhindern ------------------------------------ */
function initSubmitGuards() {
document.querySelectorAll("form").forEach(function (form) {
@@ -220,6 +335,7 @@
initFileDrop();
initRangeOutputs();
initDispatchBulk();
initDispatchCopy();
initSubmitGuards();
});
})();
+4
View File
@@ -815,7 +815,11 @@ hr { border: 0; border-top: 1px solid var(--line); margin: 1rem 0; }
/* ---------- Versendung ---------- */
.dispatch-page .range-label { font-family: var(--serif); font-size: .95rem; color: var(--ink-soft); }
.dispatch-bulk { display: flex; gap: .3rem; flex-wrap: wrap; justify-content: flex-end; }
.dispatch-copy-actions { display: flex; align-items: center; gap: .45rem; flex-wrap: wrap; justify-content: flex-end; }
.dispatch-table td { vertical-align: top; }
.dispatch-text-cell { white-space: nowrap; }
.dispatch-text-cell .icon-button + .icon-button { margin-left: .15rem; }
.icon-button.is-copied { color: var(--green-dark); background: var(--green-soft); border-color: #c3d5c6; }
.dispatch-table select { min-width: 9.5rem; }
.dispatch-person { display: flex; flex-direction: column; gap: .1rem; min-width: 11rem; }
.dispatch-person strong { font-size: .9rem; }
+45 -7
View File
@@ -57,6 +57,8 @@ type personPageData struct {
Weekdays []weekdayOption
CanEdit bool
CanManageAll bool
CanEditContact bool
OwnContact bool
UpcomingCount int
TotalCount int
Year int
@@ -185,6 +187,7 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
person = *loaded
}
canManageAll := s.store.CanEditTenant(r.Context(), user, tenant.ID)
ownContact := false
if !canManageAll {
linkedID, linked := user.LinkedPerson(tenant.ID)
if isNew || !linked || linkedID != person.ID {
@@ -192,6 +195,7 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
"Sie dürfen nur die Daten der mit Ihrem Konto verknüpften Person einsehen.")
return
}
ownContact = true
}
absences, err := s.store.AbsencesForPerson(r.Context(), tenant.ID, person.ID)
if err != nil {
@@ -244,10 +248,18 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
sort.SliceStable(rows, func(i, j int) bool {
return rows[i].Service.Date.After(rows[j].Service.Date)
})
canManageContacts := s.store.CanManageSecrets(r.Context(), user, tenant.ID)
ownScope := store.KeyScope{Type: store.ScopePerson, TenantID: tenant.ID, ID: person.ID}
if !canManageAll {
canManageContacts = s.store.SecretIsInitialized(r.Context(), tenant.ID) &&
s.store.HasScopeAccess(r.Context(), user.ID, ownScope)
}
page := personPageData{
Person: person, IsNew: isNew, Absences: absences, Churches: churches,
Assignments: rows, Weekdays: weekdays,
CanEdit: canManageAll || !isNew, CanManageAll: canManageAll,
CanEditContact: canManageContacts,
OwnContact: ownContact,
UpcomingCount: upcoming, TotalCount: len(rows), Year: domain.Year(today),
PreferredChurches: map[string]domain.Church{},
}
@@ -280,18 +292,34 @@ func (s *Server) handlePerson(w http.ResponseWriter, r *http.Request, user *stor
func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *store.User, session *store.Session, tenant *store.Tenant) {
id := r.PathValue("id")
if id == "" || id == "new" {
isNew := id == "" || id == "new"
if isNew {
id = domain.NewID()
}
canManageAll := s.store.CanEditTenant(r.Context(), user, tenant.ID)
var existing *domain.Person
if !canManageAll {
loaded, err := s.store.Person(r.Context(), tenant.ID, id)
if err != nil {
if !isNew {
if loaded, err := s.store.Person(r.Context(), tenant.ID, id); err == nil {
existing = loaded
}
}
if !canManageAll && existing == nil {
s.renderError(w, r, http.StatusForbidden, "Keine Berechtigung", "Diese Person kann nicht bearbeitet werden.")
return
}
existing = loaded
canManageContacts := s.store.CanManageSecrets(r.Context(), user, tenant.ID)
if !canManageAll {
linkedID, linked := user.LinkedPerson(tenant.ID)
if !linked || linkedID != id {
s.renderError(w, r, http.StatusForbidden, "Keine Berechtigung",
"Sie dürfen nur die Daten der mit Ihrem Konto verknüpften Person bearbeiten.")
return
}
// A reader may set their own address as soon as the tenant is
// encrypted and the session holds the person's data key.
canManageContacts = s.store.SecretIsInitialized(r.Context(), tenant.ID) &&
s.store.HasScopeAccess(r.Context(), user.ID,
store.KeyScope{Type: store.ScopePerson, TenantID: tenant.ID, ID: id})
}
var roles []domain.Role
for _, role := range domain.AllRoles {
@@ -299,7 +327,7 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
roles = append(roles, role)
}
}
if existing != nil {
if existing != nil && !canManageAll {
roles = existing.Roles
}
if len(roles) == 0 {
@@ -310,7 +338,7 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
person := domain.Person{
ID: id, FirstName: strings.TrimSpace(r.FormValue("first_name")),
LastName: strings.TrimSpace(r.FormValue("last_name")), Roles: roles,
Email: strings.TrimSpace(r.FormValue("email")), Phone: strings.TrimSpace(r.FormValue("phone")),
Email: strings.TrimSpace(r.FormValue("email")),
PreferredChurchIDs: r.Form["preferred_churches"],
PreferredServiceTitles: splitList(r.FormValue("preferred_titles")),
MaxPerMonth: parseInt(r.FormValue("max_per_month"), 6),
@@ -323,13 +351,23 @@ func (s *Server) handlePersonSave(w http.ResponseWriter, r *http.Request, user *
}
}
if existing != nil {
// Readers keep their planning status. When their own contact cannot be
// written yet, the existing encrypted value must be preserved.
if !canManageAll {
person.Active = existing.Active
}
if !canManageContacts {
person.Email = existing.Email
person.EmailLocked = true
}
person.EmailLocked = person.EmailLocked || (existing.EmailLocked && person.Email == "")
}
if err := s.store.UpsertPerson(r.Context(), tenant.ID, person); err != nil {
s.setFlash(w, "Die Person konnte nicht gespeichert werden: "+err.Error(), "error")
s.redirectBack(w, r, "/team/person/"+id)
return
}
s.refreshCachedKeyrings(r.Context())
s.setFlash(w, "Person gespeichert.", "success")
s.redirect(w, r, "/team/person/"+id)
}
+42 -13
View File
@@ -9,8 +9,10 @@
<div class="intro-actions">
{{if .Data.SMTPConfigured}}
<span class="badge badge-green">{{icon "mail"}} SMTP bereit · {{.Data.SMTPFrom}}</span>
{{else}}
{{else if .Data.CanManageSecrets}}
<span class="badge badge-gold">{{icon "mail"}} SMTP nicht konfiguriert</span>
{{else}}
<span class="badge badge-gold">{{icon "mail"}} SMTP wird von Redakteuren verwaltet</span>
{{end}}
</div>
</section>
@@ -32,7 +34,7 @@
</section>
<section class="stat-strip four">
<article class="mini-stat"><span class="mini-stat-label">E-Mail</span><strong>{{.Data.EmailCount}}</strong><small>Empfänger mit Adresse</small></article>
<article class="mini-stat"><span class="mini-stat-label">E-Mail</span><strong>{{.Data.EmailCount}}</strong><small>{{if .Data.CanManageSecrets}}Empfänger mit Adresse{{else}}Adressen für dieses Konto gesperrt{{end}}</small></article>
<article class="mini-stat"><span class="mini-stat-label">Ausdruck</span><strong>{{.Data.PrintCount}}</strong><small>im Sammel-PDF</small></article>
<article class="mini-stat"><span class="mini-stat-label">Ohne Versand</span><strong>{{.Data.NoneCount}}</strong><small>bewusst ausgelassen</small></article>
<article class="mini-stat"><span class="mini-stat-label">Offene Dienste</span><strong>{{.Data.OpenSlots}}</strong><small>in {{.Data.ServiceCount}} Gottesdiensten</small></article>
@@ -42,14 +44,23 @@
<div class="notice notice-gold">
<span class="notice-mark">{{icon "mail"}}</span>
<div>
<strong>E-Mail-Versand noch nicht eingerichtet</strong>
<p>Hinterlegen Sie die SMTP-Zugangsdaten in den Einstellungen, damit E-Mails direkt verschickt werden können. Ausdrucke funktionieren bereits ohne SMTP.</p>
</div>
{{if .Data.CanManageSecrets}}
<strong>Kein SMTP-Konto hinterlegt – Versand über Ihr E-Mail-Programm</strong>
<p>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.</p>
<a class="btn btn-secondary btn-small" href="/settings">{{icon "settings"}} Zu den Einstellungen</a>
{{else}}
<strong>Direkter E-Mail-Versand ist für dieses Konto nicht verfügbar</strong>
<p>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.</p>
{{end}}
</div>
</div>
{{end}}
<form method="post" action="/dispatch/save" class="page-stack" data-dispatch-form>
<form method="post" action="/dispatch/save" class="page-stack" data-dispatch-form
data-mail-subject="{{.Data.MailSubject}}"
data-range-start="{{.Data.StartLabel}}"
data-range-end="{{.Data.EndLabel}}"
data-default-intro="{{.Data.DefaultIntro}}">
<input type="hidden" name="csrf" value="{{.CSRF}}">
<input type="hidden" name="start" value="{{.Data.Start}}">
<input type="hidden" name="end" value="{{.Data.End}}">
@@ -57,20 +68,23 @@
<section class="card">
<div class="card-head">
<div><span class="eyebrow">Texte</span><h3>Anschreiben</h3></div>
<div class="dispatch-copy-actions">
<span class="count-pill">Platzhalter {start} und {end}</span>
<button class="icon-button" type="button" data-copy-shared title="Einleitung und Gruß in die Zwischenablage kopieren" aria-label="Einleitung und Gruß kopieren">{{icon "copy"}}</button>
</div>
</div>
<div class="settings-grid">
<div class="settings-copy">
<h4>Ein Text für alle</h4>
<p>Der Einleitungstext erscheint in jeder E-Mail und als Vorblatt im Ausdruck. Zwischen Einleitung und Abschluss wird automatisch die Einsatzübersicht der jeweiligen Person eingefügt. Die Platzhalter <code>{start}</code> und <code>{end}</code> werden beim Versand durch den Planungszeitraum ersetzt.</p>
<p class="muted">Ein leer gelassenes Einleitungsfeld stellt den Standardtext wieder her.</p>
<p class="muted">Ein leer gelassenes Einleitungsfeld stellt den Standardtext wieder her. Über das Kopier-Symbol lässt sich der aktuelle Text in die Zwischenablage übernehmen.</p>
</div>
<div class="settings-fields">
<label class="field"><span class="field-label">Einleitungstext</span>
<textarea name="intro" rows="6" maxlength="6000">{{.Data.Intro}}</textarea>
<textarea name="intro" rows="6" maxlength="6000" data-dispatch-intro>{{.Data.Intro}}</textarea>
</label>
<label class="field"><span class="field-label">Abschlussgrußformel</span>
<textarea name="greeting" rows="3" maxlength="2000">{{.Data.Greeting}}</textarea>
<textarea name="greeting" rows="3" maxlength="2000" data-dispatch-greeting>{{.Data.Greeting}}</textarea>
</label>
</div>
</div>
@@ -94,6 +108,7 @@
<th>Versandweg</th>
<th>Liste</th>
<th>Vorblatt</th>
<th>Text</th>
</tr>
</thead>
<tbody>
@@ -107,6 +122,8 @@
<small>{{$person.RoleLabel}}</small>
{{if $person.Email}}
<a href="mailto:{{$person.Email}}">{{$person.Email}}</a>
{{else if $person.EmailLocked}}
<span class="dispatch-no-mail">E-Mail-Adresse gesperrt</span>
{{else}}
<span class="dispatch-no-mail">keine E-Mail-Adresse hinterlegt</span>
{{end}}
@@ -132,7 +149,7 @@
<option value="print" {{if eq .Channel "print"}}selected{{end}}>Ausdruck</option>
<option value="none" {{if eq .Channel "none"}}selected{{end}}>Nicht versenden</option>
</select>
{{if and (eq .Channel "email") (not $person.Email)}}<small class="dispatch-warn">ohne Adresse → Ausdruck</small>{{end}}
{{if and (eq .Channel "email") (not $person.Email)}}<small class="dispatch-warn">{{if $person.EmailLocked}}Adresse gesperrt{{else}}ohne Adresse{{end}} → Ausdruck</small>{{end}}
</td>
<td>
<select name="variant_{{$person.ID}}" aria-label="Liste für {{$person.FullName}}">
@@ -146,17 +163,29 @@
<span>{{if eq $effective "email"}}E-Mail-Text{{else}}Anschreiben{{end}}</span>
</label>
</td>
<td class="dispatch-text-cell">
<button class="icon-button" type="button" data-copy-person data-mail-assignments="{{.AssignmentText}}" title="Anschreiben für {{$person.FullName}} kopieren" aria-label="Anschreiben für {{$person.FullName}} kopieren">{{icon "copy"}}</button>
{{if and (not $.Data.SMTPConfigured) $person.Email}}
<a class="icon-button" href="{{.Mailto}}" data-mailto-link data-mailto-email="{{$person.Email}}" data-mail-assignments="{{.AssignmentText}}" title="Entwurf im eigenen E-Mail-Programm öffnen" aria-label="E-Mail an {{$person.FullName}} im E-Mail-Programm öffnen">{{icon "mail"}}</a>
{{end}}
</td>
</tr>
{{else}}
<tr><td colspan="5"><p class="empty-note">Im aktiven Mandanten sind noch keine aktiven Personen hinterlegt.</p></td></tr>
<tr><td colspan="6"><p class="empty-note">Im aktiven Mandanten sind noch keine aktiven Personen hinterlegt.</p></td></tr>
{{end}}
</tbody>
</table>
</div>
<p class="table-note">E-Mail-Empfänger erhalten den Plan als PDF-Anhang. Personen ohne Adresse oder mit der Auswahl „Ausdruck“ werden in einem sammelbaren PDF zusammengefasst – nacheinander mit Vorblatt und gewählter Liste.</p>
<p class="table-note">E-Mail-Empfänger erhalten den Plan als PDF-Anhang. Personen ohne Adresse oder mit der Auswahl „Ausdruck“ werden in einem sammelbaren PDF zusammengefasst – nacheinander mit Vorblatt und gewählter Liste. In der Spalte „Text“ kopiert das erste Symbol das persönliche Anschreiben; ohne SMTP öffnet das zweite Symbol einen fertigen Entwurf im eigenen E-Mail-Programm.{{if not .Data.CanManageSecrets}} Empfängeradressen und SMTP-Zugangsdaten sind für dieses Konto gesperrt und werden von Redakteuren verwaltet.{{end}}</p>
<div class="card-foot dispatch-actions">
<button class="btn btn-secondary" type="submit">{{icon "check"}} Auswahl speichern</button>
{{if .Data.SMTPConfigured}}
<button class="btn btn-primary" type="submit" formaction="/dispatch/send" data-confirm="Die E-Mails jetzt an alle ausgewählten Empfänger senden?">{{icon "send"}} E-Mails senden</button>
{{else if .Data.CanManageSecrets}}
<button class="btn btn-primary" type="button" disabled title="Kein SMTP-Konto hinterlegt – nutzen Sie das E-Mail-Symbol in der Spalte „Text“.">{{icon "send"}} E-Mails senden</button>
{{else}}
<button class="btn btn-primary" type="button" disabled title="SMTP-Zugangsdaten können nur Redakteure hinterlegen.">{{icon "send"}} E-Mails senden</button>
{{end}}
<button class="btn btn-secondary" type="submit" formaction="/dispatch/print" formtarget="_blank">{{icon "printer"}} Druck-PDF erzeugen</button>
</div>
</section>
@@ -199,7 +228,7 @@
<tr>
<td>{{.CreatedAt.Format "02.01.2006, 15:04"}}</td>
<td>{{shortDate .RangeStart}} – {{shortDate .RangeEnd}}</td>
<td>{{.PersonName}}{{if .Email}}<br><small>{{.Email}}</small>{{end}}</td>
<td>{{.PersonName}}</td>
<td>{{channelLabel .Channel}}{{if .Cover}}<br><small>mit Vorblatt</small>{{end}}</td>
<td>{{variantLabel .Variant}}</td>
<td><span class="dispatch-log-status status-{{.Status}}">{{statusLabel .Status}}</span></td>
+1 -1
View File
@@ -64,7 +64,7 @@
{{end}}
<div class="auth-note">
<span class="dot"></span>
<span>Sitzungen sind serverseitig gespeichert, Passwörter mit bcrypt geschützt.</span>
<span>Sitzungen sind serverseitig gespeichert, Passwörter mit bcrypt geschützt. Kontaktdaten und SMTP-Zugangsdaten liegen verschlüsselt.</span>
</div>
</section>
</div>
+2 -3
View File
@@ -40,8 +40,7 @@
<label class="field"><span class="field-label">Nachname</span><input type="text" name="last_name" value="{{$person.LastName}}"></label>
</div>
<div class="form-row">
<label class="field"><span class="field-label">E-Mail</span><input type="email" name="email" value="{{$person.Email}}"></label>
<label class="field"><span class="field-label">Telefon</span><input type="text" name="phone" value="{{$person.Phone}}"></label>
<label class="field"><span class="field-label">E-Mail{{if not .Data.CanEditContact}} <small>{{if .Data.OwnContact}}noch nicht freigegeben{{else}}nur Redakteure{{end}}</small>{{else if $person.EmailLocked}} <small>gesperrt</small>{{end}}</span><input type="email" name="email" value="{{$person.Email}}" {{if not .Data.CanEditContact}}disabled placeholder="{{if .Data.OwnContact}}Wird nach der Einrichtung durch einen Redakteur freigegeben{{else}}Wird nur von Redakteuren verwaltet{{end}}"{{else if $person.EmailLocked}}placeholder="Verschlüsselt – zum Ändern neu eingeben"{{end}}></label>
</div>
<div class="field-group">
<span class="field-label">Dienste</span>
@@ -81,7 +80,7 @@
<dt>Name</dt><dd>{{$person.FullName}}</dd>
<dt>Dienste</dt><dd>{{$person.RoleLabel}}</dd>
{{if $person.Email}}<dt>E-Mail</dt><dd>{{$person.Email}}</dd>{{end}}
{{if $person.Phone}}<dt>Telefon</dt><dd>{{$person.Phone}}</dd>{{end}}
{{if $person.EmailLocked}}<dt>Kontaktdaten</dt><dd>verschlüsselt und für dieses Konto nicht entsperrt</dd>{{end}}
<dt>Monatslimit</dt><dd>{{if gt $person.MaxPerMonth 0}}{{$person.MaxPerMonth}}{{else}}kein Limit{{end}}</dd>
{{if $person.Notes}}<dt>Notizen</dt><dd>{{$person.Notes}}</dd>{{end}}
</dl>
+2 -2
View File
@@ -50,14 +50,14 @@
</section>
{{end}}
{{if .Data.CanEdit}}
{{if .Data.CanManageSecrets}}
<section class="card">
<div class="card-head"><div><span class="eyebrow">Versendung</span><h3>E-Mail-Versand (SMTP)</h3></div>{{if .Data.SMTPConfigured}}<span class="badge badge-green">{{icon "check"}} konfiguriert</span>{{else}}<span class="badge badge-gold">noch nicht konfiguriert</span>{{end}}</div>
<div class="settings-grid">
<div class="settings-copy">
<h4>Zugangsdaten des Postfachs</h4>
<p>Diese Angaben gelten für den aktiven Mandanten und werden für den Versand der Pläne über die Versendungsansicht benötigt. Üblich sind Port 587 mit STARTTLS oder Port 465 mit SSL/TLS.</p>
<p class="muted">Das Passwort wird gespeichert, aber nie wieder angezeigt. Leer lassen, um das bisherige Passwort beizubehalten.</p>
<p class="muted">Die Zugangsdaten werden verschlüsselt gespeichert und sind nur für entsperrte Redakteure dieses Mandanten lesbar. Das Passwort wird nie wieder angezeigt – leer lassen, um es beizubehalten.</p>
</div>
<div class="settings-fields">
<div class="form-row">
+1 -2
View File
@@ -50,8 +50,7 @@
</div>
<div class="person-details">
{{if .Email}}<a href="mailto:{{.Email}}">{{.Email}}</a>{{end}}
{{if .Phone}}<span>{{.Phone}}</span>{{end}}
{{if or .Email .Phone}}{{else}}<span class="muted">Keine Kontaktdaten</span>{{end}}
{{if .EmailLocked}}<span class="muted">Kontaktdaten gesperrt</span>{{else if not .Email}}<span class="muted">Keine Kontaktdaten</span>{{end}}
</div>
{{if .HasPreference}}
<div class="preference-tags">
+27
View File
@@ -0,0 +1,27 @@
{{define "content"}}
<div class="page-stack narrow-page">
<section class="page-intro">
<div>
<span class="eyebrow">Sicherheit</span>
<h2>Daten entsperren</h2>
<p>Nach einem Neustart des Servers liegen die Entschlüsselungsschlüssel nicht mehr im Arbeitsspeicher. Bitte geben Sie Ihr Anmeldepasswort ein, um Ihre verschlüsselten Daten wieder zu entsperren. Redakteure entsperren damit alle Kontaktdaten und SMTP-Zugangsdaten, Leser die eigene E-Mail-Adresse.</p>
</div>
</section>
<section class="card">
<form method="post" action="/unlock" class="form-stack">
<input type="hidden" name="csrf" value="{{.CSRF}}">
<input type="hidden" name="next" value="{{.Data.Next}}">
<label class="field"><span class="field-label">Passwort</span><input type="password" name="password" required autocomplete="current-password" autofocus></label>
<div class="form-actions">
<button class="btn btn-primary" type="submit">Entsperren</button>
</div>
</form>
<form method="post" action="/logout" class="form-actions">
<input type="hidden" name="csrf" value="{{.CSRF}}">
<button class="btn btn-ghost" type="submit">Stattdessen abmelden</button>
</form>
<p class="empty-note">Wurde Ihr Passwort von einem Administrator zurückgesetzt, melden Sie sich mit dem temporären Passwort an.</p>
</section>
</div>
{{end}}