fe28278615
Postgres-RLS-Policies auf allen Tabellen mit echten Mandanten- Geschäftsdaten (antrag und alles darüber verkettete, abteilung, werkzeug/werkzeug_sperre, genehmiger_rolle/freigabe_regel, loeschfrist_einstellung). Kritischer Fund vor der Umsetzung: die Anwendung verbindet als postgres-Superuser, der RLS immer umgeht - Migration 0021 legt deshalb zusätzlich eine eingeschränkte Rolle "deklarix_app" an, nur für die greifen die Policies tatsächlich. internal/store/tenant_scope.go: WithTenantScope öffnet eine Transaktion und setzt Sitzungsvariablen (app.account_id/app.is_betreiber) per set_config mit Parameterbindung; alle Store-Methoden laufen jetzt über s.db(ctx) statt direkt s.Pool. Jede require*-Middleware umschließt die komplette Handler-Ausführung damit - jeder Request läuft dadurch auch atomar in einer Transaktion (positiver Nebeneffekt). Live end-to-end verifiziert (echter HTTP-Server + DATABASE_URL_APP auf die eingeschränkte Rolle gesetzt): zwei Firmen registriert, Isolation über Abteilung/Antrag/Bewertung bestätigt, zentraler NULL-Katalog für beide sichtbar. Produktivbetrieb braucht noch einen manuellen Schritt (Passwort für deklarix_app setzen + DATABASE_URL_APP konfigurieren, siehe CLAUDE.md) - die Migration allein aktiviert noch nichts, solange die App weiter als Superuser verbindet. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
95 lines
3.3 KiB
Go
95 lines
3.3 KiB
Go
package store
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5"
|
|
)
|
|
|
|
// Session ist eine angemeldete Sitzung. token ist der Primärschlüssel
|
|
// (das Cookie-Geheimnis selbst) — es gibt bewusst keine separate ID,
|
|
// eine Session wird immer über ihren Token nachgeschlagen.
|
|
// ImpersonatedByUserID ist gesetzt, wenn diese Sitzung durch einen
|
|
// Betreiber-Support-Login entstanden ist (siehe CreateImpersonatedSession)
|
|
// statt durch den regulären Login des Nutzers selbst.
|
|
type Session struct {
|
|
Token string
|
|
UserID string
|
|
ImpersonatedByUserID *string
|
|
ExpiresAt time.Time
|
|
CreatedAt time.Time
|
|
}
|
|
|
|
const sessionColumns = `token, user_id, impersonated_by_user_id, expires_at, created_at`
|
|
|
|
func scanSession(row interface {
|
|
Scan(dest ...any) error
|
|
}) (Session, error) {
|
|
var sess Session
|
|
err := row.Scan(&sess.Token, &sess.UserID, &sess.ImpersonatedByUserID, &sess.ExpiresAt, &sess.CreatedAt)
|
|
return sess, err
|
|
}
|
|
|
|
// CreateSession speichert eine neue Sitzung. token muss bereits ein
|
|
// kryptographisch zufälliges Geheimnis sein (siehe internal/auth).
|
|
func (s *Store) CreateSession(ctx context.Context, token, userID string, expiresAt time.Time) (Session, error) {
|
|
row := s.db(ctx).QueryRow(ctx, `
|
|
INSERT INTO session (token, user_id, expires_at)
|
|
VALUES ($1, $2, $3)
|
|
RETURNING `+sessionColumns,
|
|
token, userID, expiresAt,
|
|
)
|
|
sess, err := scanSession(row)
|
|
if err != nil {
|
|
return Session{}, fmt.Errorf("store: create session: %w", err)
|
|
}
|
|
return sess, nil
|
|
}
|
|
|
|
// CreateImpersonatedSession speichert eine Support-Login-Sitzung: ein
|
|
// Betreiber meldet sich als ein bestimmter Kunden-Nutzer an, ohne
|
|
// dessen Passwort zu kennen (siehe handleBetreiberLoginAls). Anders als
|
|
// bei CreateSession bleibt hier festgehalten, WER die Sitzung ausgelöst
|
|
// hat — für den sichtbaren Hinweis-Banner und das Audit-Log.
|
|
func (s *Store) CreateImpersonatedSession(ctx context.Context, token, userID, impersonatedByUserID string, expiresAt time.Time) (Session, error) {
|
|
row := s.db(ctx).QueryRow(ctx, `
|
|
INSERT INTO session (token, user_id, impersonated_by_user_id, expires_at)
|
|
VALUES ($1, $2, $3, $4)
|
|
RETURNING `+sessionColumns,
|
|
token, userID, impersonatedByUserID, expiresAt,
|
|
)
|
|
sess, err := scanSession(row)
|
|
if err != nil {
|
|
return Session{}, fmt.Errorf("store: create impersonated session: %w", err)
|
|
}
|
|
return sess, nil
|
|
}
|
|
|
|
// GetSession liest eine Sitzung anhand ihres Tokens. Liefert
|
|
// ErrNotFound, wenn der Token unbekannt ist — abgelaufene Sitzungen
|
|
// werden NICHT automatisch als "nicht gefunden" behandelt, das prüft
|
|
// der Aufrufer über ExpiresAt (siehe internal/auth), damit die
|
|
// Unterscheidung "gab es nie" vs. "ist abgelaufen" nicht verloren geht.
|
|
func (s *Store) GetSession(ctx context.Context, token string) (Session, error) {
|
|
row := s.db(ctx).QueryRow(ctx, `SELECT `+sessionColumns+` FROM session WHERE token = $1`, token)
|
|
sess, err := scanSession(row)
|
|
if errors.Is(err, pgx.ErrNoRows) {
|
|
return Session{}, ErrNotFound
|
|
}
|
|
if err != nil {
|
|
return Session{}, fmt.Errorf("store: get session: %w", err)
|
|
}
|
|
return sess, nil
|
|
}
|
|
|
|
// DeleteSession beendet eine Sitzung (Logout).
|
|
func (s *Store) DeleteSession(ctx context.Context, token string) error {
|
|
if _, err := s.db(ctx).Exec(ctx, `DELETE FROM session WHERE token = $1`, token); err != nil {
|
|
return fmt.Errorf("store: delete session: %w", err)
|
|
}
|
|
return nil
|
|
}
|