Files

477 lines
15 KiB
Go

package store
import (
"context"
"crypto/rand"
"crypto/sha256"
"database/sql"
"encoding/hex"
"errors"
"strings"
"time"
"golang.org/x/crypto/bcrypt"
"lektorenplan/domain"
)
// UserRole is the application-wide permission level of an account.
type UserRole string
const (
RoleAdmin UserRole = "admin"
RoleEditor UserRole = "editor"
RoleReader UserRole = "reader"
)
// UserRoleTitle returns the German label of a role.
func UserRoleTitle(role UserRole) string {
switch role {
case RoleAdmin:
return "Administrator"
case RoleEditor:
return "Redakteur"
default:
return "Leser"
}
}
// IsValid reports whether the role is known.
func (r UserRole) IsValid() bool {
return r == RoleAdmin || r == RoleEditor || r == RoleReader
}
// CanEdit reports whether the role may modify planning data.
func (r UserRole) CanEdit() bool { return r == RoleAdmin || r == RoleEditor }
// IsAdmin reports whether the role may manage tenants and accounts.
func (r UserRole) IsAdmin() bool { return r == RoleAdmin }
// User is a login account. Memberships are loaded on demand.
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"displayName"`
PasswordHash string `json:"-"`
Role UserRole `json:"role"`
Active bool `json:"active"`
MustChangePassword bool `json:"mustChangePassword"`
LinkedTenantID string `json:"linkedTenantID,omitempty"`
LinkedPersonID string `json:"linkedPersonID,omitempty"`
CreatedAt time.Time `json:"createdAt"`
TenantIDs []string `json:"tenantIDs,omitempty"`
}
// LinkedPerson returns the tenant-scoped person linked to this account, if any.
func (u *User) LinkedPerson(tenantID string) (string, bool) {
if u == nil || u.LinkedPersonID == "" || u.LinkedTenantID != tenantID {
return "", false
}
return u.LinkedPersonID, true
}
// RoleTitle is a template helper.
func (u *User) RoleTitle() string { return UserRoleTitle(u.Role) }
// Users lists all accounts with their memberships.
func (s *Store) Users(ctx context.Context) ([]User, error) {
rows, err := s.db.QueryContext(ctx,
"SELECT id, username, display_name, password_hash, role, active, must_change_password, "+
"linked_tenant_id, linked_person_id, created_at FROM users ORDER BY username COLLATE NOCASE")
if err != nil {
return nil, err
}
defer rows.Close()
var out []User
for rows.Next() {
user, err := scanUser(rows)
if err != nil {
rows.Close()
return nil, err
}
out = append(out, *user)
}
if err := rows.Err(); err != nil {
rows.Close()
return nil, err
}
// Close the result set before loading memberships: the pool deliberately
// uses a single connection, so nested queries would otherwise block.
rows.Close()
for i := range out {
tenantIDs, err := s.Memberships(ctx, out[i].ID)
if err != nil {
return nil, err
}
out[i].TenantIDs = tenantIDs
}
return out, nil
}
// User loads an account by id.
func (s *Store) User(ctx context.Context, id string) (*User, error) {
row := s.db.QueryRowContext(ctx,
"SELECT id, username, display_name, password_hash, role, active, must_change_password, "+
"linked_tenant_id, linked_person_id, created_at FROM users WHERE id=?", id)
user, err := scanUser(row)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
tenantIDs, err := s.Memberships(ctx, user.ID)
if err != nil {
return nil, err
}
user.TenantIDs = tenantIDs
return user, nil
}
// UserByUsername loads an account by login name.
func (s *Store) UserByUsername(ctx context.Context, username string) (*User, error) {
row := s.db.QueryRowContext(ctx,
"SELECT id, username, display_name, password_hash, role, active, must_change_password, "+
"linked_tenant_id, linked_person_id, created_at FROM users WHERE username=? COLLATE NOCASE",
strings.TrimSpace(username))
user, err := scanUser(row)
if errors.Is(err, sql.ErrNoRows) {
return nil, ErrNotFound
}
if err != nil {
return nil, err
}
tenantIDs, err := s.Memberships(ctx, user.ID)
if err != nil {
return nil, err
}
user.TenantIDs = tenantIDs
return user, nil
}
type rowScanner interface {
Scan(dest ...any) error
}
func scanUser(row rowScanner) (*User, error) {
var user User
var role, created string
var active, mustChange int
if err := row.Scan(&user.ID, &user.Username, &user.DisplayName, &user.PasswordHash,
&role, &active, &mustChange, &user.LinkedTenantID, &user.LinkedPersonID, &created); err != nil {
return nil, err
}
user.Role = UserRole(role)
user.Active = active != 0
user.MustChangePassword = mustChange != 0
user.CreatedAt = parseTime(created)
return &user, nil
}
// HashPassword returns a bcrypt hash suitable for storage.
func HashPassword(password string) (string, error) {
if len(password) < 6 {
return "", errors.New("Das Passwort muss mindestens 6 Zeichen lang sein.")
}
hash, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
if err != nil {
return "", err
}
return string(hash), nil
}
// Authenticate validates credentials and returns the active account.
func (s *Store) Authenticate(ctx context.Context, username, password string) (*User, error) {
user, err := s.UserByUsername(ctx, username)
if err != nil {
if errors.Is(err, ErrNotFound) {
return nil, errors.New("Benutzername oder Passwort ist falsch.")
}
return nil, err
}
if !user.Active {
return nil, errors.New("Dieses Konto ist deaktiviert.")
}
if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)); err != nil {
return nil, errors.New("Benutzername oder Passwort ist falsch.")
}
return user, nil
}
// CreateUser adds an account and its tenant memberships.
func (s *Store) CreateUser(ctx context.Context, username, displayName, password string, role UserRole, active bool, tenantIDs []string) (*User, error) {
username = strings.TrimSpace(username)
displayName = strings.TrimSpace(displayName)
if username == "" || displayName == "" {
return nil, errors.New("Benutzername und Anzeigename sind erforderlich")
}
if !role.IsValid() {
return nil, errors.New("Unbekannte Rolle")
}
hash, err := HashPassword(password)
if err != nil {
return nil, err
}
user := &User{
ID: domain.NewID(), Username: username, DisplayName: displayName,
PasswordHash: hash, Role: role, Active: active, MustChangePassword: true,
CreatedAt: time.Now().UTC(),
}
err = s.transaction(ctx, func(tx *sql.Tx) error {
if _, err := tx.ExecContext(ctx, `
INSERT INTO users(id, username, display_name, password_hash, role, active,
must_change_password, linked_tenant_id, linked_person_id, created_at)
VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
user.ID, user.Username, user.DisplayName, user.PasswordHash, string(user.Role),
boolInt(user.Active), 1, "", "", user.CreatedAt.Format(time.RFC3339)); err != nil {
return err
}
seen := map[string]bool{}
for _, tenantID := range tenantIDs {
if tenantID == "" || seen[tenantID] {
continue
}
seen[tenantID] = true
if _, err := tx.ExecContext(ctx,
"INSERT INTO memberships(user_id, tenant_id) VALUES(?, ?)", user.ID, tenantID); err != nil {
return err
}
}
return nil
})
if err != nil {
if isUniqueViolation(err) {
return nil, errors.New("Dieser Benutzername ist bereits vergeben.")
}
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
}
// UpdateUser saves account fields. An empty password keeps the old hash.
// Setting a new password by an administrator also forces a change at the next
// login. linkedTenantID/linkedPersonID may be empty to remove the link.
func (s *Store) UpdateUser(ctx context.Context, id, username, displayName, password string, role UserRole, active bool, tenantIDs []string, forcePasswordChange bool, linkedTenantID, linkedPersonID string) error {
username = strings.TrimSpace(username)
displayName = strings.TrimSpace(displayName)
linkedTenantID = strings.TrimSpace(linkedTenantID)
linkedPersonID = strings.TrimSpace(linkedPersonID)
if username == "" || displayName == "" {
return errors.New("Benutzername und Anzeigename sind erforderlich")
}
if !role.IsValid() {
return errors.New("Unbekannte Rolle")
}
if role != RoleReader {
linkedTenantID, linkedPersonID = "", ""
}
if linkedPersonID == "" {
linkedTenantID = ""
}
return s.transaction(ctx, func(tx *sql.Tx) error {
if password != "" {
hash, err := HashPassword(password)
if err != nil {
return err
}
if _, err := tx.ExecContext(ctx,
"UPDATE users SET username=?, display_name=?, role=?, active=?, password_hash=?, "+
"must_change_password=?, linked_tenant_id=?, linked_person_id=? WHERE id=?",
username, displayName, string(role), boolInt(active), hash,
boolInt(forcePasswordChange || password != ""), linkedTenantID, linkedPersonID, id); err != nil {
return err
}
} else {
if _, err := tx.ExecContext(ctx,
"UPDATE users SET username=?, display_name=?, role=?, active=?, "+
"must_change_password=CASE WHEN ? THEN 1 ELSE must_change_password END, "+
"linked_tenant_id=?, linked_person_id=? WHERE id=?",
username, displayName, string(role), boolInt(active),
boolInt(forcePasswordChange), linkedTenantID, linkedPersonID, id); err != nil {
return err
}
}
if _, err := tx.ExecContext(ctx, "DELETE FROM memberships WHERE user_id=?", id); err != nil {
return err
}
seen := map[string]bool{}
for _, tenantID := range tenantIDs {
if tenantID == "" || seen[tenantID] {
continue
}
seen[tenantID] = true
if _, err := tx.ExecContext(ctx,
"INSERT INTO memberships(user_id, tenant_id) VALUES(?, ?)", id, tenantID); err != nil {
return err
}
}
return nil
})
}
// SetUserPassword updates the password hash and the forced-change flag.
func (s *Store) SetUserPassword(ctx context.Context, id, password string, mustChange bool) error {
hash, err := HashPassword(password)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx,
"UPDATE users SET password_hash=?, must_change_password=? WHERE id=?",
hash, boolInt(mustChange), id)
return err
}
// SetUserPersonLink ties a reader account to a person inside one tenant.
func (s *Store) SetUserPersonLink(ctx context.Context, id, tenantID, personID string) error {
_, err := s.db.ExecContext(ctx,
"UPDATE users SET linked_tenant_id=?, linked_person_id=? WHERE id=?",
strings.TrimSpace(tenantID), strings.TrimSpace(personID), id)
return err
}
// DeleteUser removes an account and its sessions.
func (s *Store) DeleteUser(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM users WHERE id=?", id)
return err
}
// CountUsers returns the number of accounts.
func (s *Store) CountUsers(ctx context.Context) (int, error) {
var count int
err := s.db.QueryRowContext(ctx, "SELECT COUNT(*) FROM users").Scan(&count)
return count, err
}
// EnsureAdmin creates the first administrator when no account exists.
// It returns true when a new account was created.
func (s *Store) EnsureAdmin(ctx context.Context, username, password string) (bool, error) {
count, err := s.CountUsers(ctx)
if err != nil {
return false, err
}
if count > 0 {
return false, nil
}
if strings.TrimSpace(username) == "" {
username = "admin"
}
if strings.TrimSpace(password) == "" {
password = "admin123"
}
_, err = s.CreateUser(ctx, username, "Administrator", password, RoleAdmin, true, nil)
if err != nil {
return false, err
}
return true, nil
}
// Session is a server-side login session. The cookie holds the raw token;
// only its SHA-256 digest is stored here.
type Session struct {
ID string `json:"id"`
UserID string `json:"userID"`
CSRFToken string `json:"-"`
CreatedAt time.Time `json:"createdAt"`
ExpiresAt time.Time `json:"expiresAt"`
}
func randomToken(bytes int) (string, error) {
buf := make([]byte, bytes)
if _, err := rand.Read(buf); err != nil {
return "", err
}
return hex.EncodeToString(buf), nil
}
func tokenDigest(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
// CreateSession starts a login session and returns the raw cookie token.
func (s *Store) CreateSession(ctx context.Context, userID string, ttl time.Duration) (*Session, string, error) {
token, err := randomToken(32)
if err != nil {
return nil, "", err
}
csrf, err := randomToken(32)
if err != nil {
return nil, "", err
}
now := time.Now().UTC()
session := &Session{
ID: tokenDigest(token), UserID: userID, CSRFToken: csrf,
CreatedAt: now, ExpiresAt: now.Add(ttl),
}
_, err = s.db.ExecContext(ctx, `
INSERT INTO sessions(id, user_id, csrf_token, created_at, expires_at)
VALUES(?, ?, ?, ?, ?)`,
session.ID, session.UserID, session.CSRFToken,
session.CreatedAt.Format(time.RFC3339), session.ExpiresAt.Format(time.RFC3339))
if err != nil {
return nil, "", err
}
return session, token, nil
}
// SessionUser resolves a cookie token to its session and account.
func (s *Store) SessionUser(ctx context.Context, token string) (*Session, *User, error) {
if token == "" {
return nil, nil, ErrNotFound
}
var session Session
var created, expires string
err := s.db.QueryRowContext(ctx,
"SELECT id, user_id, csrf_token, created_at, expires_at FROM sessions WHERE id=?",
tokenDigest(token)).Scan(&session.ID, &session.UserID, &session.CSRFToken, &created, &expires)
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, ErrNotFound
}
if err != nil {
return nil, nil, err
}
session.CreatedAt = parseTime(created)
session.ExpiresAt = parseTime(expires)
if time.Now().UTC().After(session.ExpiresAt) {
_ = s.DeleteSession(ctx, session.ID)
return nil, nil, ErrNotFound
}
user, err := s.User(ctx, session.UserID)
if err != nil {
return nil, nil, err
}
if !user.Active {
return nil, nil, ErrNotFound
}
return &session, user, nil
}
// DeleteSession invalidates one session by its stored digest.
func (s *Store) DeleteSession(ctx context.Context, id string) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM sessions WHERE id=?", id)
return err
}
// DeleteSessionByToken invalidates a session using the raw cookie token.
func (s *Store) DeleteSessionByToken(ctx context.Context, token string) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM sessions WHERE id=?", tokenDigest(token))
return err
}
// PurgeExpiredSessions removes stale rows.
func (s *Store) PurgeExpiredSessions(ctx context.Context) error {
_, err := s.db.ExecContext(ctx, "DELETE FROM sessions WHERE expires_at < ?", time.Now().UTC().Format(time.RFC3339))
return err
}