269 lines
8.7 KiB
Go
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)
|
|
}
|