Files
LektorenPlan/web/web/keyring_handlers.go
T

269 lines
8.7 KiB
Go

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)
}