SMTP-Credentials und E_Mail-Adressen verschlüsselt abgelegt
This commit is contained in:
1 parent
781aa20253
commit
66659d9a23
32 files changed
+3276
-132
No files matched your search
@@ -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
|
||||
}
|
||||
|
||||
|
||||
@@ -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
@@ -139,7 +139,6 @@ CREATE TABLE IF NOT EXISTS people (
|
||||
last_name TEXT NOT NULL,
|
||||
roles TEXT NOT NULL,
|
||||
email TEXT NOT NULL DEFAULT '',
|
||||
phone TEXT NOT NULL DEFAULT '',
|
||||
preferred_church_ids TEXT NOT NULL DEFAULT '[]',
|
||||
preferred_weekdays TEXT NOT NULL DEFAULT '[]',
|
||||
preferred_service_titles TEXT NOT NULL DEFAULT '[]',
|
||||
@@ -279,6 +278,43 @@ CREATE TABLE IF NOT EXISTS dispatch_log (
|
||||
created_by TEXT NOT NULL DEFAULT ''
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_dispatch_log_tenant ON dispatch_log(tenant_id, created_at);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS user_keys (
|
||||
user_id TEXT PRIMARY KEY REFERENCES users(id) ON DELETE CASCADE,
|
||||
kdf_salt BLOB NOT NULL,
|
||||
kdf_version TEXT NOT NULL,
|
||||
public_key BLOB NOT NULL,
|
||||
wrapped_private BLOB NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS key_wrappers (
|
||||
scope_type TEXT NOT NULL,
|
||||
tenant_id TEXT NOT NULL,
|
||||
scope_id TEXT NOT NULL,
|
||||
user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
ephemeral_public BLOB NOT NULL,
|
||||
wrapped_dek BLOB NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
PRIMARY KEY (scope_type, tenant_id, scope_id, user_id)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_key_wrappers_user ON key_wrappers(user_id);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS secrets (
|
||||
tenant_id TEXT NOT NULL REFERENCES tenants(id) ON DELETE CASCADE,
|
||||
scope_type TEXT NOT NULL,
|
||||
scope_id TEXT NOT NULL,
|
||||
secret_key TEXT NOT NULL,
|
||||
ciphertext BLOB NOT NULL,
|
||||
updated_at TEXT NOT NULL,
|
||||
PRIMARY KEY (tenant_id, scope_type, scope_id, secret_key)
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS secret_state (
|
||||
tenant_id TEXT PRIMARY KEY REFERENCES tenants(id) ON DELETE CASCADE,
|
||||
initialized_at TEXT NOT NULL
|
||||
);
|
||||
`
|
||||
|
||||
func (s *Store) migrate(ctx context.Context) error {
|
||||
@@ -309,10 +345,53 @@ func (s *Store) migrate(ctx context.Context) error {
|
||||
}
|
||||
}
|
||||
if _, err := s.db.ExecContext(ctx,
|
||||
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '3') "+
|
||||
"INSERT INTO schema_meta(key, value) VALUES('schemaVersion', '5') "+
|
||||
"ON CONFLICT(key) DO UPDATE SET value=excluded.value"); err != nil {
|
||||
return fmt.Errorf("record schema version: %w", err)
|
||||
}
|
||||
// Phone numbers are no longer stored anywhere in the web app. Remove both
|
||||
// the encrypted values and the legacy plaintext column.
|
||||
if _, err := s.db.ExecContext(ctx,
|
||||
"DELETE FROM secrets WHERE secret_key='phone'"); err != nil {
|
||||
return fmt.Errorf("remove encrypted phone numbers: %w", err)
|
||||
}
|
||||
hasPhone, err := s.hasColumn(ctx, "people", "phone")
|
||||
if err != nil {
|
||||
return fmt.Errorf("inspect people table: %w", err)
|
||||
}
|
||||
if hasPhone {
|
||||
if _, err := s.db.ExecContext(ctx, "ALTER TABLE people DROP COLUMN phone"); err != nil {
|
||||
return fmt.Errorf("drop people.phone: %w", err)
|
||||
}
|
||||
}
|
||||
// Editors and linked readers hold key material; administrators never do.
|
||||
// Readers may only keep the scope of their linked person.
|
||||
if _, err := s.db.ExecContext(ctx,
|
||||
"DELETE FROM key_wrappers WHERE user_id IN (SELECT id FROM users WHERE role='admin')"); err != nil {
|
||||
return fmt.Errorf("prune administrator key wrappers: %w", err)
|
||||
}
|
||||
if _, err := s.db.ExecContext(ctx,
|
||||
"DELETE FROM user_keys WHERE user_id IN (SELECT id FROM users WHERE role='admin')"); err != nil {
|
||||
return fmt.Errorf("prune administrator keys: %w", err)
|
||||
}
|
||||
if _, err := s.db.ExecContext(ctx, `
|
||||
DELETE FROM key_wrappers WHERE user_id IN (
|
||||
SELECT u.id FROM users u WHERE u.role='reader' AND (
|
||||
u.linked_tenant_id='' OR u.linked_person_id='' OR NOT (
|
||||
key_wrappers.scope_type='person'
|
||||
AND key_wrappers.tenant_id=u.linked_tenant_id
|
||||
AND key_wrappers.scope_id=u.linked_person_id
|
||||
)
|
||||
)
|
||||
)`); err != nil {
|
||||
return fmt.Errorf("prune unlinked reader key wrappers: %w", err)
|
||||
}
|
||||
// Dispatch logs used to contain the full recipient address. Remove that
|
||||
// plaintext now that addresses are stored encrypted.
|
||||
if _, err := s.db.ExecContext(ctx,
|
||||
"UPDATE dispatch_log SET email='' WHERE email<>''"); err != nil {
|
||||
return fmt.Errorf("redact dispatch log: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
+4
-4
@@ -73,17 +73,17 @@ func badGodesbergSpec() demoTenantSpec {
|
||||
|
||||
people := []domain.Person{
|
||||
{ID: "p-anna", FirstName: "Anna", LastName: "Berg", Roles: []domain.Role{domain.RoleLector},
|
||||
Email: "anna.berg@example.org", Phone: "0228 555 0101",
|
||||
Email: "anna.berg@example.org",
|
||||
PreferredChurchIDs: []string{"c-andreas"}, PreferredWeekdays: []int{1},
|
||||
PreferredServiceTitles: []string{"Hochamt"}, MaxPerMonth: 7, Active: true,
|
||||
Notes: "Liest besonders gerne die Sonntagslesungen."},
|
||||
{ID: "p-markus", FirstName: "Markus", LastName: "Weber", Roles: []domain.Role{domain.RoleLector},
|
||||
Email: "markus.weber@example.org", Phone: "0228 555 0102",
|
||||
Email: "markus.weber@example.org",
|
||||
PreferredChurchIDs: []string{"c-herzjesu"}, PreferredWeekdays: []int{1, 7},
|
||||
PreferredServiceTitles: []string{"Vorabendmesse"}, MaxPerMonth: 8, Active: true},
|
||||
{ID: "p-elisabeth", FirstName: "Elisabeth", LastName: "Klein",
|
||||
Roles: []domain.Role{domain.RoleLector, domain.RoleHelper},
|
||||
Email: "elisabeth.klein@example.org", Phone: "0228 555 0103",
|
||||
Roles: []domain.Role{domain.RoleLector, domain.RoleHelper},
|
||||
Email: "elisabeth.klein@example.org",
|
||||
MaxPerMonth: 9, Active: true, Notes: "Flexibel einsetzbar, auch kurzfristig."},
|
||||
{ID: "p-johannes", FirstName: "Johannes", LastName: "Schmitz", Roles: []domain.Role{domain.RoleLector},
|
||||
Email: "johannes.schmitz@example.org", PreferredChurchIDs: []string{"c-evergislus"},
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,586 @@
|
||||
package store
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// openDemoStore returns an in-memory store with the demo tenant.
|
||||
func openDemoStore(t *testing.T) *Store {
|
||||
t.Helper()
|
||||
st, err := Open(":memory:")
|
||||
if err != nil {
|
||||
t.Fatalf("open store: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { st.Close() })
|
||||
if err := st.SeedDemo(context.Background()); err != nil {
|
||||
t.Fatalf("seed demo: %v", err)
|
||||
}
|
||||
return st
|
||||
}
|
||||
|
||||
type secretFixture struct {
|
||||
tenantID string
|
||||
personID string
|
||||
email string
|
||||
editor *User
|
||||
reader *User
|
||||
}
|
||||
|
||||
func prepareSecretFixture(t *testing.T, st *Store) secretFixture {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
var fixture secretFixture
|
||||
if err := st.db.QueryRowContext(ctx,
|
||||
"SELECT tenant_id, id, email FROM people WHERE email<>'' LIMIT 1").
|
||||
Scan(&fixture.tenantID, &fixture.personID, &fixture.email); err != nil {
|
||||
t.Fatalf("contact person: %v", err)
|
||||
}
|
||||
editor, err := st.UserByUsername(ctx, "editor")
|
||||
if err != nil {
|
||||
t.Fatalf("editor: %v", err)
|
||||
}
|
||||
reader, err := st.UserByUsername(ctx, "reader")
|
||||
if err != nil {
|
||||
t.Fatalf("reader: %v", err)
|
||||
}
|
||||
fixture.editor = editor
|
||||
fixture.reader = reader
|
||||
return fixture
|
||||
}
|
||||
|
||||
func TestSecretsEncryptContactsAndSMTP(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
if err := st.SetTenantSetting(ctx, fixture.tenantID, "smtp.host", "smtp.example.org"); err != nil {
|
||||
t.Fatalf("legacy smtp host: %v", err)
|
||||
}
|
||||
if err := st.SetTenantSetting(ctx, fixture.tenantID, "smtp.password", "secret"); err != nil {
|
||||
t.Fatalf("legacy smtp password: %v", err)
|
||||
}
|
||||
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
if !st.SecretIsInitialized(ctx, fixture.tenantID) {
|
||||
t.Fatal("tenant is not marked as encrypted")
|
||||
}
|
||||
|
||||
var plainEmail string
|
||||
if err := st.db.QueryRowContext(ctx,
|
||||
"SELECT email FROM people WHERE tenant_id=? AND id=?",
|
||||
fixture.tenantID, fixture.personID).Scan(&plainEmail); err != nil {
|
||||
t.Fatalf("read person row: %v", err)
|
||||
}
|
||||
if plainEmail != "" {
|
||||
t.Fatalf("plaintext contact remains: email=%q", plainEmail)
|
||||
}
|
||||
if got := st.TenantSetting(ctx, fixture.tenantID, "smtp.password"); got != "" {
|
||||
t.Fatalf("SMTP password remains as tenant setting %q", got)
|
||||
}
|
||||
|
||||
keyCtx := WithKeyring(ctx, editorKey)
|
||||
if got, ok := st.SecretValue(keyCtx, fixture.tenantID, ScopeTenant, fixture.tenantID, "smtp.host"); !ok || got != "smtp.example.org" {
|
||||
t.Fatalf("smtp host = %q, ok=%v", got, ok)
|
||||
}
|
||||
if got, ok := st.SecretValue(keyCtx, fixture.tenantID, ScopeTenant, fixture.tenantID, "smtp.password"); !ok || got != "secret" {
|
||||
t.Fatalf("smtp password = %q, ok=%v", got, ok)
|
||||
}
|
||||
|
||||
person, err := st.Person(keyCtx, fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person with keyring: %v", err)
|
||||
}
|
||||
if person.Email != fixture.email || person.EmailLocked {
|
||||
t.Fatalf("decrypted e-mail = %q locked=%v, want %q", person.Email, person.EmailLocked, fixture.email)
|
||||
}
|
||||
|
||||
locked, err := st.Person(ctx, fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person without keyring: %v", err)
|
||||
}
|
||||
if locked.Email != "" || !locked.EmailLocked {
|
||||
t.Fatalf("locked e-mail = %q locked=%v", locked.Email, locked.EmailLocked)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWrongPasswordDoesNotUnlockKeys(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err != nil {
|
||||
t.Fatalf("create keys: %v", err)
|
||||
}
|
||||
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "falsch"); err == nil {
|
||||
t.Fatal("wrong password unlocked the keypair")
|
||||
}
|
||||
}
|
||||
|
||||
func TestScopeWrappersFollowRolePolicy(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil {
|
||||
t.Fatalf("link reader: %v", err)
|
||||
}
|
||||
if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("reconcile: %v", err)
|
||||
}
|
||||
|
||||
readerScopes, err := st.ScopesForUser(ctx, fixture.reader.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("reader scopes: %v", err)
|
||||
}
|
||||
if len(readerScopes) != 1 || readerScopes[0].Type != ScopePerson ||
|
||||
readerScopes[0].TenantID != fixture.tenantID || readerScopes[0].ID != fixture.personID {
|
||||
t.Fatalf("reader scopes = %+v, want only own person scope", readerScopes)
|
||||
}
|
||||
|
||||
// Administrators must not receive wrappers, even if stale key material
|
||||
// exists for them.
|
||||
admin, err := st.UserByUsername(ctx, "admin")
|
||||
if err != nil {
|
||||
t.Fatalf("admin: %v", err)
|
||||
}
|
||||
if _, err := st.EnsureUserKeys(ctx, admin.ID, "temporary"); err != nil {
|
||||
t.Fatalf("legacy admin keys: %v", err)
|
||||
}
|
||||
if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("reconcile after admin keys: %v", err)
|
||||
}
|
||||
if adminScopes, _ := st.ScopesForUser(ctx, admin.ID); len(adminScopes) != 0 {
|
||||
t.Fatalf("administrator received %d encrypted scopes", len(adminScopes))
|
||||
}
|
||||
|
||||
// A reader has access to the own address only.
|
||||
readerKey, err := st.EnsureUserKeys(ctx, fixture.reader.ID, "reader123")
|
||||
if err != nil {
|
||||
t.Fatalf("reader keys: %v", err)
|
||||
}
|
||||
if err := st.UnlockAccessibleKeys(ctx, readerKey); err != nil {
|
||||
t.Fatalf("unwrap reader keys: %v", err)
|
||||
}
|
||||
own, err := st.Person(WithKeyring(ctx, readerKey), fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("own person: %v", err)
|
||||
}
|
||||
if own.Email != fixture.email {
|
||||
t.Fatalf("reader e-mail = %q, want %q", own.Email, fixture.email)
|
||||
}
|
||||
var otherID string
|
||||
if err := st.db.QueryRowContext(ctx,
|
||||
"SELECT id FROM people WHERE tenant_id=? AND id<>? LIMIT 1",
|
||||
fixture.tenantID, fixture.personID).Scan(&otherID); err != nil {
|
||||
t.Fatalf("other person: %v", err)
|
||||
}
|
||||
other, err := st.Person(WithKeyring(ctx, readerKey), fixture.tenantID, otherID)
|
||||
if err != nil {
|
||||
t.Fatalf("other person: %v", err)
|
||||
}
|
||||
if other.Email != "" {
|
||||
t.Fatalf("reader decrypted another person's e-mail %q", other.Email)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPasswordChangeKeepsDataKeys(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
if _, err := st.RekeyUserPassword(ctx, fixture.editor.ID, "editor123", "neues-passwort"); err != nil {
|
||||
t.Fatalf("rekey: %v", err)
|
||||
}
|
||||
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err == nil {
|
||||
t.Fatal("old password still unlocks the keypair")
|
||||
}
|
||||
rekeyed, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "neues-passwort")
|
||||
if err != nil {
|
||||
t.Fatalf("new password: %v", err)
|
||||
}
|
||||
if err := st.UnlockAccessibleKeys(ctx, rekeyed); err != nil {
|
||||
t.Fatalf("unlock rekeyed: %v", err)
|
||||
}
|
||||
person, err := st.Person(WithKeyring(ctx, rekeyed), fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person after rekey: %v", err)
|
||||
}
|
||||
if person.Email != fixture.email {
|
||||
t.Fatalf("e-mail after rekey = %q, want %q", person.Email, fixture.email)
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdminResetRewrapsEditorScopes(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
_, scopes, err := st.ResetUserKeys(ctx, fixture.editor.ID, "temp-passwort")
|
||||
if err != nil {
|
||||
t.Fatalf("reset editor keys: %v", err)
|
||||
}
|
||||
if _, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123"); err == nil {
|
||||
t.Fatal("old password still unlocks after reset")
|
||||
}
|
||||
// Another unlocked editor can restore the scopes without ever exposing
|
||||
// the data to an administrator.
|
||||
granted, err := st.RewrapScopes(ctx, editorKey, fixture.editor.ID, scopes)
|
||||
if err != nil {
|
||||
t.Fatalf("rewrap: %v", err)
|
||||
}
|
||||
if granted == 0 {
|
||||
t.Fatal("no scopes were granted again")
|
||||
}
|
||||
resetKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "temp-passwort")
|
||||
if err != nil {
|
||||
t.Fatalf("temporary password: %v", err)
|
||||
}
|
||||
if err := st.UnlockAccessibleKeys(ctx, resetKey); err != nil {
|
||||
t.Fatalf("unlock reset keys: %v", err)
|
||||
}
|
||||
person, err := st.Person(WithKeyring(ctx, resetKey), fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person after reset: %v", err)
|
||||
}
|
||||
if person.Email != fixture.email {
|
||||
t.Fatalf("e-mail after reset = %q, want %q", person.Email, fixture.email)
|
||||
}
|
||||
}
|
||||
|
||||
func TestExchangeExportOmitsContacts(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
exchange, err := st.ExportResources(WithKeyring(ctx, editorKey), fixture.tenantID)
|
||||
if err != nil {
|
||||
t.Fatalf("export: %v", err)
|
||||
}
|
||||
for _, person := range exchange.Resources.People {
|
||||
if person.Email != "" {
|
||||
t.Fatalf("export contains contact data for %s", person.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestPruneUserWrappersRestrictsReaderToOwnScope(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil {
|
||||
t.Fatalf("link reader: %v", err)
|
||||
}
|
||||
tenantScope := KeyScope{Type: ScopeTenant, TenantID: fixture.tenantID, ID: fixture.tenantID}
|
||||
tenantDEK, err := st.ensureScope(ctx, editorKey, tenantScope)
|
||||
if err != nil {
|
||||
t.Fatalf("tenant scope: %v", err)
|
||||
}
|
||||
ownScope := KeyScope{Type: ScopePerson, TenantID: fixture.tenantID, ID: fixture.personID}
|
||||
ownDEK, err := st.ensureScope(ctx, editorKey, ownScope)
|
||||
if err != nil {
|
||||
t.Fatalf("own scope: %v", err)
|
||||
}
|
||||
// Simulate stale grants from older versions.
|
||||
if err := st.grantScopeDEK(ctx, editorKey, tenantScope, tenantDEK, []string{fixture.reader.ID}); err != nil {
|
||||
t.Fatalf("legacy tenant grant: %v", err)
|
||||
}
|
||||
if err := st.grantScopeDEK(ctx, editorKey, ownScope, ownDEK, []string{fixture.reader.ID}); err != nil {
|
||||
t.Fatalf("legacy person grant: %v", err)
|
||||
}
|
||||
if err := st.PruneUserWrappers(ctx, fixture.reader.ID); err != nil {
|
||||
t.Fatalf("prune reader: %v", err)
|
||||
}
|
||||
scopes, err := st.ScopesForUser(ctx, fixture.reader.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("reader scopes: %v", err)
|
||||
}
|
||||
if len(scopes) != 1 || scopes[0].String() != ownScope.String() {
|
||||
t.Fatalf("reader scopes = %+v, want only %s", scopes, ownScope.String())
|
||||
}
|
||||
if !st.HasUserKeys(ctx, fixture.reader.ID) {
|
||||
t.Fatal("reader lost key material")
|
||||
}
|
||||
|
||||
// Administrators lose both wrappers and key material.
|
||||
admin, err := st.UserByUsername(ctx, "admin")
|
||||
if err != nil {
|
||||
t.Fatalf("admin: %v", err)
|
||||
}
|
||||
if _, err := st.EnsureUserKeys(ctx, admin.ID, "temporary"); err != nil {
|
||||
t.Fatalf("legacy admin keys: %v", err)
|
||||
}
|
||||
if err := st.grantScopeDEK(ctx, editorKey, tenantScope, tenantDEK, []string{admin.ID}); err != nil {
|
||||
t.Fatalf("legacy admin grant: %v", err)
|
||||
}
|
||||
if err := st.PruneUserWrappers(ctx, admin.ID); err != nil {
|
||||
t.Fatalf("prune admin: %v", err)
|
||||
}
|
||||
if adminScopes, _ := st.ScopesForUser(ctx, admin.ID); len(adminScopes) != 0 {
|
||||
t.Fatalf("administrator still holds %d wrappers", len(adminScopes))
|
||||
}
|
||||
if st.HasUserKeys(ctx, admin.ID) {
|
||||
t.Fatal("administrator still holds key material")
|
||||
}
|
||||
}
|
||||
|
||||
func TestReaderRefreshesAccessForNewEditors(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
if err := st.SetUserPersonLink(ctx, fixture.reader.ID, fixture.tenantID, fixture.personID); err != nil {
|
||||
t.Fatalf("link reader: %v", err)
|
||||
}
|
||||
if err := st.ReconcileTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("reconcile: %v", err)
|
||||
}
|
||||
readerKey, err := st.EnsureUserKeys(ctx, fixture.reader.ID, "reader123")
|
||||
if err != nil {
|
||||
t.Fatalf("reader keys: %v", err)
|
||||
}
|
||||
if err := st.UnlockAccessibleKeys(ctx, readerKey); err != nil {
|
||||
t.Fatalf("unwrap reader keys: %v", err)
|
||||
}
|
||||
|
||||
ownScope := KeyScope{Type: ScopePerson, TenantID: fixture.tenantID, ID: fixture.personID}
|
||||
newEditor, err := st.CreateUser(ctx, "editor-neu", "Neue Redaktion", "editor-neu-123",
|
||||
RoleEditor, true, []string{fixture.tenantID})
|
||||
if err != nil {
|
||||
t.Fatalf("create editor: %v", err)
|
||||
}
|
||||
if st.HasScopeAccess(ctx, newEditor.ID, ownScope) {
|
||||
t.Fatal("new editor already has the person scope")
|
||||
}
|
||||
|
||||
// The next login of the reader wraps the address for the new editor.
|
||||
if err := st.EnsurePersonScope(ctx, readerKey, fixture.tenantID, fixture.personID); err != nil {
|
||||
t.Fatalf("reader refresh: %v", err)
|
||||
}
|
||||
if !st.HasScopeAccess(ctx, newEditor.ID, ownScope) {
|
||||
t.Fatal("new editor did not receive the person scope")
|
||||
}
|
||||
newKey, err := st.EnsureUserKeys(ctx, newEditor.ID, "editor-neu-123")
|
||||
if err != nil {
|
||||
t.Fatalf("new editor keys: %v", err)
|
||||
}
|
||||
if err := st.UnlockAccessibleKeys(ctx, newKey); err != nil {
|
||||
t.Fatalf("unlock new editor: %v", err)
|
||||
}
|
||||
person, err := st.Person(WithKeyring(ctx, newKey), fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person as new editor: %v", err)
|
||||
}
|
||||
if person.Email != fixture.email {
|
||||
t.Fatalf("new editor e-mail = %q, want %q", person.Email, fixture.email)
|
||||
}
|
||||
}
|
||||
|
||||
func TestPruneUserWrappersKeepsEditorMembershipScopes(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
before, err := st.ScopesForUser(ctx, fixture.editor.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("editor scopes: %v", err)
|
||||
}
|
||||
if len(before) == 0 {
|
||||
t.Fatal("editor received no scopes")
|
||||
}
|
||||
if err := st.PruneUserWrappers(ctx, fixture.editor.ID); err != nil {
|
||||
t.Fatalf("prune editor: %v", err)
|
||||
}
|
||||
after, err := st.ScopesForUser(ctx, fixture.editor.ID)
|
||||
if err != nil {
|
||||
t.Fatalf("editor scopes after prune: %v", err)
|
||||
}
|
||||
if len(after) != len(before) {
|
||||
t.Fatalf("editor scopes changed from %d to %d", len(before), len(after))
|
||||
}
|
||||
}
|
||||
|
||||
func TestBootstrapMigratesPlaintextCreatedAfterInitialization(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
editorKey, err := st.EnsureUserKeys(ctx, fixture.editor.ID, "editor123")
|
||||
if err != nil {
|
||||
t.Fatalf("editor keys: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("bootstrap: %v", err)
|
||||
}
|
||||
|
||||
// Simulate a seeding or restore run without a keyring that writes a
|
||||
// plaintext address after the tenant was already migrated and its
|
||||
// encrypted value was removed together with the planning data.
|
||||
lateEmail := "nachzuegler@example.org"
|
||||
if _, err := st.db.ExecContext(ctx,
|
||||
"DELETE FROM secrets WHERE tenant_id=? AND scope_type='person' AND scope_id=? AND secret_key='email'",
|
||||
fixture.tenantID, fixture.personID); err != nil {
|
||||
t.Fatalf("delete old secret: %v", err)
|
||||
}
|
||||
if _, err := st.db.ExecContext(ctx,
|
||||
"UPDATE people SET email=? WHERE tenant_id=? AND id=?",
|
||||
lateEmail, fixture.tenantID, fixture.personID); err != nil {
|
||||
t.Fatalf("late plaintext: %v", err)
|
||||
}
|
||||
if err := st.BootstrapTenant(ctx, editorKey, fixture.tenantID); err != nil {
|
||||
t.Fatalf("second bootstrap: %v", err)
|
||||
}
|
||||
|
||||
var plain string
|
||||
if err := st.db.QueryRowContext(ctx,
|
||||
"SELECT email FROM people WHERE tenant_id=? AND id=?",
|
||||
fixture.tenantID, fixture.personID).Scan(&plain); err != nil {
|
||||
t.Fatalf("read person: %v", err)
|
||||
}
|
||||
if plain != "" {
|
||||
t.Fatalf("late plaintext remains: %q", plain)
|
||||
}
|
||||
person, err := st.Person(WithKeyring(ctx, editorKey), fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person: %v", err)
|
||||
}
|
||||
if person.Email != lateEmail {
|
||||
t.Fatalf("migrated e-mail = %q, want %q", person.Email, lateEmail)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLockedLegacyContactSurvivesKeylessUpdate(t *testing.T) {
|
||||
st := openDemoStore(t)
|
||||
ctx := context.Background()
|
||||
fixture := prepareSecretFixture(t, st)
|
||||
|
||||
// Before the first editor login the tenant is not migrated. An
|
||||
// administrator session has no keyring, so the plaintext address is
|
||||
// hidden and marked as locked.
|
||||
person, err := st.Person(ctx, fixture.tenantID, fixture.personID)
|
||||
if err != nil {
|
||||
t.Fatalf("person: %v", err)
|
||||
}
|
||||
if person.Email != "" || !person.EmailLocked {
|
||||
t.Fatalf("keyless contact = %q locked=%v", person.Email, person.EmailLocked)
|
||||
}
|
||||
person.Notes = "geändert ohne Kontaktschlüssel"
|
||||
if err := st.UpsertPerson(ctx, fixture.tenantID, *person); err != nil {
|
||||
t.Fatalf("update: %v", err)
|
||||
}
|
||||
var plain string
|
||||
if err := st.db.QueryRowContext(ctx,
|
||||
"SELECT email FROM people WHERE tenant_id=? AND id=?",
|
||||
fixture.tenantID, fixture.personID).Scan(&plain); err != nil {
|
||||
t.Fatalf("read person: %v", err)
|
||||
}
|
||||
if plain != fixture.email {
|
||||
t.Fatalf("legacy e-mail was changed from %q to %q", fixture.email, plain)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMigrationRemovesPhoneNumbers(t *testing.T) {
|
||||
path := t.TempDir() + "/lektorenplan.db"
|
||||
st, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatalf("open store: %v", err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
if err := st.SeedDemo(ctx); err != nil {
|
||||
t.Fatalf("seed demo: %v", err)
|
||||
}
|
||||
var tenantID string
|
||||
if err := st.db.QueryRowContext(ctx,
|
||||
"SELECT tenant_id FROM people WHERE id='p-anna'").Scan(&tenantID); err != nil {
|
||||
t.Fatalf("tenant: %v", err)
|
||||
}
|
||||
// Recreate the legacy column and a matching encrypted value.
|
||||
if _, err := st.db.ExecContext(ctx,
|
||||
"ALTER TABLE people ADD COLUMN phone TEXT NOT NULL DEFAULT ''"); err != nil {
|
||||
t.Fatalf("add legacy column: %v", err)
|
||||
}
|
||||
if _, err := st.db.ExecContext(ctx,
|
||||
"UPDATE people SET phone='0228 555 0101' WHERE tenant_id=? AND id='p-anna'", tenantID); err != nil {
|
||||
t.Fatalf("legacy phone: %v", err)
|
||||
}
|
||||
if _, err := st.db.ExecContext(ctx, `
|
||||
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
|
||||
VALUES(?, 'person', 'p-anna', 'phone', X'00', ?)`,
|
||||
tenantID, nowText()); err != nil {
|
||||
t.Fatalf("legacy secret: %v", err)
|
||||
}
|
||||
st.Close()
|
||||
|
||||
reopened, err := Open(path)
|
||||
if err != nil {
|
||||
t.Fatalf("reopen store: %v", err)
|
||||
}
|
||||
defer reopened.Close()
|
||||
hasPhone, err := reopened.hasColumn(ctx, "people", "phone")
|
||||
if err != nil {
|
||||
t.Fatalf("inspect people: %v", err)
|
||||
}
|
||||
if hasPhone {
|
||||
t.Fatal("phone column still exists after migration")
|
||||
}
|
||||
var count int
|
||||
if err := reopened.db.QueryRowContext(ctx,
|
||||
"SELECT COUNT(*) FROM secrets WHERE secret_key='phone'").Scan(&count); err != nil {
|
||||
t.Fatalf("count phone secrets: %v", err)
|
||||
}
|
||||
if count != 0 {
|
||||
t.Fatalf("%d phone secrets remain after migration", count)
|
||||
}
|
||||
}
|
||||
+132
-24
@@ -6,6 +6,7 @@ import (
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"lektorenplan/domain"
|
||||
)
|
||||
@@ -151,35 +152,68 @@ func (s *Store) DeleteChurch(ctx context.Context, tenantID, id string) error {
|
||||
// People lists a tenant's volunteers.
|
||||
func (s *Store) People(ctx context.Context, tenantID string) ([]domain.Person, error) {
|
||||
rows, err := s.db.QueryContext(ctx, `
|
||||
SELECT id, first_name, last_name, roles, email, phone, preferred_church_ids,
|
||||
SELECT id, first_name, last_name, roles, email, preferred_church_ids,
|
||||
preferred_weekdays, preferred_service_titles, max_per_month, active, notes
|
||||
FROM people WHERE tenant_id=? ORDER BY last_name COLLATE NOCASE, first_name COLLATE NOCASE`, tenantID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
var out []domain.Person
|
||||
for rows.Next() {
|
||||
person, err := scanPerson(rows)
|
||||
if err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
out = append(out, *person)
|
||||
}
|
||||
return out, rows.Err()
|
||||
if err := rows.Err(); err != nil {
|
||||
rows.Close()
|
||||
return nil, err
|
||||
}
|
||||
rows.Close()
|
||||
// The connection pool has a single connection, so the rows must be closed
|
||||
// before the encrypted contacts are loaded.
|
||||
for index := range out {
|
||||
s.hydratePersonContacts(ctx, tenantID, &out[index])
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
// Person loads one volunteer.
|
||||
func (s *Store) Person(ctx context.Context, tenantID, id string) (*domain.Person, error) {
|
||||
row := s.db.QueryRowContext(ctx, `
|
||||
SELECT id, first_name, last_name, roles, email, phone, preferred_church_ids,
|
||||
SELECT id, first_name, last_name, roles, email, preferred_church_ids,
|
||||
preferred_weekdays, preferred_service_titles, max_per_month, active, notes
|
||||
FROM people WHERE tenant_id=? AND id=?`, tenantID, id)
|
||||
person, err := scanPerson(row)
|
||||
if errors.Is(err, sql.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return person, err
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
s.hydratePersonContacts(ctx, tenantID, person)
|
||||
return person, nil
|
||||
}
|
||||
|
||||
// hydratePersonContacts fills the e-mail address from the encrypted store.
|
||||
// Values that exist but cannot be decrypted stay empty and are marked as
|
||||
// locked so the UI can explain the situation. Before a tenant has been
|
||||
// migrated, plaintext contacts are only exposed to key-holding editors.
|
||||
func (s *Store) hydratePersonContacts(ctx context.Context, tenantID string, person *domain.Person) {
|
||||
if !s.SecretIsInitialized(ctx, tenantID) {
|
||||
if KeyringFrom(ctx) == nil && strings.TrimSpace(person.Email) != "" {
|
||||
person.Email = ""
|
||||
person.EmailLocked = true
|
||||
}
|
||||
return
|
||||
}
|
||||
email, emailLocked := s.PersonContactSecrets(ctx, tenantID, person.ID)
|
||||
if person.Email == "" {
|
||||
person.Email = email
|
||||
person.EmailLocked = emailLocked
|
||||
}
|
||||
}
|
||||
|
||||
func scanPerson(row rowScanner) (*domain.Person, error) {
|
||||
@@ -187,7 +221,7 @@ func scanPerson(row rowScanner) (*domain.Person, error) {
|
||||
var roles, churches, weekdays, titles string
|
||||
var active int
|
||||
if err := row.Scan(&person.ID, &person.FirstName, &person.LastName, &roles,
|
||||
&person.Email, &person.Phone, &churches, &weekdays, &titles,
|
||||
&person.Email, &churches, &weekdays, &titles,
|
||||
&person.MaxPerMonth, &active, &person.Notes); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
@@ -221,24 +255,88 @@ func (s *Store) UpsertPerson(ctx context.Context, tenantID string, person domain
|
||||
if person.MaxPerMonth < 0 {
|
||||
person.MaxPerMonth = 0
|
||||
}
|
||||
_, err := s.db.ExecContext(ctx, `
|
||||
INSERT INTO people(tenant_id, id, first_name, last_name, roles, email, phone,
|
||||
preferred_church_ids, preferred_weekdays, preferred_service_titles,
|
||||
max_per_month, active, notes)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(tenant_id, id) DO UPDATE SET
|
||||
first_name=excluded.first_name, last_name=excluded.last_name, roles=excluded.roles,
|
||||
email=excluded.email, phone=excluded.phone,
|
||||
preferred_church_ids=excluded.preferred_church_ids,
|
||||
preferred_weekdays=excluded.preferred_weekdays,
|
||||
preferred_service_titles=excluded.preferred_service_titles,
|
||||
max_per_month=excluded.max_per_month, active=excluded.active, notes=excluded.notes`,
|
||||
tenantID, person.ID, person.FirstName, person.LastName, encodeStrings(roleStrings),
|
||||
person.Email, person.Phone, encodeStrings(person.PreferredChurchIDs),
|
||||
encodeInts(person.PreferredWeekdays),
|
||||
encodeStrings(person.PreferredServiceTitles), person.MaxPerMonth,
|
||||
boolInt(person.Active), person.Notes)
|
||||
return err
|
||||
initialized := s.SecretIsInitialized(ctx, tenantID)
|
||||
keyring := KeyringFrom(ctx)
|
||||
// Plaintext contact writes are only a migration fallback for callers
|
||||
// without key material. A reader who is logged in never stores an address
|
||||
// in the legacy column.
|
||||
manageContacts := !initialized && keyring == nil
|
||||
// A locked field that was left empty must keep its existing value. This
|
||||
// also lets readers without their own data key update their profile and
|
||||
// prevents an administrator who cannot see plaintext contacts from
|
||||
// clearing them before the tenant has been migrated.
|
||||
preserveContact := person.EmailLocked && strings.TrimSpace(person.Email) == ""
|
||||
updateLegacyContact := manageContacts && !preserveContact
|
||||
var dek []byte
|
||||
if initialized && keyring != nil && !preserveContact {
|
||||
if err := s.EnsurePersonScope(ctx, keyring, tenantID, person.ID); err != nil {
|
||||
return err
|
||||
}
|
||||
var err error
|
||||
dek, err = s.scopeDEK(ctx, keyring, KeyScope{Type: ScopePerson, TenantID: tenantID, ID: person.ID})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return s.transaction(ctx, func(tx *sql.Tx) error {
|
||||
email := person.Email
|
||||
if initialized || !manageContacts {
|
||||
// Contact details only live in the encrypted secrets table.
|
||||
email = ""
|
||||
}
|
||||
_, err := tx.ExecContext(ctx, `
|
||||
INSERT INTO people(tenant_id, id, first_name, last_name, roles, email,
|
||||
preferred_church_ids, preferred_weekdays, preferred_service_titles,
|
||||
max_per_month, active, notes)
|
||||
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(tenant_id, id) DO UPDATE SET
|
||||
first_name=excluded.first_name, last_name=excluded.last_name, roles=excluded.roles,
|
||||
email=CASE WHEN ? THEN excluded.email ELSE people.email END,
|
||||
preferred_church_ids=excluded.preferred_church_ids,
|
||||
preferred_weekdays=excluded.preferred_weekdays,
|
||||
preferred_service_titles=excluded.preferred_service_titles,
|
||||
max_per_month=excluded.max_per_month, active=excluded.active, notes=excluded.notes`,
|
||||
tenantID, person.ID, person.FirstName, person.LastName, encodeStrings(roleStrings),
|
||||
email, encodeStrings(person.PreferredChurchIDs),
|
||||
encodeInts(person.PreferredWeekdays),
|
||||
encodeStrings(person.PreferredServiceTitles), person.MaxPerMonth,
|
||||
boolInt(person.Active), person.Notes, boolInt(updateLegacyContact))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if !initialized || keyring == nil {
|
||||
return nil
|
||||
}
|
||||
setSecret := func(key, value string) error {
|
||||
if strings.TrimSpace(value) == "" {
|
||||
_, err := tx.ExecContext(ctx, `
|
||||
DELETE FROM secrets
|
||||
WHERE tenant_id=? AND scope_type=? AND scope_id=? AND secret_key=?`,
|
||||
tenantID, ScopePerson, person.ID, key)
|
||||
return err
|
||||
}
|
||||
sealed, err := sealAESGCM(dek, []byte(value),
|
||||
keyAAD(ScopePerson, tenantID, person.ID, key))
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = tx.ExecContext(ctx, `
|
||||
INSERT INTO secrets(tenant_id, scope_type, scope_id, secret_key, ciphertext, updated_at)
|
||||
VALUES(?, ?, ?, ?, ?, ?)
|
||||
ON CONFLICT(tenant_id, scope_type, scope_id, secret_key) DO UPDATE SET
|
||||
ciphertext=excluded.ciphertext, updated_at=excluded.updated_at`,
|
||||
tenantID, ScopePerson, person.ID, key, sealed,
|
||||
time.Now().UTC().Format(time.RFC3339))
|
||||
return err
|
||||
}
|
||||
// A locked field that was left empty must keep its existing secret.
|
||||
if !(person.EmailLocked && strings.TrimSpace(person.Email) == "") {
|
||||
if err := setSecret("email", person.Email); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
// DeletePerson removes a volunteer with assignments and absences.
|
||||
@@ -252,6 +350,16 @@ func (s *Store) DeletePerson(ctx context.Context, tenantID, id string) error {
|
||||
"DELETE FROM absences WHERE tenant_id=? AND person_id=?", tenantID, id); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
"DELETE FROM secrets WHERE tenant_id=? AND scope_type=? AND scope_id=?",
|
||||
tenantID, ScopePerson, id); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := tx.ExecContext(ctx,
|
||||
"DELETE FROM key_wrappers WHERE scope_type=? AND tenant_id=? AND scope_id=?",
|
||||
ScopePerson, tenantID, id); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := tx.ExecContext(ctx, "DELETE FROM people WHERE tenant_id=? AND id=?", tenantID, id)
|
||||
return err
|
||||
})
|
||||
|
||||
@@ -102,6 +102,8 @@ func (s *Store) DeleteAllTenantData(ctx context.Context, tenantID string) error
|
||||
"DELETE FROM dispatch_preferences WHERE tenant_id=?",
|
||||
"DELETE FROM dispatch_log WHERE tenant_id=?",
|
||||
"DELETE FROM tenant_settings WHERE tenant_id=?",
|
||||
"DELETE FROM secrets WHERE tenant_id=?",
|
||||
"DELETE FROM key_wrappers WHERE tenant_id=? AND scope_type='person'",
|
||||
}
|
||||
for _, statement := range statements {
|
||||
if _, err := tx.ExecContext(ctx, statement, tenantID); err != nil {
|
||||
|
||||
+17
-2
@@ -123,8 +123,13 @@ func (s *Store) UpdateTenant(ctx context.Context, tenant *Tenant) error {
|
||||
|
||||
// DeleteTenant removes a tenant and, through cascades, its planning data.
|
||||
func (s *Store) DeleteTenant(ctx context.Context, id string) error {
|
||||
_, err := s.db.ExecContext(ctx, "DELETE FROM tenants WHERE id=?", id)
|
||||
return err
|
||||
return s.transaction(ctx, func(tx *sql.Tx) error {
|
||||
if _, err := tx.ExecContext(ctx, "DELETE FROM key_wrappers WHERE tenant_id=?", id); err != nil {
|
||||
return err
|
||||
}
|
||||
_, err := tx.ExecContext(ctx, "DELETE FROM tenants WHERE id=?", id)
|
||||
return err
|
||||
})
|
||||
}
|
||||
|
||||
func slugify(value string) string {
|
||||
@@ -236,6 +241,16 @@ func (s *Store) CanAccessTenant(ctx context.Context, user *User, tenantID string
|
||||
return count > 0
|
||||
}
|
||||
|
||||
// CanManageSecrets reports whether the user may manage encrypted contacts and
|
||||
// SMTP credentials. Administrators are deliberately excluded: only editors
|
||||
// hold the keys for these scopes.
|
||||
func (s *Store) CanManageSecrets(ctx context.Context, user *User, tenantID string) bool {
|
||||
if user == nil || !user.Active || user.Role != RoleEditor {
|
||||
return false
|
||||
}
|
||||
return s.CanAccessTenant(ctx, user, tenantID)
|
||||
}
|
||||
|
||||
// CanEditTenant reports whether the user may change planning data.
|
||||
func (s *Store) CanEditTenant(ctx context.Context, user *User, tenantID string) bool {
|
||||
if user == nil || !user.Active {
|
||||
|
||||
Reference in new issue
Block a user