Merge #38: Sicherheitsprüfung abarbeiten (v1.11.0)

Zwei Kommentare versprachen Schutz, den es nicht gab. Das ist schlimmer
als eine fehlende Zusage, weil man sich darauf verlaesst:

- In middleware.ts stand "Ohne Authentifizierungs-Cookie gar nicht erst
  weiterreichen". Die Middleware prueft keine Anmeldung, sie setzt
  Kopfzeilen; die Liste steuert allein den Cache-Control-Kopf. Wer den
  Satz glaubt, verzichtet an einer neuen Seite auf erfordereBenutzer().
  Die Liste heisst jetzt OHNE_CACHE_SPERRE und sagt selbst, was sie ist.

- In datei.ts hiess es, die Pfadpruefung fange "Symlink-Tricks" ab.
  resolve() rechnet mit Zeichenketten und folgt keinem Link - dafuer
  braeuchte es realpath(). Nachgeruestet wird es nicht: Wer dort einen
  Symlink anlegen kann, hat schon Schreibrechte im Datenverzeichnis. Der
  Satz musste trotzdem weg.

Dazu docs/SICHERHEIT.md: Bedrohungsmodell, der Durchgang entlang der
OWASP Top 10 - und ein eigener Abschnitt darueber, was ausdruecklich NICHT
geschuetzt ist.

Aus dem OWASP-Durchgang kamen keine weiteren Funde. Zwei Stellen sahen
danach aus und waren es nicht: Prisma.join() in suche.ts fuegt nur bereits
parametrisierte Fragmente zusammen, und der Suchausschnitt mit den
<mark>-Markern aus ts_headline wird zerlegt und als React-Kinder
gerendert, nicht als HTML - obwohl die Quelle der OCR-Text hochgeladener
Dokumente ist.

Refs #38

.env.example

@@ -15,9 +15,17 @@ DATABASE_URL="postgresql://cockpit:bitte-aendern@localhost:5432/betreuungs_cockp
 # 32 zufaellige Bytes, base64. Erzeugen: npm run schluessel
 AUTH_SECRET=
 # Oeffentliche Basis-URL der Anwendung (ohne abschliessenden Slash).
+# Hinter einem Proxy die Adresse, die im Browser in der Adresszeile steht -
+# nicht die interne. Passkeys pruefen dagegen.
 AUTH_URL=http://localhost:3000
-# Hinter einem Reverse Proxy auf true setzen.
+
-AUTH_TRUST_HOST=true
+# Darf der Host-Kopf der Anfrage die Adresse bestimmen?
+#
+# Solange AUTH_URL gesetzt ist: nein, und die Zeile bleibt weg. Die Adresse
+# ist dann bekannt und muss nicht aus einer Kopfzeile abgeleitet werden, die
+# von aussen kommt. Ein "X-Forwarded-Host: fremde.example" schlaegt sonst in
+# erzeugte Adressen durch.
+# AUTH_TRUST_HOST=true
 
 # --- Erreichbarkeit: HIER MUSST DU DICH ENTSCHEIDEN -------------------------
 #
@@ -73,6 +81,25 @@ LOGIN_MAX_VERSUCHE=5
 LOGIN_FENSTER_SEKUNDEN=900
 LOGIN_SPERRE_SEKUNDEN=900
 
+# Geheimnis fuer die Ersteinrichtung. OHNE DIESEN WERT LAESST SICH DER ERSTE
+# ZUGANG NICHT ANLEGEN - das ist Absicht.
+#
+# Zwischen dem ersten Start und dem Anlegen des Zugangs stand die
+# Einrichtungsseite sonst offen: Wer sie in diesem Fenster findet, wird
+# Administrator. Erzeugen: npm run schluessel
+ERSTEINRICHTUNG_GEHEIMNIS=
+
+# Steht ein Reverse Proxy davor?
+#
+# Nur mit "true" wird "X-Forwarded-For" geglaubt - und dann von HINTEN
+# gelesen, weil der vordere Teil der Liste vom Aufrufer selbst kommt.
+# Ohne diese Zeile zaehlt die Anmeldesperre nur nach E-Mail-Adresse.
+#
+# Der dokumentierte Betrieb (Reverse Proxy davor) braucht sie also:
+VERTRAUE_PROXY=true
+# Bei mehreren gestaffelten Proxys deren Anzahl. Sonst weglassen.
+# VERTRAUE_PROXY_STUFEN=1
+
 # --- Objektspeicher (S3-kompatibel, EU!) ------------------------------------
 # Wird ab Etappe 3 verwendet. Beispiel: Hetzner Object Storage, Falkenstein.
 # ACHTUNG: Mit dem Anbieter muss ein AV-Vertrag nach Art. 28 DSGVO bestehen.

.gitattributes

@@ -0,0 +1,32 @@
+# Zeilenenden
+#
+# Im Repository steht ueberall LF, unabhaengig davon, auf welchem System
+# gearbeitet wird. Der Grund ist nicht Geschmack, sondern eine Falle:
+#
+# Solange Dateien gemischt vorliegen, schreibt jedes zeilenweise
+# arbeitende Werkzeug - sed, ein Formatierer, ein Skript - die Datei mit
+# LF zurueck. Der Diff zeigt dann nicht die drei geaenderten Zeilen,
+# sondern die ganze Datei. Genau das ist passiert: 578 Diff-Zeilen statt
+# 8, kurz vor einem Push bemerkt.
+#
+# Nebenwirkung derselben Mischung: "git diff --check" meldet bei
+# CRLF-Dateien jede hinzugefuegte Zeile als "trailing whitespace", weil
+# es das CR so wertet. Damit ist die Pruefung fuer diese Dateien wertlos.
+* text=auto eol=lf
+
+# Shell-Skripte laufen auf dem Server. Ein CRLF im Shebang macht sie
+# unbrauchbar ("bad interpreter"), und der Fehler ist von aussen nicht
+# anzusehen. Deshalb hier ausdruecklich, nicht nur ueber die Regel oben.
+*.sh text eol=lf
+
+# Binaerdateien nie anfassen.
+*.png binary
+*.jpg binary
+*.jpeg binary
+*.gif binary
+*.ico binary
+*.pdf binary
+*.woff binary
+*.woff2 binary
+*.ttf binary
+*.zip binary

CHANGELOG.md

@@ -26,6 +26,235 @@ Wiederherstellung*.
 
 _Noch nichts._
 
+## [1.11.0] – 2026-08-24
+
+Diese Fassung geht aus einer Sicherheitsprüfung hervor. Sie ändert nichts
+an der Bedienung, schließt aber mehrere Lücken — darunter drei, bei denen
+im Code eine Zusage stand, die so nicht galt.
+
+### Vor dem Update: zwei neue Zeilen in der `.env`
+
+```bash
+ERSTEINRICHTUNG_GEHEIMNIS=<zufälliger Wert, npm run schluessel erzeugt einen>
+VERTRAUE_PROXY=true
+```
+
+Beide sind nicht zwingend, aber beide haben Folgen, wenn sie fehlen:
+
+- Ohne `ERSTEINRICHTUNG_GEHEIMNIS` läuft alles weiter — nur der **erste**
+  Zugang ließe sich nicht mehr anlegen. Auf einer bestehenden Installation
+  ist das genau richtig; bei einer Neuinstallation brauchst du den Wert.
+- Ohne `VERTRAUE_PROXY=true` zählt die Anmeldesperre nur noch nach
+  E-Mail-Adresse, nicht mehr zusätzlich nach Anschluss. Beim ersten Mal
+  steht eine erklärende Zeile im Log.
+
+### Nach dem Update, nur mit Objektspeicher
+
+Bereits abgelegte Dateien liegen weiter unverschlüsselt, bis sie einmal
+umgeschrieben werden. Lesen funktioniert durchgehend, der Lauf lässt sich
+jederzeit abbrechen und wiederholen:
+
+```bash
+npm run speicher:verschluesseln              # erst schauen
+npm run speicher:verschluesseln -- --anwenden
+```
+
+Wer beim Dateitreiber bleibt, muss nichts tun — dort wurde immer schon
+verschlüsselt.
+
+### Behoben
+
+- **Der zweite Faktor war eine Anzeige, keine Grenze.** „TOTP ist Pflicht"
+  galt nur für Seiten. Server Actions und Downloads liefen daran vorbei:
+  Wer sich mit Passwort angemeldet, die Einrichtung aber nie abgeschlossen
+  hatte, kam an die Daten. Die Prüfung sitzt jetzt an der Stelle, durch die
+  alles muss.
+
+- **Ein Dokumenten-Download fragte nur nach der Anmeldung.** Dieselbe
+  Lücke, an einer Stelle, die bei der ersten Durchsicht übersehen wurde.
+
+- **Die Anmeldesperre sperrte dauerhaft aus.** Jeder Versuch während einer
+  laufenden Sperre verlängerte sie um die volle Dauer. Wer alle zehn
+  Minuten ein falsches Passwort an eine fremde Adresse schickte, sperrte
+  deren Inhaber aus — ohne das Passwort zu kennen. Nebenbei wuchs die
+  Tabelle mit jedem Versuch.
+
+- **Ein Code aus der Authenticator-App galt mehrfach.** Bis zu 90 Sekunden
+  lang ließ sich derselbe Code erneut einlösen — abgelesen, abgefangen
+  oder aus dem Browserverlauf. Jetzt gilt jeder genau einmal.
+
+- **Passkeys ließen sich ohne Rückfrage anlegen und entfernen.** An einem
+  unbeaufsichtigten Rechner waren das zwei Klicks zu einem dauerhaften
+  eigenen Zugang, der auch einen Passwortwechsel überlebt hätte. Jetzt
+  fragt die Anwendung vorher nach Passwort und Code — wie beim Export.
+
+- **Die Ersteinrichtung stand offen.** Zwischen dem ersten Start und dem
+  Anlegen des Zugangs konnte jeder, der die Seite fand, Administrator
+  werden. Zwei gleichzeitige Anfragen legten außerdem beide einen Zugang
+  an.
+
+- **Dateien im Objektspeicher lagen mit dem Schlüssel des Anbieters da.**
+  Gegen eine verlorene Festplatte im Rechenzentrum half das, gegen den
+  Anbieter und gegen gestohlene Zugangsdaten zum Speicher nicht. Jetzt
+  liegt derselbe Umschlag darum wie bei der Ablage auf dem eigenen Server,
+  mit einem Schlüssel, der die Anwendung nie verlässt.
+
+- **Ein präpariertes PDF konnte den Server umbringen.** Beim Auslesen des
+  eingebetteten Texts gab es keine Obergrenze: Wenige Kilobyte Füllung
+  blähen sich beim Auspacken auf Gigabyte auf. Ebenso beim Umwandeln in
+  Bilder — die Seitengröße steht im Dokument, und bei fester Auflösung
+  ergab eine künstlich große Seite ein Bild von mehreren Gigabyte.
+
+- **32 Schwachstellen in mitgelieferten Paketen, davon 5 kritische.**
+  Jetzt keine.
+
+### Geändert
+
+- **Downloads laufen jetzt immer über die Anwendung**, auch mit
+  Objektspeicher. Das ist die Folge der Verschlüsselung — entschlüsseln
+  kann nur die Anwendung. Nebeneffekt: Jeder Abruf prüft die Berechtigung
+  und wird protokolliert. Ein weitergeleiteter Link allein öffnet nichts
+  mehr.
+
+- **`docs/SICHERHEIT.md`** ist neu: Bedrohungsmodell, der Durchgang entlang
+  der OWASP Top 10 — und ein Abschnitt darüber, was ausdrücklich **nicht**
+  geschützt ist.
+
+## [1.10.2] – 2026-08-24
+
+### Behoben
+
+- **Das Update brach ohne Meldung ab.** Beim Sprung von 1.5.0 auf 1.10.1
+  endete `scripts/update.sh` mitten in der Ausgabe — kein Fehler, keine
+  Zeile, einfach zurück zur Eingabeaufforderung. Ursache war eine
+  abgeschnittene Leitung:
+
+  ```
+  git log --oneline "HEAD..$ZIEL" | head -15 | sed ...
+  ```
+
+  `head` schließt die Leitung nach 15 Zeilen, `git log` schreibt weiter
+  und bekommt SIGPIPE. Weil das Skript mit `set -o pipefail` und
+  `set -e` läuft, gilt die ganze Kette als gescheitert und das Skript
+  beendet sich — stumm.
+
+  Das ist zeitabhängig und deshalb monatelang nicht aufgefallen: Solange
+  `git log` fertig war, bevor `head` zumachte, ging alles gut. Genau bei
+  1.10.0 lagen zum ersten Mal **mehr als 15 Commits** dazwischen.
+
+- **Dieselbe Falle in der Selbstprüfung der Sicherung.** `sicherung.sh`
+  prüfte mit `openssl … | head -c 5 | grep -q "PGDMP"`, ob sich die
+  frische Sicherung wieder entschlüsseln lässt. Bei kleiner Datenbank
+  ging das gut, weil alles im Puffer stand. Mit wachsender Datenbank
+  hätte es gekippt — und dann hätte das Skript eine **völlig intakte
+  Sicherung als kaputt gemeldet** und das Update verweigert.
+
+### Geändert
+
+- **Ein stummer Abbruch ist nicht mehr möglich.** `update.sh` meldet
+  jetzt bei jedem unerwarteten Ende die Zeilennummer und den Exitcode,
+  und erklärt bei 141 ausdrücklich, dass es sich um SIGPIPE handelt und
+  um einen Fehler im Skript, nicht um einen Bedienfehler.
+- Stehen mehr als 15 Commits an, steht jetzt „… und N weitere" darunter,
+  statt sie wortlos wegzulassen.
+
+### Geprüft
+
+- Ein Test verbietet das Muster künftig in allen Betriebsskripten:
+  Wer wieder `| head` in eine Leitung schreibt, bekommt die Zeilennummer
+  genannt. Gegenprobe gemacht — der Test schlägt an.
+- Der Ablauf von 1.5.0 auf 1.10.1 einmal nachgestellt: läuft durch.
+
+## [1.10.1] – 2026-08-23
+
+### Geändert
+
+- **Der Beispielfall hat jetzt ein Jahr Kontobewegungen**
+  ([#22](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/22)).
+  Bisher brachte er Konten und Kontostände mit, aber keine einzige
+  Buchung — Kassenbuch, Belegpflicht, Dauerzahlungen und die Erkennung
+  wiederkehrender Zahlungen liefen darin also leer. Wer die Anwendung zum
+  ersten Mal ansah, musste erst eine CSV importieren.
+
+  Neu sind 107 Buchungen über zwölf Monate: Rente, Betriebsrente und
+  Pflegekasse als Einnahmen, Heimentgelt, Barbetrag, Sterbegeldbeitrag,
+  Telefon und Kontoführung als monatliche Ausgaben, dazu Rundfunkbeitrag
+  und Grundsteuer vierteljährlich sowie eine Handvoll Einzelposten.
+
+  Das betrifft nur neue Installationen mit `SEED_DEMO=true` — an einem
+  bestehenden Bestand ändert sich nichts.
+
+### Behoben
+
+- **„gGmbH" wurde nicht als Rechtsform erkannt.** Beim Zusammenfassen
+  wiederkehrender Zahlungen galten „Seniorenzentrum St. Katharina" und
+  „Seniorenzentrum St. Katharina gGmbH" als zwei verschiedene Empfänger —
+  und damit zerfiel die Gruppe genau dort, wo sie am meisten zählt: Heime,
+  Sozialdienste und Träger sind fast durchweg gGmbH.
+
+### Was der Beispielfall jetzt zeigt
+
+- Das Heimentgelt steht in **drei Schreibweisen** auf dem Auszug und wird
+  trotzdem als eine monatliche Zahlung von 2.489 € geführt.
+- Genau **eine** Buchung hat weder Quittung noch Begründung — damit die
+  Belegpflicht etwas zu zeigen hat, aber die Liste nicht rot leuchtet.
+- Die Sterbegeld-Lastschriften sind bewusst **nicht** zugeordnet: So lässt
+  sich der Handgriff „zwölf Zahlungen als belegt zuordnen" ausprobieren.
+  Der Beitrag steigt im Mai von 18,40 € auf 19,80 €, damit auch die
+  Abweichungsprüfung sichtbar wird.
+- Der Kontostand zum 31.07.2026 wird aus dem Anfangsstand und den
+  Buchungen **gerechnet**, nicht behauptet. Ein Beispielfall, der sich
+  selbst widerspricht, wäre schlimmer als einer ohne Buchungen.
+
+### Geprüft
+
+- Ein Einheitstest für die gGmbH-Erkennung.
+- Vier End-to-End-Tests am Beispielfall: Umfang und Zeitraum der
+  Buchungen, die Übereinstimmung von Kontostand und Buchungssumme, die
+  erkannten Zahlungsgruppen und das Kassenbuch.
+
+## [1.10.0] – 2026-08-23
+
+### Hinzugefügt
+
+- **Deine Anschrift steht jetzt in jedem Schreiben**
+  ([#21](https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/issues/21)).
+  Bisher ging jeder Brief ohne Rücksendeadresse hinaus — im
+  Absenderblock stand nur dein Name, und in der Datumszeile fehlte der
+  Ort. Bei einer Versicherung oder Behörde wirkt das unseriös und macht
+  es der Gegenstelle unnötig schwer zu antworten.
+
+  Unter **Mein Konto → Meine Anschrift** einmal Straße, PLZ und Ort
+  hinterlegen. Ab da stehen sie im Absenderblock jedes erzeugten
+  Schreibens, und die Datumszeile lautet „Bayreuth, den 23.08.2026".
+  Betroffen ist alles: Rückkaufswert-Anfrage, Serienabfrage, Kündigung,
+  Sachstandsanfrage und die eigenen Vorlagen.
+
+- **Zwei neue Platzhalter** für eigene Vorlagen: `{{betreuer_anschrift}}`
+  und `{{betreuer_ort}}`.
+
+### Eine Zusage
+
+**Was fehlt, bleibt weg.** Jede der drei Angaben ist einzeln freiwillig.
+Hinterlegst du nur den Ort, bekommst du die Datumszeile mit Ort und einen
+Absenderblock, der weiterhin nur aus deinem Namen besteht — keine leeren
+Zeilen, kein Komma ohne Ort. Eine halb ausgefüllte Adresse sieht nach
+Fehler aus, ein bloßer Name nach Absicht.
+
+### Datenbank
+
+Eine Migration: drei Felder am Benutzer. Die Anschrift hängt an dir und
+nicht an der betreuten Person — sie gilt für alle Akten.
+
+### Geprüft
+
+- Sieben Einheitstests für den Absenderblock, darunter jede
+  Teilbefüllung und die Gegenprobe, dass nie die Heimadresse der
+  betreuten Person im Absender landet.
+- Vier End-to-End-Tests: der Brief ohne hinterlegte Anschrift, das
+  Speichern unter *Mein Konto*, der Brief danach und die Gegenprobe am
+  Rückkaufswert-Schreiben.
+
 ## [1.9.0] – 2026-08-23
 
 ### Hinzugefügt
@@ -1036,7 +1265,11 @@ Was davon wann angegangen wird, steht in [`docs/ROADMAP.md`](docs/ROADMAP.md).
 
 ---
 
-[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.9.0...HEAD
+[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.11.0...HEAD
+[1.11.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.10.2...v1.11.0
+[1.10.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.10.1...v1.10.2
+[1.10.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.10.0...v1.10.1
+[1.10.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.9.0...v1.10.0
 [1.9.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.8.0...v1.9.0
 [1.8.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.7.0...v1.8.0
 [1.7.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.6.0...v1.7.0

README.md

@@ -97,11 +97,12 @@ DATABASE_URL="postgresql://cockpit:entwicklung@localhost:5433/betreuungs_cockpit
 **3. Datenbank einrichten:**
 
 ```bash
-npx prisma migrate dev --name fundament
+npm run setup             # Migrationen, Volltextsuche, Audit-Schutz, Beispieldaten
-npm run db:sql            # Volltextsuche und Audit-Schutz
-npm run db:seed
 ```
 
+Das ist die Kurzform für `db:deploy`, `db:sql` und `db:seed` — die drei
+Schritte laufen ohne Rückfrage durch.
+
 **4. Starten:**
 
 ```bash
@@ -513,6 +514,35 @@ npm run protokoll        # Bauprotokoll aus der Git-Historie
 npm run version -- patch # Version anheben, Changelog vorbereiten
 ```
 
+### Die Datenbankbefehle
+
+Welcher Befehl wofür — und welcher am Terminal Rückfragen stellt. Nur
+`db:migrate` ist interaktiv; alle anderen laufen in Skripten, in der CI
+und im Container durch.
+
+| Befehl | Wofür | Rückfragen? |
+|---|---|---|
+| `npm run setup` | Ersteinrichtung: Migrationen, SQL-Skripte, Beispieldaten | nein |
+| `npm run db:migration -- <name>` | Schemaänderung während der Entwicklung — erzeugt die Migration und nimmt die `DROP INDEX`-Zeilen zur Volltextsuche heraus | nein |
+| `npm run db:deploy` | Vorhandene Migrationen anwenden (Server, CI, Container) | nein |
+| `npm run db:migrate` | `prisma migrate dev` — fragt nach dem Namen und bietet an, die Datenbank zurückzusetzen | **ja** |
+| `npm run db:sql` | Volltextsuche und Audit-Schutz; läuft nicht mit den Migrationen mit | nein |
+| `npm run db:pruefen` | Nachsehen, ob die Trigramm-Indizes noch stehen | nein |
+| `npm run db:seed` | Beispieldaten einspielen | nein |
+
+Der übliche Weg für eine Schemaänderung:
+
+```bash
+# Schema in prisma/schema.prisma ändern, dann
+npm run db:migration -- ansprechpartner   # erzeugen und lesen
+npm run db:deploy                          # anwenden
+npm run db:pruefen                         # Indizes nachsehen
+```
+
+`db:migrate` braucht man dafür nicht mehr. Es bleibt für die Fälle, in
+denen man wirklich den interaktiven Prisma-Ablauf will — etwa um eine
+verkorkste Entwicklungsdatenbank zurückzusetzen.
+
 Konventionen — verbindlich für alle Beiträge:
 [`docs/KONVENTIONEN.md`](docs/KONVENTIONEN.md).
 Schnittstellen zwischen den Modulen:
@@ -545,7 +575,8 @@ Produktion.
   über den Abschnitt `environment:`.
 - Beim ersten Start eines Containers laufen die Migrationen automatisch
   mit. Die beiden SQL-Skripte (Volltextsuche, Audit-Schutz) sind
-  **einmalig von Hand** anzustoßen, siehe oben.
+  **einmalig von Hand** anzustoßen, siehe oben. Beim Aktualisieren
+  erledigt das `scripts/update.sh` mit — beide Skripte sind idempotent.
 
 ### Technische Grundlage
 

docs/INSTALLATION.md

@@ -131,14 +131,14 @@ cd /opt/betreuungs-cockpit
 
 # Auf die letzte veröffentlichte Fassung wechseln,
 # nicht auf den laufenden Entwicklungsstand
-git checkout v1.9.0
+git checkout v1.10.2
 ```
 
 ### Kontrolle
 
 ```bash
 ls docker-compose.yml Dockerfile .env.example   # alle drei da
-git describe --tags                              # v1.9.0
+git describe --tags                              # v1.10.2
 ```
 
 ---
@@ -156,6 +156,7 @@ const w = n => b(n).replace(/[+/=]/g,'x');
 console.log('AUTH_SECRET=' + b(32));
 console.log('ENC_KEY_V1=' + b(32));
 console.log('INDEX_KEY=' + b(32));
+console.log('ERSTEINRICHTUNG_GEHEIMNIS=' + w(24));
 console.log('POSTGRES_PASSWORD=' + w(24));
 console.log('SICHERUNG_PASSWORT=' + w(24));
 console.log('S3_ACCESS_KEY_ID=' + w(12));
@@ -192,7 +193,15 @@ POSTGRES_PASSWORD=<aus Schritt 2>
 # --- Anmeldung ---
 AUTH_SECRET=<aus Schritt 2>
 AUTH_URL=https://cockpit.deine-domain.de      # exakt deine Adresse, mit https
-AUTH_TRUST_HOST=true
+
+# Ohne diesen Wert laesst sich der erste Zugang nicht anlegen. Absicht:
+# sonst steht die Einrichtungsseite bis zum ersten Anlegen fuer jeden offen.
+ERSTEINRICHTUNG_GEHEIMNIS=<aus Schritt 2>
+
+# Ein Reverse Proxy steht davor (Schritt 7). Nur damit wird der
+# weitergereichte Kopf geglaubt, aus dem die Anmeldesperre den Anschluss
+# liest. Ohne die Zeile zaehlt sie nur nach E-Mail-Adresse.
+VERTRAUE_PROXY=true
 
 # --- Verschlüsselung ---
 ENC_KEY_V1=<aus Schritt 2>
@@ -258,12 +267,16 @@ chmod 600 .env
 
 ```bash
 # Sind alle Pflichtwerte gefüllt? Zeigt nur die Namen, nicht die Werte.
-grep -E '^(POSTGRES_PASSWORD|AUTH_SECRET|AUTH_URL|ENC_KEY_V1|INDEX_KEY|S3_ACCESS_KEY_ID|S3_SECRET_ACCESS_KEY|SICHERUNG_PASSWORT)=.+' .env \
+grep -E '^(POSTGRES_PASSWORD|AUTH_SECRET|AUTH_URL|ERSTEINRICHTUNG_GEHEIMNIS|VERTRAUE_PROXY|ENC_KEY_V1|INDEX_KEY|S3_ACCESS_KEY_ID|S3_SECRET_ACCESS_KEY|SICHERUNG_PASSWORT)=.+' .env \
   | sed 's/=.*/ = gesetzt/'
 ```
 
-Acht Zeilen müssen erscheinen. Fehlt eine, startet die Anwendung nicht —
+Zehn Zeilen müssen erscheinen. Fehlt eine, startet die Anwendung nicht —
-und sagt dir beim Start auch, welche.
+und sagt dir beim Start auch, welche. Zwei Ausnahmen: Fehlt
+`ERSTEINRICHTUNG_GEHEIMNIS`, startet die Anwendung, aber der erste Zugang
+lässt sich nicht anlegen. Fehlt `VERTRAUE_PROXY`, läuft alles — die
+Anmeldesperre zählt dann nur nach E-Mail-Adresse und schreibt beim ersten
+Mal eine Zeile ins Log.
 
 ---
 
@@ -299,7 +312,7 @@ betreuungs-cockpit-sicherung-1  Up
 ```bash
 # Antwortet die Anwendung? (Port anpassen, falls du APP_PORT gesetzt hast)
 curl -s http://127.0.0.1:3000/api/gesundheit
-# {"status":"bereit","version":"1.9.0","commit":"..."}
+# {"status":"bereit","version":"1.10.2","commit":"..."}
 ```
 
 Kommt hier nichts, sieh in die Logs:
@@ -649,7 +662,7 @@ Erst **vom Proxy-Server aus** — kommt er überhaupt an?
 
 ```bash
 curl -s http://10.0.0.5:3000/api/gesundheit
-# {"status":"bereit","version":"1.9.0",...}
+# {"status":"bereit","version":"1.10.2",...}
 ```
 
 Kommt hier nichts, liegt es an 7a: falsche `APP_BIND`, Firewall, oder der
@@ -700,7 +713,7 @@ Zum Schluss: **Fristen → Pflichtfristen ableiten**.
 - Du kommst mit E-Mail, Passwort und dem Code aus der App herein.
 - Unter **Fristen** stehen Einträge mit Paragraphenbezug.
 - Unter **Protokoll** siehst du deine eigene Anmeldung.
-- Unten links in der Seitenleiste steht `Version 1.9.0 · <commit>`.
+- Unten links in der Seitenleiste steht `Version 1.10.2 · <commit>`.
 
 ---
 
@@ -875,7 +888,7 @@ alles so vor wie zuvor.
 | Aufruf | Wirkung |
 |---|---|
 | `./scripts/update.sh` | auf die neueste veröffentlichte Fassung |
-| `./scripts/update.sh v1.9.0` | auf eine bestimmte Fassung |
+| `./scripts/update.sh v1.10.2` | auf eine bestimmte Fassung |
 | `./scripts/update.sh --pruefen` | nur nachsehen, nichts ändern |
 | `./scripts/update.sh --ja` | ohne Rückfrage (für cron) |
 | `./scripts/update.sh --verwerfen` | eigene Änderungen wegwerfen statt beiseitelegen |
@@ -913,7 +926,7 @@ git fetch --tags
 git log --oneline HEAD..origin/main
 
 # 3. Umschalten
-git checkout v1.9.0
+git checkout v1.10.2
 
 # 4. Neu bauen und starten
 GIT_COMMIT=$(git rev-parse --short HEAD) BUILD_ZEIT=$(date -Iseconds) docker compose up -d --build

docs/ROADMAP.md

@@ -9,7 +9,7 @@ Zeit spart. Er steht weit unten, wenn er nur schön wäre.
 Diese Datei ist eine Absichtserklärung, kein Vertrag. Was sich im Betrieb
 als wichtiger herausstellt, rutscht nach oben.
 
-Stand: 23.08.2026 · Aktuelle Fassung: **1.9.0** ([CHANGELOG](../CHANGELOG.md))
+Stand: 23.08.2026 · Aktuelle Fassung: **1.10.2** ([CHANGELOG](../CHANGELOG.md))
 
 ---
 

docs/SICHERHEIT.md

@@ -0,0 +1,168 @@
+# Sicherheit
+
+Was in dieser Anwendung gegen welche Bedrohung steht — und was
+ausdrücklich **nicht**. Der zweite Teil ist der wichtigere: Eine Zusage,
+die nicht gilt, ist gefährlicher als eine fehlende, weil man sich auf sie
+verlässt.
+
+Stand: v1.11.0. Die Fassung entstand beim Abarbeiten von Issue #38
+(Sicherheitsprüfung durch ein zweites Modell) und dem eigenen Durchgang
+entlang der OWASP Top 10 (2021).
+
+---
+
+## Das Bedrohungsmodell
+
+Eine ehrenamtliche rechtliche Betreuung. Ein Benutzer, eine betreute
+Person, ein kleiner Server hinter einem Reverse Proxy. In der Datenbank
+liegen Gesundheitsdaten (Art. 9 DSGVO), Kontobewegungen und
+Vermögensverzeichnisse.
+
+Nach Wahrscheinlichkeit geordnet:
+
+| Was | Wie wahrscheinlich | Was dagegen steht |
+|---|---|---|
+| Offene Sitzung an einem unbeaufsichtigten Rechner | hoch | Abmeldung nach 30 min Leerlauf; erneute Bestätigung vor Export, Löschen, Benutzer- und Passkey-Verwaltung |
+| Verlorenes oder gestohlenes Gerät | mittel | Zweiter Faktor ist Pflicht; Passkeys verlangen Nutzerverifikation |
+| Kopiertes Backup, falsch gerechtetes Verzeichnis | mittel | Feldverschlüsselung (AES-256-GCM), Dateien im Umschlag, Schlüssel nur in der Umgebung |
+| Zugangsdaten zum Objektspeicher abhandengekommen | mittel | Objekte liegen verschlüsselt, an ihren Ablageort gebunden |
+| Raten von Passwörtern über das Formular | mittel | Anmeldesperre nach E-Mail **und** Anschluss, Argon2id |
+| Einbruch in den Server selbst | gering | Kaum etwas — wer dort Wurzelrechte hat, hat die Schlüssel |
+
+Der letzte Punkt ist keine Nachlässigkeit, sondern eine Grenze: Die
+Anwendung braucht die Schlüssel zur Laufzeit. Wer den Prozess kontrolliert,
+kommt an sie heran. Dagegen hilft Betriebssicherheit, kein Anwendungscode.
+
+---
+
+## Was ausdrücklich nicht geschützt ist
+
+- **Der Server selbst.** Siehe oben.
+- **Metadaten in der Datenbank.** Verschlüsselt sind einzelne Felder —
+  Diagnosen, IBANs, Verwendungszwecke, Notizen. Dass es einen Vorgang
+  „Betreuungsgericht" gibt und wann er angelegt wurde, steht im Klartext.
+  Sonst ließe sich nichts mehr sortieren oder filtern.
+- **Symlinks im Ablageverzeichnis.** `resolve()` folgt keinen Links. Wer
+  dort einen anlegen kann, hat bereits Schreibrechte im Datenverzeichnis —
+  dann ist der Umweg über einen Link die geringste Sorge. Bis v1.10.2 stand
+  im Code das Gegenteil; der Satz ist entfernt.
+- **Die Middleware prüft keine Anmeldung.** Sie setzt Kopfzeilen, mehr
+  nicht. Der Zugriffsschutz sitzt in `src/lib/auth/sitzung.ts`, und nur
+  dort. Bis v1.10.2 behauptete ein Kommentar das Gegenteil.
+- **Verfügbarkeit.** Es gibt keinen Schutz gegen jemanden, der den Server
+  mit Anfragen überzieht. Bei einem Nutzer hinter einem Proxy ist das die
+  Aufgabe des Proxys.
+
+---
+
+## Der Durchgang entlang der OWASP Top 10 (2021)
+
+### A01 Broken Access Control
+
+Jede Server Action und jede Seite geht durch `erfordereZugang()`, das
+zeilenweise gegen die `betreuteId` prüft — nie nur im UI ausgeblendet.
+Fremdschlüssel aus Formularen werden über `src/lib/auth/verweise.ts`
+geprüft; ein verändertes Auswahlfeld kann keine fremde Akte verknüpfen
+(e2e-Test `fremdakte.spec.ts`).
+
+Weiterleitungsziele laufen durch `sicheresZiel()` — kein offener Redirect.
+
+**Behoben in dieser Runde:** Die MFA-Pflicht galt nur für Seiten, nicht
+für Server Actions und Route Handler. Sie steckt jetzt in
+`erfordereBenutzer()` selbst. `tests/mfa-grenze.test.ts` liest den
+Quelltext und schlägt an, sobald eine weitere Umgehung dazukommt.
+
+### A02 Cryptographic Failures
+
+- Felder: AES-256-GCM, Umschlag `bc1.<version>.<iv>.<tag>.<ct>`, Feldname
+  als Zusatzdaten — ein Geheimtext lässt sich nicht von einem Feld in ein
+  anderes kopieren.
+- Dateien: AES-256-GCM, Umschlag `BCD1`, seit v1.11.0 **beide** Treiber,
+  mit dem Ablageschlüssel als Zusatzdaten.
+- Passwörter: Argon2id, Parameter im Hash, Nachziehen beim Anmelden.
+- Schlüsselrotation über `ENC_KEY_V<n>` / `ENC_KEY_AKTIV`; alte Schlüssel
+  bleiben zum Entschlüsseln stehen.
+- Alle Geheimnisvergleiche laufen über `timingSafeEqual` — geprüft für
+  Reauth-Cookie, Zugriffstoken, ICS-Signatur, Wartungsschlüssel und das
+  Einrichtungsgeheimnis.
+
+**Behoben in dieser Runde:** Der Objektspeicher verließ sich auf
+`ServerSideEncryption: 'AES256'` — den Schlüssel des Anbieters.
+
+### A03 Injection
+
+Prisma parametrisiert. Die fünf Rohabfragen benutzen ausnahmslos
+`Prisma.sql`-Templates; `Prisma.join()` in `suche.ts` fügt nur bereits
+parametrisierte Fragmente zusammen und ist damit unbedenklich.
+
+Zu XSS: `ts_headline` liefert `<mark>`-Marker im Suchausschnitt, und die
+Quelle ist der OCR-Text hochgeladener Dokumente. Gerendert wird er in
+`dokument-liste.tsx` aber nicht als HTML, sondern zerlegt und als React-
+Kinder ausgegeben — also escaped. Das einzige
+`dangerouslySetInnerHTML` der Anwendung setzt eine feste Konstante für die
+Themenumschaltung. **Kein Fund.**
+
+### A04 Insecure Design
+
+Erneute Bestätigung vor den folgenschweren Handlungen. Anmeldesperre nach
+zwei Dimensionen. Löschen ist ein Papierkorb mit 30 Tagen Frist.
+
+**Behoben in dieser Runde:** Passkeys ließen sich ohne erneute
+Bestätigung anlegen und entfernen — ein Passkey ist ein vollwertiger
+Zugang, der einen Passwortwechsel überlebt.
+
+### A05 Security Misconfiguration
+
+CSP mit Nonce pro Anfrage und `strict-dynamic` im Produktivbetrieb; dazu
+`X-Content-Type-Options`, `X-Frame-Options: DENY`, `Referrer-Policy:
+no-referrer`, `Permissions-Policy`, HSTS mit zwei Jahren.
+`poweredByHeader` aus.
+
+**Behoben in dieser Runde:** `trustHost` stand fest auf `true`, obwohl
+`AUTH_URL` gesetzt ist. `X-Forwarded-For` wurde ohne Proxy geglaubt und
+aus dem falschen Ende gelesen.
+
+### A06 Vulnerable and Outdated Components
+
+`npm audit`: 0 Schwachstellen (vorher 32, davon 5 kritisch).
+
+### A07 Identification and Authentication Failures
+
+Passwort + TOTP in einem Schritt, kein Zwischenzustand. Passkeys mit
+erzwungener Nutzerverifikation zählen als zwei Faktoren.
+`sitzungsGeneration` macht alle Sitzungen auf einen Schlag ungültig.
+Antwortzeiten sind angeglichen, damit sich keine E-Mail-Adressen abfragen
+lassen.
+
+**Behoben in dieser Runde:** TOTP-Codes galten mehrfach; die Anmeldesperre
+verlängerte sich selbst; die Ersteinrichtung stand offen und war nicht
+atomar.
+
+### A08 Software and Data Integrity Failures
+
+Zu jedem abgelegten Dokument steht eine SHA-256-Prüfsumme über den
+Klartext in der Datenbank — der Nachweis der Unverändertheit gegenüber dem
+Gericht. Der Umschlag ist authentifiziert (GCM), Veränderungen fallen beim
+Lesen auf.
+
+### A09 Security Logging and Monitoring Failures
+
+`AuditLog` hält Anmeldungen, Fehlversuche, Exporte, Löschungen und
+Passkey-Änderungen fest. Anmeldeversuche stehen zusätzlich in
+`login_versuch` und werden nach 30 Tagen aufgeräumt.
+
+**Behoben in dieser Runde:** Während einer Sperre entstand pro Anfrage
+eine Zeile — die Tabelle ließ sich vollschreiben. Jetzt eine je Sperre.
+
+### A10 Server-Side Request Forgery
+
+Die Anwendung ruft nichts von außen ab: kein `fetch`, keine
+HTTP-Bibliothek, keine Webhooks, keine URL-Vorschauen. Ausgehend geht nur
+SMTP an den konfigurierten Server. **Keine Angriffsfläche.**
+
+---
+
+## Wenn etwas gefunden wird
+
+Kein öffentliches Issue. Der Weg führt über das Dashboard; dort wird
+entschieden, ob und wie es hier landet.

e2e/absenderanschrift.spec.ts

@@ -0,0 +1,97 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Die eigene Anschrift im Schreiben — gegen die echte Anwendung.
+ *
+ * Der Weg, um den es geht: einmal unter „Mein Konto" hinterlegen, und
+ * ab da steht sie im Absenderblock und der Ort in der Datumszeile —
+ * ohne dass man beim Schreiben daran denken muss.
+ */
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+/** Zurück auf „nichts hinterlegt", damit der Fall auch prüfbar bleibt. */
+async function anschriftLeeren(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.user.updateMany({ data: { strasse: null, plz: null, ort: null } })
+  })
+}
+
+test.describe('Absenderanschrift', () => {
+  test.beforeAll(async () => {
+    await anschriftLeeren()
+  })
+
+  test.afterAll(async () => {
+    await anschriftLeeren()
+  })
+
+  test('ohne hinterlegte Anschrift steht nur der Name im Brief', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    const text = await page.locator('textarea#text').inputValue()
+    const zeilen = text.split('\n')
+
+    // Erste Zeile ist der Absender, danach kommt gleich die Leerzeile.
+    expect(zeilen[0]).toBe('Florian Wilde')
+    expect(zeilen[1]).toBe('')
+    // Kein Ort in der Datumszeile, also auch kein Komma davor.
+    expect(text).not.toContain(', den ')
+  })
+
+  test('speichert die Anschrift unter Mein Konto', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/konto')
+
+    await page.locator('input#strasse').fill('Cottenbacher Str. 23')
+    await page.locator('input#plz').fill('95445')
+    await page.locator('input#ort').fill('Bayreuth')
+    await page.getByRole('button', { name: 'Anschrift speichern' }).click()
+
+    await expect(page.getByText('Deine Anschrift ist gespeichert.')).toBeVisible()
+
+    await page.reload()
+    await expect(page.locator('input#strasse')).toHaveValue('Cottenbacher Str. 23')
+  })
+
+  test('trägt sie in Absenderblock und Datumszeile des Schreibens', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/schreiben/neu?art=FREI')
+
+    const text = await page.locator('textarea#text').inputValue()
+    const zeilen = text.split('\n')
+
+    expect(zeilen[0]).toBe('Florian Wilde')
+    expect(zeilen[1]).toBe('Cottenbacher Str. 23')
+    expect(zeilen[2]).toBe('95445 Bayreuth')
+    expect(text).toContain('Bayreuth, den ')
+  })
+
+  test('steht auch im Rückkaufswert-Schreiben zum Vertrag', async ({ page }) => {
+    const vertragId = await mitDb(async (db) => {
+      const vertrag = await db.vertrag.findFirst({
+        where: { art: 'LEBENSVERSICHERUNG', geloeschtAm: null },
+        select: { id: true },
+      })
+      return vertrag?.id ?? ''
+    })
+    test.skip(vertragId === '', 'Kein Lebensversicherungsvertrag im Bestand.')
+
+    await anmelden(page)
+    await page.goto(`/schreiben/neu?art=RUECKKAUFSWERT&vertragId=${vertragId}`)
+
+    const text = await page.locator('textarea#text').inputValue()
+    expect(text).toContain('Cottenbacher Str. 23')
+    expect(text).toContain('Bayreuth, den ')
+  })
+})

e2e/demofall.spec.ts

@@ -0,0 +1,138 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Der Demo-Fall mit Kontobewegungen — gegen die echte Anwendung.
+ *
+ * Was hier geprüft wird, ist kein Verhalten der Anwendung, sondern die
+ * Brauchbarkeit der Beispieldaten: Wer die Anwendung zum ersten Mal
+ * ansieht, soll auf den Finanzseiten etwas vorfinden und nicht erst
+ * eine CSV importieren müssen.
+ *
+ * Die Prüfungen sind bewusst grob gehalten — sie sollen anschlagen, wenn
+ * der Demo-Fall leer läuft, und nicht bei jeder geänderten Zahl.
+ */
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+test.describe('Demo-Fall', () => {
+  test('bringt ein Jahr Kontobewegungen mit', async () => {
+    const zahlen = await mitDb(async (db) => {
+      const betreute = await db.betreute.findFirst({
+        where: { vorname: 'Erika', nachname: 'Musterfrau' },
+        select: { id: true },
+      })
+      if (!betreute) return null
+
+      const buchungen = await db.buchung.findMany({
+        where: { betreuteId: betreute.id, geloeschtAm: null },
+        select: { datum: true },
+        orderBy: { datum: 'asc' },
+      })
+      const ohneNachweis = await db.buchung.count({
+        where: { betreuteId: betreute.id, belegId: null, belegFehltBegruendung: null },
+      })
+      return { buchungen, ohneNachweis }
+    })
+
+    test.skip(zahlen === null, 'Kein Demo-Fall in dieser Datenbank.')
+    if (!zahlen) return
+
+    expect(zahlen.buchungen.length).toBeGreaterThan(50)
+
+    // Über mindestens zwölf Monate verteilt, nicht alle an einem Tag.
+    const erste = zahlen.buchungen[0]!.datum
+    const letzte = zahlen.buchungen[zahlen.buchungen.length - 1]!.datum
+    const monate =
+      (letzte.getUTCFullYear() - erste.getUTCFullYear()) * 12 +
+      (letzte.getUTCMonth() - erste.getUTCMonth())
+    expect(monate).toBeGreaterThanOrEqual(11)
+
+    // Genau ein Fall ohne Beleg und ohne Begründung — sonst hätte die
+    // Belegpflicht nichts zu zeigen, oder zu viel.
+    expect(zahlen.ohneNachweis).toBe(1)
+  })
+
+  test('der Kontostand stimmt mit der Summe der Buchungen überein', async () => {
+    const ergebnis = await mitDb(async (db) => {
+      const konto = await db.konto.findFirst({
+        where: { art: 'GIRO', betreute: { vorname: 'Erika', nachname: 'Musterfrau' } },
+        select: { id: true },
+      })
+      if (!konto) return null
+
+      const staende = await db.saldostand.findMany({
+        where: { kontoId: konto.id },
+        orderBy: { stichtag: 'asc' },
+      })
+      if (staende.length < 2) return null
+
+      const [anfang, ende] = [staende[0]!, staende[staende.length - 1]!]
+      const bewegungen = await db.buchung.findMany({
+        where: {
+          kontoId: konto.id,
+          geloeschtAm: null,
+          datum: { gt: anfang.stichtag, lte: ende.stichtag },
+        },
+        select: { betragCent: true, richtung: true },
+      })
+
+      const summe = bewegungen.reduce(
+        (wert, b) => (b.richtung === 'EINNAHME' ? wert + b.betragCent : wert - b.betragCent),
+        0n,
+      )
+      return { erwartet: anfang.betragCent + summe, tatsaechlich: ende.betragCent }
+    })
+
+    test.skip(ergebnis === null, 'Kein Demo-Fall mit zwei Kontoständen.')
+    if (!ergebnis) return
+
+    // Ein Demo-Fall, der sich selbst widerspricht, ist schlimmer als
+    // einer ohne Buchungen: Man rechnet nach und verliert das Vertrauen.
+    expect(ergebnis.tatsaechlich).toBe(ergebnis.erwartet)
+  })
+
+  test('die Erkennung wiederkehrender Zahlungen findet mehrere Gruppen', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/wiederkehrend')
+
+    const inhalt = await page.locator('body').innerText()
+
+    // Monatliches und Vierteljährliches, beides erkannt.
+    expect(inhalt).toContain('Seniorenzentrum')
+    expect(inhalt).toContain('TeleCare')
+    expect(inhalt).toContain('Beitragsservice')
+    expect(inhalt).toContain('monatlich')
+    expect(inhalt).toContain('vierteljährlich')
+
+    // Der eigentliche Vorführeffekt: Das Heim steht in drei Schreibweisen
+    // auf dem Auszug und wird trotzdem als eine Zahlung geführt.
+    expect(inhalt).toContain('3 Schreibweisen zusammengefasst')
+
+    // Die Sterbekasse steht im zweiten Abschnitt: Zu ihr gibt es einen
+    // Vertrag, die Zahlungen sind ihm aber noch nicht zugeordnet. Damit
+    // lässt sich der Handgriff aus der Dauerzahlungs-Zuordnung am
+    // Demo-Fall ausprobieren, statt ihn nur zu beschreiben.
+    expect(inhalt).toContain('Schon einem Vertrag zugeordnet')
+    expect(inhalt).toContain('Nordheim Sterbekasse')
+    expect(inhalt).toContain('als belegt zuordnen')
+  })
+
+  test('das Kassenbuch zeigt die Buchungen und die fehlende Quittung', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/finanzen/buchungen')
+
+    const inhalt = await page.locator('body').innerText()
+    expect(inhalt).toContain('Heimentgelt')
+    // Die eine Buchung ohne Quittung und ohne Begründung.
+    expect(inhalt).toContain('Modehaus Lindner')
+  })
+})

e2e/fremdakte.spec.ts

@@ -0,0 +1,116 @@
+import { expect, test } from '@playwright/test'
+import { PrismaClient } from '@prisma/client'
+import { anmelden } from './hilfen'
+
+/**
+ * Verweise über Aktengrenzen hinweg — gegen die echte Anwendung.
+ *
+ * Die Auswahllisten im Browser zeigen nur die eigene Akte. Darauf darf
+ * sich der Server nicht verlassen: Wer das Formular verändert, schickt
+ * jede beliebige Id.
+ *
+ * Genau das wird hier nachgestellt — nicht als nachgebauter Aufruf,
+ * sondern indem dem echten Auswahlfeld ein Eintrag mit einer fremden Id
+ * untergeschoben und das Formular ganz normal abgeschickt wird. Nur so
+ * beweist der Test etwas: Er liefe rot, wenn die Prüfung fehlte.
+ *
+ * Solange nur eine betreute Person angelegt ist, wäre der Fehler
+ * folgenlos. Er bliebe es nicht — ein fremder Name stünde im Briefkopf.
+ */
+
+const KENNUNG = 'Prüfhausen Fremdakte'
+
+async function mitDb<T>(arbeit: (db: PrismaClient) => Promise<T>): Promise<T> {
+  const db = new PrismaClient()
+  try {
+    return await arbeit(db)
+  } finally {
+    await db.$disconnect()
+  }
+}
+
+async function aufraeumen(): Promise<void> {
+  await mitDb(async (db) => {
+    await db.betreute.deleteMany({ where: { nachname: { contains: 'Fremdakte' } } })
+  })
+}
+
+test.describe('Verweise auf eine fremde Akte', () => {
+  test.beforeAll(async () => {
+    await aufraeumen()
+  })
+
+  test.afterAll(async () => {
+    await aufraeumen()
+  })
+
+  test('weist einen Kontakt aus einer anderen Akte ab', async ({ page }) => {
+    // Zweite Akte mit einem Kontakt darin — der angemeldete Benutzer hat
+    // auf sie keinen Zugriff.
+    const fremderKontakt = await mitDb(async (db) => {
+      const fremde = await db.betreute.create({
+        data: {
+          vorname: 'Otto',
+          nachname: `${KENNUNG} Fremdakte`,
+          geburtsdatum: new Date(Date.UTC(1940, 0, 1)),
+        },
+      })
+      const kontakt = await db.kontakt.create({
+        data: {
+          betreuteId: fremde.id,
+          name: `${KENNUNG} Fremder Sachbearbeiter`,
+          rolle: 'SACHBEARBEITER_BEZIRK',
+        },
+      })
+      return kontakt.id
+    })
+
+    await anmelden(page)
+    // Irgendeinen Vorgang der eigenen Akte öffnen.
+    const vorgangId = await mitDb(async (db) => {
+      const vorgang = await db.vorgang.findFirst({
+        where: { geloeschtAm: null, betreute: { vorname: 'Erika' } },
+        select: { id: true },
+      })
+      return vorgang?.id ?? ''
+    })
+    test.skip(vorgangId === '', 'Kein Vorgang in der eigenen Akte.')
+
+    await page.goto(`/vorgaenge/${vorgangId}`)
+    const auswahl = page.locator('select[name="ansprechpartnerId"]')
+    await auswahl.waitFor()
+
+    // Dem echten Auswahlfeld die fremde Id unterschieben und ganz normal
+    // abschicken — so, wie es ein verändertes Formular täte.
+    await auswahl.evaluate((feld, id) => {
+      const eintrag = document.createElement('option')
+      eintrag.value = id
+      eintrag.textContent = 'untergeschoben'
+      ;(feld as HTMLSelectElement).append(eintrag)
+      ;(feld as HTMLSelectElement).value = id
+    }, fremderKontakt)
+
+    await page.getByRole('button', { name: 'Speichern' }).click()
+
+    // Der Server lehnt ab, mit einer Meldung, die den Grund nennt.
+    // Grosszuegige Frist: Im Entwicklungsmodus wird die Server Action beim
+    // ersten Aufruf uebersetzt, und das dauert laenger als die Vorgabe.
+    await expect(page.getByText(/gehört nicht zu dieser betreuten Person/).first()).toBeVisible({
+      timeout: 45_000,
+    })
+
+    // Und vor allem: Die Verknüpfung ist nicht entstanden.
+    const verknuepft = await mitDb((db) =>
+      db.vorgang.count({ where: { ansprechpartnerId: fremderKontakt } }),
+    )
+    expect(verknuepft).toBe(0)
+  })
+
+  test('die Auswahlliste zeigt den fremden Kontakt gar nicht erst', async ({ page }) => {
+    await anmelden(page)
+    await page.goto('/vorgaenge')
+
+    const inhalt = await page.locator('body').innerText()
+    expect(inhalt).not.toContain('Fremder Sachbearbeiter')
+  })
+})

e2e/hilfen.ts

@@ -117,3 +117,46 @@ export function beispielPdf(text = 'Bescheid'): Buffer {
 
   return Buffer.from(pdf, 'latin1')
 }
+
+/**
+ * Doppelt gerenderte Listen — was beim Suchen schiefgeht.
+ *
+ * Die Dokumentenliste (und moeglicherweise kuenftig weitere) rendert
+ * denselben Inhalt ZWEIMAL: als Karten fuers Handy, als Tabelle ab
+ * Tablet. Eine der beiden Fassungen ist per Breakpoint versteckt, steht
+ * aber im DOM.
+ *
+ * Die Folge im Test:
+ *
+ *   await expect(page.getByText('Bescheid').first()).toBeVisible()
+ *   // -> "element is not visible", obwohl die Seite richtig aussieht
+ *
+ * `.first()` nimmt, was zuerst im Baum steht - und das ist die Karte,
+ * also am Schreibtisch die unsichtbare Fassung. Es liegt NICHT an der
+ * Anwendung.
+ *
+ * Nachgemessen an /dokumente mit acht Dokumenten: Ein Titel liefert 16
+ * Treffer, davon 8 sichtbar - und `.first()` ist unsichtbar.
+ *
+ * Drei Wege, die tragen:
+ *
+ *   1. Ueber den Seitentext pruefen, wenn es nur um "steht das da?" geht:
+ *
+ *        const inhalt = await page.locator('body').innerText()
+ *        expect(inhalt).toContain('Bescheid')
+ *
+ *      innerText liefert nur sichtbaren Text - die versteckte Fassung
+ *      faellt von selbst weg. (Fuer Inhalt in einem zugeklappten
+ *      <details> braucht es dagegen textContent.)
+ *
+ *   2. Auf die sichtbare Fassung einschraenken, wenn geklickt wird:
+ *
+ *        page.getByRole('link', { name: 'Bescheid' }).locator('visible=true')
+ *
+ *   3. Die Zusammenfassungszeile pruefen ("12 Dokumente"), wenn es um
+ *      Anzahlen geht - die steht nur einmal.
+ *
+ * Was nicht traegt: eine feste Anzahl erwarten. `getByText(...)` findet
+ * jeden Eintrag zweimal, und wer das mit toHaveCount(1) prueft, schreibt
+ * einen Test, der bei jeder Layoutaenderung umfaellt.
+ */

package.json

@@ -1,6 +1,6 @@
 {
   "name": "betreuungs-cockpit",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "private": true,
   "description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
   "engines": {
@@ -17,6 +17,9 @@
     "db:generate": "prisma generate",
     "db:migrate": "prisma migrate dev",
     "db:deploy": "prisma migrate deploy",
+    "db:migration": "node scripts/migration-erzeugen.mjs",
+    "speicher:verschluesseln": "tsx --env-file=.env scripts/speicher-verschluesseln.mts",
+    "db:pruefen": "node -e \"import('./scripts/migration-erzeugen.mjs').then(m => m.indizesPruefen())\"",
     "db:volltext": "prisma db execute --schema prisma/schema.prisma --file prisma/sql/volltextsuche.sql",
     "db:seed": "prisma db seed",
     "db:studio": "prisma studio",
@@ -35,8 +38,8 @@
     "seed": "tsx prisma/seed.ts"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "3.735.0",
+    "@aws-sdk/client-s3": "3.1116.0",
-    "@aws-sdk/s3-request-presigner": "3.735.0",
+    "@aws-sdk/s3-request-presigner": "3.1116.0",
     "@node-rs/argon2": "2.0.2",
     "@prisma/client": "6.3.1",
     "@radix-ui/react-dialog": "1.1.4",
@@ -52,9 +55,9 @@
     "date-fns": "4.1.0",
     "docx": "9.1.1",
     "lucide-react": "0.474.0",
-    "next": "15.1.6",
+    "next": "15.5.23",
-    "next-auth": "5.0.0-beta.25",
+    "next-auth": "5.0.0-beta.32",
-    "nodemailer": "6.10.0",
+    "nodemailer": "9.0.5",
     "otpauth": "9.3.6",
     "pdf-lib": "1.17.1",
     "qrcode": "1.5.4",
@@ -67,22 +70,22 @@
     "zod": "3.24.1"
   },
   "devDependencies": {
-    "@playwright/test": "1.50.1",
+    "@playwright/test": "1.62.1",
     "@types/archiver": "6.0.3",
     "@types/node": "22.13.1",
-    "@types/nodemailer": "6.4.17",
+    "@types/nodemailer": "7.0.4",
     "@types/qrcode": "1.5.5",
     "@types/react": "19.0.8",
     "@types/react-dom": "19.0.3",
     "autoprefixer": "10.4.20",
-    "eslint": "9.19.0",
+    "eslint": "9.39.1",
-    "eslint-config-next": "15.1.6",
+    "eslint-config-next": "15.5.23",
-    "postcss": "8.5.1",
+    "postcss": "8.5.26",
     "prisma": "6.3.1",
     "tailwindcss": "3.4.17",
-    "tsx": "4.19.2",
+    "tsx": "4.20.6",
     "typescript": "5.7.3",
-    "vitest": "3.0.5"
+    "vitest": "3.2.6"
   },
   "allowScripts": {
     "@prisma/client@6.3.1": true,
@@ -97,6 +100,9 @@
     "next-auth": {
       "@simplewebauthn/server": "$@simplewebauthn/server",
       "@simplewebauthn/browser": "$@simplewebauthn/browser"
-    }
+    },
+    "nodemailer": "9.0.5",
+    "postcss": "8.5.26",
+    "sharp": "0.35.3"
   }
 }

prisma/migrations/20260822160000_passkey_anmeldung/migration.sql

@@ -2,10 +2,11 @@
 --
 -- ACHTUNG beim Erzeugen weiterer Migrationen: "prisma migrate diff" wollte
 -- hier zusaetzlich die Trigramm-Indizes "dokument_absender_trgm" und
--- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/suche.sql und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
 -- sind Prisma unbekannt - ein DROP haette die unscharfe Suche stillgelegt,
 -- ohne dass irgendetwas fehlgeschlagen waere. Solche Zeilen gehoeren aus
 -- jeder erzeugten Migration entfernt.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- CreateEnum
 CREATE TYPE "PasskeyAnfrageArt" AS ENUM ('REGISTRIERUNG', 'ANMELDUNG');

prisma/migrations/20260823000500_zahlungsgruppe_geklaert/migration.sql

@@ -2,10 +2,11 @@
 --
 -- ACHTUNG, zum zweiten Mal in diesem Projekt: "prisma migrate diff" wollte
 -- hier wieder die Trigramm-Indizes "dokument_absender_trgm" und
--- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/suche.sql und
+-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/volltextsuche.sql und
 -- sind Prisma unbekannt; ein DROP haette die unscharfe Suche stillgelegt,
 -- ohne dass irgendetwas fehlgeschlagen waere. Die Zeilen sind entfernt.
 -- Wer die naechste Migration erzeugt: nachsehen und wieder herausnehmen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- CreateTable
 CREATE TABLE "zahlungsgruppe_geklaert" (

prisma/migrations/20260823062000_buchung_vertragszahlung/migration.sql

@@ -2,10 +2,11 @@
 --
 -- ACHTUNG, zum dritten Mal: "prisma migrate diff" wollte wieder die
 -- Trigramm-Indizes "dokument_absender_trgm" und "vorgang_titel_trgm"
--- loeschen. Sie stammen aus prisma/sql/suche.sql und sind Prisma
+-- loeschen. Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma
 -- unbekannt; ein DROP legt die unscharfe Suche stumm, ohne dass etwas
 -- fehlschlaegt. Zeilen entfernt. Wer die naechste Migration erzeugt:
 -- nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- AlterTable
 ALTER TABLE "buchung" ADD COLUMN     "vertragAutomatisch" BOOLEAN NOT NULL DEFAULT false,

prisma/migrations/20260823102500_schreibvorlage/migration.sql

@@ -1,8 +1,9 @@
 -- Eigene Schreibvorlagen.
 --
 -- ACHTUNG, zum vierten Mal: "prisma migrate diff" wollte wieder die
--- Trigramm-Indizes aus prisma/sql/suche.sql loeschen. Zeilen entfernt.
+-- Trigramm-Indizes aus prisma/sql/volltextsuche.sql loeschen. Zeilen entfernt.
 -- Wer die naechste Migration erzeugt: nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- CreateTable
 CREATE TABLE "schreibvorlage" (

prisma/migrations/20260823153000_ansprechpartner/migration.sql

@@ -1,8 +1,9 @@
 -- Ansprechpartner am Vorgang, Anrede am Kontakt.
 --
 -- ACHTUNG, zum fuenften Mal: "prisma migrate diff" wollte wieder die
--- Trigramm-Indizes aus prisma/sql/suche.sql loeschen. Zeilen entfernt.
+-- Trigramm-Indizes aus prisma/sql/volltextsuche.sql loeschen. Zeilen entfernt.
 -- Wer die naechste Migration erzeugt: nachsehen.
+-- Kuenftig nimmt "npm run db:migration" diese Zeilen selbst heraus.
 
 -- CreateEnum
 CREATE TYPE "KontaktAnrede" AS ENUM ('OHNE', 'FRAU', 'HERR');

prisma/migrations/20260823193832_betreuer_anschrift/migration.sql

@@ -0,0 +1,14 @@
+-- betreuer_anschrift
+--
+-- Erzeugt mit "npm run db:migration". Entfernt wurden die
+-- DROP-INDEX-Anweisungen zu diesen Indizes:
+--   dokument_absender_trgm
+--   vorgang_titel_trgm
+--
+-- Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma unbekannt;
+-- ohne sie waere die Volltextsuche still langsam geworden.
+
+-- AlterTable
+ALTER TABLE "benutzer" ADD COLUMN     "ort" TEXT,
+ADD COLUMN     "plz" TEXT,
+ADD COLUMN     "strasse" TEXT;

prisma/migrations/20260824074643_sicherheitsaudit/migration.sql

@@ -0,0 +1,31 @@
+-- sicherheitsaudit
+--
+-- Erzeugt mit "npm run db:migration". Entfernt wurden die
+-- DROP-INDEX-Anweisungen zu diesen Indizes:
+--   dokument_absender_trgm
+--   vorgang_titel_trgm
+--
+-- Sie stammen aus prisma/sql/volltextsuche.sql und sind Prisma unbekannt;
+-- ohne sie waere die Volltextsuche still langsam geworden.
+
+-- AlterTable
+ALTER TABLE "benutzer" ADD COLUMN     "totpLetzterSchritt" INTEGER;
+
+-- CreateTable
+CREATE TABLE "ersteinrichtung" (
+    "id" TEXT NOT NULL,
+    "abgeschlossenAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "userId" TEXT,
+
+    CONSTRAINT "ersteinrichtung_pkey" PRIMARY KEY ("id")
+);
+
+-- Bestehende Installationen nachziehen.
+--
+-- Die Tabelle oben ist die Sperre fuer die Ersteinrichtung. Auf einem
+-- System, das schon laeuft, ist die Einrichtung laengst erledigt - ohne
+-- diese Zeile stuende die Sperre nach dem Update offen, und der Weg zum
+-- Anlegen eines Administrators waere wieder frei.
+INSERT INTO "ersteinrichtung" ("id", "userId")
+SELECT 'einmalig', (SELECT "id" FROM "benutzer" ORDER BY "erstelltAm" ASC LIMIT 1)
+WHERE EXISTS (SELECT 1 FROM "benutzer");

prisma/schema.prisma

@@ -70,6 +70,13 @@ model User {
   // TOTP ist Pflicht. Das Secret liegt verschluesselt, nicht im Klartext.
   totpSecretVerschluesselt String?
   totpAktiviertAm          DateTime?
+  /// Der zuletzt akzeptierte TOTP-Zeitschritt (Unixzeit / 30).
+  ///
+  /// Ein TOTP-Code gilt 30 Sekunden, mit Toleranz bis zu 90. In dieser Zeit
+  /// liesse sich derselbe Code ein zweites Mal einloesen - abgelesen ueber
+  /// die Schulter oder abgefangen. Deshalb wird der Schritt festgehalten
+  /// und nur noch ein groesserer akzeptiert.
+  totpLetzterSchritt       Int?
   // Einmal-Wiederherstellungscodes, einzeln Argon2id-gehasht.
   wiederherstellungscodes  String[]  @default([])
 
@@ -81,6 +88,13 @@ model User {
   // (Passwortwechsel, Rollenaenderung, Verdacht auf Kompromittierung).
   sitzungsGeneration Int @default(0)
 
+  /// Die eigene Anschrift - Absenderblock und Ort in der Datumszeile
+  /// jedes erzeugten Schreibens. Sie gehoert zum Betreuer und nicht zur
+  /// betreuten Person: Sie gilt fuer alle Akten.
+  strasse String?
+  plz     String?
+  ort     String?
+
   // Oberflaechen-Einstellungen
   theme String @default("system") // "system" | "hell" | "dunkel"
 
@@ -121,6 +135,25 @@ model BetreuungsZugang {
   @@map("betreuungs_zugang")
 }
 
+/// Haelt fest, dass die Ersteinrichtung stattgefunden hat.
+///
+/// Die Tabelle hat genau eine Zeile mit fester Id. Das ist kein Protokoll,
+/// sondern eine Sperre: Vorher stand im Code "wenn es noch keinen Benutzer
+/// gibt, lege einen an" - zwei Anfragen gleichzeitig kamen beide durch die
+/// Pruefung und legten beide einen Administrator an. Ueber den
+/// Primaerschluessel entscheidet das jetzt die Datenbank, und zwar fuer
+/// genau einen Gewinner.
+model Ersteinrichtung {
+  /// Immer "einmalig". Der feste Wert ist die Sperre.
+  id String @id
+
+  abgeschlossenAm DateTime @default(now())
+  /// Wer den Zugang angelegt hat - nur zum Nachvollziehen.
+  userId          String?
+
+  @@map("ersteinrichtung")
+}
+
 /// Fehlgeschlagene und erfolgreiche Anmeldeversuche - Grundlage fuer das
 /// Rate-Limiting am Login. Wird nach 30 Tagen aufgeraeumt.
 model LoginVersuch {

prisma/seed.ts

@@ -22,7 +22,7 @@
  *
  * Der Seed ist idempotent: mehrfaches Ausfuehren aendert nichts.
  */
-import { PrismaClient } from '@prisma/client'
+import { PrismaClient, type BuchungKategorie, type Prisma } from '@prisma/client'
 import { hash } from '@node-rs/argon2'
 import { createCipheriv, randomBytes } from 'node:crypto'
 
@@ -112,6 +112,14 @@ async function ersterZugang() {
     },
   })
 
+  // Die Ersteinrichtung ist damit erledigt. Ohne diese Zeile stuende die
+  // Einrichtungsseite nach dem Seed weiter offen.
+  await db.ersteinrichtung.upsert({
+    where: { id: 'einmalig' },
+    update: {},
+    create: { id: 'einmalig', userId: benutzer.id },
+  })
+
   console.log(`Zugang ${email} angelegt.`)
   if (devSecret) {
     console.log('  Zweiter Faktor mit dem Entwicklungs-Geheimnis vorbelegt.')
@@ -263,9 +271,11 @@ async function demofall(userId: string) {
       art: 'GIRO',
       ibanVerschluesselt: verschluesseln('DE02773501100123456789', 'ibanVerschluesselt'),
       saldostaende: {
+        // Nur der Anfangsstand. Der spaetere wird weiter unten aus den
+        // Buchungen gerechnet - ein Demofall, der sich selbst
+        // widerspricht, waere schlimmer als einer ohne Buchungen.
         create: [
           { stichtag: datum('2026-02-14'), betragCent: cent(4218.36), quelle: 'Kontoauszug 02/2026' },
-          { stichtag: datum('2026-07-31'), betragCent: cent(2967.11), quelle: 'Kontoauszug 07/2026' },
         ],
       },
     },
@@ -523,6 +533,309 @@ async function demofall(userId: string) {
     })
   }
 
+
+  // --- Kontobewegungen ----------------------------------------------------
+  // Zwoelf Monate auf dem Girokonto. Erzeugt aus einem Muster und nicht
+  // einzeln abgetippt: So bleibt der Fall aenderbar, und die Betraege
+  // widersprechen sich nicht.
+  //
+  // Die Gegenstellen sind absichtlich uneinheitlich geschrieben. Genau
+  // damit muss die Zusammenfassung wiederkehrender Zahlungen umgehen - auf
+  // einem Kontoauszug steht dieselbe Stelle auch mal in Grossbuchstaben.
+  type Buchungsvorlage = {
+    tag: number
+    betrag: number
+    richtung: 'EINNAHME' | 'AUSGABE'
+    kategorie: BuchungKategorie
+    gegenstellen: string[]
+    zweck: string
+  }
+
+  const MONATLICH: Buchungsvorlage[] = [
+    {
+      tag: 1,
+      betrag: 1284.17,
+      richtung: 'EINNAHME',
+      kategorie: 'RENTE',
+      gegenstellen: [
+        'Deutsche Rentenversicherung Bund',
+        'DRV BUND',
+        'Deutsche Rentenversich. Bund',
+      ],
+      zweck: 'Altersrente',
+    },
+    {
+      tag: 1,
+      betrag: 96.4,
+      richtung: 'EINNAHME',
+      kategorie: 'RENTE',
+      gegenstellen: ['Zusatzversorgungskasse Bayern', 'ZVK Bayern'],
+      zweck: 'Betriebsrente',
+    },
+    {
+      tag: 3,
+      betrag: 1262,
+      richtung: 'EINNAHME',
+      kategorie: 'PFLEGEKASSE',
+      gegenstellen: ['Pflegekasse bei der AOK Bayern', 'AOK Bayern - Pflegekasse'],
+      zweck: 'Leistung vollstationaere Pflege, Pflegegrad 3',
+    },
+    {
+      tag: 5,
+      betrag: 2489,
+      richtung: 'AUSGABE',
+      kategorie: 'HEIMKOSTEN',
+      gegenstellen: [
+        'Seniorenzentrum St. Katharina',
+        'SENIORENZENTRUM ST KATHARINA',
+        'Seniorenzentrum St. Katharina gGmbH',
+      ],
+      zweck: 'Heimentgelt',
+    },
+    {
+      tag: 5,
+      betrag: 135,
+      richtung: 'AUSGABE',
+      kategorie: 'BARBETRAG',
+      // Eigene Gegenstelle, nicht das Heim: Sonst faellt der Barbetrag
+      // mit dem Heimentgelt in eine Gruppe, und aus zwei sauberen
+      // monatlichen Zahlungen wird eine "schwankende".
+      gegenstellen: ['Barauszahlung Verwahrgeldkonto'],
+      zweck: 'Barbetrag zur persoenlichen Verfuegung',
+    },
+    {
+      tag: 15,
+      betrag: 18.4,
+      richtung: 'AUSGABE',
+      kategorie: 'VERSICHERUNG',
+      gegenstellen: ['Nordheim Sterbekasse VVaG', 'NORDHEIM STERBEKASSE', 'Nordheim Sterbekasse'],
+      zweck: 'Beitrag Sterbegeldversicherung SG-220417',
+    },
+    {
+      tag: 20,
+      betrag: 24.9,
+      richtung: 'AUSGABE',
+      kategorie: 'TELEFON_INTERNET',
+      gegenstellen: ['TeleCare Kommunikation GmbH', 'TELECARE KOMMUNIKATION'],
+      zweck: 'Telefon und Fernsehen im Zimmer',
+    },
+    {
+      tag: 28,
+      betrag: 4.9,
+      richtung: 'AUSGABE',
+      kategorie: 'BANKGEBUEHREN',
+      gegenstellen: ['Sparkasse Bayreuth'],
+      zweck: 'Kontofuehrung',
+    },
+  ]
+
+  /** Zwoelf Monate bis einschliesslich Juli 2026. */
+  const MONATE = [
+    '2025-08',
+    '2025-09',
+    '2025-10',
+    '2025-11',
+    '2025-12',
+    '2026-01',
+    '2026-02',
+    '2026-03',
+    '2026-04',
+    '2026-05',
+    '2026-06',
+    '2026-07',
+  ]
+
+  const buchungen: Prisma.BuchungCreateManyInput[] = []
+
+  MONATE.forEach((monat, lauf) => {
+    MONATLICH.forEach((vorlage, stelle) => {
+      // Die Sterbegeld-Lastschrift steigt im Mai 2026. Daran wird die
+      // Pruefung beim Zuordnen einer Dauerzahlung sichtbar: Der Betrag
+      // weicht vom hinterlegten Beitrag ab.
+      const betrag =
+        vorlage.kategorie === 'VERSICHERUNG' && monat >= '2026-05' ? 19.8 : vorlage.betrag
+
+      buchungen.push({
+        betreuteId: betreute.id,
+        kontoId: giro.id,
+        datum: datum(`${monat}-${String(vorlage.tag).padStart(2, '0')}`),
+        betragCent: cent(betrag),
+        richtung: vorlage.richtung,
+        kategorie: vorlage.kategorie,
+        gegenstelle: vorlage.gegenstellen[lauf % vorlage.gegenstellen.length],
+        verwendungszweckVerschluesselt: verschluesseln(
+          vorlage.zweck,
+          'verwendungszweckVerschluesselt',
+        ),
+        // Wiederkehrende Zahlungen brauchen keinen Einzelbeleg - der
+        // Bescheid bzw. der Vertrag dahinter ist der Nachweis.
+        belegFehltBegruendung:
+          vorlage.richtung === 'EINNAHME'
+            ? 'Laufender Bezug, Nachweis ist der Bescheid.'
+            : 'Wiederkehrende Zahlung aus laufendem Vertrag.',
+        // Die Stelle in der Vorlagenliste gehoert in die Referenz: Zwei
+        // Renten am Monatsersten haetten sonst dieselbe, und der
+        // Unique-Index gegen Doppelbuchungen schlaegt zu Recht zu.
+        importReferenz: `demo-${monat}-${stelle}-${vorlage.kategorie}`,
+      })
+    })
+  })
+
+  // Vierteljaehrliches und Einmaliges - damit nicht alles im Monatsraster
+  // liegt und die Belegpflicht etwas zu zeigen hat.
+  const EINZELN: {
+    datum: string
+    betrag: number
+    richtung: 'EINNAHME' | 'AUSGABE'
+    kategorie: BuchungKategorie
+    gegenstelle: string
+    zweck: string
+    begruendung?: string
+  }[] = [
+    {
+      datum: '2025-08-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 3. Quartal 2025',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2025-11-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 4. Quartal 2025',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2026-02-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 1. Quartal 2026',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2026-05-15',
+      betrag: 55.08,
+      richtung: 'AUSGABE',
+      kategorie: 'RUNDFUNKBEITRAG',
+      gegenstelle: 'ARD ZDF Deutschlandradio Beitragsservice',
+      zweck: 'Rundfunkbeitrag 2. Quartal 2026',
+      begruendung: 'Wiederkehrende Zahlung, Beitragsbescheid liegt vor.',
+    },
+    {
+      datum: '2026-02-16',
+      betrag: 187.5,
+      richtung: 'AUSGABE',
+      kategorie: 'GRUNDSTEUER',
+      gegenstelle: 'Gemeinde Bindlach',
+      zweck: 'Grundsteuer B, 1. Rate 2026',
+      begruendung: 'Bescheid der Gemeinde liegt in der Akte.',
+    },
+    {
+      datum: '2026-05-16',
+      betrag: 187.5,
+      richtung: 'AUSGABE',
+      kategorie: 'GRUNDSTEUER',
+      gegenstelle: 'Gemeinde Bindlach',
+      zweck: 'Grundsteuer B, 2. Rate 2026',
+      begruendung: 'Bescheid der Gemeinde liegt in der Akte.',
+    },
+    {
+      datum: '2026-01-19',
+      betrag: 240,
+      richtung: 'AUSGABE',
+      kategorie: 'IMMOBILIE_BETRIEBSKOSTEN',
+      gegenstelle: 'Stadtwerke Bayreuth',
+      zweck: 'Abschlag Strom und Wasser, Haus Bindlach',
+      begruendung: 'Jahresabrechnung steht noch aus.',
+    },
+    {
+      datum: '2026-03-11',
+      betrag: 10,
+      richtung: 'AUSGABE',
+      kategorie: 'ZUZAHLUNG',
+      gegenstelle: 'Apotheke am Markt',
+      zweck: 'Zuzahlung Rezept',
+      begruendung: 'Quittung liegt in der Akte.',
+    },
+    // Der Fall fuer die Belegpflicht: keine Quittung und keine Begruendung.
+    // Genau so sieht eine Buchung aus, die noch Arbeit macht.
+    {
+      datum: '2026-04-08',
+      betrag: 89.95,
+      richtung: 'AUSGABE',
+      kategorie: 'BEKLEIDUNG',
+      gegenstelle: 'Modehaus Lindner',
+      zweck: 'Winterjacke und zwei Nachthemden',
+    },
+    {
+      datum: '2026-06-17',
+      betrag: 23,
+      richtung: 'AUSGABE',
+      kategorie: 'SONSTIGE_AUSGABE',
+      gegenstelle: 'Friseur im Haus',
+      zweck: 'Friseur',
+      begruendung: 'Bar aus dem Barbetrag bezahlt, keine Quittung ausgestellt.',
+    },
+    {
+      datum: '2026-07-02',
+      betrag: 62.4,
+      richtung: 'EINNAHME',
+      kategorie: 'ZINSEN',
+      gegenstelle: 'Sparkasse Bayreuth',
+      zweck: 'Zinsgutschrift',
+      begruendung: 'Der Kontoauszug ist der Nachweis.',
+    },
+  ]
+
+  for (const eintrag of EINZELN) {
+    buchungen.push({
+      betreuteId: betreute.id,
+      kontoId: giro.id,
+      datum: datum(eintrag.datum),
+      betragCent: cent(eintrag.betrag),
+      richtung: eintrag.richtung,
+      kategorie: eintrag.kategorie,
+      gegenstelle: eintrag.gegenstelle,
+      verwendungszweckVerschluesselt: verschluesseln(
+        eintrag.zweck,
+        'verwendungszweckVerschluesselt',
+      ),
+      belegFehltBegruendung: eintrag.begruendung ?? null,
+      importReferenz: `demo-${eintrag.datum}-${eintrag.kategorie}`,
+    })
+  }
+
+  await db.buchung.createMany({ data: buchungen })
+
+  // Der Kontostand zum 31.07.2026 wird gerechnet, nicht behauptet: Anfangs-
+  // stand plus alles, was seither ueber das Konto gelaufen ist. Sonst
+  // widerspraeche der Demofall sich selbst, sobald jemand nachrechnet.
+  const bewegungCent = buchungen
+    .filter((eintrag) => {
+      const tag = eintrag.datum as Date
+      return tag > datum('2026-02-14') && tag <= datum('2026-07-31')
+    })
+    .reduce((summe, eintrag) => {
+      const betrag = eintrag.betragCent as bigint
+      return eintrag.richtung === 'EINNAHME' ? summe + betrag : summe - betrag
+    }, 0n)
+
+  await db.saldostand.create({
+    data: {
+      kontoId: giro.id,
+      stichtag: datum('2026-07-31'),
+      betragCent: cent(4218.36) + bewegungCent,
+      quelle: 'Kontoauszug 07/2026',
+    },
+  })
+
   console.log('Demofall "Erika Musterfrau" angelegt.')
 }
 

scripts/migration-erzeugen.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Typen fuer das Werkzeugskript.
+ *
+ * Das Skript selbst bleibt .mjs - es laeuft ohne Bauschritt, auch auf
+ * einem Rechner, auf dem nur Node steht. Die Typen daneben sorgen dafuer,
+ * dass die Tests trotzdem geprueft werden und nicht stillschweigend
+ * gegen "any" laufen.
+ */
+
+export type GeschuetzterIndex = {
+  name: string
+  quelle: string
+}
+
+export declare const GESCHUETZTE_INDIZES: GeschuetzterIndex[]
+
+export declare function dropZeilenEntfernen(
+  sql: string,
+  geschuetzt?: GeschuetzterIndex[],
+): { sql: string; entfernt: string[] }
+
+export declare function hatAnweisungen(sql: string): boolean
+
+export declare function kopfBauen(
+  name: string,
+  entfernt: string[],
+  geschuetzt?: GeschuetzterIndex[],
+): string
+
+export declare function ordnernameBauen(name: string, jetzt?: Date): string
+
+export declare function indizesPruefen(): void

scripts/migration-erzeugen.mjs

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+/**
+ * Eine Migration erzeugen, ohne die Volltextsuche kaputtzumachen.
+ *
+ *   npm run db:migration -- ansprechpartner
+ *   npm run db:migration -- ansprechpartner --anwenden
+ *
+ * Das Problem, das dieses Skript loest: "prisma migrate diff" kennt nur
+ * das, was im Prisma-Schema steht. Die Trigramm-Indizes der Suche stehen
+ * aber in prisma/sql/volltextsuche.sql und sind Prisma unbekannt - also
+ * haelt es sie fuer ueberfluessig und schreibt in JEDE erzeugte Migration:
+ *
+ *   DROP INDEX "dokument_absender_trgm";
+ *   DROP INDEX "vorgang_titel_trgm";
+ *
+ * Fuenfmal ist das passiert, fuenfmal mussten die Zeilen von Hand raus.
+ * Auf dem Server waere es nicht aufgefallen, weil update.sh die Indizes
+ * hinterher ohnehin neu anlegt - in der Entwicklung dagegen waere die
+ * Suche still langsam geworden, ohne dass etwas fehlschlaegt.
+ *
+ * Was das Skript macht:
+ *   1. Migration mit "migrate diff" erzeugen.
+ *   2. DROP-Zeilen zu geschuetzten Indizes entfernen und im Kopf
+ *      vermerken, welche das waren.
+ *   3. Auf Wunsch (--anwenden) "migrate deploy" laufen lassen und danach
+ *      pruefen, dass die geschuetzten Indizes wirklich noch stehen.
+ *
+ * Nicht automatisch angewendet wird die Migration ohne --anwenden: Erst
+ * liest man, was da erzeugt wurde.
+ */
+import { execFileSync } from 'node:child_process'
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const WURZEL = join(dirname(fileURLToPath(import.meta.url)), '..')
+
+/**
+ * Indizes, die es nur in prisma/sql/ gibt und die Prisma deshalb nicht
+ * kennt. Wer dort einen hinzufuegt, traegt ihn hier ein - sonst faellt er
+ * der naechsten Migration zum Opfer.
+ */
+export const GESCHUETZTE_INDIZES = [
+  { name: 'dokument_absender_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+  { name: 'vorgang_titel_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+]
+
+/**
+ * Entfernt DROP-INDEX-Anweisungen zu geschuetzten Indizes.
+ *
+ * Bewusst eng gefasst: Nur eine Anweisung, die genau einen geschuetzten
+ * Index nennt, faellt weg. Ein DROP INDEX auf einen Prisma-eigenen Index
+ * bleibt stehen - der soll ja weg. Der Kommentar "-- DropIndex", den
+ * Prisma darueber setzt, wird mitgenommen, damit keine verwaisten
+ * Ueberschriften zurueckbleiben.
+ *
+ * @param {string} sql
+ * @param {{name: string}[]} geschuetzt
+ * @returns {{sql: string, entfernt: string[]}}
+ */
+export function dropZeilenEntfernen(sql, geschuetzt = GESCHUETZTE_INDIZES) {
+  const namen = geschuetzt.map((eintrag) => eintrag.name)
+  const zeilen = sql.split('\n')
+  const behalten = []
+  const entfernt = []
+
+  for (let i = 0; i < zeilen.length; i++) {
+    const zeile = zeilen[i]
+    const treffer = namen.find(
+      (name) => /^\s*DROP\s+INDEX\b/i.test(zeile) && zeile.includes(name),
+    )
+
+    if (!treffer) {
+      behalten.push(zeile)
+      continue
+    }
+
+    entfernt.push(treffer)
+
+    // Die "-- DropIndex"-Ueberschrift darueber mitnehmen, samt der
+    // Leerzeile davor - sonst bleiben Luecken im Text stehen.
+    while (behalten.length > 0 && /^\s*--\s*DropIndex\s*$/i.test(behalten[behalten.length - 1])) {
+      behalten.pop()
+      while (behalten.length > 0 && behalten[behalten.length - 1].trim() === '') behalten.pop()
+    }
+
+    // Leerzeilen, die der entfernten Anweisung folgen, ebenfalls.
+    while (i + 1 < zeilen.length && zeilen[i + 1].trim() === '') i++
+  }
+
+  return { sql: behalten.join('\n').replace(/\n{3,}/g, '\n\n').trimStart(), entfernt }
+}
+
+/**
+ * Steht in dem SQL ueberhaupt noch eine Anweisung?
+ *
+ * Wichtig fuer den Normalfall: Wenn Schema und Datenbank uebereinstimmen,
+ * besteht der ganze Diff aus den beiden bekannten DROP-INDEX-Zeilen. Nach
+ * dem Entfernen bleibt nichts uebrig - und eine leere Migration anzulegen
+ * waere schlimmer als gar keine, weil sie als angewendet in der Historie
+ * steht und niemand mehr weiss, wofuer sie gut war.
+ *
+ * @param {string} sql
+ * @returns {boolean}
+ */
+export function hatAnweisungen(sql) {
+  return sql
+    .split('\n')
+    .some((zeile) => zeile.trim() !== '' && !zeile.trim().startsWith('--'))
+}
+
+/** Der Kopfkommentar der erzeugten Datei. */
+export function kopfBauen(name, entfernt, geschuetzt = GESCHUETZTE_INDIZES) {
+  const zeilen = [`-- ${name}`, '--']
+
+  if (entfernt.length === 0) {
+    zeilen.push('-- Erzeugt mit "npm run db:migration". Nichts zu entfernen.')
+  } else {
+    const quellen = [
+      ...new Set(
+        entfernt.map(
+          (eintrag) => geschuetzt.find((g) => g.name === eintrag)?.quelle ?? 'prisma/sql/',
+        ),
+      ),
+    ]
+    zeilen.push(
+      '-- Erzeugt mit "npm run db:migration". Entfernt wurden die',
+      '-- DROP-INDEX-Anweisungen zu diesen Indizes:',
+      ...entfernt.map((eintrag) => `--   ${eintrag}`),
+      '--',
+      `-- Sie stammen aus ${quellen.join(', ')} und sind Prisma unbekannt;`,
+      '-- ohne sie waere die Volltextsuche still langsam geworden.',
+    )
+  }
+
+  zeilen.push('')
+  return zeilen.join('\n')
+}
+
+/** Zeitstempel im Prisma-Format, aus der lokalen Uhr. */
+export function ordnernameBauen(name, jetzt = new Date()) {
+  const zwei = (zahl) => String(zahl).padStart(2, '0')
+  const stempel = [
+    jetzt.getFullYear(),
+    zwei(jetzt.getMonth() + 1),
+    zwei(jetzt.getDate()),
+    zwei(jetzt.getHours()),
+    zwei(jetzt.getMinutes()),
+    zwei(jetzt.getSeconds()),
+  ].join('')
+  return `${stempel}_${name}`
+}
+
+// --- Ab hier: Ausfuehrung ----------------------------------------------------
+
+/**
+ * Prisma direkt ueber sein Eintrittsskript aufrufen, nicht ueber npx.
+ *
+ * Mit "shell: true" wuerde Node warnen (Argumente werden dann nur
+ * aneinandergehaengt statt maskiert), und ohne Shell findet Windows das
+ * npx-Skript nicht. Der Weg ueber node loest beides und ist derselbe,
+ * den scripts/update.sh schon nimmt.
+ */
+function prisma(argumente, optionen = {}) {
+  const eintritt = join(WURZEL, 'node_modules', 'prisma', 'build', 'index.js')
+  return execFileSync(process.execPath, [eintritt, ...argumente], {
+    cwd: WURZEL,
+    encoding: 'utf8',
+    ...optionen,
+  })
+}
+
+function abbruch(meldung) {
+  console.error(`\n  Abbruch: ${meldung}\n`)
+  process.exit(1)
+}
+
+function hauptlauf() {
+  const argumente = process.argv.slice(2)
+  const anwenden = argumente.includes('--anwenden')
+  const name = argumente.find((eintrag) => !eintrag.startsWith('--'))
+
+  if (!name) {
+    abbruch(
+      'Bitte einen Namen angeben:  npm run db:migration -- <name> [--anwenden]\n' +
+        '           Beispiel:              npm run db:migration -- ansprechpartner',
+    )
+  }
+  if (!/^[a-z0-9_]+$/.test(name)) {
+    abbruch(`"${name}" taugt nicht als Ordnername. Erlaubt: a-z, 0-9 und _`)
+  }
+
+  console.log(`\n  Migration "${name}" erzeugen\n`)
+
+  let roh
+  try {
+    roh = prisma([
+      'migrate',
+      'diff',
+      '--from-schema-datasource',
+      'prisma/schema.prisma',
+      '--to-schema-datamodel',
+      'prisma/schema.prisma',
+      '--script',
+    ])
+  } catch (fehler) {
+    abbruch(`"prisma migrate diff" ist fehlgeschlagen:\n${fehler.message}`)
+  }
+
+  if (roh.trim() === '' || /^--\s*This is an empty migration/im.test(roh)) {
+    abbruch('Schema und Datenbank stimmen bereits ueberein - es gibt nichts zu migrieren.')
+  }
+
+  const { sql, entfernt } = dropZeilenEntfernen(roh)
+
+  if (!hatAnweisungen(sql)) {
+    const grund =
+      entfernt.length > 0
+        ? `Uebrig blieben nur die bekannten DROP-INDEX-Zeilen (${entfernt.join(', ')}).`
+        : 'Der Vergleich hat keine Anweisungen ergeben.'
+    abbruch(
+      `Es gibt nichts zu migrieren. ${grund}\n` +
+        '           Es wurde keine Migration angelegt.',
+    )
+  }
+
+  const ordner = join(WURZEL, 'prisma', 'migrations', ordnernameBauen(name))
+  mkdirSync(ordner, { recursive: true })
+  const datei = join(ordner, 'migration.sql')
+  writeFileSync(datei, `${kopfBauen(name, entfernt)}\n${sql.trimEnd()}\n`, 'utf8')
+
+  console.log(`  Geschrieben: ${datei.replace(WURZEL, '.')}`)
+  if (entfernt.length > 0) {
+    console.log('\n  Entfernte DROP-INDEX-Anweisungen:')
+    for (const eintrag of entfernt) console.log(`    - ${eintrag}`)
+  } else {
+    console.log('  Keine DROP-INDEX-Anweisung zu schuetzenden Indizes gefunden.')
+  }
+
+  if (!anwenden) {
+    console.log('\n  Jetzt: die Datei lesen, dann anwenden mit')
+    console.log('    npm run db:deploy && npm run db:pruefen\n')
+    return
+  }
+
+  console.log('\n  Anwenden ...')
+  try {
+    prisma(['migrate', 'deploy'], { stdio: 'inherit' })
+  } catch {
+    abbruch('"prisma migrate deploy" ist fehlgeschlagen. Die Datei bleibt liegen.')
+  }
+
+  indizesPruefen()
+}
+
+/**
+ * Stehen die geschuetzten Indizes noch?
+ *
+ * Der Sinn des ganzen Skripts haengt an dieser Pruefung: Sie ist der
+ * Unterschied zwischen "sollte gutgegangen sein" und "nachgesehen".
+ */
+export function indizesPruefen() {
+  const bedingung = GESCHUETZTE_INDIZES.map((eintrag) => `'${eintrag.name}'`).join(', ')
+  const sql = `DO $$
+BEGIN
+  IF (SELECT count(*) FROM pg_indexes WHERE indexname IN (${bedingung})) <> ${GESCHUETZTE_INDIZES.length} THEN
+    RAISE EXCEPTION 'Es fehlen geschuetzte Indizes';
+  END IF;
+END $$;`
+
+  // In den Temp-Ordner, nicht ins Repository: Die Datei ist Werkzeug,
+  // kein Bestandteil des Projekts.
+  const datei = join(tmpdir(), `indizes-pruefung-${process.pid}.sql`)
+  writeFileSync(datei, sql, 'utf8')
+
+  try {
+    prisma(['db', 'execute', '--schema', 'prisma/schema.prisma', '--file', datei], {
+      stdio: 'pipe',
+    })
+    console.log('\n  Geschuetzte Indizes stehen:')
+    for (const eintrag of GESCHUETZTE_INDIZES) console.log(`    - ${eintrag.name}`)
+    console.log('')
+  } catch {
+    abbruch(
+      'Nach der Migration fehlen geschuetzte Indizes.\n' +
+        '           Wiederherstellen mit:  npm run db:sql',
+    )
+  } finally {
+    rmSync(datei, { force: true })
+  }
+}
+
+if (process.argv[1] && process.argv[1].endsWith('migration-erzeugen.mjs')) {
+  hauptlauf()
+}

scripts/schluessel-erzeugen.mjs

@@ -18,6 +18,7 @@ AUTH_SECRET=${b64(32)}
 ENC_KEY_V1=${b64(32)}
 ENC_KEY_AKTIV=1
 INDEX_KEY=${b64(32)}
+ERSTEINRICHTUNG_GEHEIMNIS=${b64(24)}
 POSTGRES_PASSWORD=${b64(24).replace(/[+/=]/g, 'x')}
 
 # WICHTIG: ENC_KEY_V1 geht NICHT verloren gehen duerfen.

scripts/sicherung.sh

@@ -75,9 +75,19 @@ done
 # --- Selbstpruefung ----------------------------------------------------------
 # Ein Backup, das sich nicht entschluesseln laesst, ist kein Backup.
 # Deshalb wird sofort geprueft, ob die Datei wieder lesbar ist.
-if openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000 \
+# Kein "| head -c 5 | grep -q": Beide schliessen die Leitung, sobald sie
-     -pass env:SICHERUNG_PASSWORT -in "$DATEI" 2>/dev/null \
+# genug haben. openssl schreibt dann in ein geschlossenes Rohr, bekommt
-   | head -c 5 | grep -q "PGDMP"; then
+# SIGPIPE - und mit "set -o pipefail" gilt die ganze Kette als
+# gescheitert. Bei einer kleinen Datenbank faellt das nicht auf, weil
+# alles schon im Puffer steht; mit wachsender Datenbank kippt es, und
+# dann meldet die Selbstpruefung eine INTAKTE Sicherung als kaputt.
+#
+# "dd" liest eine feste Menge und beendet sich regulaer.
+KOPF="$(openssl enc -d -aes-256-cbc -pbkdf2 -iter 200000 \
+          -pass env:SICHERUNG_PASSWORT -in "$DATEI" 2>/dev/null \
+        | dd bs=1 count=5 2>/dev/null || true)"
+
+if [ "$KOPF" = "PGDMP" ]; then
   echo "$(date -Iseconds) Selbstpruefung bestanden."
 else
   echo "$(date -Iseconds) FEHLER: Die Sicherung laesst sich nicht entschluesseln!" >&2

scripts/speicher-verschluesseln.mts

@@ -0,0 +1,184 @@
+/**
+ * Bestehende Dateien nachtraeglich in den Umschlag stecken.
+ *
+ *   npm run speicher:verschluesseln            # nur schauen
+ *   npm run speicher:verschluesseln -- --anwenden
+ *
+ * Warum es diesen Lauf gibt: Der Objektspeicher-Treiber hat bis v1.10.2
+ * unverschluesselt abgelegt - es stand nur ServerSideEncryption: 'AES256'
+ * darauf, also Verschluesselung mit dem Schluessel des Anbieters. Seit
+ * v1.11.0 liegt derselbe Umschlag darum wie beim Dateitreiber. Neue Dateien
+ * bekommen ihn beim Ablegen; die alten liegen weiter im Klartext, bis sie
+ * hier einmal umgeschrieben werden.
+ *
+ * Lesen funktioniert waehrenddessen durchgehend: Der Treiber erkennt am
+ * Kopf, ob ein Umschlag da ist, und reicht alles andere unveraendert durch.
+ * Der Lauf laesst sich also jederzeit starten, abbrechen und wiederholen.
+ *
+ * Er ist absichtlich langsam und einfach: ein Objekt nach dem anderen,
+ * lesen, pruefen, zurueckschreiben. Bei ein paar hundert Dokumenten dauert
+ * das Sekunden, und ein Fehler betrifft immer nur eine Datei.
+ *
+ * OHNE --anwenden wird nichts geschrieben.
+ */
+import { createRequire } from 'node:module'
+import { readFile, writeFile } from 'node:fs/promises'
+
+/**
+ * "server-only" fuer diesen Lauf neutralisieren.
+ *
+ * Das Paket wirft beim Import ausserhalb einer Server-Umgebung - genau
+ * dafuer ist es da. Hier laufen wir aber bewusst ausserhalb von Next, und
+ * die Alternative waere, den Umschlag im Skript noch einmal zu schreiben.
+ * Zwei Fassungen derselben Krypto sind die schlechtere Wahl: Wenn eine
+ * davon abweicht, merkt es niemand, bis eine Datei nicht mehr aufgeht.
+ *
+ * Deshalb wird der Modullader vorher umgebogen und danach dynamisch
+ * importiert - statische Importe wuerden vorgezogen und liefen in den
+ * Fehler.
+ */
+const verlangen = createRequire(import.meta.url)
+const modulLader = verlangen('node:module') as {
+  _load: (anfrage: string, ...rest: unknown[]) => unknown
+}
+const echterLader = modulLader._load
+modulLader._load = function (anfrage: string, ...rest: unknown[]) {
+  if (anfrage === 'server-only') return {}
+  return echterLader.call(this, anfrage, ...rest)
+}
+
+const { env } = await import('../src/lib/env')
+const { istVerschluesselt, verschluesselnBinaer } = await import('../src/lib/speicher/umschlag')
+
+const anwenden = process.argv.includes('--anwenden')
+
+type Bilanz = { geprueft: number; umgeschrieben: number; schonGut: number; fehler: number }
+
+function zeile(text = ''): void {
+  console.log(text)
+}
+
+/** Objektspeicher: auflisten, lesen, bei Bedarf zurueckschreiben. */
+async function s3Durchgehen(): Promise<Bilanz> {
+  const s3 = await import('../src/lib/speicher/s3')
+  const bilanz: Bilanz = { geprueft: 0, umgeschrieben: 0, schonGut: 0, fehler: 0 }
+
+  const schluessel = await s3.objekteAuflisten()
+  zeile(`  ${schluessel.length} Objekte im Eimer "${env.s3.bucket}".`)
+  zeile()
+
+  for (const eintrag of schluessel) {
+    bilanz.geprueft += 1
+    try {
+      const roh = await s3.rohLesen(eintrag)
+
+      if (istVerschluesselt(roh)) {
+        bilanz.schonGut += 1
+        continue
+      }
+
+      if (anwenden) {
+        // schreiben() legt den Umschlag selbst an - der Inhalt geht also
+        // als Klartext hinein und kommt verschluesselt im Eimer an.
+        await s3.schreiben(eintrag, roh, 'application/octet-stream')
+      }
+      bilanz.umgeschrieben += 1
+      zeile(`    ${anwenden ? 'umgeschrieben' : 'waere umzuschreiben'}: ${eintrag}`)
+    } catch (fehler) {
+      bilanz.fehler += 1
+      zeile(`    FEHLER bei ${eintrag}: ${fehler instanceof Error ? fehler.message : fehler}`)
+    }
+  }
+
+  return bilanz
+}
+
+/** Dateitreiber: dasselbe fuer das Ablageverzeichnis. */
+async function dateienDurchgehen(): Promise<Bilanz> {
+  const { readdir, stat } = await import('node:fs/promises')
+  const { join, relative, sep } = await import('node:path')
+  const treiber = await import('../src/lib/speicher/datei')
+  const bilanz: Bilanz = { geprueft: 0, umgeschrieben: 0, schonGut: 0, fehler: 0 }
+
+  const wurzel = treiber.ablageverzeichnis()
+  zeile(`  Verzeichnis ${wurzel}`)
+  zeile()
+
+  async function absteigen(verzeichnis: string): Promise<void> {
+    let eintraege: string[]
+    try {
+      eintraege = await readdir(verzeichnis)
+    } catch {
+      return // gibt es noch nicht
+    }
+
+    for (const name of eintraege) {
+      const pfad = join(verzeichnis, name)
+      if ((await stat(pfad)).isDirectory()) {
+        await absteigen(pfad)
+        continue
+      }
+
+      bilanz.geprueft += 1
+      try {
+        const roh = await readFile(pfad)
+        if (istVerschluesselt(roh)) {
+          bilanz.schonGut += 1
+          continue
+        }
+
+        // Der Ablageschluessel ist der Pfad unterhalb der Wurzel, mit
+        // Schraegstrichen - genau das, was der Treiber beim Schreiben
+        // benutzt. Er gehoert in die Zusatzdaten, sonst waere die Datei
+        // hinterher zwar verschluesselt, aber nicht an ihren Platz
+        // gebunden, und liesse sich unter fremdem Namen wieder einspielen.
+        const ablageschluessel = relative(wurzel, pfad).split(sep).join('/')
+
+        if (anwenden) {
+          await writeFile(pfad, verschluesselnBinaer(roh, ablageschluessel), { mode: 0o600 })
+        }
+        bilanz.umgeschrieben += 1
+        zeile(`    ${anwenden ? 'umgeschrieben' : 'waere umzuschreiben'}: ${pfad}`)
+      } catch (fehler) {
+        bilanz.fehler += 1
+        zeile(`    FEHLER bei ${pfad}: ${fehler instanceof Error ? fehler.message : fehler}`)
+      }
+    }
+  }
+
+  await absteigen(wurzel)
+  return bilanz
+}
+
+async function main(): Promise<void> {
+  zeile()
+  zeile('  Bestehende Dateien in den Umschlag stecken')
+  zeile('  ' + '-'.repeat(50))
+  zeile()
+
+  if (!anwenden) {
+    zeile('  TROCKENLAUF - es wird nichts geschrieben.')
+    zeile('  Zum Anwenden: npm run speicher:verschluesseln -- --anwenden')
+    zeile()
+  }
+
+  const treiber = env.speicherTreiber
+  zeile(`  Treiber: ${treiber}`)
+  zeile()
+
+  const bilanz = treiber === 's3' ? await s3Durchgehen() : await dateienDurchgehen()
+
+  zeile()
+  zeile(`  Geprueft:        ${bilanz.geprueft}`)
+  zeile(`  Schon im Umschlag: ${bilanz.schonGut}`)
+  zeile(`  ${anwenden ? 'Umgeschrieben' : 'Umzuschreiben'}:   ${bilanz.umgeschrieben}`)
+  if (bilanz.fehler > 0) zeile(`  Fehler:          ${bilanz.fehler}`)
+  zeile()
+
+  if (bilanz.fehler > 0) process.exitCode = 1
+}
+
+main().catch((fehler) => {
+  console.error(fehler)
+  process.exitCode = 1
+})

scripts/update.sh

@@ -52,6 +52,32 @@ gut()      { printf '    %s%s%s\n' "$GRUEN" "$1" "$AUS"; }
 warnung()  { printf '    %s%s%s\n' "$GELB" "$1" "$AUS"; }
 abbruch()  { printf '\n%sAbbruch: %s%s\n\n' "$ROT" "$1" "$AUS" >&2; exit 1; }
 
+# --- Unerwarteter Abbruch ----------------------------------------------------
+#
+# "set -e" beendet das Skript bei jedem Befehl, der nicht 0 zurueckgibt -
+# stumm. Auf dem Bildschirm bricht die Ausgabe dann einfach ab, und man
+# sucht an der falschen Stelle.
+#
+# Genau das ist beim Sprung von v1.5.0 auf v1.10.1 passiert: Eine Leitung
+# der Form "git log ... | head -15" hat den Erzeuger mit SIGPIPE beendet,
+# "pipefail" hat das an die Kette weitergereicht, und das Skript war weg.
+#
+# Diese Falle sagt jetzt wenigstens, WO es passiert ist. Exitcode 141
+# heisst SIGPIPE - dann wurde irgendwo wieder eine Leitung zu frueh
+# geschlossen.
+unerwartet() {
+  code=$1
+  zeile=$2
+  printf '%sAbbruch in Zeile %s (Exitcode %s).%s\n' "$ROT" "$zeile" "$code" "$AUS" >&2
+  if [ "$code" = "141" ]; then
+    printf '%sExitcode 141 ist SIGPIPE: eine Leitung wurde zu frueh geschlossen,%s\n' "$ROT" "$AUS" >&2
+    printf '%setwa durch "| head". Das ist ein Fehler im Skript, nicht bei dir.%s\n' "$ROT" "$AUS" >&2
+  fi
+  printf '%sKam der Abbruch vor Schritt 5, wurde nichts veraendert.%s\n' "$ROT" "$AUS" >&2
+}
+trap 'unerwartet $? $LINENO' ERR
+
+
 # --- Aufrufparameter ---------------------------------------------------------
 
 ZIEL=""
@@ -113,7 +139,11 @@ if ! git fetch --tags --quiet origin; then
 fi
 
 JETZT="$(git describe --tags --exact-match 2>/dev/null || git rev-parse --short HEAD)"
-NEUESTE="$(git tag --list 'v*' --sort=-v:refname | head -1)"
+# Kein "| head -1": Siehe den Hinweis zu SIGPIPE weiter unten. Die erste
+# Zeile holt die Shell selbst.
+ALLE_TAGS="$(git tag --list 'v*' --sort=-v:refname)"
+NEUESTE="${ALLE_TAGS%%$'
+'*}"
 
 [ -n "$NEUESTE" ] || abbruch "Es gibt keine veroeffentlichte Fassung (kein Tag)."
 
@@ -123,7 +153,8 @@ fi
 
 git rev-parse --verify --quiet "$ZIEL^{commit}" >/dev/null \
   || abbruch "Die Fassung '$ZIEL' gibt es nicht. Vorhanden:
-$(git tag --list 'v*' --sort=-v:refname | head -5 | sed 's/^/           /')"
+$(printf '%s
+' "$ALLE_TAGS" | sed -n '1,5p' | sed 's/^/           /')"
 
 printf '    Jetzt:   %s\n' "$JETZT"
 printf '    Ziel:    %s%s%s\n' "$FETT" "$ZIEL" "$AUS"
@@ -152,14 +183,23 @@ if [ -n "$CHANGELOG" ]; then
       if (nummer == jetzt) exit
       drucken = (nummer != "Unveröffentlicht")
     }
-    drucken { print "    " $0 }
+    drucken && zeilen < 60 { print "    " $0; zeilen++ }
-  ' | head -60
+  '
 else
   warnung "Kein CHANGELOG.md in $ZIEL gefunden."
 fi
 
 printf '\n'
-git log --oneline --no-decorate "HEAD..$ZIEL" | head -15 | sed 's/^/    /'
+# "-15" statt "| head -15": Bei mehr Commits als der Grenze schliesst head
+# die Leitung, git bekommt SIGPIPE, und mit "set -o pipefail" gilt die ganze
+# Kette als gescheitert - "set -e" beendet das Skript dann OHNE Meldung.
+# Genau das ist beim Sprung von v1.5.0 auf v1.10.1 passiert.
+ANZAHL="$(git rev-list --count "HEAD..$ZIEL")"
+git log --oneline --no-decorate -15 "HEAD..$ZIEL" | sed 's/^/    /'
+if [ "$ANZAHL" -gt 15 ]; then
+  printf '    ... und %s weitere
+' "$((ANZAHL - 15))"
+fi
 
 if [ "$NUR_PRUEFEN" = "1" ]; then
   printf '\n'

src/app/(app)/berichte/export/datei/route.ts

@@ -1,6 +1,6 @@
 import { Readable } from 'node:stream'
 import type { NextRequest } from 'next/server'
-import { aktiveBetreute, erfordereBenutzer, reauthGueltig } from '@/lib/auth/sitzung'
+import { aktiveBetreute, benutzerFuerRoute, reauthGueltig } from '@/lib/auth/sitzung'
 import { darf } from '@/lib/auth/rollen'
 import { db, nichtGeloescht } from '@/lib/db'
 import { protokollieren } from '@/lib/audit'
@@ -33,7 +33,11 @@ function abgelehnt(nachricht: string, status: number): Response {
 }
 
 export async function GET(anfrage: NextRequest): Promise<Response> {
-  const benutzer = await erfordereBenutzer('/berichte/export')
+  // Eine Route antwortet mit einem Statuscode, nicht mit einer
+  // Anmeldeseite als Dateiinhalt.
+  const angemeldet = await benutzerFuerRoute()
+  if (!angemeldet.ok) return angemeldet.antwort
+  const benutzer = angemeldet.benutzer
 
   const gewuenscht = anfrage.nextUrl.searchParams.get('betreute')
   const aktive = await aktiveBetreute(benutzer)

src/app/(app)/konto/anschrift-formular.tsx

@@ -0,0 +1,89 @@
+'use client'
+
+import { useActionState } from 'react'
+import { useFormStatus } from 'react-dom'
+import { AlertCircle, CheckCircle2, Loader2 } from 'lucide-react'
+import { anschriftSpeichern, type AnschriftZustand } from '@/server/actions/konto'
+import { Alert, AlertDescription } from '@/components/ui/alert'
+import { Button } from '@/components/ui/button'
+import { Input } from '@/components/ui/input'
+import { Feld } from '@/components/feld'
+
+function Absenden() {
+  const { pending } = useFormStatus()
+  return (
+    <Button type="submit" disabled={pending}>
+      {pending && <Loader2 className="animate-spin" aria-hidden="true" />}
+      {pending ? 'Wird gespeichert …' : 'Anschrift speichern'}
+    </Button>
+  )
+}
+
+export function AnschriftFormular({
+  strasse,
+  plz,
+  ort,
+}: {
+  strasse: string | null
+  plz: string | null
+  ort: string | null
+}) {
+  const [zustand, aktion] = useActionState<AnschriftZustand, FormData>(anschriftSpeichern, {})
+
+  return (
+    <form action={aktion} className="space-y-4" noValidate>
+      {zustand.fehler && (
+        <Alert variant="fehler">
+          <AlertCircle aria-hidden="true" />
+          <AlertDescription>{zustand.fehler}</AlertDescription>
+        </Alert>
+      )}
+      {zustand.erfolg && (
+        <Alert variant="erfolg">
+          <CheckCircle2 aria-hidden="true" />
+          <AlertDescription>{zustand.erfolg}</AlertDescription>
+        </Alert>
+      )}
+
+      <Feld id="strasse" beschriftung="Straße und Hausnummer" fehler={zustand.felder?.strasse}>
+        <Input
+          id="strasse"
+          name="strasse"
+          defaultValue={strasse ?? ''}
+          maxLength={150}
+          autoComplete="street-address"
+        />
+      </Feld>
+
+      <div className="grid gap-4 sm:grid-cols-[8rem_1fr]">
+        <Feld id="plz" beschriftung="PLZ" fehler={zustand.felder?.plz}>
+          <Input
+            id="plz"
+            name="plz"
+            defaultValue={plz ?? ''}
+            maxLength={10}
+            autoComplete="postal-code"
+            inputMode="numeric"
+          />
+        </Feld>
+
+        <Feld
+          id="ort"
+          beschriftung="Ort"
+          erklaerung="Steht außerdem in der Datumszeile: „Bayreuth, den 23.08.2026“."
+          fehler={zustand.felder?.ort}
+        >
+          <Input
+            id="ort"
+            name="ort"
+            defaultValue={ort ?? ''}
+            maxLength={100}
+            autoComplete="address-level2"
+          />
+        </Feld>
+      </div>
+
+      <Absenden />
+    </form>
+  )
+}

src/app/(app)/konto/page.tsx

@@ -1,6 +1,6 @@
 import type { Metadata } from 'next'
 import Link from 'next/link'
-import { Fingerprint, KeyRound, ShieldCheck } from 'lucide-react'
+import { Fingerprint, KeyRound, MapPin, ShieldCheck } from 'lucide-react'
 import { Badge } from '@/components/ui/badge'
 import { Button } from '@/components/ui/button'
 import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
@@ -11,6 +11,7 @@ import { PasskeyVerwaltung } from '@/components/konto/passkey-verwaltung'
 import { ROLLEN_BESCHRIFTUNG, ROLLEN_ERKLAERUNG } from '@/lib/auth/rollen'
 import { formatDatumZeit } from '@/lib/utils'
 import { PasswortFormular } from './passwort-formular'
+import { AnschriftFormular } from './anschrift-formular'
 
 export const metadata: Metadata = { title: 'Mein Konto' }
 export const dynamic = 'force-dynamic'
@@ -22,7 +23,10 @@ export default async function KontoSeite() {
 
   return (
     <div className="max-w-2xl space-y-6">
-      <SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten, zweiter Faktor und Passkeys." />
+      <SeitenKopf
+        titel="Mein Konto"
+        beschreibung="Zugangsdaten, eigene Anschrift, zweiter Faktor und Passkeys."
+      />
 
       <Card>
         <CardHeader className="pb-3">
@@ -55,6 +59,27 @@ export default async function KontoSeite() {
         </CardContent>
       </Card>
 
+      <Card>
+        <CardHeader className="pb-3">
+          <CardTitle className="flex items-center gap-2 text-base">
+            <MapPin className="size-5" aria-hidden="true" />
+            Meine Anschrift
+          </CardTitle>
+          <CardDescription>
+            Steht im Absenderblock jedes Schreibens, das hier entsteht, und liefert den Ort für
+            die Datumszeile. Ohne sie geht ein förmlicher Brief ohne Rücksendeadresse hinaus.
+            Jede Angabe ist einzeln freiwillig — was fehlt, bleibt im Brief einfach weg.
+          </CardDescription>
+        </CardHeader>
+        <CardContent>
+          <AnschriftFormular
+            strasse={benutzer.strasse}
+            plz={benutzer.plz}
+            ort={benutzer.ort}
+          />
+        </CardContent>
+      </Card>
+
       <Card>
         <CardHeader className="pb-3">
           <CardTitle className="flex items-center gap-2 text-base">

src/app/(app)/schreiben/neu/page.tsx

@@ -50,7 +50,7 @@ export default async function SchreibenSeite({
   try {
     entwurf = await entwurfBauen({
       betreuteId: aktive.id,
-      benutzerName: benutzer.name,
+      benutzer,
       art,
       vertragId: text('vertragId') || null,
       vorgangId: text('vorgangId') || null,

src/app/(auth)/ersteinrichtung/page.tsx

@@ -21,8 +21,16 @@ export const dynamic = 'force-dynamic'
 export default async function ErsteinrichtungSeite() {
   const anzahlBenutzer = await db.user.count({ where: { geloeschtAm: null } })
 
+  // Die Sperrzeile ist die eigentliche Auskunft darueber, ob eingerichtet
+  // wurde. Der Benutzerzaehler allein genuegt nicht: Liegt der erste Zugang
+  // im Papierkorb, stuende Schritt 1 sonst wieder offen.
+  const sperre = await db.ersteinrichtung.findUnique({
+    where: { id: 'einmalig' },
+    select: { id: true },
+  })
+
   // --- Schritt 1: Es gibt noch keinen Zugang -------------------------------
-  if (anzahlBenutzer === 0) {
+  if (anzahlBenutzer === 0 && !sperre) {
     return (
       <>
         <Card>

src/app/(auth)/ersteinrichtung/zugang-formular.tsx

@@ -61,6 +61,23 @@ export function ZugangFormular() {
         />
       </Feld>
 
+      <Feld
+        id="geheimnis"
+        beschriftung="Einrichtungsgeheimnis"
+        erklaerung="Der Wert von ERSTEINRICHTUNG_GEHEIMNIS aus der .env. Er verhindert, dass jemand
+          anders diesen Zugang anlegt, solange die Seite noch offensteht."
+        fehler={zustand.felder?.geheimnis}
+        pflicht
+      >
+        <Input
+          name="geheimnis"
+          type="password"
+          autoComplete="off"
+          spellCheck={false}
+          required
+        />
+      </Feld>
+
       <Feld
         id="passwort"
         beschriftung="Passwort"

src/app/api/dokumente/datei/[signatur]/route.ts

@@ -2,7 +2,7 @@ import { NextResponse } from 'next/server'
 import type { Modul } from '@prisma/client'
 import { protokollieren } from '@/lib/audit'
 import { darf } from '@/lib/auth/rollen'
-import { aktuellerBenutzer } from '@/lib/auth/sitzung'
+import { benutzerFuerRoute } from '@/lib/auth/sitzung'
 import { db, nichtGeloescht } from '@/lib/db'
 import { typErkennen } from '@/lib/speicher/dateityp'
 import { betreuteIdAusSchluessel, lesen } from '@/lib/speicher'
@@ -55,7 +55,10 @@ function nurText(status: number, meldung: string): NextResponse {
 export async function GET(
   _anfrage: Request,
   { params }: { params: Promise<{ signatur: string }> },
-): Promise<NextResponse> {
+  // Response statt NextResponse: Die Abweisung ohne zweiten Faktor kommt
+  // aus benutzerFuerRoute() und ist eine schlichte Response. NextResponse
+  // erbt davon, die uebrigen Rueckgaben passen also weiterhin.
+): Promise<Response> {
   const { signatur } = await params
 
   // 1. Signatur und Ablauf
@@ -70,9 +73,14 @@ export async function GET(
   }
   const schluessel = geprueft.schluessel
 
-  // 2. Angemeldet?
+  // 2. Angemeldet - und mit abgeschlossenem zweitem Faktor.
-  const benutzer = await aktuellerBenutzer()
+  //
-  if (!benutzer) return nurText(401, 'Bitte melde dich an.')
+  // Frueher stand hier nur die Frage nach der Anmeldung. Damit kam jemand,
+  // der die TOTP-Einrichtung nie abgeschlossen hatte, an jedes Dokument -
+  // die MFA-Pflicht galt nur fuer Seiten, nicht fuer diesen Abruf.
+  const angemeldet = await benutzerFuerRoute()
+  if (!angemeldet.ok) return angemeldet.antwort
+  const benutzer = angemeldet.benutzer
 
   // 3. Zugriff auf genau diese betreute Person
   const betreuteId = betreuteIdAusSchluessel(schluessel)

src/auth.ts

@@ -3,15 +3,17 @@ import Credentials from 'next-auth/providers/credentials'
 import type { Rolle } from '@prisma/client'
 import { db } from '@/lib/db'
 import { env } from '@/lib/env'
-import { hashVeraltet, passwortHashen, passwortPruefen, wiederherstellungscodeFinden } from '@/lib/crypto/hash'
+import { hashVeraltet, passwortHashen, passwortPruefen } from '@/lib/crypto/hash'
-import { totpPruefen, totpSecretEntschluesseln } from '@/lib/crypto/totp'
 import {
   anmeldungErlaubt,
   aufMindestdauerWarten,
   fehlversucheZuruecksetzen,
+  sperreVermerken,
   versuchFesthalten,
 } from '@/lib/auth/ratelimit'
 import { protokollieren } from '@/lib/audit'
+import { zweitenFaktorEinloesen } from '@/lib/auth/zweiter-faktor'
+import { anschlussAus } from '@/lib/auth/anschluss'
 import { PasskeyFehler, anmeldungPruefen } from '@/lib/auth/passkey'
 import type { AuthenticationResponseJSON } from '@simplewebauthn/server'
 
@@ -64,12 +66,13 @@ export class PasskeyAnmeldeFehler extends CredentialsSignin {
 
 function ipAusAnfrage(anfrage: Request | undefined): string | null {
   if (!anfrage) return null
-  const weitergeleitet = anfrage.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
+  return anschlussAus(anfrage.headers)
-  return weitergeleitet || anfrage.headers.get('x-real-ip') || null
 }
 
 export const { handlers, signIn, signOut, auth } = NextAuth({
-  trustHost: true,
+  // Siehe env.vertraueHost: Ist AUTH_URL gesetzt, wird dem Host-Kopf nicht
+  // geglaubt. Vorher stand hier fest "true".
+  trustHost: env.vertraueHost,
   secret: process.env.AUTH_SECRET,
 
   session: {
@@ -110,7 +113,7 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         // 1. Sperre pruefen, bevor teuer gerechnet wird.
         const sperre = await anmeldungErlaubt(email, ip)
         if (sperre.gesperrt) {
-          await versuchFesthalten(email, ip, false, 'gesperrt')
+          await sperreVermerken(email, ip)
           throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
         }
 
@@ -141,33 +144,13 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
           throw new AnmeldeFehler('konto-inaktiv')
         }
 
-        // 3. Zweiter Faktor. Ohne eingerichtetes TOTP kommt der Benutzer
+        // 3. Zweiter Faktor. Ist er noch nicht eingerichtet, kommt der
-        //    zwar herein, das App-Layout schickt ihn aber sofort zur
+        //    Benutzer nur bis zur Einrichtungsseite - erzwungen in
-        //    Einrichtung - er kann nichts anderes tun.
+        //    erfordereBenutzer(), nicht erst im Layout.
         if (benutzer.totpSecretVerschluesselt && benutzer.totpAktiviertAm) {
-          const codeOhneTrenner = code.replace(/[\s-]/g, '')
+          const eingeloest = await zweitenFaktorEinloesen(benutzer, code)
-          let zweiterFaktorOk = false
 
-          if (/^\d{6}$/.test(codeOhneTrenner)) {
+          if (!eingeloest.ok) {
-            const secret = totpSecretEntschluesseln(benutzer.totpSecretVerschluesselt)
-            zweiterFaktorOk = totpPruefen(secret, benutzer.email, codeOhneTrenner).gueltig
-          } else if (codeOhneTrenner.length >= 12) {
-            // Wiederherstellungscode - wird nach Gebrauch entfernt.
-            const treffer = await wiederherstellungscodeFinden(
-              benutzer.wiederherstellungscodes,
-              code,
-            )
-            if (treffer >= 0) {
-              zweiterFaktorOk = true
-              const rest = benutzer.wiederherstellungscodes.filter((_, i) => i !== treffer)
-              await db.user.update({
-                where: { id: benutzer.id },
-                data: { wiederherstellungscodes: rest },
-              })
-            }
-          }
-
-          if (!zweiterFaktorOk) {
             await versuchFesthalten(email, ip, false, 'code-falsch')
             await protokollieren({
               aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
@@ -175,7 +158,10 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
               entitaetId: benutzer.id,
               userEmail: email,
               userId: benutzer.id,
-              bezeichnung: 'Zweiter Faktor falsch',
+              bezeichnung:
+                eingeloest.grund === 'wiederverwendet'
+                  ? 'Zweiter Faktor bereits verbraucht'
+                  : 'Zweiter Faktor falsch',
             })
             await aufMindestdauerWarten(begonnen)
             throw new AnmeldeFehler('code-falsch')
@@ -274,7 +260,7 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         // anmeldet - erraten laesst sich ein Passkey ohnehin nicht.
         const sperre = await anmeldungErlaubt(benutzer.email, ip)
         if (sperre.gesperrt) {
-          await versuchFesthalten(benutzer.email, ip, false, 'gesperrt')
+          await sperreVermerken(benutzer.email, ip)
           throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
         }
 

src/components/dokumente/dokument-liste.tsx

@@ -17,6 +17,21 @@ import {
  *
  * Am Handy eine Karte je Dokument, ab Tablet eine Tabelle - die Tabelle
  * scrollt dabei im eigenen Rahmen, nie die ganze Seite.
+ *
+ * ACHTUNG, jeder Inhalt steht ZWEIMAL im DOM: einmal als Karte, einmal
+ * als Tabellenzeile. Eine der beiden Fassungen ist per Breakpoint
+ * versteckt, steht aber trotzdem im Baum.
+ *
+ * Fuer Tests heisst das: getByText(...).first() trifft womoeglich die
+ * unsichtbare Kopie, und die Pruefung scheitert mit "element is not
+ * visible" an einer Stelle, die augenscheinlich in Ordnung ist. Der Weg,
+ * der traegt, steht in e2e/hilfen.ts unter "Doppelt gerenderte Listen".
+ *
+ * Warum nicht eine Fassung fuer beide? Eine Tabelle, die sich zu Karten
+ * umbricht, verlangt display:block auf Zeilen und Zellen. Damit ist es
+ * keine Tabelle mehr - Vorlesesoftware verliert den Zusammenhang von
+ * Spaltenkopf und Wert, und genau der macht eine Dokumentenliste mit
+ * acht Spalten erst benutzbar. Die Verdopplung ist der Preis dafuer.
  */
 export function DokumentListe({ eintraege }: { eintraege: Listeneintrag[] }) {
   return (

src/lib/auth/anschluss.ts

@@ -0,0 +1,92 @@
+import 'server-only'
+import { env } from '@/lib/env'
+
+/**
+ * Von welchem Anschluss kommt diese Anfrage?
+ *
+ * Gebraucht wird das nur fuer eines: die zweite Dimension der Anmeldesperre.
+ * Gezaehlt wird nach E-Mail UND nach Anschluss, damit es weder hilft,
+ * dieselbe Adresse von vielen Anschluessen zu probieren, noch viele
+ * Adressen von einem.
+ *
+ * ## Warum das vorher nichts geschuetzt hat
+ *
+ * Der Wert kam aus "x-forwarded-for", und zwar aus dem ERSTEN Eintrag:
+ *
+ *     kopf.get('x-forwarded-for')?.split(',')[0]?.trim()
+ *
+ * Dieser Kopf ist eine Liste, an die jeder Zwischenknoten hinten anhaengt.
+ * Der erste Eintrag ist deshalb der, den der Aufrufer selbst geschickt hat -
+ * frei erfunden. Wer bei jeder Anfrage eine andere Zahl hineinschrieb, sah
+ * fuer die Sperre wie tausend verschiedene Anschluesse aus. Die Zaehlung
+ * nach Anschluss war damit nicht nur wirkungslos, sondern irrefuehrend: Im
+ * Protokoll standen tausend Anschluesse, wo einer war.
+ *
+ * Richtig ist das andere Ende: Was der vertraute Proxy anhaengt, hat er
+ * selbst gesehen und nicht der Aufrufer geschrieben.
+ *
+ * ## Und wenn kein Proxy davor steht
+ *
+ * Dann ist der Kopf vollstaendig fremdbestimmt und es gibt hier nichts zu
+ * holen - also null. Keine Zaehlung nach Anschluss ist besser als eine, die
+ * sich mit einer Kopfzeile aushebeln laesst. Deshalb muss der Betrieb
+ * ausdruecklich sagen, dass ein Proxy davorsteht (VERTRAUE_PROXY=true).
+ */
+
+let gewarnt = false
+
+/**
+ * Warnt einmal, wenn weitergereichte Koepfe ankommen, ihnen aber nicht
+ * geglaubt wird. Genau dann fehlt die Einstellung im Betrieb.
+ */
+function einmalWarnen(): void {
+  if (gewarnt) return
+  gewarnt = true
+  console.warn(
+    '[anschluss] Es kommen "x-forwarded-for"-Koepfe an, aber VERTRAUE_PROXY ist nicht gesetzt. ' +
+      'Die Anmeldesperre zaehlt deshalb nur nach E-Mail-Adresse, nicht nach Anschluss. ' +
+      'Steht ein Reverse Proxy davor, setze VERTRAUE_PROXY=true (und, bei mehreren, ' +
+      'VERTRAUE_PROXY_STUFEN=<Anzahl>). Steht keiner davor, ist das hier richtig so.',
+  )
+}
+
+/**
+ * Liest die Adresse des Aufrufers aus den Koepfen.
+ *
+ * @param kopf Die Kopfzeilen der Anfrage.
+ * @returns Die Adresse, oder null, wenn sie sich nicht vertrauenswuerdig
+ *          bestimmen laesst.
+ */
+export function anschlussAus(kopf: Headers): string | null {
+  const weitergereicht = kopf.get('x-forwarded-for')
+  const echterIp = kopf.get('x-real-ip')
+
+  if (!env.vertraueProxy) {
+    if (weitergereicht || echterIp) einmalWarnen()
+    return null
+  }
+
+  if (weitergereicht) {
+    const kette = weitergereicht
+      .split(',')
+      .map((teil) => teil.trim())
+      .filter((teil) => teil.length > 0)
+
+    // Von hinten zaehlen: Der letzte Eintrag stammt vom naechsten
+    // Zwischenknoten, der zweitletzte von dem davor. Bei einer Stufe ist
+    // der letzte Eintrag der Aufrufer, wie der Proxy ihn gesehen hat.
+    if (kette.length > 0) {
+      const stelle = kette.length - env.vertraueProxyStufen
+      return kette[Math.max(0, stelle)] ?? null
+    }
+  }
+
+  // Manche Proxys setzen nur diesen Kopf. Er enthaelt genau eine Adresse,
+  // also gibt es hier nichts abzuzaehlen.
+  return echterIp?.trim() || null
+}
+
+/** Nur fuer Tests: setzt die einmalige Warnung zurueck. */
+export function warnungZuruecksetzen(): void {
+  gewarnt = false
+}

src/lib/auth/ratelimit.ts

@@ -14,8 +14,32 @@ import { ipHashen } from '@/lib/crypto/hash'
  * Gezaehlt wird nach E-Mail UND nach Anschluss (IP-Hash). Damit hilft es
  * weder, dieselbe Adresse von vielen Anschluessen zu probieren, noch viele
  * Adressen von einem Anschluss.
+ *
+ * ## Warum abgewiesene Versuche nicht mitzaehlen
+ *
+ * Frueher wurde jeder Aufruf festgehalten, auch der, der wegen einer
+ * laufenden Sperre gar nicht geprueft wurde. Zusammen mit einer Frist, die
+ * vom juengsten Fehlversuch aus gerechnet wurde, ergab das eine
+ * Rueckkopplung: Jeder abgewiesene Aufruf schob die Frist um die volle
+ * Sperrdauer nach hinten. Wer alle zehn Minuten ein falsches Passwort an
+ * eine fremde Adresse schickte, sperrte deren Inhaber dauerhaft aus - ohne
+ * das Passwort zu kennen. Und jeder dieser Aufrufe hinterliess eine Zeile,
+ * die erst der Wartungslauf nach 30 Tagen wieder los wurde.
+ *
+ * Deshalb jetzt zwei getrennte Dinge:
+ *
+ * - Ein *geprueft* fehlgeschlagener Versuch (falsches Passwort, falscher
+ *   Code, unbekannte Adresse) zaehlt und wird einzeln festgehalten.
+ * - Ein *abgewiesener* Aufruf waehrend der Sperre zaehlt nicht und wird
+ *   hoechstens einmal je Sperre vermerkt.
+ *
+ * Damit steht die Frist fest, sobald sie einmal gesetzt ist, und die
+ * Tabelle waechst nicht mit der Zahl der Angriffsversuche.
  */
 
+/** Grund fuer eine Zeile, die nur den abgewiesenen Aufruf dokumentiert. */
+const GRUND_ABGEWIESEN = 'gesperrt'
+
 export type SperrErgebnis =
   | { gesperrt: false; verbleibendeVersuche: number }
   | { gesperrt: true; nochSekunden: number }
@@ -29,33 +53,49 @@ function fensterStart(): Date {
  * Passwortvergleich aufgerufen - ein gesperrter Zugang soll gar nicht erst
  * Rechenzeit fuer Argon2 kosten.
  */
-export async function anmeldungErlaubt(
+export async function anmeldungErlaubt(email: string, ip: string | null): Promise<SperrErgebnis> {
-  email: string,
+  const jetzt = Date.now()
-  ip: string | null,
-): Promise<SperrErgebnis> {
-  const seit = fensterStart()
   const kennung = email.trim().toLowerCase()
   const ipH = ipHashen(ip)
 
   const fehlversuche = await db.loginVersuch.findMany({
     where: {
       erfolg: false,
-      zeitpunkt: { gte: seit },
+      // Abgewiesene Aufrufe zaehlen nicht mit - sonst haelt sich die Sperre
+      // selbst am Leben, siehe Kopf dieser Datei.
+      grund: { not: GRUND_ABGEWIESEN },
+      zeitpunkt: { gte: new Date(jetzt - env.loginFensterSekunden * 1000) },
       OR: [{ email: kennung }, ...(ipH ? [{ ipHash: ipH }] : [])],
     },
-    orderBy: { zeitpunkt: 'desc' },
+    orderBy: { zeitpunkt: 'asc' },
     select: { zeitpunkt: true },
-    take: env.loginMaxVersuche + 1,
+    // Deckel gegen eine ausufernde Abfrage. Mehr als eine Handvoll Runden
+    // passt ohnehin nicht in ein Zeitfenster, in dem jede Runde gesperrt
+    // wird.
+    take: 200,
   })
 
-  if (fehlversuche.length >= env.loginMaxVersuche) {
+  // Von alt nach neu durchgehen und die Runden nachvollziehen: Sobald das
-    const juengster = fehlversuche[0]!.zeitpunkt.getTime()
+  // Mass voll ist, beginnt an genau diesem Versuch eine Sperre, und der
-    const frei = juengster + env.loginSperreSekunden * 1000
+  // Zaehler faengt von vorn an. Ist ihre Frist inzwischen abgelaufen, sind
-    const nochSekunden = Math.max(1, Math.ceil((frei - Date.now()) / 1000))
+  // die Versuche davor abgegolten - sonst bliebe der Zugang bis zum Ende
-    return { gesperrt: true, nochSekunden }
+  // des Zeitfensters dicht, obwohl die Sperre laengst um ist.
+  let zaehler = 0
+  let sperreBis = 0
+
+  for (const versuch of fehlversuche) {
+    zaehler += 1
+    if (zaehler >= env.loginMaxVersuche) {
+      sperreBis = versuch.zeitpunkt.getTime() + env.loginSperreSekunden * 1000
+      zaehler = 0
+    }
   }
 
-  return { gesperrt: false, verbleibendeVersuche: env.loginMaxVersuche - fehlversuche.length }
+  if (sperreBis > jetzt) {
+    return { gesperrt: true, nochSekunden: Math.max(1, Math.ceil((sperreBis - jetzt) / 1000)) }
+  }
+
+  return { gesperrt: false, verbleibendeVersuche: env.loginMaxVersuche - zaehler }
 }
 
 /** Haelt einen Versuch fest. Der Grund hilft spaeter beim Nachvollziehen. */
@@ -75,6 +115,34 @@ export async function versuchFesthalten(
   })
 }
 
+/**
+ * Vermerkt einen abgewiesenen Aufruf - aber nur den ersten je Sperre.
+ *
+ * Dass eine Sperre gegriffen hat, will man im Protokoll sehen. Wie oft
+ * dagegen geklopft wurde, ist die Information nicht wert: Sie kostet eine
+ * Zeile pro Anfrage, und genau daraus laesst sich die Tabelle vollschreiben.
+ * Eine Zeile je Sperre reicht, um den Vorgang zu erkennen.
+ *
+ * @returns true, wenn tatsaechlich vermerkt wurde.
+ */
+export async function sperreVermerken(email: string, ip: string | null): Promise<boolean> {
+  const kennung = email.trim().toLowerCase()
+  const vorhanden = await db.loginVersuch.findFirst({
+    where: {
+      email: kennung,
+      erfolg: false,
+      grund: GRUND_ABGEWIESEN,
+      zeitpunkt: { gte: fensterStart() },
+    },
+    select: { id: true },
+  })
+
+  if (vorhanden) return false
+
+  await versuchFesthalten(kennung, ip, false, GRUND_ABGEWIESEN)
+  return true
+}
+
 /**
  * Nach einer erfolgreichen Anmeldung werden die Fehlversuche dieser
  * Adresse geloescht - sonst bliebe der Zaehler bis zum Fensterende stehen.

src/lib/auth/sitzung.ts

@@ -46,8 +46,46 @@ export async function aktuellerBenutzer(): Promise<User | null> {
   return benutzer
 }
 
-/** Wie aktuellerBenutzer, leitet aber zum Anmeldeformular um. */
+/** Hat dieser Benutzer den zweiten Faktor abgeschlossen? */
+export function zweiterFaktorFertig(benutzer: User): boolean {
+  return Boolean(benutzer.totpAktiviertAm && benutzer.totpSecretVerschluesselt)
+}
+
+/**
+ * Der angemeldete Benutzer - mit abgeschlossenem zweitem Faktor.
+ *
+ * Die MFA-Pflicht steckt bewusst HIER und nicht im App-Layout. Ein Layout
+ * schuetzt nur, was durch das Layout gerendert wird; Server Actions und
+ * Route Handler laufen daran vorbei. Wer eine Passwort-Sitzung hat, aber
+ * die TOTP-Einrichtung nie abgeschlossen hat, konnte sie frueher direkt
+ * aufrufen - "MFA ist Pflicht" war damit eine Aussage ueber die
+ * Oberflaeche, keine Sicherheitsgrenze.
+ *
+ * Massgeblich ist der Datenbankstand aus aktuellerBenutzer(), nicht das
+ * Feld im Sitzungstoken: Das laesst sich ueber session.update() vom
+ * Client beeinflussen.
+ *
+ * Die Ausnahmen sind klein und aufgezaehlt - Einrichtung des zweiten
+ * Faktors und Abmelden. Wer eine weitere braucht, nimmt bewusst
+ * erfordereBenutzerOhneZweitenFaktor() und begruendet es dort.
+ */
 export async function erfordereBenutzer(zielNachAnmeldung?: string): Promise<User> {
+  const benutzer = await erfordereBenutzerOhneZweitenFaktor(zielNachAnmeldung)
+  if (!zweiterFaktorFertig(benutzer)) {
+    redirect('/zwei-faktor/einrichten')
+  }
+  return benutzer
+}
+
+/**
+ * Nur fuer die Handvoll Stellen, die VOR abgeschlossener MFA erreichbar
+ * sein muessen: die Einrichtung selbst und das Abmelden. Jede weitere
+ * Verwendung ist ein Loch in der MFA-Pflicht und braucht eine
+ * Begruendung im Code.
+ */
+export async function erfordereBenutzerOhneZweitenFaktor(
+  zielNachAnmeldung?: string,
+): Promise<User> {
   const benutzer = await aktuellerBenutzer()
   if (!benutzer) {
     const ziel = zielNachAnmeldung ? `?weiter=${encodeURIComponent(zielNachAnmeldung)}` : ''
@@ -57,11 +95,37 @@ export async function erfordereBenutzer(zielNachAnmeldung?: string): Promise<Use
 }
 
 /**
- * Erzwingt den eingerichteten zweiten Faktor. Wird im App-Layout
+ * Fuer Route Handler: Statt umzuleiten wird abgewiesen.
- * aufgerufen: ohne TOTP kommt niemand an Fachdaten.
+ *
+ * Ein Redirect ist bei einer Datei- oder Kalenderantwort die falsche
+ * Antwort - der Aufrufer will Daten, nicht eine Anmeldeseite als Inhalt.
+ */
+export async function benutzerFuerRoute(): Promise<
+  { ok: true; benutzer: User } | { ok: false; antwort: Response }
+> {
+  const benutzer = await aktuellerBenutzer()
+  if (!benutzer) {
+    return { ok: false, antwort: new Response('Nicht angemeldet.', { status: 401 }) }
+  }
+  if (!zweiterFaktorFertig(benutzer)) {
+    return {
+      ok: false,
+      antwort: new Response('Zweiter Faktor ist nicht eingerichtet.', { status: 403 }),
+    }
+  }
+  return { ok: true, benutzer }
+}
+
+/**
+ * Erzwingt den eingerichteten zweiten Faktor.
+ *
+ * Bleibt als eigener Aufruf im App-Layout bestehen, obwohl
+ * erfordereBenutzer() das inzwischen selbst tut: Zwei Sperren an
+ * derselben Stelle kosten nichts und die aeussere ist die, die man beim
+ * Lesen des Layouts sieht.
  */
 export async function erfordereZweitenFaktor(benutzer: User): Promise<void> {
-  if (!benutzer.totpAktiviertAm || !benutzer.totpSecretVerschluesselt) {
+  if (!zweiterFaktorFertig(benutzer)) {
     redirect('/zwei-faktor/einrichten')
   }
 }

src/lib/auth/verweise.ts

@@ -0,0 +1,121 @@
+import 'server-only'
+import { db, nichtGeloescht } from '@/lib/db'
+
+/**
+ * Gehoert ein verknuepfter Datensatz zu dieser Akte?
+ *
+ * Wenn ein Formular einen Fremdschluessel mitschickt - Konto, Vertrag,
+ * Immobilie, Dokument, Vorgang, Kontakt -, dann kommt der aus einer
+ * Auswahlliste im Browser. Der Server darf sich darauf nicht verlassen:
+ * Eine veraenderte Anfrage kann jede beliebige Id enthalten.
+ *
+ * Ohne die Pruefung entstuende eine Verknuepfung ueber Aktengrenzen
+ * hinweg. Was daran gefaehrlich ist, sieht man erst an den Folgen: Der
+ * Rueckkaufswert der einen Akte haengt am Vertrag der anderen, ein
+ * fremder Name steht im Briefkopf, ein fremder Beschluss in der
+ * Genehmigungskette.
+ *
+ * Solange nur eine betreute Person angelegt ist, ist all das folgenlos.
+ * Die Pruefung gehoert trotzdem hin - sie kostet eine Abfrage, und die
+ * zweite betreute Person kommt frueher, als man denkt.
+ *
+ * Bewusst KEINE Ausnahme geworfen: Formularaktionen geben Fehler zurueck,
+ * damit die Eingaben des Benutzers nicht verlorengehen.
+ */
+
+/** Die Tabellen, auf die ein Formular verweisen darf. */
+export type Verweisziel =
+  | 'konto'
+  | 'vertrag'
+  | 'immobilie'
+  | 'dokument'
+  | 'vorgang'
+  | 'kontakt'
+  | 'vermoegensposten'
+  | 'buchung'
+
+type Sucher = (id: string, betreuteId: string) => Promise<{ id: string } | null>
+
+/**
+ * Je Ziel eine Abfrage, ausgeschrieben statt dynamisch zusammengesetzt.
+ *
+ * Das ist ein paar Zeilen laenger als ein Zugriff ueber den Tabellennamen -
+ * dafuer ist die Liste der erlaubten Ziele eine bewusste Aufzaehlung und
+ * keine Nebenwirkung, und der Typpruefer sieht jede Abfrage.
+ */
+const SUCHER: Record<Verweisziel, Sucher> = {
+  konto: (id, betreuteId) =>
+    db.konto.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+  vertrag: (id, betreuteId) =>
+    db.vertrag.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+  immobilie: (id, betreuteId) =>
+    db.immobilie.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+  dokument: (id, betreuteId) =>
+    db.dokument.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+  vorgang: (id, betreuteId) =>
+    db.vorgang.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+  kontakt: (id, betreuteId) =>
+    db.kontakt.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+  vermoegensposten: (id, betreuteId) =>
+    db.vermoegensposten.findFirst({
+      where: { id, betreuteId, ...nichtGeloescht },
+      select: { id: true },
+    }),
+  buchung: (id, betreuteId) =>
+    db.buchung.findFirst({ where: { id, betreuteId, ...nichtGeloescht }, select: { id: true } }),
+}
+
+const BESCHRIFTUNG: Record<Verweisziel, string> = {
+  konto: 'Dieses Konto',
+  vertrag: 'Dieser Vertrag',
+  immobilie: 'Diese Immobilie',
+  dokument: 'Dieses Dokument',
+  vorgang: 'Dieser Vorgang',
+  kontakt: 'Dieser Kontakt',
+  vermoegensposten: 'Dieser Vermögensposten',
+  buchung: 'Diese Buchung',
+}
+
+/**
+ * Prueft einen einzelnen Verweis.
+ *
+ * Ein leerer Verweis ist in Ordnung - "keine Verknuepfung" ist ein
+ * gueltiger Zustand und keine Verletzung.
+ *
+ * @returns null, wenn alles stimmt; sonst die fertige Fehlermeldung.
+ */
+export async function verweisPruefen(
+  ziel: Verweisziel,
+  id: string | null | undefined,
+  betreuteId: string,
+): Promise<string | null> {
+  if (!id) return null
+
+  const treffer = await SUCHER[ziel](id, betreuteId)
+
+  return treffer ? null : `${BESCHRIFTUNG[ziel]} gehört nicht zu dieser betreuten Person.`
+}
+
+/**
+ * Prueft mehrere Verweise auf einmal und meldet den ersten Verstoss.
+ *
+ * Die Abfragen laufen nebeneinander: Bei vier Verweisen ist das eine
+ * Wartezeit statt vier.
+ *
+ * @example
+ *   const fehler = await verweisePruefen(betreuteId, {
+ *     konto: werte.kontoId,
+ *     vertrag: werte.vertragId,
+ *   })
+ *   if (fehler) return { fehler }
+ */
+export async function verweisePruefen(
+  betreuteId: string,
+  verweise: Partial<Record<Verweisziel, string | null | undefined>>,
+): Promise<string | null> {
+  const eintraege = Object.entries(verweise) as [Verweisziel, string | null | undefined][]
+  const ergebnisse = await Promise.all(
+    eintraege.map(([ziel, id]) => verweisPruefen(ziel, id, betreuteId)),
+  )
+  return ergebnisse.find((meldung) => meldung !== null) ?? null
+}

src/lib/auth/zweiter-faktor.ts

@@ -0,0 +1,93 @@
+import 'server-only'
+import type { User } from '@prisma/client'
+import { db } from '@/lib/db'
+import { wiederherstellungscodeFinden } from '@/lib/crypto/hash'
+import { totpPruefen, totpSchritt, totpSecretEntschluesseln } from '@/lib/crypto/totp'
+
+/**
+ * Einloesen des zweiten Faktors - einmal und nur einmal.
+ *
+ * Ein TOTP-Code gilt 30 Sekunden, mit der Toleranz von einem Fenster bis zu
+ * 90. Wer ihn in dieser Zeit noch einmal einreicht, kommt ohne die
+ * Toleranz ein zweites Mal herein: abgelesen ueber die Schulter,
+ * mitgeschrieben von einem Zwischenglied, oder aus einem Formular, das im
+ * Browserverlauf steht. Der Kommentar in totp.ts versprach seit dem Anfang,
+ * der Aufrufer speichere das getroffene Fenster - getan hat es niemand.
+ *
+ * Deshalb hier: Der Schritt wird festgehalten, und angenommen wird nur ein
+ * groesserer. Damit ist jeder Code genau einmal gut.
+ *
+ * ## Warum updateMany und nicht update
+ *
+ * Die Bedingung steht im WHERE, nicht in einem if davor. Zwei Anfragen mit
+ * demselben Code, gleichzeitig abgeschickt, wuerden sonst beide den
+ * Vergleich bestehen, bevor eine von ihnen schreibt. So entscheidet die
+ * Datenbank: Genau eine trifft eine Zeile, die andere keine.
+ */
+
+export type ZweiterFaktorErgebnis =
+  | { ok: true; art: 'totp' | 'wiederherstellungscode' }
+  | { ok: false; grund: 'falsch' | 'wiederverwendet' }
+
+/** Ab dieser Laenge wird die Eingabe als Wiederherstellungscode gelesen. */
+const CODE_MINDESTLAENGE = 12
+
+/**
+ * Prueft die Eingabe und verbraucht sie.
+ *
+ * Nimmt sowohl einen sechsstelligen TOTP-Code als auch einen
+ * Wiederherstellungscode. Letzterer wird nach Gebrauch aus der Liste
+ * entfernt - auch das eine Einmalverwendung, nur mit anderem Mechanismus.
+ *
+ * @param benutzer Der Datensatz aus der Datenbank, nicht aus der Sitzung.
+ * @param eingabe  Was im Formular stand, ungereinigt.
+ */
+export async function zweitenFaktorEinloesen(
+  benutzer: User,
+  eingabe: string,
+): Promise<ZweiterFaktorErgebnis> {
+  const ohneTrenner = eingabe.replace(/[\s-]/g, '')
+
+  if (/^\d{6}$/.test(ohneTrenner)) {
+    if (!benutzer.totpSecretVerschluesselt) return { ok: false, grund: 'falsch' }
+
+    const secret = totpSecretEntschluesseln(benutzer.totpSecretVerschluesselt)
+    const { gueltig, delta } = totpPruefen(secret, benutzer.email, ohneTrenner)
+    if (!gueltig || delta === null) return { ok: false, grund: 'falsch' }
+
+    const schritt = totpSchritt(delta)
+
+    const { count } = await db.user.updateMany({
+      where: {
+        id: benutzer.id,
+        OR: [{ totpLetzterSchritt: null }, { totpLetzterSchritt: { lt: schritt } }],
+      },
+      data: { totpLetzterSchritt: schritt },
+    })
+
+    // Keine Zeile getroffen: Dieser Schritt war schon einmal dran. Der Code
+    // ist rechnerisch richtig und trotzdem verbraucht.
+    if (count === 0) return { ok: false, grund: 'wiederverwendet' }
+
+    return { ok: true, art: 'totp' }
+  }
+
+  if (ohneTrenner.length >= CODE_MINDESTLAENGE) {
+    const treffer = await wiederherstellungscodeFinden(benutzer.wiederherstellungscodes, eingabe)
+    if (treffer < 0) return { ok: false, grund: 'falsch' }
+
+    // Auch hier die Bedingung in die Abfrage: Sonst koennten zwei
+    // gleichzeitige Anmeldungen denselben Code einloesen, weil beide noch
+    // die alte Liste sehen.
+    const rest = benutzer.wiederherstellungscodes.filter((_, i) => i !== treffer)
+    const { count } = await db.user.updateMany({
+      where: { id: benutzer.id, wiederherstellungscodes: { equals: benutzer.wiederherstellungscodes } },
+      data: { wiederherstellungscodes: rest },
+    })
+    if (count === 0) return { ok: false, grund: 'wiederverwendet' }
+
+    return { ok: true, art: 'wiederherstellungscode' }
+  }
+
+  return { ok: false, grund: 'falsch' }
+}

src/lib/crypto/totp.ts

@@ -20,6 +20,9 @@ const ZIFFERN = 6
 const PERIODE = 30
 const TOLERANZ_FENSTER = 1
 
+/** Laenge eines TOTP-Fensters in Sekunden - fuer den Wiederverwendungsschutz. */
+export const TOTP_PERIODE = PERIODE
+
 function totpBauen(secret: string, kennung: string): TOTP {
   return new TOTP({
     issuer: AUSSTELLER,
@@ -54,10 +57,24 @@ export async function totpQrCode(secret: string, kennung: string): Promise<strin
   })
 }
 
+/**
+ * Der absolute Zeitschritt, auf den ein Code passt.
+ *
+ * validate() gibt nur die Abweichung zum aktuellen Fenster zurueck (delta).
+ * Zum Festhalten braucht es eine Zahl, die nicht davon abhaengt, wann
+ * geprueft wurde - sonst waere ein spaeter geprueftes Fenster kleiner als
+ * ein frueher geprueftes.
+ */
+export function totpSchritt(delta: number, jetztMs = Date.now()): number {
+  return Math.floor(jetztMs / 1000 / PERIODE) + delta
+}
+
 /**
  * Prueft einen eingegebenen Sechsstelligen gegen das Geheimnis.
- * Gibt zusaetzlich das getroffene Zeitfenster zurueck - der Aufrufer
+ *
- * speichert es, um eine Wiederverwendung desselben Codes zu verhindern.
+ * Gibt zusaetzlich das getroffene Zeitfenster zurueck. Wer damit anmeldet,
+ * muss es ueber zweitenFaktorEinloesen() festhalten - sonst gilt derselbe
+ * Code bis zu 90 Sekunden lang ein zweites Mal.
  */
 export function totpPruefen(
   secret: string,

src/lib/env.ts

@@ -31,6 +31,18 @@ function zahl(name: string, standard: number): number {
   return n
 }
 
+/**
+ * Ein Ja/Nein-Schalter. Bewusst nur "true"/"1"/"ja" als Ja - alles andere,
+ * auch ein Tippfehler, gilt als Nein. Bei einem Sicherheitsschalter ist das
+ * die richtige Richtung: Wer sich verschreibt, bekommt die strengere
+ * Einstellung, nicht die laxere.
+ */
+function schalter(name: string, standard = false): boolean {
+  const wert = process.env[name]?.trim().toLowerCase()
+  if (wert === undefined || wert === '') return standard
+  return wert === 'true' || wert === '1' || wert === 'ja'
+}
+
 function schluessel32(name: string): Buffer {
   const roh = pflicht(name)
   const buf = Buffer.from(roh, 'base64')
@@ -214,6 +226,65 @@ export const env = {
     }
   },
 
+  /**
+   * Darf der Host-Kopf der Anfrage die oeffentliche Adresse bestimmen?
+   *
+   * Standard: nur dann, wenn AUTH_URL nicht gesetzt ist. Ist die Adresse
+   * konfiguriert - der dokumentierte Betrieb setzt sie, Passkeys brauchen
+   * sie ohnehin -, gibt es keinen Grund, sie aus einer Kopfzeile von aussen
+   * abzuleiten. Vorher stand in auth.ts fest "true", und ein
+   * "X-Forwarded-Host: fremde.example" haette in erzeugte Adressen
+   * durchgeschlagen.
+   *
+   * AUTH_TRUST_HOST bleibt wirksam, damit die dokumentierte Einstellung
+   * nicht stillschweigend uebergangen wird.
+   */
+  get vertraueHost() {
+    return schalter('AUTH_TRUST_HOST', !process.env.AUTH_URL)
+  },
+
+  /**
+   * Geheimnis fuer die Ersteinrichtung.
+   *
+   * Zwischen dem ersten Start und dem Anlegen des Zugangs steht die Seite
+   * offen: Wer sie in diesem Fenster findet, legt sich selbst einen
+   * Administratorzugang an. Das Fenster ist kurz, aber es ist da - und bei
+   * einer Anwendung mit Gesundheits- und Finanzdaten ist "kurz" kein
+   * Argument.
+   *
+   * Ohne diesen Wert ist die Ersteinrichtung gesperrt. Das ist Absicht:
+   * Eine Installation, bei der das Feld vergessen wurde, soll nicht
+   * einrichtbar sein, sondern eine Meldung zeigen.
+   */
+  get ersteinrichtungGeheimnis() {
+    return process.env.ERSTEINRICHTUNG_GEHEIMNIS?.trim() ?? ''
+  },
+
+  /**
+   * Steht ein Reverse Proxy davor, dem die weitergereichten Koepfe zu
+   * glauben sind?
+   *
+   * Standard ist nein. Das ist die unbequeme, aber richtige Voreinstellung:
+   * Ohne Proxy ist "x-forwarded-for" frei erfunden, und eine Sperre, die
+   * darauf zaehlt, laesst sich mit einer Kopfzeile aushebeln. Wer einen
+   * Proxy davorstellt - der dokumentierte Betrieb tut das -, sagt es hier
+   * ausdruecklich. Siehe src/lib/auth/anschluss.ts.
+   */
+  get vertraueProxy() {
+    return schalter('VERTRAUE_PROXY', false)
+  },
+
+  /**
+   * Wie viele Zwischenknoten vertraut werden. Bei einem Proxy: 1.
+   *
+   * Die Zahl sagt, wie weit von hinten in der Kette der Aufrufer steht.
+   * Zu hoch gesetzt liest man wieder fremdbestimmte Eintraege, deshalb
+   * bleibt es bei eins, solange nichts anderes dasteht.
+   */
+  get vertraueProxyStufen() {
+    return Math.max(1, zahl('VERTRAUE_PROXY_STUFEN', 1))
+  },
+
   get istProduktion() {
     return process.env.NODE_ENV === 'production'
   },

src/lib/finanzen/wiederkehrend.ts

@@ -122,6 +122,10 @@ export type Zahlungsgruppe = {
 const RECHTSFORMEN = [
   'gmbh & co kg',
   'gmbh und co kg',
+  // Die haeufigste Rechtsform in diesem Fachgebiet ueberhaupt: Heime,
+  // Sozialdienste und Traeger sind fast durchweg gGmbH. Fehlte sie,
+  // zerfiele die Zusammenfassung genau dort, wo sie gebraucht wird.
+  'ggmbh',
   'gmbh',
   'mbh',
   'ohg',

src/lib/ocr/index.ts

@@ -1,6 +1,6 @@
 import 'server-only'
 import { execFile } from 'node:child_process'
-import { mkdtemp, readdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { promisify } from 'node:util'
@@ -43,6 +43,26 @@ const MAX_SEITEN = 30
 /** Mehr als das braucht keine Volltextsuche - und die Spalte bleibt handhabbar. */
 const MAX_ZEICHEN = 400_000
 
+/**
+ * Laengste Kante einer gerenderten Seite in Pixeln.
+ *
+ * Vorher wurde mit festen 300 dpi gerendert. Bei einer normalen A4-Seite
+ * sind das rund 2480 x 3510 Pixel - unproblematisch. Die Seitengroesse
+ * steht aber im PDF und kann beliebig gross angegeben werden: Bei einer
+ * Seite von 200 x 200 Zoll ergeben 300 dpi ein Bild von 60000 x 60000
+ * Pixeln, also mehrere Gigabyte auf der Platte, und das je Seite. Ein
+ * Dokument, das jemand in die Akte legt, haette so den Server vollschreiben
+ * koennen.
+ *
+ * "-scale-to" haengt die Aufloesung an die Pixelzahl statt an die
+ * angegebene Papiergroesse. 3500 Pixel entsprechen bei A4 etwa 300 dpi -
+ * fuer den Regelfall bleibt also alles wie vorher.
+ */
+const MAX_KANTE_PIXEL = 3500
+
+/** Wie viel die gerenderten Seiten zusammen belegen duerfen. */
+const MAX_BILDER_BYTES = 512 * 1024 * 1024
+
 // -----------------------------------------------------------------------------
 // Verfuegbarkeit
 // -----------------------------------------------------------------------------
@@ -146,14 +166,39 @@ async function tesseractAufDatei(pfad: string): Promise<{ text: string; meldung?
 async function pdfInBilder(verzeichnis: string, pdfPfad: string): Promise<string[]> {
   await ausfuehren(
     'pdftoppm',
-    ['-r', '300', '-gray', '-png', '-l', String(MAX_SEITEN), pdfPfad, join(verzeichnis, 'seite')],
+    [
-    { timeout: ZEITGRENZE_JE_SEITE_MS * 4, windowsHide: true },
+      // Statt fester dpi: Die laengste Kante wird auf eine feste Pixelzahl
+      // gebracht. Siehe MAX_KANTE_PIXEL - eine im PDF angegebene Riesenseite
+      // ergibt sonst ein Riesenbild.
+      '-scale-to',
+      String(MAX_KANTE_PIXEL),
+      '-gray',
+      '-png',
+      '-l',
+      String(MAX_SEITEN),
+      pdfPfad,
+      join(verzeichnis, 'seite'),
+    ],
+    { timeout: ZEITGRENZE_JE_SEITE_MS * 4, maxBuffer: 1024 * 1024, windowsHide: true },
   )
-  const dateien = await readdir(verzeichnis)
+
-  return dateien
+  const dateien = (await readdir(verzeichnis))
     .filter((name) => name.startsWith('seite') && name.endsWith('.png'))
     .sort()
     .map((name) => join(verzeichnis, name))
+
+  // Zweiter Deckel, hinterher: Was pdftoppm trotz -scale-to abgelegt hat,
+  // wird nur bis zu einer Gesamtgroesse weiterverarbeitet. Der Rest bleibt
+  // liegen und wird mit dem Arbeitsverzeichnis geloescht.
+  const genommen: string[] = []
+  let gesamt = 0
+  for (const pfad of dateien) {
+    const { size } = await stat(pfad)
+    if (gesamt + size > MAX_BILDER_BYTES) break
+    gesamt += size
+    genommen.push(pfad)
+  }
+  return genommen
 }
 
 /**

src/lib/ocr/pdf-text.ts

@@ -15,8 +15,33 @@ import { inflateSync, inflateRawSync, unzipSync } from 'node:zlib'
  * "nicht_verfuegbar", und der Nutzer traegt die Metadaten von Hand ein.
  *
  * Rein, ohne Seiteneffekte, ohne Netz.
+ *
+ * ## Grenzen, und warum es sie braucht
+ *
+ * Ein Flate-Strom sagt nicht, wie gross er ausgepackt wird. Ein paar
+ * Kilobyte Nullen komprimieren auf fast nichts und blaehen sich beim
+ * Auspacken auf Gigabyte auf - die klassische Dekompressionsbombe. Vorher
+ * lief das Auspacken ohne Obergrenze, und ein Dokument, das jemand in die
+ * Akte legt, haette den Server damit aus dem Speicher werfen koennen.
+ *
+ * Deshalb drei Deckel: einer je Strom, einer fuer die Summe, und die
+ * bestehende Obergrenze von 2000 Stroemen. Wird einer erreicht, bricht das
+ * Auspacken ab und der Text ist eben unvollstaendig - besser ein
+ * "nicht_verfuegbar" als ein Serverneustart.
  */
 
+/**
+ * Wie gross ein einzelner ausgepackter Strom werden darf.
+ *
+ * Acht Megabyte sind fuer eine Seite Text absurd viel - ein
+ * Behoerdenbescheid liegt bei einigen Kilobyte. Die Grenze ist bewusst
+ * grosszuegig: Sie soll Bomben abfangen, nicht ungewoehnliche PDFs.
+ */
+const MAX_STROM_BYTES = 8 * 1024 * 1024
+
+/** Und wie viel es ueber alle Stroeme zusammen sein darf. */
+const MAX_GESAMT_BYTES = 64 * 1024 * 1024
+
 /** Oktal-Escapes und Standard-Escapes in PDF-Literalstrings. */
 function literalEntpacken(roh: string): string {
   let ergebnis = ''
@@ -108,8 +133,9 @@ function stroemeAuspacken(pdf: Buffer): string[] {
   const roh = pdf.toString('latin1')
   const stroeme: string[] = []
   let suchAb = 0
+  let gesamt = 0
 
-  while (stroeme.length < 2000) {
+  while (stroeme.length < 2000 && gesamt < MAX_GESAMT_BYTES) {
     const beginn = roh.indexOf('stream', suchAb)
     if (beginn < 0) break
 
@@ -131,28 +157,50 @@ function stroemeAuspacken(pdf: Buffer): string[] {
     }
 
     if (/\/Filter\s*(\/FlateDecode|\[\s*\/FlateDecode)/.test(kopf)) {
-      const entpackt = flateVersuchen(daten)
+      const entpackt = flateVersuchen(daten, MAX_GESAMT_BYTES - gesamt)
-      if (entpackt) stroeme.push(entpackt.toString('latin1'))
+      if (entpackt) {
+        gesamt += entpackt.length
+        stroeme.push(entpackt.toString('latin1'))
+      }
       continue
     }
 
     if (!/\/Filter/.test(kopf)) {
+      // Unkomprimiert: Hier gibt es nichts, was sich aufblaehen koennte -
+      // die Bytes stehen so in der Datei. Sie zaehlen trotzdem mit, damit
+      // die Summe stimmt.
+      gesamt += daten.length
       stroeme.push(daten.toString('latin1'))
       continue
     }
 
     // Unbekannter Filter: trotzdem einen Flate-Versuch wagen.
-    const entpackt = flateVersuchen(daten)
+    const entpackt = flateVersuchen(daten, MAX_GESAMT_BYTES - gesamt)
-    if (entpackt) stroeme.push(entpackt.toString('latin1'))
+    if (entpackt) {
+      gesamt += entpackt.length
+      stroeme.push(entpackt.toString('latin1'))
+    }
   }
 
   return stroeme
 }
 
-function flateVersuchen(daten: Buffer): Buffer | null {
+/**
+ * Packt einen Strom aus - mit Deckel.
+ *
+ * maxOutputLength laesst zlib abbrechen, sobald die Ausgabe die Grenze
+ * ueberschreitet; der Fehler landet im catch wie jeder andere. Ohne diese
+ * Angabe entpackt Node so lange, wie Speicher da ist.
+ *
+ * @param rest Wie viele Bytes ueber alle Stroeme noch uebrig sind.
+ */
+function flateVersuchen(daten: Buffer, rest: number): Buffer | null {
+  const grenze = Math.min(MAX_STROM_BYTES, rest)
+  if (grenze <= 0) return null
+
   for (const fn of [inflateSync, unzipSync, inflateRawSync]) {
     try {
-      return fn(daten)
+      return fn(daten, { maxOutputLength: grenze })
     } catch {
       // naechster Versuch
     }

src/lib/schreiben/entwurf.ts

@@ -1,7 +1,7 @@
 import 'server-only'
 import { db, nichtGeloescht } from '@/lib/db'
 import { oeffnen } from '@/lib/crypto/feld'
-import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import { briefkopfBauen, type Absender } from '@/lib/vertraege/briefkopf'
 import {
   absenderBlock,
   anschriftBlock,
@@ -107,7 +107,8 @@ export function betreffAusText(text: string): string {
 
 export type EntwurfEingabe = {
   betreuteId: string
-  benutzerName: string
+  /** Wer schreibt - mit Anschrift, wenn hinterlegt. */
+  benutzer: Absender
   art: SchreibenArt
   vertragId?: string | null
   vorgangId?: string | null
@@ -127,7 +128,7 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
 
   const kopf = briefkopfBauen({
     betreute: oeffnen('Betreute', betreute),
-    benutzer: { name: eingabe.benutzerName },
+    benutzer: eingabe.benutzer,
   })
 
   const gemeinsam = {
@@ -229,7 +230,7 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
         geburtsdatum: betreute.geburtsdatum,
       },
       betreuer: {
-        name: eingabe.benutzerName,
+        name: eingabe.benutzer.name,
         aktenzeichenGericht: betreute.aktenzeichenGericht,
         betreuungsgericht: betreute.betreuungsgericht,
       },
@@ -278,6 +279,11 @@ export async function entwurfBauen(eingabe: EntwurfEingabe): Promise<SchreibenEn
         : null,
       betreute_anschrift: kopf.betreuteAnschrift,
       betreuer_name: kopf.betreuerName,
+      betreuer_anschrift:
+        [kopf.betreuerStrasse, [kopf.betreuerPlz, kopf.betreuerOrt].filter(Boolean).join(' ')]
+          .filter((zeile) => zeile && zeile.trim() !== '')
+          .join('\n') || null,
+      betreuer_ort: kopf.betreuerOrt,
       betreuungsgericht: kopf.betreuungsgericht,
       aktenzeichen_gericht: kopf.aktenzeichenGericht,
       bestellung_datum: kopf.bestellungAm ? formatDatum(kopf.bestellungAm) : null,

src/lib/schreiben/platzhalter.ts

@@ -21,6 +21,8 @@ export type PlatzhalterName =
   | 'betreute_geburtsdatum'
   | 'betreute_anschrift'
   | 'betreuer_name'
+  | 'betreuer_anschrift'
+  | 'betreuer_ort'
   | 'betreuungsgericht'
   | 'aktenzeichen_gericht'
   | 'bestellung_datum'
@@ -49,6 +51,12 @@ export const PLATZHALTER: readonly PlatzhalterBeschreibung[] = [
   { name: 'betreute_geburtsdatum', beschriftung: 'Geburtsdatum', quelle: 'Stammdaten' },
   { name: 'betreute_anschrift', beschriftung: 'Anschrift (Heim)', quelle: 'Stammdaten' },
   { name: 'betreuer_name', beschriftung: 'Dein Name', quelle: 'Dein Zugang' },
+  {
+    name: 'betreuer_anschrift',
+    beschriftung: 'Deine Anschrift',
+    quelle: 'Mein Konto',
+  },
+  { name: 'betreuer_ort', beschriftung: 'Dein Ort', quelle: 'Mein Konto' },
   { name: 'betreuungsgericht', beschriftung: 'Betreuungsgericht', quelle: 'Stammdaten' },
   { name: 'aktenzeichen_gericht', beschriftung: 'Aktenzeichen des Gerichts', quelle: 'Stammdaten' },
   { name: 'bestellung_datum', beschriftung: 'Datum der Bestellung', quelle: 'Stammdaten' },

src/lib/speicher/datei.ts

@@ -1,8 +1,8 @@
 import 'server-only'
-import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
 import { mkdir, readFile, rm, stat, writeFile } from 'node:fs/promises'
 import { dirname, join, resolve, sep } from 'node:path'
 import { env } from '@/lib/env'
+import { entschluesselnBinaer, verschluesselnBinaer } from '@/lib/speicher/umschlag'
 import {
   dateiRoutePfad,
   schluesselErfordern,
@@ -23,15 +23,10 @@ import {
  * gibt sonst Bescheide, Arztbriefe und Kontoauszuege im Klartext preis.
  * Der Schluessel liegt in der Umgebung, nicht neben den Daten.
  *
- * Umschlag (binaer):
+ * Der Umschlag selbst steht in src/lib/speicher/umschlag.ts - der
- *   "BCD1" | Schluesselversion (uint32 BE) | IV (12) | AuthTag (16) | Geheimtext
+ * Objektspeicher benutzt denselben.
  */
 
-const MAGIE = Buffer.from('BCD1', 'ascii')
-const IV_LAENGE = 12
-const TAG_LAENGE = 16
-const KOPF_LAENGE = MAGIE.length + 4 + IV_LAENGE + TAG_LAENGE
-
 function wurzel(): string {
   return resolve(process.cwd(), env.dateiSpeicherPfad)
 }
@@ -39,8 +34,18 @@ function wurzel(): string {
 /**
  * Baut den Dateipfad - und prueft danach noch einmal, dass er wirklich
  * unterhalb des Ablageverzeichnisses liegt. Der Schluessel ist zwar bereits
- * streng geprueft, aber diese zweite Sperre kostet nichts und faengt auch
+ * streng geprueft, aber diese zweite Sperre kostet nichts.
- * Symlink-Tricks und Windows-Eigenheiten ab.
+ *
+ * Was sie NICHT abfaengt, obwohl hier lange das Gegenteil stand: Symlinks.
+ * resolve() rechnet nur mit Zeichenketten und folgt keinem Link - dafuer
+ * braeuchte es realpath(). Ein untergeschobener Symlink im Ablageverzeichnis
+ * wuerde also nicht auffallen.
+ *
+ * Nachgeruestet wird das trotzdem nicht, und zwar aus einem Grund und nicht
+ * aus Bequemlichkeit: Wer dort einen Symlink anlegen kann, hat bereits
+ * Schreibrechte im Datenverzeichnis des Servers - dann ist der Umweg ueber
+ * einen Link die Sorge, die am wenigsten draengt. Der Satz musste
+ * verschwinden, weil er eine Sicherheit versprach, die es nie gab.
  */
 function pfadFuer(schluessel: string): string {
   const geprueft = schluesselErfordern(schluessel)
@@ -52,57 +57,15 @@ function pfadFuer(schluessel: string): string {
   return ziel
 }
 
-function verschluesselnBinaer(inhalt: Buffer): Buffer {
-  const version = env.aktiveSchluesselversion
-  const schluessel = env.verschluesselungsschluessel.get(version)
-  if (!schluessel) throw new Error(`Verschlüsselungsschlüssel Version ${version} fehlt.`)
-
-  const iv = randomBytes(IV_LAENGE)
-  const cipher = createCipheriv('aes-256-gcm', schluessel, iv, { authTagLength: TAG_LAENGE })
-  cipher.setAAD(Buffer.from(`bcd:${version}`, 'utf8'))
-  const geheim = Buffer.concat([cipher.update(inhalt), cipher.final()])
-
-  const versionBytes = Buffer.alloc(4)
-  versionBytes.writeUInt32BE(version, 0)
-
-  return Buffer.concat([MAGIE, versionBytes, iv, cipher.getAuthTag(), geheim])
-}
-
-function entschluesselnBinaer(roh: Buffer): Buffer {
-  // Dateien ohne Umschlag (von Hand hineingelegt, aus einer aelteren
-  // Installation uebernommen) werden unveraendert durchgereicht.
-  if (roh.length < KOPF_LAENGE || !roh.subarray(0, MAGIE.length).equals(MAGIE)) return roh
-
-  const version = roh.readUInt32BE(MAGIE.length)
-  const schluessel = env.verschluesselungsschluessel.get(version)
-  if (!schluessel) {
-    throw new Error(
-      `Zum Entschlüsseln dieser Datei fehlt ENC_KEY_V${version}. Alte Schlüssel dürfen beim ` +
-        `Rotieren nicht aus der Umgebung entfernt werden.`,
-    )
-  }
-
-  const ivVon = MAGIE.length + 4
-  const iv = roh.subarray(ivVon, ivVon + IV_LAENGE)
-  const tag = roh.subarray(ivVon + IV_LAENGE, ivVon + IV_LAENGE + TAG_LAENGE)
-  const geheim = roh.subarray(KOPF_LAENGE)
-
-  const decipher = createDecipheriv('aes-256-gcm', schluessel, iv, { authTagLength: TAG_LAENGE })
-  decipher.setAAD(Buffer.from(`bcd:${version}`, 'utf8'))
-  decipher.setAuthTag(tag)
-
-  return Buffer.concat([decipher.update(geheim), decipher.final()])
-}
-
 export async function schreiben(schluessel: string, inhalt: Buffer): Promise<void> {
   const pfad = pfadFuer(schluessel)
   await mkdir(dirname(pfad), { recursive: true })
-  await writeFile(pfad, verschluesselnBinaer(inhalt), { mode: 0o600 })
+  await writeFile(pfad, verschluesselnBinaer(inhalt, schluessel), { mode: 0o600 })
 }
 
 export async function lesen(schluessel: string): Promise<Buffer> {
   const roh = await readFile(pfadFuer(schluessel))
-  return entschluesselnBinaer(roh)
+  return entschluesselnBinaer(roh, schluessel)
 }
 
 export async function entfernen(schluessel: string): Promise<void> {

src/lib/speicher/s3.ts

@@ -3,12 +3,18 @@ import {
   DeleteObjectCommand,
   GetObjectCommand,
   HeadObjectCommand,
+  ListObjectsV2Command,
   PutObjectCommand,
   S3Client,
 } from '@aws-sdk/client-s3'
-import { getSignedUrl } from '@aws-sdk/s3-request-presigner'
 import { env } from '@/lib/env'
-import { schluesselErfordern, TOKEN_STANDARD_SEKUNDEN } from '@/lib/speicher/schluessel'
+import {
+  dateiRoutePfad,
+  schluesselErfordern,
+  zugriffTokenErzeugen,
+  TOKEN_STANDARD_SEKUNDEN,
+} from '@/lib/speicher/schluessel'
+import { entschluesselnBinaer, verschluesselnBinaer } from '@/lib/speicher/umschlag'
 
 /**
  * Treiber "s3": S3-kompatibler Objektspeicher, betrieben in der EU.
@@ -17,10 +23,28 @@ import { schluesselErfordern, TOKEN_STANDARD_SEKUNDEN } from '@/lib/speicher/sch
  * Art. 28 DSGVO mit dem Anbieter - hier liegen Gesundheits- und
  * Finanzdaten. Ohne diesen Vertrag bleibt es beim Dateitreiber.
  *
- * Ausgeliefert wird nur ueber kurzlebige presigned URLs. Sie tragen
+ * ## Anwendungsseitige Verschluesselung
- * Content-Disposition: attachment und einen festen Content-Type, damit der
+ *
- * Objektspeicher eine hochgeladene Datei niemals als HTML im Browser
+ * Frueher stand hier nur ServerSideEncryption: 'AES256'. Das ist
- * rendern kann.
+ * Verschluesselung mit dem Schluessel des Anbieters: Er entschluesselt beim
+ * Ausliefern selbst. Gegen eine verlorene Festplatte im Rechenzentrum hilft
+ * das, gegen den Anbieter und gegen gestohlene Zugangsdaten zum Eimer
+ * nicht - und in diesem Eimer liegen Bescheide, Arztbriefe und
+ * Kontoauszuege.
+ *
+ * Deshalb liegt jetzt derselbe Umschlag darum wie beim Dateitreiber, mit
+ * einem Schluessel aus der Umgebung. Die serverseitige Verschluesselung
+ * bleibt zusaetzlich stehen; sie kostet nichts.
+ *
+ * ## Und deshalb keine presigned URLs mehr
+ *
+ * Eine presigned URL laesst den Browser direkt beim Objektspeicher laden.
+ * Was dort liegt, ist jetzt aber Geheimtext - der Browser bekaeme
+ * unlesbare Bytes. Die Auslieferung geht darum ueber dieselbe eigene Route
+ * wie beim Dateitreiber: Sie prueft zusaetzlich die Berechtigung des
+ * angemeldeten Benutzers und schreibt einen Audit-Eintrag. Dass jeder
+ * Abruf durch die Anwendung laeuft, ist bei einer Handvoll Dokumenten am
+ * Tag kein Thema.
  */
 
 let klient: S3Client | null = null
@@ -42,18 +66,29 @@ function eimer(): string {
   return env.s3.bucket
 }
 
+/**
+ * Legt ein Objekt ab - verschluesselt.
+ *
+ * Der gemeldete MIME-Typ wird nicht mehr gebraucht: Was hier landet, ist
+ * Geheimtext und wird als application/octet-stream ausgezeichnet. Der
+ * Parameter bleibt in der Signatur, damit die Fassade beide Treiber gleich
+ * aufrufen kann.
+ */
 export async function schreiben(
   schluessel: string,
   inhalt: Buffer,
-  mimeTyp: string,
+  _mimeTyp: string,
 ): Promise<void> {
   const geprueft = schluesselErfordern(schluessel)
   await s3().send(
     new PutObjectCommand({
       Bucket: eimer(),
       Key: geprueft,
-      Body: inhalt,
+      Body: verschluesselnBinaer(inhalt, geprueft),
-      ContentType: mimeTyp,
+      // Bewusst nicht der echte Typ: Was hier liegt, ist Geheimtext. Ein
+      // "application/pdf" darauf waere eine Falschauskunft, und der einzige
+      // Weg zum Inhalt fuehrt ohnehin durch die Anwendung.
+      ContentType: 'application/octet-stream',
       // Auch beim direkten Abruf niemals im Browser darstellen.
       ContentDisposition: 'attachment',
       // Serverseitige Verschluesselung, wo der Anbieter sie unterstuetzt.
@@ -67,7 +102,10 @@ export async function lesen(schluessel: string): Promise<Buffer> {
   const antwort = await s3().send(new GetObjectCommand({ Bucket: eimer(), Key: geprueft }))
   if (!antwort.Body) throw new Error(`Objekt ${geprueft} ist leer.`)
   const bytes = await antwort.Body.transformToByteArray()
-  return Buffer.from(bytes)
+  // Objekte, die vor dieser Aenderung abgelegt wurden, tragen keinen
+  // Umschlag und kommen unveraendert zurueck. Der Migrationslauf
+  // (npm run speicher:verschluesseln) schreibt sie nach und nach um.
+  return entschluesselnBinaer(Buffer.from(bytes), geprueft)
 }
 
 export async function entfernen(schluessel: string): Promise<void> {
@@ -85,20 +123,54 @@ export async function existiert(schluessel: string): Promise<boolean> {
   }
 }
 
+/**
+ * Zeigt auf die eigene, signierte Route - nicht mehr auf den
+ * Objektspeicher.
+ *
+ * Der direkte Weg zum Anbieter lieferte den Rohinhalt aus. Solange der
+ * Klartext war, ging das; jetzt ist es Geheimtext, und entschluesseln kann
+ * nur die Anwendung. Der Nebeneffekt ist erwuenscht: Die Route prueft die
+ * Berechtigung des angemeldeten Benutzers und schreibt einen Audit-Eintrag.
+ * Ein weitergeleiteter Link allein oeffnet also nichts mehr.
+ */
 export async function signierteUrl(
   schluessel: string,
   sekunden: number = TOKEN_STANDARD_SEKUNDEN,
 ): Promise<string> {
   const geprueft = schluesselErfordern(schluessel)
-  return getSignedUrl(
+  return dateiRoutePfad(zugriffTokenErzeugen(geprueft, sekunden))
-    s3(),
+}
-    new GetObjectCommand({
+
-      Bucket: eimer(),
+// -----------------------------------------------------------------------------
-      Key: geprueft,
+// Wartung
-      // Die Antwort des Objektspeichers wird hier festgenagelt: Anhang,
+// -----------------------------------------------------------------------------
-      // niemals HTML, egal was beim Hochladen gemeldet wurde.
+//
-      ResponseContentDisposition: 'attachment',
+// Nur fuer den Migrationslauf, der bestehende Objekte nachtraeglich in den
-    }),
+// Umschlag steckt. Bewusst hier und nicht im Skript: Der Zugang zum Eimer
-    { expiresIn: Math.min(Math.max(Math.floor(sekunden), 1), 60 * 60) },
+// wird an genau einer Stelle aufgebaut.
-  )
+
+/** Alle Ablageschluessel im Eimer, seitenweise geholt. */
+export async function objekteAuflisten(): Promise<string[]> {
+  const gefunden: string[] = []
+  let weiter: string | undefined
+
+  do {
+    const antwort = await s3().send(
+      new ListObjectsV2Command({ Bucket: eimer(), ContinuationToken: weiter }),
+    )
+    for (const eintrag of antwort.Contents ?? []) {
+      if (eintrag.Key) gefunden.push(eintrag.Key)
+    }
+    weiter = antwort.IsTruncated ? antwort.NextContinuationToken : undefined
+  } while (weiter)
+
+  return gefunden
+}
+
+/** Der Inhalt, wie er im Eimer liegt - ohne den Umschlag abzunehmen. */
+export async function rohLesen(schluessel: string): Promise<Buffer> {
+  const geprueft = schluesselErfordern(schluessel)
+  const antwort = await s3().send(new GetObjectCommand({ Bucket: eimer(), Key: geprueft }))
+  if (!antwort.Body) throw new Error(`Objekt ${geprueft} ist leer.`)
+  return Buffer.from(await antwort.Body.transformToByteArray())
 }

src/lib/speicher/umschlag.ts

@@ -0,0 +1,119 @@
+import 'server-only'
+import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
+import { env } from '@/lib/env'
+
+/**
+ * Anwendungsseitiger Umschlag fuer abgelegte Dateien (AES-256-GCM).
+ *
+ * Der Dateitreiber hat das von Anfang an getan, der Objektspeicher nicht:
+ * Dort stand nur ServerSideEncryption: 'AES256'. Das ist Verschluesselung
+ * mit dem Schluessel des Anbieters - er entschluesselt beim Ausliefern
+ * selbst. Gegen ein kopiertes Backup hilft es, gegen den Anbieter und gegen
+ * gestohlene Zugangsdaten zum Eimer nicht. Bei Bescheiden, Arztbriefen und
+ * Kontoauszuegen ist das der falsche Zuschnitt.
+ *
+ * Jetzt liegt derselbe Umschlag um beides. Der Schluessel kommt aus der
+ * Umgebung und nie aus der Datenbank oder vom Anbieter.
+ *
+ * ## Format
+ *
+ *     "BCD1" | Schluesselversion (uint32 BE) | IV (12) | AuthTag (16) | Geheimtext
+ *
+ * Bewusst dasselbe Format wie bisher im Dateitreiber - bestehende Dateien
+ * bleiben ohne Umschreiben lesbar.
+ *
+ * ## Zusatzdaten
+ *
+ * Mitauthentifiziert wird die Schluesselversion und, wo der Aufrufer ihn
+ * angibt, der Ablageschluessel des Objekts. Letzteres bindet den Geheimtext
+ * an seinen Platz: Wer Schreibrechte auf den Eimer hat, kann die Bytes von
+ * Dokument A nicht unter dem Namen von Dokument B ablegen - beim Lesen
+ * schlaegt die Pruefung fehl, statt den falschen Bescheid auszuliefern.
+ *
+ * Ohne Angabe bleibt es bei "bcd:<version>", damit die Dateien, die der
+ * Dateitreiber frueher geschrieben hat, weiter aufgehen.
+ */
+
+const MAGIE = Buffer.from('BCD1', 'ascii')
+const IV_LAENGE = 12
+const TAG_LAENGE = 16
+
+export const KOPF_LAENGE = MAGIE.length + 4 + IV_LAENGE + TAG_LAENGE
+
+function zusatzdaten(version: number, ablageschluessel?: string): Buffer {
+  return Buffer.from(
+    ablageschluessel ? `bcd:${version}:${ablageschluessel}` : `bcd:${version}`,
+    'utf8',
+  )
+}
+
+/** Traegt dieser Inhalt bereits einen Umschlag? */
+export function istVerschluesselt(roh: Buffer): boolean {
+  return roh.length >= KOPF_LAENGE && roh.subarray(0, MAGIE.length).equals(MAGIE)
+}
+
+export function verschluesselnBinaer(inhalt: Buffer, ablageschluessel?: string): Buffer {
+  const version = env.aktiveSchluesselversion
+  const schluessel = env.verschluesselungsschluessel.get(version)
+  if (!schluessel) throw new Error(`Verschlüsselungsschlüssel Version ${version} fehlt.`)
+
+  const iv = randomBytes(IV_LAENGE)
+  const cipher = createCipheriv('aes-256-gcm', schluessel, iv, { authTagLength: TAG_LAENGE })
+  cipher.setAAD(zusatzdaten(version, ablageschluessel))
+  const geheim = Buffer.concat([cipher.update(inhalt), cipher.final()])
+
+  const versionBytes = Buffer.alloc(4)
+  versionBytes.writeUInt32BE(version, 0)
+
+  return Buffer.concat([MAGIE, versionBytes, iv, cipher.getAuthTag(), geheim])
+}
+
+/**
+ * Nimmt den Umschlag ab.
+ *
+ * Inhalte ohne Umschlag werden unveraendert durchgereicht: Dateien aus
+ * einer aelteren Installation, von Hand hineingelegte, und - bis der
+ * Migrationslauf durch ist - die Objekte, die vor dieser Aenderung im
+ * Objektspeicher lagen.
+ */
+export function entschluesselnBinaer(roh: Buffer, ablageschluessel?: string): Buffer {
+  if (!istVerschluesselt(roh)) return roh
+
+  const version = roh.readUInt32BE(MAGIE.length)
+  const schluessel = env.verschluesselungsschluessel.get(version)
+  if (!schluessel) {
+    throw new Error(
+      `Zum Entschlüsseln dieser Datei fehlt ENC_KEY_V${version}. Alte Schlüssel dürfen beim ` +
+        `Rotieren nicht aus der Umgebung entfernt werden.`,
+    )
+  }
+
+  const ivVon = MAGIE.length + 4
+  const iv = roh.subarray(ivVon, ivVon + IV_LAENGE)
+  const tag = roh.subarray(ivVon + IV_LAENGE, ivVon + IV_LAENGE + TAG_LAENGE)
+  const geheim = roh.subarray(KOPF_LAENGE)
+
+  // Zwei Anlaeufe: erst mit dem Ablageschluessel als Zusatzdaten, dann ohne.
+  // Der zweite Anlauf ist fuer alles, was vor der Bindung an den Platz
+  // geschrieben wurde - ohne ihn waeren die alten Dateien nicht mehr
+  // lesbar, und das waere ein Datenverlust fuer eine Verbesserung.
+  const varianten = ablageschluessel ? [ablageschluessel, undefined] : [undefined]
+
+  let letzterFehler: unknown = null
+  for (const variante of varianten) {
+    try {
+      const decipher = createDecipheriv('aes-256-gcm', schluessel, iv, {
+        authTagLength: TAG_LAENGE,
+      })
+      decipher.setAAD(zusatzdaten(version, variante))
+      decipher.setAuthTag(tag)
+      return Buffer.concat([decipher.update(geheim), decipher.final()])
+    } catch (fehler) {
+      letzterFehler = fehler
+    }
+  }
+
+  throw letzterFehler instanceof Error
+    ? letzterFehler
+    : new Error('Die Datei ließ sich nicht entschlüsseln.')
+}

src/lib/version.ts

@@ -17,7 +17,7 @@
  */
 
 /** Muss zur "version" in der package.json passen. */
-export const VERSION = '1.9.0'
+export const VERSION = '1.11.0'
 
 /**
  * Kurzer Git-Stand, beim Bauen hineingereicht:

src/lib/vertraege/briefkopf.ts

@@ -3,11 +3,20 @@ import type { Briefkopf } from '@/lib/vertraege/anschreiben'
 /**
  * Baut den Briefkopf aus Stammdaten und angemeldetem Benutzer.
  *
- * Die Anschrift des Betreuers steht im Datenmodell nicht - der Benutzer
+ * Die Anschrift des Betreuers haengt am Benutzer, nicht an der betreuten
- * hat nur Name und E-Mail. Sie bleibt deshalb leer; im erzeugten Text
+ * Person: Sie gehoert zu mir und gilt fuer alle Akten. Ist sie nicht
- * fehlen dann schlicht die beiden Zeilen, und wer den Entwurf kopiert,
+ * hinterlegt, bleiben die Zeilen weg - ein Absenderblock mit leeren
- * ergaenzt sie im Briefkopf seines Textverarbeitungsprogramms ohnehin.
+ * Zeilen sieht schlimmer aus als einer, der nur aus dem Namen besteht.
  */
+
+/** Wer schreibt - Name und, wenn hinterlegt, die eigene Anschrift. */
+export type Absender = {
+  name: string
+  strasse?: string | null
+  plz?: string | null
+  ort?: string | null
+}
+
 export type BriefkopfQuelle = {
   betreute: {
     vorname: string
@@ -22,7 +31,7 @@ export type BriefkopfQuelle = {
     aktenzeichenGericht: string | null
     bestellungAm: Date | null
   }
-  benutzer: { name: string }
+  benutzer: Absender
 }
 
 export function briefkopfBauen(quelle: BriefkopfQuelle): Briefkopf {
@@ -37,11 +46,11 @@ export function briefkopfBauen(quelle: BriefkopfQuelle): Briefkopf {
 
   return {
     betreuerName: quelle.benutzer.name,
-    betreuerStrasse: null,
+    betreuerStrasse: quelle.benutzer.strasse ?? null,
-    betreuerPlz: null,
+    betreuerPlz: quelle.benutzer.plz ?? null,
-    // Der Ort in der Datumszeile ist der Ort des Betreuers, nicht der des
+    // Der Ort in der Datumszeile ist der Ort des Betreuers, nicht der
-    // Heims - er steht nirgends im Datenmodell und bleibt deshalb leer.
+    // des Heims.
-    betreuerOrt: null,
+    betreuerOrt: quelle.benutzer.ort ?? null,
     betreuteName: `${b.anrede ? `${b.anrede} ` : ''}${b.vorname} ${b.nachname}`.trim(),
     betreuteGeburtsdatum: b.geburtsdatum,
     betreuteAnschrift: anschrift || null,

src/lib/vertraege/serienlauf.ts

@@ -4,7 +4,7 @@ import { db, nichtGeloescht } from '@/lib/db'
 import { oeffnen } from '@/lib/crypto/feld'
 import { protokollieren } from '@/lib/audit'
 import { ablegenMitTyp } from '@/lib/speicher'
-import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import { briefkopfBauen, type Absender } from '@/lib/vertraege/briefkopf'
 import {
   RUECKKAUFSWERT_WIEDERVORLAGE_TAGE,
   rueckkaufswertAnschreiben,
@@ -53,7 +53,7 @@ export async function serienlaufDurchfuehren(eingabe: {
   betreuteId: string
   vertragIds: string[]
   stichtag: Date
-  benutzer: { id: string; name: string; email: string }
+  benutzer: { id: string; name: string; email: string } & Absender
 }): Promise<SerienErgebnis> {
   const heute = heuteAlsTag()
   const { betreuteId, benutzer } = eingabe
@@ -65,7 +65,7 @@ export async function serienlaufDurchfuehren(eingabe: {
 
   const kopf = briefkopfBauen({
     betreute: oeffnen('Betreute', betreute),
-    benutzer: { name: benutzer.name },
+    benutzer,
   })
 
   // Nur Vertraege dieser betreuten Person - fremde IDs laufen ins Leere.

src/middleware.ts

@@ -30,8 +30,21 @@ import { NextResponse, type NextRequest } from 'next/server'
  *   Data-URI eingebettet, statt sie ueber einen Fremddienst zu holen.
  */
 
-/** Ohne Authentifizierungs-Cookie gar nicht erst weiterreichen. */
+/**
-const OEFFENTLICHE_PFADE = [
+ * Seiten, die auch ohne Anmeldung sinnvoll im Verlauf stehen duerfen.
+ *
+ * ACHTUNG - was diese Liste NICHT ist: eine Zugriffskontrolle. Frueher
+ * stand hier "Ohne Authentifizierungs-Cookie gar nicht erst weiterreichen",
+ * und das war schlicht falsch: Die Middleware prueft keine Anmeldung, sie
+ * setzt Kopfzeilen. Ausgewertet wird die Liste einzig fuer die Frage, ob
+ * "Cache-Control: no-store" gesetzt wird.
+ *
+ * Der Irrtum waere teuer geworden: Wer den Satz glaubt, verzichtet an einer
+ * neuen Seite auf erfordereBenutzer() - "die Middleware faengt das ja ab".
+ * Sie faengt nichts ab. Der Zugriffsschutz sitzt in
+ * src/lib/auth/sitzung.ts, und nur dort.
+ */
+const OHNE_CACHE_SPERRE = [
   '/anmelden',
   '/ersteinrichtung',
   '/datenschutz',
@@ -79,7 +92,7 @@ export function middleware(anfrage: NextRequest) {
 
   // Verhindert, dass ein Bericht oder Beleg im Verlauf des Browsers
   // zwischengespeichert wird.
-  if (!OEFFENTLICHE_PFADE.some((pfad) => anfrage.nextUrl.pathname.startsWith(pfad))) {
+  if (!OHNE_CACHE_SPERRE.some((pfad) => anfrage.nextUrl.pathname.startsWith(pfad))) {
     antwort.headers.set('Cache-Control', 'no-store, must-revalidate')
   }
 

src/server/actions/anmelden.ts

@@ -5,6 +5,7 @@ import { headers } from 'next/headers'
 import { z } from 'zod'
 import { signIn } from '@/auth'
 import { anmeldungErlaubt } from '@/lib/auth/ratelimit'
+import { anschlussAus } from '@/lib/auth/anschluss'
 
 /**
  * Server Action fuer das Anmeldeformular.
@@ -43,11 +44,10 @@ function istWeiterleitung(fehler: unknown): boolean {
   )
 }
 
-/** Hinter dem Reverse Proxy steht die echte Adresse im weitergereichten Kopf. */
+/** Siehe src/lib/auth/anschluss.ts - der Kopf wird nur mit Proxy geglaubt. */
 async function ipDerAnfrage(): Promise<string | null> {
   try {
-    const kopf = await headers()
+    return anschlussAus(await headers())
-    return kopf.get('x-forwarded-for')?.split(',')[0]?.trim() || kopf.get('x-real-ip') || null
   } catch {
     return null
   }

src/server/actions/bestaetigen.ts

@@ -5,7 +5,7 @@ import { z } from 'zod'
 import { db } from '@/lib/db'
 import { erfordereBenutzer, reauthBestaetigen } from '@/lib/auth/sitzung'
 import { passwortPruefen } from '@/lib/crypto/hash'
-import { totpPruefen, totpSecretEntschluesseln } from '@/lib/crypto/totp'
+import { zweitenFaktorEinloesen } from '@/lib/auth/zweiter-faktor'
 import { aufMindestdauerWarten } from '@/lib/auth/ratelimit'
 
 /**
@@ -56,10 +56,14 @@ export async function anmeldungBestaetigen(
 
   const passwortStimmt = await passwortPruefen(frisch.passwortHash, gelesen.data.passwort)
 
+  // Der Code wird nur eingeloest, wenn das Passwort stimmt. Sonst
+  // verbrauchte ein falsches Passwort mit richtigem Code das Zeitfenster,
+  // und der Benutzer muesste dreissig Sekunden auf den naechsten warten -
+  // ohne zu verstehen, warum.
   let codeStimmt = true
-  if (frisch.totpSecretVerschluesselt && frisch.totpAktiviertAm) {
+  if (passwortStimmt && frisch.totpSecretVerschluesselt && frisch.totpAktiviertAm) {
-    const secret = totpSecretEntschluesseln(frisch.totpSecretVerschluesselt)
+    const eingeloest = await zweitenFaktorEinloesen(frisch, gelesen.data.code)
-    codeStimmt = totpPruefen(secret, frisch.email, gelesen.data.code).gueltig
+    codeStimmt = eingeloest.ok
   }
 
   if (!passwortStimmt || !codeStimmt) {

src/server/actions/ersteinrichtung.ts

@@ -1,25 +1,49 @@
 'use server'
 
 import { redirect } from 'next/navigation'
+import { createHash, timingSafeEqual } from 'node:crypto'
 import { z } from 'zod'
 import { db } from '@/lib/db'
+import { env } from '@/lib/env'
 import { passwortHashen } from '@/lib/crypto/hash'
 import { protokollieren } from '@/lib/audit'
+import { aufMindestdauerWarten } from '@/lib/auth/ratelimit'
 
 /**
  * Anlegen des allerersten Zugangs.
  *
- * Diese Aktion ist nur so lange erreichbar, wie es noch keinen Benutzer
+ * Diese Aktion ist die einzige Stelle der Anwendung, an der jemand ohne
- * gibt. Danach sperrt sie sich selbst - sonst koennte sich jemand von
+ * Anmeldung etwas schreiben darf. Entsprechend eng ist sie gebaut - zwei
- * aussen einen Administratorzugang anlegen.
+ * Dinge sichern sie ab:
+ *
+ * ## 1. Ein Geheimnis aus der Umgebung
+ *
+ * Vorher galt: "Wenn es noch keinen Benutzer gibt, darf jeder einen
+ * anlegen." Zwischen dem ersten Start und dem Anlegen des Zugangs stand die
+ * Seite damit offen - wer sie in diesem Fenster fand, wurde Administrator
+ * einer Anwendung mit Gesundheits- und Finanzdaten. Das Fenster ist kurz,
+ * aber Zufall ist keine Zugriffskontrolle. Jetzt muss ERSTEINRICHTUNG_
+ * GEHEIMNIS aus der .env mit eingegeben werden.
+ *
+ * ## 2. Eine Sperre in der Datenbank
+ *
+ * Die Pruefung "gibt es schon einen Benutzer?" und das Anlegen waren zwei
+ * getrennte Schritte. Zwei Anfragen gleichzeitig kamen beide durch die
+ * Pruefung, bevor eine von ihnen schrieb - und legten beide einen
+ * Administrator an. Jetzt entscheidet der Primaerschluessel der Tabelle
+ * ersteinrichtung, und der laesst genau einen Gewinner zu.
  */
 
 const PASSWORT_MINDESTLAENGE = 12
 
+/** Fester Schluessel der einen Zeile, die die Sperre bildet. */
+const SPERRE = 'einmalig'
+
 const ZugangSchema = z
   .object({
     name: z.string().trim().min(2, 'Bitte deinen Namen angeben.').max(120),
     email: z.string().trim().toLowerCase().email('Bitte eine gültige E-Mail-Adresse angeben.'),
+    geheimnis: z.string().min(1, 'Bitte das Einrichtungsgeheimnis aus der .env eingeben.'),
     passwort: z
       .string()
       .min(
@@ -37,22 +61,54 @@ const ZugangSchema = z
 
 export type ZugangZustand = {
   fehler?: string
-  felder?: Partial<Record<'name' | 'email' | 'passwort' | 'passwortWiederholung', string>>
+  felder?: Partial<
+    Record<'name' | 'email' | 'passwort' | 'passwortWiederholung' | 'geheimnis', string>
+  >
   werte?: { name?: string; email?: string }
 }
 
+/**
+ * Vergleicht zwei Zeichenketten in gleichbleibender Zeit.
+ *
+ * Ueber die Laenge wird gehasht, nicht abgeschnitten: timingSafeEqual will
+ * gleich lange Puffer, und ein vorgeschalteter Laengenvergleich verriete
+ * die Laenge des Geheimnisses.
+ */
+function gleich(eingabe: string, erwartet: string): boolean {
+  const a = createHash('sha256').update(eingabe).digest()
+  const b = createHash('sha256').update(erwartet).digest()
+  return timingSafeEqual(a, b)
+}
+
 export async function erstenZugangAnlegen(
   _vorher: ZugangZustand,
   formular: FormData,
 ): Promise<ZugangZustand> {
-  const vorhandene = await db.user.count()
+  const begonnen = Date.now()
-  if (vorhandene > 0) {
+
+  // Ist die Einrichtung schon gelaufen, ist hier Schluss - unabhaengig
+  // davon, ob der Benutzer inzwischen im Papierkorb liegt.
+  const bereitsErledigt = await db.ersteinrichtung.findUnique({
+    where: { id: SPERRE },
+    select: { id: true },
+  })
+  if (bereitsErledigt || (await db.user.count()) > 0) {
     return { fehler: 'Es gibt bereits einen Zugang. Bitte melde dich an.' }
   }
 
+  if (env.ersteinrichtungGeheimnis === '') {
+    return {
+      fehler:
+        'Die Ersteinrichtung ist gesperrt, weil ERSTEINRICHTUNG_GEHEIMNIS in der .env fehlt. ' +
+        'Trage dort einen zufälligen Wert ein („npm run schluessel“ erzeugt passende), starte ' +
+        'die Anwendung neu und gib ihn hier ein.',
+    }
+  }
+
   const gelesen = ZugangSchema.safeParse({
     name: formular.get('name'),
     email: formular.get('email'),
+    geheimnis: formular.get('geheimnis'),
     passwort: formular.get('passwort'),
     passwortWiederholung: formular.get('passwortWiederholung'),
   })
@@ -64,6 +120,7 @@ export async function erstenZugangAnlegen(
       felder: {
         name: felder.name?.[0],
         email: felder.email?.[0],
+        geheimnis: felder.geheimnis?.[0],
         passwort: felder.passwort?.[0],
         passwortWiederholung: felder.passwortWiederholung?.[0],
       },
@@ -74,24 +131,50 @@ export async function erstenZugangAnlegen(
     }
   }
 
-  const { name, email, passwort } = gelesen.data
+  const { name, email, passwort, geheimnis } = gelesen.data
 
-  const benutzer = await db.user.create({
+  if (!gleich(geheimnis, env.ersteinrichtungGeheimnis)) {
-    data: {
+    // Dieselbe Mindestdauer wie am Anmeldeformular: Sonst verraet die
-      name,
+    // Antwortzeit, ob das Geheimnis stimmte und erst das Anlegen scheiterte.
-      email,
+    await aufMindestdauerWarten(begonnen)
-      passwortHash: await passwortHashen(passwort),
+    return {
-      // Der erste Zugang verwaltet auch die Anwendung.
+      fehler: 'Das Einrichtungsgeheimnis stimmt nicht.',
-      rolle: 'ADMIN',
+      felder: { geheimnis: 'Stimmt nicht mit ERSTEINRICHTUNG_GEHEIMNIS überein.' },
-    },
+      werte: { name, email },
-  })
+    }
+  }
+
+  // Anlegen und Sperren in einem Zug. Kommt eine zweite Anfrage gleichzeitig
+  // hier an, scheitert sie am Primaerschluessel der Sperrzeile - und zwar
+  // bevor ein zweiter Administrator entstanden ist.
+  let benutzerId: string
+  try {
+    const ergebnis = await db.$transaction(async (tx) => {
+      const benutzer = await tx.user.create({
+        data: {
+          name,
+          email,
+          passwortHash: await passwortHashen(passwort),
+          // Der erste Zugang verwaltet auch die Anwendung.
+          rolle: 'ADMIN',
+        },
+      })
+      await tx.ersteinrichtung.create({ data: { id: SPERRE, userId: benutzer.id } })
+      return benutzer
+    })
+    benutzerId = ergebnis.id
+  } catch {
+    // Der haeufigste Fall ist die verlorene Wettlauf-Anfrage. Für den, der
+    // davorsitzt, ist die Auskunft dieselbe wie oben.
+    return { fehler: 'Es gibt bereits einen Zugang. Bitte melde dich an.' }
+  }
 
   await protokollieren({
     aktion: 'ERSTELLT',
     entitaet: 'User',
-    entitaetId: benutzer.id,
+    entitaetId: benutzerId,
     bezeichnung: `${name} (erster Zugang)`,
-    userId: benutzer.id,
+    userId: benutzerId,
     userEmail: email,
     userName: name,
   })

src/server/actions/finanzen.ts

@@ -4,6 +4,7 @@ import { revalidatePath } from 'next/cache'
 import { redirect } from 'next/navigation'
 import { Prisma } from '@prisma/client'
 import { db, nichtGeloescht } from '@/lib/db'
+import { verweisePruefen } from '@/lib/auth/verweise'
 import { erfordereZugang, ZugriffVerweigert } from '@/lib/auth/sitzung'
 import { aenderungErmitteln, protokollieren } from '@/lib/audit'
 import { sealen } from '@/lib/crypto/feld'
@@ -325,29 +326,15 @@ export async function buchungSpeichern(
     }
     const werte = gepruft.data
 
-    if (werte.kontoId) {
+    // Alle vier Verweise auf einmal - der Vorgang war bisher der einzige,
-      const konto = await db.konto.findFirst({
+    // der ungeprueft durchging.
-        where: { id: werte.kontoId, betreuteId, ...nichtGeloescht },
+    const verweisfehler = await verweisePruefen(betreuteId, {
-        select: { id: true },
+      konto: werte.kontoId,
-      })
+      vertrag: werte.vertragId,
-      if (!konto) return { fehler: 'Dieses Konto gehört nicht zu dieser betreuten Person.' }
+      dokument: werte.belegId,
-    }
+      vorgang: werte.vorgangId,
-
+    })
-    // Wie beim Konto: Der Vertrag muss zu dieser Akte gehoeren.
+    if (verweisfehler) return { fehler: verweisfehler }
-    if (werte.vertragId) {
-      const vertrag = await db.vertrag.findFirst({
-        where: { id: werte.vertragId, betreuteId, ...nichtGeloescht },
-        select: { id: true },
-      })
-      if (!vertrag) return { fehler: 'Dieser Vertrag gehört nicht zu dieser betreuten Person.' }
-    }
-    if (werte.belegId) {
-      const beleg = await db.dokument.findFirst({
-        where: { id: werte.belegId, betreuteId, ...nichtGeloescht },
-        select: { id: true },
-      })
-      if (!beleg) return { fehler: 'Dieses Dokument gehört nicht zu dieser betreuten Person.' }
-    }
 
     const felder = {
       kontoId: werte.kontoId,
@@ -635,34 +622,14 @@ export async function vermoegenspostenSpeichern(
     }
     const werte = gepruft.data
 
-    if (werte.kontoId) {
+    // An der Verknuepfung zum Vertrag haengt dessen Rueckkaufswert - sie
-      const konto = await db.konto.findFirst({
+    // darf nicht in eine fremde Akte zeigen.
-        where: { id: werte.kontoId, betreuteId, ...nichtGeloescht },
+    const verweisfehler = await verweisePruefen(betreuteId, {
-        select: { id: true },
+      konto: werte.kontoId,
-      })
+      vertrag: werte.vertragId,
-      if (!konto) return { fehler: 'Dieses Konto gehört nicht zu dieser betreuten Person.' }
+      immobilie: werte.immobilieId,
-    }
+    })
-
+    if (verweisfehler) return { fehler: verweisfehler }
-    // Dieselbe Pruefung fuer die beiden anderen Verweise. Sie fehlte:
-    // An der Verknuepfung zum Vertrag haengt dessen Rueckkaufswert, und
-    // die darf nicht in eine fremde Akte zeigen.
-    if (werte.vertragId) {
-      const vertrag = await db.vertrag.findFirst({
-        where: { id: werte.vertragId, betreuteId, ...nichtGeloescht },
-        select: { id: true },
-      })
-      if (!vertrag) return { fehler: 'Dieser Vertrag gehört nicht zu dieser betreuten Person.' }
-    }
-
-    if (werte.immobilieId) {
-      const immobilie = await db.immobilie.findFirst({
-        where: { id: werte.immobilieId, betreuteId, ...nichtGeloescht },
-        select: { id: true },
-      })
-      if (!immobilie) {
-        return { fehler: 'Diese Immobilie gehört nicht zu dieser betreuten Person.' }
-      }
-    }
 
     const felder = {
       bezeichnung: werte.bezeichnung,

src/server/actions/konto.ts

@@ -1,5 +1,6 @@
 'use server'
 
+import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
 import { db } from '@/lib/db'
 import { erfordereBenutzer } from '@/lib/auth/sitzung'
@@ -102,3 +103,82 @@ export async function passwortAendern(
   await aufMindestdauerWarten(begonnen)
   return { erfolg: true }
 }
+
+/**
+ * Die eigene Anschrift.
+ *
+ * Sie steht im Absenderblock jedes erzeugten Schreibens und liefert den
+ * Ort fuer die Datumszeile. Angaben sind einzeln freiwillig: Wer nur den
+ * Ort hinterlegt, bekommt "Bayreuth, den 23.08.2026" und keinen
+ * Absenderblock mit leeren Zeilen.
+ */
+const AnschriftSchema = z.object({
+  strasse: z.string().trim().max(150, 'Bitte höchstens 150 Zeichen.'),
+  plz: z.string().trim().max(10, 'Bitte höchstens 10 Zeichen.'),
+  ort: z.string().trim().max(100, 'Bitte höchstens 100 Zeichen.'),
+})
+
+export type AnschriftZustand = {
+  fehler?: string
+  felder?: Partial<Record<'strasse' | 'plz' | 'ort', string>>
+  erfolg?: string
+}
+
+export async function anschriftSpeichern(
+  _vorher: AnschriftZustand,
+  formular: FormData,
+): Promise<AnschriftZustand> {
+  const benutzer = await erfordereBenutzer()
+
+  const gelesen = AnschriftSchema.safeParse({
+    strasse: formular.get('strasse') ?? '',
+    plz: formular.get('plz') ?? '',
+    ort: formular.get('ort') ?? '',
+  })
+
+  if (!gelesen.success) {
+    const felder = gelesen.error.flatten().fieldErrors
+    return {
+      fehler: 'Bitte prüfe die Eingaben.',
+      felder: {
+        strasse: felder.strasse?.[0],
+        plz: felder.plz?.[0],
+        ort: felder.ort?.[0],
+      },
+    }
+  }
+
+  // Leer heisst "nicht hinterlegt", nicht "leere Zeichenkette" - sonst
+  // stuende im Brief eine Zeile aus Leerzeichen.
+  const leerZuNull = (wert: string) => (wert === '' ? null : wert)
+
+  await db.user.update({
+    where: { id: benutzer.id },
+    data: {
+      strasse: leerZuNull(gelesen.data.strasse),
+      plz: leerZuNull(gelesen.data.plz),
+      ort: leerZuNull(gelesen.data.ort),
+    },
+  })
+
+  await protokollieren({
+    aktion: 'GEAENDERT',
+    entitaet: 'User',
+    entitaetId: benutzer.id,
+    bezeichnung: benutzer.name,
+    userId: benutzer.id,
+    userEmail: benutzer.email,
+    userName: benutzer.name,
+    aenderung: {
+      anschrift: {
+        alt: [benutzer.strasse, benutzer.plz, benutzer.ort].filter(Boolean).join(', ') || null,
+        neu:
+          [gelesen.data.strasse, gelesen.data.plz, gelesen.data.ort].filter(Boolean).join(', ') ||
+          null,
+      },
+    },
+  })
+
+  revalidatePath('/konto')
+  return { erfolg: 'Deine Anschrift ist gespeichert.' }
+}

src/server/actions/passkey.ts

@@ -20,7 +20,11 @@ import {
   registrierungPruefen,
   registrierungVorbereiten,
 } from '@/lib/auth/passkey'
-import { erfordereBenutzer, reauthBestaetigen } from '@/lib/auth/sitzung'
+import {
+  erfordereBenutzer,
+  erfordereFrischeAnmeldung,
+  reauthBestaetigen,
+} from '@/lib/auth/sitzung'
 
 /**
  * Server Actions rund um Passkeys.
@@ -42,6 +46,21 @@ export type PasskeyStart<T> = { ok: true; optionen: T } | { ok: false; fehler: s
 /** Ergebnis eines abschliessenden Schritts. */
 export type PasskeyErgebnis = { ok: true; meldung?: string } | { ok: false; fehler: string }
 
+/**
+ * Erkennt die Weiterleitung, die Next.js intern als Ausnahme wirft.
+ * Wie in anmelden.ts ueber das digest-Feld statt ueber einen Import aus
+ * next/dist - interne Pfade aendern sich zwischen Nebenversionen.
+ */
+function istWeiterleitung(fehler: unknown): boolean {
+  return (
+    typeof fehler === 'object' &&
+    fehler !== null &&
+    'digest' in fehler &&
+    typeof (fehler as { digest?: unknown }).digest === 'string' &&
+    (fehler as { digest: string }).digest.startsWith('NEXT_REDIRECT')
+  )
+}
+
 function alsFehler(fehler: unknown): { ok: false; fehler: string } {
   if (fehler instanceof PasskeyFehler) {
     return { ok: false, fehler: PASSKEY_MELDUNG[fehler.grund] }
@@ -50,6 +69,18 @@ function alsFehler(fehler: unknown): { ok: false; fehler: string } {
   return { ok: false, fehler: PASSKEY_MELDUNG.ungueltig }
 }
 
+/**
+ * Wie alsFehler, wirft aber die Weiterleitung von Next durch.
+ *
+ * Ohne das verschwindet der Ruf nach einer erneuten Bestaetigung in der
+ * allgemeinen Meldung "Der Passkey konnte nicht geprueft werden" - der
+ * Benutzer sieht einen Fehler, wo eine Zwischenfrage gemeint war.
+ */
+function alsFehlerOderWeiter(fehler: unknown): { ok: false; fehler: string } {
+  if (istWeiterleitung(fehler)) throw fehler
+  return alsFehler(fehler)
+}
+
 /**
  * Parst die Antwort des Browsers.
  *
@@ -74,14 +105,26 @@ function antwortLesen<T>(roh: string): T {
 // Einrichten (angemeldet, unter "Mein Konto")
 // ---------------------------------------------------------------------------
 
+/**
+ * Ein Passkey ist ein vollwertiger Zugang - wer einen anlegt, kommt danach
+ * ohne Passwort und ohne Code herein. Deshalb dasselbe Vorzimmer wie beim
+ * Vollexport: Die Anmeldung muss frisch sein.
+ *
+ * Das ist genau der Fall, gegen den die erneute Bestaetigung da ist: Eine
+ * offene Sitzung an einem unbeaufsichtigten Rechner ist in diesem Umfeld
+ * der wahrscheinlichste Angriffsweg. Wer daran vorbeikaeme, richtete sich
+ * in zwei Klicks einen dauerhaften eigenen Zugang ein - und der ueberlebte
+ * auch einen Passwortwechsel.
+ */
 export async function passkeyEinrichtungStarten(): Promise<
   PasskeyStart<PublicKeyCredentialCreationOptionsJSON>
 > {
   try {
     const benutzer = await erfordereBenutzer()
+    await erfordereFrischeAnmeldung(benutzer, '/konto')
     return { ok: true, optionen: await registrierungVorbereiten(benutzer) }
   } catch (fehler) {
-    return alsFehler(fehler)
+    return alsFehlerOderWeiter(fehler)
   }
 }
 
@@ -97,6 +140,11 @@ export async function passkeyEinrichtungAbschliessen(
 ): Promise<PasskeyErgebnis> {
   try {
     const benutzer = await erfordereBenutzer()
+    // Auch im zweiten Schritt: Zwischen Optionen holen und Antwort
+    // einreichen liegt der Griff zum Sensor, und die Frist kann in dieser
+    // Zeit ablaufen. Ohne die Pruefung waere der erste Schritt nur eine
+    // Empfehlung.
+    await erfordereFrischeAnmeldung(benutzer, '/konto')
 
     const geprueft = NameSchema.safeParse(name)
     if (!geprueft.success) {
@@ -122,7 +170,7 @@ export async function passkeyEinrichtungAbschliessen(
     revalidatePath('/konto')
     return { ok: true, meldung: `„${passkey.name}“ ist eingerichtet.` }
   } catch (fehler) {
-    return alsFehler(fehler)
+    return alsFehlerOderWeiter(fehler)
   }
 }
 
@@ -130,9 +178,15 @@ export async function passkeyEinrichtungAbschliessen(
 // Verwalten
 // ---------------------------------------------------------------------------
 
+/**
+ * Entfernen braucht die frische Anmeldung genauso wie das Anlegen: Wer
+ * einem Betreuer alle Passkeys wegnimmt, sperrt ihn von dem Weg aus, auf
+ * dem er hereinkommt.
+ */
 export async function passkeyEntfernen(id: string): Promise<PasskeyErgebnis> {
   try {
     const benutzer = await erfordereBenutzer()
+    await erfordereFrischeAnmeldung(benutzer, '/konto')
 
     // Zeilenweise Pruefung: Es genuegt nicht, dass die ID existiert - sie
     // muss zu DIESEM Benutzer gehoeren. deleteMany mit userId im WHERE
@@ -163,7 +217,7 @@ export async function passkeyEntfernen(id: string): Promise<PasskeyErgebnis> {
     revalidatePath('/konto')
     return { ok: true, meldung: `„${passkey.name}“ wurde entfernt.` }
   } catch (fehler) {
-    return alsFehler(fehler)
+    return alsFehlerOderWeiter(fehler)
   }
 }
 
@@ -187,21 +241,6 @@ function sicheresZiel(ziel: string): string {
   return ziel
 }
 
-/**
- * Erkennt die Weiterleitung, die Next.js intern als Ausnahme wirft.
- * Wie in anmelden.ts ueber das digest-Feld statt ueber einen Import aus
- * next/dist - interne Pfade aendern sich zwischen Nebenversionen.
- */
-function istWeiterleitung(fehler: unknown): boolean {
-  return (
-    typeof fehler === 'object' &&
-    fehler !== null &&
-    'digest' in fehler &&
-    typeof (fehler as { digest?: unknown }).digest === 'string' &&
-    (fehler as { digest: string }).digest.startsWith('NEXT_REDIRECT')
-  )
-}
-
 /**
  * Uebersetzt den Fehlercode aus authorize() in einen lesbaren Satz.
  * "passkey:<grund>" kommt aus PasskeyAnmeldeFehler, alles andere aus dem

src/server/actions/vorgaenge.ts

@@ -6,6 +6,7 @@ import type { Prisma } from '@prisma/client'
 import { db, nichtGeloescht } from '@/lib/db'
 import { erfordereZugang } from '@/lib/auth/sitzung'
 import { aenderungErmitteln, protokollieren, type Aenderung } from '@/lib/audit'
+import { verweisePruefen } from '@/lib/auth/verweise'
 import { oeffnen, sealen } from '@/lib/crypto/feld'
 import {
   AufgabeAbhakenSchema,
@@ -69,34 +70,6 @@ async function kontaktnameZu(kontaktId: string | null): Promise<string | null> {
   return [kontakt.name, kontakt.organisation].filter(Boolean).join(', ')
 }
 
-/**
- * Gehoert der Ansprechpartner zu dieser Akte?
- *
- * Ohne die Pruefung koennte ein veraendertes Formular einen Kontakt aus
- * einer fremden Akte an den Vorgang haengen - und sein Name stuende
- * anschliessend im Briefkopf.
- */
-async function ansprechpartnerPruefen(
-  betreuteId: string,
-  ansprechpartnerId: string | null,
-): Promise<{ ok: true } | { ok: false; zustand: Formularzustand }> {
-  if (!ansprechpartnerId) return { ok: true }
-
-  const kontakt = await db.kontakt.findFirst({
-    where: { id: ansprechpartnerId, betreuteId, geloeschtAm: null },
-    select: { id: true },
-  })
-  if (kontakt) return { ok: true }
-
-  return {
-    ok: false,
-    zustand: {
-      fehler: 'Diesen Kontakt gibt es nicht (mehr).',
-      felder: { ansprechpartnerId: 'Bitte einen Kontakt aus dem Verzeichnis wählen.' },
-    },
-  }
-}
-
 export async function vorgangAnlegen(
   _vorher: Formularzustand,
   formular: FormData,
@@ -119,8 +92,13 @@ export async function vorgangAnlegen(
 
   const eingabe = gelesen.data
 
-  const geprueft = await ansprechpartnerPruefen(betreuteId, eingabe.ansprechpartnerId)
+  // Sein Name stuende sonst im Briefkopf - siehe lib/auth/verweise.ts.
-  if (!geprueft.ok) return geprueft.zustand
+  const verweisfehler = await verweisePruefen(betreuteId, {
+    kontakt: eingabe.ansprechpartnerId,
+  })
+  if (verweisfehler) {
+    return { fehler: verweisfehler, felder: { ansprechpartnerId: verweisfehler } }
+  }
 
   const jetzt = new Date()
 
@@ -250,8 +228,12 @@ export async function vorgangAendern(
 
   const eingabe = gelesen.data
 
-  const geprueft = await ansprechpartnerPruefen(vorgang.betreuteId, eingabe.ansprechpartnerId)
+  const verweisfehler = await verweisePruefen(vorgang.betreuteId, {
-  if (!geprueft.ok) return geprueft.zustand
+    kontakt: eingabe.ansprechpartnerId,
+  })
+  if (verweisfehler) {
+    return { fehler: verweisfehler, felder: { ansprechpartnerId: verweisfehler } }
+  }
 
   const vorherOffen = oeffnen('Vorgang', vorgang)
 

src/server/actions/zwei-faktor.ts

@@ -3,10 +3,15 @@
 import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
 import { db } from '@/lib/db'
-import { erfordereBenutzer, erfordereFrischeAnmeldung } from '@/lib/auth/sitzung'
+import {
+  erfordereBenutzer,
+  erfordereBenutzerOhneZweitenFaktor,
+  erfordereFrischeAnmeldung,
+} from '@/lib/auth/sitzung'
 import { protokollieren } from '@/lib/audit'
 import {
   totpPruefen,
+  totpSchritt,
   totpQrCode,
   totpSecretEntschluesseln,
   totpSecretErzeugen,
@@ -40,7 +45,9 @@ export type EinrichtungsDaten = {
 }
 
 export async function zweitenFaktorVorbereiten(): Promise<EinrichtungsDaten> {
-  const benutzer = await erfordereBenutzer()
+  // Ausnahme von der MFA-Pflicht, und zwar die offensichtliche: Wer den
+  // zweiten Faktor gerade einrichtet, hat ihn noch nicht.
+  const benutzer = await erfordereBenutzerOhneZweitenFaktor()
 
   if (benutzer.totpAktiviertAm && benutzer.totpSecretVerschluesselt) {
     // Schon eingerichtet - kein neues Geheimnis, sonst waere die alte App
@@ -78,7 +85,8 @@ export async function zweitenFaktorBestaetigen(
   _vorher: BestaetigungsZustand,
   formular: FormData,
 ): Promise<BestaetigungsZustand> {
-  const benutzer = await erfordereBenutzer()
+  // Zweite und letzte Ausnahme: der Abschluss der Einrichtung selbst.
+  const benutzer = await erfordereBenutzerOhneZweitenFaktor()
 
   if (benutzer.totpAktiviertAm) {
     return { fehler: 'Der zweite Faktor ist bereits eingerichtet.' }
@@ -93,9 +101,9 @@ export async function zweitenFaktorBestaetigen(
   }
 
   const secret = totpSecretEntschluesseln(benutzer.totpSecretVerschluesselt)
-  const { gueltig } = totpPruefen(secret, benutzer.email, gelesen.data)
+  const { gueltig, delta } = totpPruefen(secret, benutzer.email, gelesen.data)
 
-  if (!gueltig) {
+  if (!gueltig || delta === null) {
     return {
       fehler:
         'Der Code stimmt nicht. Prüfe, ob die Uhrzeit deines Geräts automatisch gestellt wird — ' +
@@ -108,7 +116,14 @@ export async function zweitenFaktorBestaetigen(
 
   await db.user.update({
     where: { id: benutzer.id },
-    data: { totpAktiviertAm: new Date(), wiederherstellungscodes: hashes },
+    data: {
+      totpAktiviertAm: new Date(),
+      wiederherstellungscodes: hashes,
+      // Der Code, mit dem gerade bestaetigt wurde, ist verbraucht. Ohne
+      // diese Zeile liesse er sich unmittelbar danach fuer die erste
+      // Anmeldung noch einmal verwenden.
+      totpLetzterSchritt: totpSchritt(delta),
+    },
   })
 
   await protokollieren({

tests/anmeldesperre.test.ts

@@ -0,0 +1,250 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+/**
+ * Die Anmeldesperre - und warum sie sich frueher selbst am Leben hielt.
+ *
+ * Bis v1.10.2 wurde jeder Aufruf festgehalten, auch der, der wegen einer
+ * laufenden Sperre gar nicht geprueft wurde. Gleichzeitig lief die Frist ab
+ * dem juengsten Fehlversuch. Beides zusammen ergab eine Rueckkopplung: Wer
+ * regelmaessig gegen eine gesperrte Adresse klopfte, verlaengerte die Sperre
+ * bei jedem Klopfen um die volle Dauer - und sperrte den Inhaber damit
+ * dauerhaft aus, ohne dessen Passwort zu kennen. Nebenbei wuchs die Tabelle
+ * mit jedem Versuch.
+ *
+ * Diese Tests laufen gegen eine Attrappe der Datenbank. Das reicht: Was hier
+ * geprueft wird, ist die Rechnung, nicht die Abfrage.
+ */
+
+// Kuerzere Sperre als Zeitfenster - nur so wird sichtbar, ob die Frist
+// wirklich ablaeuft oder bis zum Fensterende stehen bleibt.
+process.env.LOGIN_MAX_VERSUCHE = '5'
+process.env.LOGIN_FENSTER_SEKUNDEN = '3600'
+process.env.LOGIN_SPERRE_SEKUNDEN = '900'
+
+type Zeile = {
+  id: string
+  email: string
+  ipHash: string | null
+  erfolg: boolean
+  grund: string | null
+  zeitpunkt: Date
+}
+
+let tabelle: Zeile[] = []
+let laufendeNummer = 0
+
+/** Nur die Abfrageformen, die in ratelimit.ts wirklich vorkommen. */
+function passt(zeile: Zeile, wo: Record<string, unknown>): boolean {
+  if ('erfolg' in wo && zeile.erfolg !== wo.erfolg) return false
+  if ('email' in wo && zeile.email !== wo.email) return false
+
+  if ('grund' in wo) {
+    const bedingung = wo.grund
+    if (typeof bedingung === 'object' && bedingung !== null && 'not' in bedingung) {
+      if (zeile.grund === (bedingung as { not: string }).not) return false
+    } else if (zeile.grund !== bedingung) {
+      return false
+    }
+  }
+
+  if ('zeitpunkt' in wo) {
+    const { gte, lt } = wo.zeitpunkt as { gte?: Date; lt?: Date }
+    if (gte && zeile.zeitpunkt < gte) return false
+    if (lt && zeile.zeitpunkt >= lt) return false
+  }
+
+  if ('OR' in wo) {
+    const zweige = wo.OR as Record<string, unknown>[]
+    if (!zweige.some((zweig) => passt(zeile, zweig))) return false
+  }
+
+  if ('ipHash' in wo && zeile.ipHash !== wo.ipHash) return false
+
+  return true
+}
+
+vi.mock('@/lib/db', () => ({
+  db: {
+    loginVersuch: {
+      findMany: async ({
+        where,
+        orderBy,
+        take,
+      }: {
+        where: Record<string, unknown>
+        orderBy?: { zeitpunkt?: 'asc' | 'desc' }
+        take?: number
+      }) => {
+        const treffer = tabelle.filter((zeile) => passt(zeile, where))
+        treffer.sort((a, b) =>
+          orderBy?.zeitpunkt === 'desc'
+            ? b.zeitpunkt.getTime() - a.zeitpunkt.getTime()
+            : a.zeitpunkt.getTime() - b.zeitpunkt.getTime(),
+        )
+        return take ? treffer.slice(0, take) : treffer
+      },
+
+      findFirst: async ({ where }: { where: Record<string, unknown> }) =>
+        tabelle.find((zeile) => passt(zeile, where)) ?? null,
+
+      create: async ({ data }: { data: Omit<Zeile, 'id' | 'zeitpunkt'> }) => {
+        laufendeNummer += 1
+        const zeile: Zeile = {
+          id: `z${laufendeNummer}`,
+          email: data.email,
+          ipHash: data.ipHash ?? null,
+          erfolg: data.erfolg,
+          grund: data.grund ?? null,
+          zeitpunkt: new Date(),
+        }
+        tabelle.push(zeile)
+        return zeile
+      },
+
+      deleteMany: async ({ where }: { where: Record<string, unknown> }) => {
+        const vorher = tabelle.length
+        tabelle = tabelle.filter((zeile) => !passt(zeile, where))
+        return { count: vorher - tabelle.length }
+      },
+    },
+  },
+}))
+
+const { anmeldungErlaubt, sperreVermerken, versuchFesthalten, fehlversucheZuruecksetzen } =
+  await import('@/lib/auth/ratelimit')
+
+const OPFER = 'opfer@example.de'
+const ANSCHLUSS = '198.51.100.7'
+const FREMD = '203.0.113.9'
+const START = new Date('2026-08-24T12:00:00Z').getTime()
+
+/** Setzt die Uhr auf START plus so viele Sekunden. */
+function beiSekunde(sekunden: number): void {
+  vi.setSystemTime(new Date(START + sekunden * 1000))
+}
+
+async function fehlversuch(sekunde: number): Promise<void> {
+  beiSekunde(sekunde)
+  await versuchFesthalten(OPFER, ANSCHLUSS, false, 'passwort-falsch')
+}
+
+describe('Anmeldesperre', () => {
+  beforeEach(() => {
+    tabelle = []
+    laufendeNummer = 0
+    vi.useFakeTimers()
+    beiSekunde(0)
+  })
+
+  it('sperrt erst, wenn das Mass voll ist', async () => {
+    for (let i = 0; i < 4; i += 1) await fehlversuch(i)
+
+    beiSekunde(10)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(false)
+
+    await fehlversuch(11)
+    beiSekunde(12)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(true)
+  })
+
+  it('laesst die Frist ablaufen, obwohl die Fehlversuche noch im Zeitfenster stehen', async () => {
+    for (let i = 0; i < 5; i += 1) await fehlversuch(i)
+
+    beiSekunde(890)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(true)
+
+    // Kurz danach offen - und mit vollem Kontingent, nicht mit null
+    // Restversuchen. Das Zeitfenster laeuft noch (3600 s), die fuenf
+    // Fehlversuche stehen also weiterhin in der Tabelle.
+    beiSekunde(905)
+    const frei = await anmeldungErlaubt(OPFER, ANSCHLUSS)
+    expect(frei.gesperrt).toBe(false)
+    if (!frei.gesperrt) expect(frei.verbleibendeVersuche).toBe(5)
+  })
+
+  it('laesst sich durch Klopfen waehrend der Sperre nicht verlaengern', async () => {
+    for (let i = 0; i < 5; i += 1) await fehlversuch(i)
+
+    // Der Angreifer klopft mitten in der Sperre weiter. Genau das hat die
+    // Frist frueher jedes Mal um volle 900 s nach hinten geschoben.
+    for (const sekunde of [100, 300, 600, 880]) {
+      beiSekunde(sekunde)
+      expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(true)
+      await sperreVermerken(OPFER, FREMD)
+    }
+
+    // Die Frist haengt am fuenften echten Fehlversuch (Sekunde 4), nicht am
+    // letzten Klopfen (Sekunde 880).
+    beiSekunde(905)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(false)
+  })
+
+  it('rechnet einen abgewiesenen Aufruf nicht als Fehlversuch', async () => {
+    // Vier echte Fehlversuche - das Mass ist noch nicht voll.
+    for (let i = 0; i < 4; i += 1) await fehlversuch(i)
+
+    // Dazu ein Vermerk ueber einen abgewiesenen Aufruf. Er steht als
+    // fuenfte Zeile in der Tabelle, darf aber nicht mitzaehlen: Geprueft
+    // wurde bei ihm nichts, also sagt er ueber die Zugangsdaten nichts aus.
+    beiSekunde(5)
+    await sperreVermerken(OPFER, FREMD)
+    expect(tabelle.length).toBe(5)
+
+    beiSekunde(6)
+    const stand = await anmeldungErlaubt(OPFER, ANSCHLUSS)
+    expect(stand.gesperrt).toBe(false)
+    if (!stand.gesperrt) expect(stand.verbleibendeVersuche).toBe(1)
+  })
+
+  it('rechnet die Frist ab dem Versuch, der das Mass vollgemacht hat', async () => {
+    // Vier Fehlversuche ganz frueh, der fuenfte deutlich spaeter. Die
+    // Sperre beginnt beim fuenften - nicht beim ersten und nicht beim
+    // naechsten, der noch kommt.
+    for (let i = 0; i < 4; i += 1) await fehlversuch(i)
+    await fehlversuch(600)
+
+    beiSekunde(1400)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(true)
+
+    beiSekunde(1510)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(false)
+  })
+
+  it('schreibt je Sperre hoechstens eine Zeile, egal wie oft geklopft wird', async () => {
+    for (let i = 0; i < 5; i += 1) await fehlversuch(i)
+    const nachSperre = tabelle.length
+
+    for (let i = 0; i < 200; i += 1) {
+      beiSekunde(10 + i)
+      await sperreVermerken(OPFER, FREMD)
+    }
+
+    expect(tabelle.length).toBe(nachSperre + 1)
+  })
+
+  it('zaehlt die naechste Runde erst nach Ablauf der Sperre wieder hoch', async () => {
+    for (let i = 0; i < 5; i += 1) await fehlversuch(i)
+
+    await fehlversuch(906)
+    const stand = await anmeldungErlaubt(OPFER, ANSCHLUSS)
+    expect(stand.gesperrt).toBe(false)
+    if (!stand.gesperrt) expect(stand.verbleibendeVersuche).toBe(4)
+
+    // Vier weitere - dann greift die zweite Sperre.
+    for (let i = 1; i < 5; i += 1) await fehlversuch(906 + i)
+    beiSekunde(915)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(true)
+  })
+
+  it('raeumt die Fehlversuche nach erfolgreicher Anmeldung ab', async () => {
+    for (let i = 0; i < 5; i += 1) await fehlversuch(i)
+    beiSekunde(10)
+    expect((await anmeldungErlaubt(OPFER, ANSCHLUSS)).gesperrt).toBe(true)
+
+    await fehlversucheZuruecksetzen(OPFER)
+
+    const frei = await anmeldungErlaubt(OPFER, ANSCHLUSS)
+    expect(frei.gesperrt).toBe(false)
+    if (!frei.gesperrt) expect(frei.verbleibendeVersuche).toBe(5)
+  })
+})

tests/anschluss.test.ts

@@ -0,0 +1,136 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { anschlussAus, warnungZuruecksetzen } from '@/lib/auth/anschluss'
+
+/**
+ * Aus welchem Kopf die Adresse des Aufrufers gelesen wird.
+ *
+ * Vorher stand dort der ERSTE Eintrag von "x-forwarded-for". Das ist die
+ * klassische Verwechslung: Der Kopf ist eine Liste, an die jeder
+ * Zwischenknoten hinten anhaengt - der erste Eintrag ist also der, den der
+ * Aufrufer selbst mitgeschickt hat. Wer bei jeder Anfrage eine andere Zahl
+ * hineinschrieb, sah fuer die Anmeldesperre wie tausend Anschluesse aus.
+ */
+
+function koepfe(werte: Record<string, string>): Headers {
+  return new Headers(werte)
+}
+
+describe('Anschluss des Aufrufers', () => {
+  beforeEach(() => {
+    warnungZuruecksetzen()
+    delete process.env.VERTRAUE_PROXY
+    delete process.env.VERTRAUE_PROXY_STUFEN
+  })
+
+  afterEach(() => {
+    delete process.env.VERTRAUE_PROXY
+    delete process.env.VERTRAUE_PROXY_STUFEN
+    vi.restoreAllMocks()
+  })
+
+  describe('ohne vertrauten Proxy', () => {
+    it('glaubt dem weitergereichten Kopf nicht', () => {
+      const warnung = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      expect(anschlussAus(koepfe({ 'x-forwarded-for': '203.0.113.9' }))).toBeNull()
+      expect(warnung).toHaveBeenCalledOnce()
+    })
+
+    it('warnt nur einmal, nicht bei jeder Anfrage', () => {
+      const warnung = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      for (let i = 0; i < 20; i += 1) {
+        anschlussAus(koepfe({ 'x-forwarded-for': `203.0.113.${i}` }))
+      }
+
+      expect(warnung).toHaveBeenCalledOnce()
+    })
+
+    it('schweigt, wenn gar kein solcher Kopf ankommt', () => {
+      const warnung = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      expect(anschlussAus(koepfe({}))).toBeNull()
+      expect(warnung).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('mit einem vertrauten Proxy', () => {
+    beforeEach(() => {
+      process.env.VERTRAUE_PROXY = 'true'
+    })
+
+    it('nimmt den letzten Eintrag, nicht den ersten', () => {
+      // Links das, was der Aufrufer selbst behauptet hat; rechts das, was
+      // der Proxy gesehen hat. Nur letzteres ist etwas wert.
+      const kopf = koepfe({ 'x-forwarded-for': '10.0.0.1, 198.51.100.7' })
+
+      expect(anschlussAus(kopf)).toBe('198.51.100.7')
+    })
+
+    it('laesst sich durch eine erfundene Kette nicht taeuschen', () => {
+      const kopf = koepfe({
+        'x-forwarded-for': '1.1.1.1, 2.2.2.2, 3.3.3.3, 198.51.100.7',
+      })
+
+      expect(anschlussAus(kopf)).toBe('198.51.100.7')
+    })
+
+    it('nimmt den einzigen Eintrag, wenn der Aufrufer keinen mitschickte', () => {
+      expect(anschlussAus(koepfe({ 'x-forwarded-for': '198.51.100.7' }))).toBe('198.51.100.7')
+    })
+
+    it('faellt auf x-real-ip zurueck', () => {
+      expect(anschlussAus(koepfe({ 'x-real-ip': '198.51.100.7' }))).toBe('198.51.100.7')
+    })
+
+    it('gibt null, wenn nichts da ist', () => {
+      expect(anschlussAus(koepfe({}))).toBeNull()
+    })
+
+    it('kommt mit Leerraum und leeren Gliedern zurecht', () => {
+      const kopf = koepfe({ 'x-forwarded-for': ' 10.0.0.1 ,  , 198.51.100.7 ' })
+
+      expect(anschlussAus(kopf)).toBe('198.51.100.7')
+    })
+  })
+
+  describe('mit mehreren Stufen', () => {
+    it('zaehlt die angegebene Anzahl von hinten ab', () => {
+      process.env.VERTRAUE_PROXY = 'true'
+      process.env.VERTRAUE_PROXY_STUFEN = '2'
+
+      // Zwei eigene Zwischenknoten: der aeussere haengt 198.51.100.7 an,
+      // der innere 10.0.0.5. Der Aufrufer steht eine Stelle weiter links.
+      const kopf = koepfe({ 'x-forwarded-for': 'erfunden, 198.51.100.7, 10.0.0.5' })
+
+      expect(anschlussAus(kopf)).toBe('198.51.100.7')
+    })
+
+    it('greift nicht ueber den Anfang der Kette hinaus', () => {
+      process.env.VERTRAUE_PROXY = 'true'
+      process.env.VERTRAUE_PROXY_STUFEN = '9'
+
+      expect(anschlussAus(koepfe({ 'x-forwarded-for': '198.51.100.7' }))).toBe('198.51.100.7')
+    })
+  })
+
+  describe('der Schalter selbst', () => {
+    it('gilt nur bei ausdruecklichem Ja', () => {
+      for (const wert of ['false', 'nein', '0', 'vielleicht', '']) {
+        warnungZuruecksetzen()
+        vi.spyOn(console, 'warn').mockImplementation(() => {})
+        process.env.VERTRAUE_PROXY = wert
+
+        expect(anschlussAus(koepfe({ 'x-forwarded-for': '198.51.100.7' }))).toBeNull()
+      }
+    })
+
+    it('nimmt true, 1 und ja', () => {
+      for (const wert of ['true', '1', 'ja', 'TRUE', ' Ja ']) {
+        process.env.VERTRAUE_PROXY = wert
+
+        expect(anschlussAus(koepfe({ 'x-forwarded-for': '198.51.100.7' }))).toBe('198.51.100.7')
+      }
+    })
+  })
+})

tests/briefkopf.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+import { briefkopfBauen } from '@/lib/vertraege/briefkopf'
+import { absenderBlock, datumsZeile } from '@/lib/vertraege/anschreiben'
+
+/**
+ * Der Absenderblock.
+ *
+ * Ein foermliches Schreiben ohne Ruecksendeadresse wirkt unserioes und
+ * macht es der Gegenstelle schwer zu antworten. Umgekehrt gilt: Lieber
+ * nur der Name als ein Block mit leeren Zeilen - eine halb ausgefuellte
+ * Adresse sieht nach Fehler aus, ein blosser Name nach Absicht.
+ */
+
+const BETREUTE = {
+  vorname: 'Erika',
+  nachname: 'Musterfrau',
+  anrede: 'Frau',
+  geburtsdatum: new Date(Date.UTC(1943, 3, 17)),
+  heimName: 'Seniorenheim Sonnenhof',
+  heimStrasse: 'Heimweg 3',
+  heimPlz: '95445',
+  heimOrt: 'Bayreuth',
+  betreuungsgericht: 'Amtsgericht Bayreuth',
+  aktenzeichenGericht: 'XVII 412/25',
+  bestellungAm: new Date(Date.UTC(2026, 1, 14)),
+}
+
+const VOLLSTAENDIG = {
+  name: 'Florian Wilde',
+  strasse: 'Cottenbacher Str. 23',
+  plz: '95445',
+  ort: 'Bayreuth',
+}
+
+describe('Absenderblock', () => {
+  it('nennt Name, Straße und Ort', () => {
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: VOLLSTAENDIG })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde\nCottenbacher Str. 23\n95445 Bayreuth')
+  })
+
+  it('bleibt beim Namen, wenn keine Anschrift hinterlegt ist', () => {
+    // Kein Block mit leeren Zeilen - das sieht nach Fehler aus.
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: { name: 'Florian Wilde' } })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde')
+  })
+
+  it('lässt die Straße weg, wenn nur der Ort bekannt ist', () => {
+    const kopf = briefkopfBauen({
+      betreute: BETREUTE,
+      benutzer: { name: 'Florian Wilde', plz: '95445', ort: 'Bayreuth' },
+    })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde\n95445 Bayreuth')
+  })
+
+  it('verträgt einen Ort ohne PLZ', () => {
+    const kopf = briefkopfBauen({
+      betreute: BETREUTE,
+      benutzer: { name: 'Florian Wilde', ort: 'Bayreuth' },
+    })
+    expect(absenderBlock(kopf)).toBe('Florian Wilde\nBayreuth')
+  })
+
+  it('nimmt die Anschrift vom Betreuer, nicht vom Heim', () => {
+    // Die Heimadresse ist die der betreuten Person und gehört in den
+    // Anschriftenblock, nie in den Absender.
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: VOLLSTAENDIG })
+    expect(absenderBlock(kopf)).not.toContain('Heimweg')
+    expect(kopf.betreuteAnschrift).toContain('Heimweg 3')
+  })
+})
+
+describe('Datumszeile', () => {
+  const heute = new Date(Date.UTC(2026, 7, 23))
+
+  it('stellt den Ort des Betreuers voran', () => {
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: VOLLSTAENDIG })
+    expect(datumsZeile(kopf.betreuerOrt, heute)).toBe('Bayreuth, den 23.08.2026')
+  })
+
+  it('lässt ohne Ort das Komma weg', () => {
+    const kopf = briefkopfBauen({ betreute: BETREUTE, benutzer: { name: 'Florian Wilde' } })
+    expect(datumsZeile(kopf.betreuerOrt, heute)).toBe('23.08.2026')
+  })
+})

tests/mfa-grenze.test.ts

@@ -0,0 +1,133 @@
+import { readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import { describe, expect, it } from 'vitest'
+
+/**
+ * Die MFA-Pflicht als Grenze, nicht als Behauptung.
+ *
+ * "Der zweite Faktor ist Pflicht" stand lange im Kopf von src/auth.ts,
+ * durchgesetzt wurde es aber nur im App-Layout. Ein Layout schuetzt, was
+ * durch das Layout gerendert wird - Server Actions und Route Handler laufen
+ * daran vorbei. Wer eine Passwort-Sitzung hatte, die TOTP-Einrichtung aber
+ * nie abgeschlossen hat, kam trotzdem an die Daten.
+ *
+ * Seitdem steckt die Pruefung in erfordereBenutzer() selbst. Damit sie dort
+ * bleibt, prueft dieser Test die Bauform statt des Verhaltens: Er liest den
+ * Quelltext und besteht darauf, dass die Umgehungen aufgezaehlt bleiben.
+ *
+ * Ein Integrationstest waere schoener, braeuchte aber eine Sitzung mit
+ * halbfertigem zweitem Faktor - also genau den Zustand, den die Anwendung
+ * nicht mehr herstellen laesst. Diese Pruefung greift dafuer bei jedem
+ * neuen Endpunkt, auch bei dem, an den beim Testeschreiben niemand denkt.
+ */
+
+const WURZEL = join(__dirname, '..', 'src')
+
+/**
+ * Wer an aktuellerBenutzer() oder erfordereBenutzerOhneZweitenFaktor()
+ * vorbei darf - und warum.
+ *
+ * Gemeinsam ist allen: Sie geben keine Daten einer betreuten Person heraus.
+ * Wer hier etwas ergaenzt, hebelt die MFA-Pflicht fuer diesen Pfad aus und
+ * schuldet eine Begruendung.
+ */
+const ERLAUBT = new Map<string, string>([
+  ['lib/auth/sitzung.ts', 'definiert die Funktionen'],
+  ['app/(auth)/anmelden/page.tsx', 'leitet bereits Angemeldete weiter, zeigt nichts an'],
+  ['app/(auth)/ersteinrichtung/page.tsx', 'laeuft, bevor es einen zweiten Faktor geben kann'],
+  ['app/(auth)/zwei-faktor/einrichten/page.tsx', 'ist die Einrichtung selbst'],
+  ['server/actions/zwei-faktor.ts', 'Vorbereiten und Bestaetigen der Einrichtung'],
+])
+
+/** Route Handler, die absichtlich ohne Anmeldung erreichbar sind. */
+const OEFFENTLICHE_ROUTEN = new Map<string, string>([
+  ['app/api/auth/[...nextauth]/route.ts', 'die Anmeldung selbst'],
+  ['app/api/gesundheit/route.ts', 'Statusabfrage fuer die Ueberwachung, ohne Daten'],
+  ['app/api/kalender/[signatur]/route.ts', 'signierter Abo-Link, eigene Pruefung'],
+  ['app/api/wartung/route.ts', 'Aufruf per Geheimnis aus dem Systemdienst'],
+])
+
+/** Alles, was einen angemeldeten Benutzer mit fertigem zweitem Faktor sichert. */
+const WAECHTER = [
+  'benutzerFuerRoute',
+  'erfordereZugang',
+  'erfordereBenutzer(',
+  'finanzKontext',
+  'berichtsKontext',
+]
+
+function dateienUnter(verzeichnis: string, endungen: string[]): string[] {
+  const gefunden: string[] = []
+
+  for (const eintrag of readdirSync(verzeichnis)) {
+    if (eintrag === 'node_modules' || eintrag === '.next') continue
+    const pfad = join(verzeichnis, eintrag)
+
+    if (statSync(pfad).isDirectory()) {
+      gefunden.push(...dateienUnter(pfad, endungen))
+    } else if (endungen.some((endung) => eintrag.endsWith(endung))) {
+      gefunden.push(pfad)
+    }
+  }
+
+  return gefunden
+}
+
+/** Pfad relativ zu src/, immer mit Schraegstrich - auch unter Windows. */
+function kennung(pfad: string): string {
+  return relative(WURZEL, pfad).split(sep).join('/')
+}
+
+describe('MFA-Grenze', () => {
+  it('umgeht die Pflicht nur an den aufgezaehlten Stellen', () => {
+    const umgehungen = dateienUnter(WURZEL, ['.ts', '.tsx'])
+      .filter((pfad) => {
+        const quelltext = readFileSync(pfad, 'utf-8')
+        return (
+          quelltext.includes('aktuellerBenutzer') ||
+          quelltext.includes('erfordereBenutzerOhneZweitenFaktor')
+        )
+      })
+      .map(kennung)
+      .sort()
+
+    expect(umgehungen).toEqual([...ERLAUBT.keys()].sort())
+  })
+
+  it('sichert jeden Route Handler oder erklaert, warum nicht', () => {
+    const ungesichert = dateienUnter(join(WURZEL, 'app'), ['route.ts'])
+      .map(kennung)
+      .filter((datei) => !OEFFENTLICHE_ROUTEN.has(datei))
+      .filter((datei) => {
+        const quelltext = readFileSync(join(WURZEL, datei), 'utf-8')
+        return !WAECHTER.some((waechter) => quelltext.includes(waechter))
+      })
+
+    expect(ungesichert).toEqual([])
+  })
+
+  it('weist einen Abruf ohne zweiten Faktor ab, statt ihn umzuleiten', () => {
+    // Ein Redirect auf die Anmeldeseite waere bei einer Datei die falsche
+    // Antwort: Der Aufrufer bekaeme HTML, wo er ein Dokument erwartet, und
+    // ein Skript wertete das womoeglich als Erfolg.
+    const quelltext = readFileSync(join(WURZEL, 'lib', 'auth', 'sitzung.ts'), 'utf-8')
+    const abschnitt = quelltext.slice(quelltext.indexOf('export async function benutzerFuerRoute'))
+
+    expect(abschnitt).toContain('status: 401')
+    expect(abschnitt).toContain('status: 403')
+  })
+
+  it('prueft den zweiten Faktor am Datenbankstand, nicht am Sitzungstoken', () => {
+    const quelltext = readFileSync(join(WURZEL, 'lib', 'auth', 'sitzung.ts'), 'utf-8')
+    const funktion = quelltext.slice(
+      quelltext.indexOf('export function zweiterFaktorFertig'),
+      quelltext.indexOf('export async function erfordereBenutzer'),
+    )
+
+    // Die Felder kommen aus dem User-Datensatz. Stuende hier etwas aus der
+    // Sitzung, liesse es sich ueber session.update() vom Client setzen.
+    expect(funktion).toContain('benutzer.totpAktiviertAm')
+    expect(funktion).toContain('benutzer.totpSecretVerschluesselt')
+    expect(funktion).not.toContain('sitzung')
+  })
+})

tests/migration-erzeugen.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'vitest'
+import {
+  dropZeilenEntfernen,
+  hatAnweisungen,
+  kopfBauen,
+  ordnernameBauen,
+} from '../scripts/migration-erzeugen.mjs'
+
+/**
+ * Der Migrations-Wrapper.
+ *
+ * Die eine Sache, die hier schiefgehen darf und nicht schiefgehen soll:
+ * zu viel entfernen. Ein DROP INDEX, das Prisma zu Recht schreibt, muss
+ * stehen bleiben - sonst repariert das Skript die Suche und zerlegt
+ * dafuer das Schema.
+ */
+
+const GESCHUETZT = [
+  { name: 'dokument_absender_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+  { name: 'vorgang_titel_trgm', quelle: 'prisma/sql/volltextsuche.sql' },
+]
+
+describe('DROP-Zeilen entfernen', () => {
+  it('nimmt die geschützte Anweisung samt Überschrift heraus', () => {
+    const roh = [
+      '-- DropIndex',
+      'DROP INDEX "dokument_absender_trgm";',
+      '',
+      '-- AlterTable',
+      'ALTER TABLE "kontakt" ADD COLUMN "anrede" TEXT;',
+    ].join('\n')
+
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+
+    expect(entfernt).toEqual(['dokument_absender_trgm'])
+    expect(sql).not.toContain('DROP INDEX')
+    expect(sql).not.toContain('DropIndex')
+    expect(sql).toContain('ALTER TABLE "kontakt"')
+  })
+
+  it('lässt ein DROP INDEX auf einen Prisma-eigenen Index stehen', () => {
+    // Der Kern der Sache: Das Skript darf nicht alles wegräumen, was nach
+    // DROP INDEX aussieht - manche sollen wirklich weg.
+    const roh = ['-- DropIndex', 'DROP INDEX "vertrag_betreuteId_status_idx";'].join('\n')
+
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+
+    expect(entfernt).toEqual([])
+    expect(sql).toContain('DROP INDEX "vertrag_betreuteId_status_idx";')
+    expect(sql).toContain('-- DropIndex')
+  })
+
+  it('entfernt mehrere geschützte Anweisungen und meldet beide', () => {
+    const roh = [
+      '-- DropIndex',
+      'DROP INDEX "dokument_absender_trgm";',
+      '',
+      '-- DropIndex',
+      'DROP INDEX "vorgang_titel_trgm";',
+      '',
+      '-- CreateTable',
+      'CREATE TABLE "schreibvorlage" ();',
+    ].join('\n')
+
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+
+    expect(entfernt).toEqual(['dokument_absender_trgm', 'vorgang_titel_trgm'])
+    expect(sql.startsWith('-- CreateTable')).toBe(true)
+  })
+
+  it('verträgt IF EXISTS und abweichende Schreibweise', () => {
+    const roh = 'drop index if exists "vorgang_titel_trgm";'
+    expect(dropZeilenEntfernen(roh, GESCHUETZT).entfernt).toEqual(['vorgang_titel_trgm'])
+  })
+
+  it('lässt eine Migration ohne Treffer unverändert', () => {
+    const roh = ['-- AlterTable', 'ALTER TABLE "vorgang" ADD COLUMN "x" TEXT;'].join('\n')
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+    expect(entfernt).toEqual([])
+    expect(sql).toBe(roh)
+  })
+
+  it('greift nicht bei einem bloßen Vorkommen des Namens im Text', () => {
+    // Ein Kommentar, der den Index nennt, ist keine Anweisung.
+    const roh = '-- dokument_absender_trgm bleibt bestehen'
+    const { sql, entfernt } = dropZeilenEntfernen(roh, GESCHUETZT)
+    expect(entfernt).toEqual([])
+    expect(sql).toBe(roh)
+  })
+})
+
+describe('Leere Migration erkennen', () => {
+  it('sieht eine echte Anweisung', () => {
+    expect(hatAnweisungen('-- AlterTable\nALTER TABLE "x" ADD COLUMN "y" TEXT;')).toBe(true)
+  })
+
+  it('hält reinen Kommentartext für leer', () => {
+    // Der Normalfall: Schema und Datenbank stimmen überein, der ganze
+    // Diff bestand aus den zwei bekannten DROP-Zeilen. Dann darf keine
+    // Migration entstehen — eine leere in der Historie ist schlimmer als
+    // keine.
+    expect(hatAnweisungen('-- nur ein Kommentar\n\n-- noch einer')).toBe(false)
+  })
+
+  it('hält Leerraum für leer', () => {
+    expect(hatAnweisungen('   \n\n  ')).toBe(false)
+  })
+})
+
+describe('Kopfkommentar', () => {
+  it('benennt die entfernten Indizes und ihre Quelle', () => {
+    const kopf = kopfBauen('ansprechpartner', ['vorgang_titel_trgm'], GESCHUETZT)
+    expect(kopf).toContain('vorgang_titel_trgm')
+    expect(kopf).toContain('prisma/sql/volltextsuche.sql')
+  })
+
+  it('sagt auch, wenn nichts zu entfernen war', () => {
+    expect(kopfBauen('leer', [], GESCHUETZT)).toContain('Nichts zu entfernen')
+  })
+})
+
+describe('Ordnername', () => {
+  it('baut den Zeitstempel im Prisma-Format', () => {
+    expect(ordnernameBauen('anrede', new Date(2026, 7, 23, 9, 5, 3))).toBe(
+      '20260823090503_anrede',
+    )
+  })
+})

tests/pdf-bombe.test.ts

@@ -0,0 +1,104 @@
+import { deflateSync } from 'node:zlib'
+import { describe, expect, it } from 'vitest'
+import { pdfTextLesen } from '@/lib/ocr/pdf-text'
+
+/**
+ * Was passiert, wenn jemand ein praepariertes PDF in die Akte legt?
+ *
+ * Ein Flate-Strom sagt nicht, wie gross er ausgepackt wird. Ein paar
+ * Kilobyte Nullen komprimieren auf fast nichts und blaehen sich beim
+ * Auspacken auf Gigabyte auf - die klassische Dekompressionsbombe. Der
+ * Textleser packte vorher ohne Obergrenze aus.
+ *
+ * Der Test rechnet nicht mit Gigabyte - das waere in einer Testsuite
+ * unhoeflich. Er baut eine Bombe, die die eingebaute Grenze knapp
+ * ueberschreitet, und besteht darauf, dass sie nicht ausgepackt wird.
+ */
+
+/** Baut ein minimales PDF mit einem einzigen Flate-Strom. */
+function pdfMitStrom(nutzlast: Buffer, filter = '/FlateDecode'): Buffer {
+  const kopf = Buffer.from(
+    `%PDF-1.4\n1 0 obj\n<< /Length ${nutzlast.length} /Filter ${filter} >>\nstream\n`,
+    'latin1',
+  )
+  const fuss = Buffer.from('\nendstream\nendobj\n%%EOF\n', 'latin1')
+  return Buffer.concat([kopf, nutzlast, fuss])
+}
+
+/**
+ * Text, den der Extraktor tatsaechlich findet: Er springt nur an, wenn im
+ * Strom PDF-Textoperatoren stehen.
+ */
+function inhaltsstrom(text: string): Buffer {
+  return Buffer.from(`BT /F1 12 Tf (${text}) Tj ET\n`, 'latin1')
+}
+
+describe('PDF-Textleser gegen praeparierte Dateien', () => {
+  it('liest einen gewoehnlichen Flate-Strom', () => {
+    const pdf = pdfMitStrom(deflateSync(inhaltsstrom('Bescheid vom Sozialamt')))
+
+    expect(pdfTextLesen(pdf)).toContain('Bescheid vom Sozialamt')
+  })
+
+  it('packt eine Bombe nicht aus, die die Stromgrenze ueberschreitet', () => {
+    // Die Nutzlast traegt eine erkennbare Marke UND 9 MB Fuellung. Beides
+    // ist wichtig: Ohne die Marke waere das Ergebnis auch ohne Grenze leer,
+    // und der Test bewiese nichts. Die Fuellung komprimiert auf wenige
+    // Kilobyte, die Grenze je Strom liegt bei 8 MB - zlib bricht ab, der
+    // Strom wird verworfen, und die Marke erscheint eben nicht.
+    const bombe = deflateSync(
+      Buffer.concat([inhaltsstrom('BOMBE-MARKE'), Buffer.alloc(9 * 1024 * 1024, 0x20)]),
+    )
+    const pdf = pdfMitStrom(bombe)
+
+    // Kein Absturz, kein Aufblaehen: einfach kein Text.
+    expect(pdfTextLesen(pdf)).toBe('')
+  })
+
+  it('liest denselben Strom, wenn er unter der Grenze bleibt', () => {
+    // Gegenprobe zum Test darueber: Dieselbe Bauform, nur 4 MB Fuellung.
+    // Damit ist belegt, dass oben die Grenze greift und nicht die Bauform
+    // des Testfalls.
+    const knappDrunter = deflateSync(
+      Buffer.concat([inhaltsstrom('BOMBE-MARKE'), Buffer.alloc(4 * 1024 * 1024, 0x20)]),
+    )
+
+    expect(pdfTextLesen(pdfMitStrom(knappDrunter))).toContain('BOMBE-MARKE')
+  })
+
+  it('bleibt handhabbar, wenn viele mittelgrosse Stroeme zusammenkommen', () => {
+    // Zwoelf Stroeme mit je 6 MB Nutzlast liegen einzeln unter der
+    // Stromgrenze, zusammen aber ueber der Gesamtgrenze von 64 MB. Ohne den
+    // zweiten Deckel waeren das 72 MB im Speicher, und zwar je Dokument.
+    const einer = deflateSync(Buffer.concat([inhaltsstrom('Seite'), Buffer.alloc(6 * 1024 * 1024, 0x20)]))
+    const teile: Buffer[] = [Buffer.from('%PDF-1.4\n', 'latin1')]
+    for (let i = 0; i < 12; i += 1) {
+      teile.push(
+        Buffer.from(`${i + 1} 0 obj\n<< /Length ${einer.length} /Filter /FlateDecode >>\nstream\n`, 'latin1'),
+        einer,
+        Buffer.from('\nendstream\nendobj\n', 'latin1'),
+      )
+    }
+    teile.push(Buffer.from('%%EOF\n', 'latin1'))
+
+    const text = pdfTextLesen(Buffer.concat(teile))
+
+    // Etwas wird gelesen - aber nicht alle zwoelf Stroeme. Waere der
+    // Gesamtdeckel weg, stuende "Seite" zwoelfmal darin.
+    const treffer = text.split('Seite').length - 1
+    expect(treffer).toBeGreaterThan(0)
+    expect(treffer).toBeLessThan(12)
+  })
+
+  it('kommt mit einem kaputten Strom zurecht, ohne zu werfen', () => {
+    const pdf = pdfMitStrom(Buffer.from('das ist kein zlib-strom', 'latin1'))
+
+    expect(() => pdfTextLesen(pdf)).not.toThrow()
+  })
+
+  it('ignoriert Bilddaten, statt sie auszupacken zu versuchen', () => {
+    const pdf = pdfMitStrom(deflateSync(inhaltsstrom('unsichtbar')), '/DCTDecode')
+
+    expect(pdfTextLesen(pdf)).toBe('')
+  })
+})

tests/skripte.test.ts

@@ -85,3 +85,50 @@ describe.skipIf(!mitGit)('Betriebsskripte', () => {
     }
   })
 })
+
+/**
+ * Abschneidende Leitungen in Skripten mit "pipefail".
+ *
+ * Anlass ist ein Abbruch im Betrieb: Beim Sprung von v1.5.0 auf v1.10.1
+ * endete update.sh mitten in der Ausgabe, ohne jede Meldung. Ursache war
+ *
+ *     git log --oneline "HEAD..$ZIEL" | head -15 | sed ...
+ *
+ * "head" schliesst die Leitung nach 15 Zeilen, "git log" schreibt weiter
+ * und bekommt SIGPIPE (Exitcode 141). Mit "set -o pipefail" gilt die
+ * ganze Kette als gescheitert, "set -e" beendet das Skript - stumm.
+ *
+ * Es ist zeitabhaengig: Solange der Erzeuger fertig wird, bevor "head"
+ * zumacht, faellt nichts auf. Deshalb lief es monatelang gut und riss
+ * genau dann, als zum ersten Mal mehr als 15 Commits dazwischenlagen.
+ *
+ * Dieselbe Falle steckte in der Selbstpruefung der Sicherung, wo sie
+ * eine intakte Sicherung als kaputt gemeldet haette, sobald die
+ * Datenbank gross genug ist.
+ *
+ * Der Test verbietet das Muster deshalb ganz. Wer eine Ausgabe kuerzen
+ * will, nimmt "git log -15", "sed -n '1,15p'" oder einen Zaehler in awk -
+ * alles drei liest bis zum Ende und schliesst nichts zu frueh.
+ */
+describe('Skripte mit pipefail', () => {
+  const skripte = ['scripts/update.sh', 'scripts/sicherung.sh', 'scripts/wiederherstellung.sh']
+
+  it.each(skripte)('%s schneidet keine Leitung mit head ab', (pfad) => {
+    const inhalt = readFileSync(pfad, 'utf8')
+    if (!/set -[a-z]*o pipefail|set -o pipefail/.test(inhalt)) return
+
+    const treffer = inhalt
+      .split('\n')
+      .map((zeile, nummer) => ({ zeile, nummer: nummer + 1 }))
+      // Kommentarzeilen erklaeren das Muster gerade - sie sind erlaubt.
+      .filter(({ zeile }) => !zeile.trim().startsWith('#'))
+      .filter(({ zeile }) => !zeile.includes('printf'))
+      .filter(({ zeile }) => /\|\s*head\b/.test(zeile))
+
+    expect(
+      treffer.map((t) => `Zeile ${t.nummer}: ${t.zeile.trim()}`),
+      'Abschneidende Leitung: der Erzeuger bekommt SIGPIPE, pipefail reicht ' +
+        'es weiter, set -e beendet das Skript stumm.',
+    ).toEqual([])
+  })
+})

tests/speicher-umschlag.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, it } from 'vitest'
+import {
+  entschluesselnBinaer,
+  istVerschluesselt,
+  KOPF_LAENGE,
+  verschluesselnBinaer,
+} from '@/lib/speicher/umschlag'
+
+/**
+ * Der Umschlag um abgelegte Dateien.
+ *
+ * Der Dateitreiber hat ihn von Anfang an benutzt, der Objektspeicher nicht:
+ * Dort stand nur ServerSideEncryption: 'AES256' - Verschluesselung mit dem
+ * Schluessel des Anbieters, der beim Ausliefern selbst entschluesselt.
+ * Gegen eine verlorene Platte im Rechenzentrum hilft das, gegen den
+ * Anbieter und gegen gestohlene Zugangsdaten zum Eimer nicht.
+ *
+ * Seit v1.11.0 liegt derselbe Umschlag um beides. Diese Tests halten die
+ * drei Eigenschaften fest, auf die es dabei ankommt: Er geht wieder auf,
+ * er merkt Veraenderungen, und er bindet den Inhalt an seinen Platz.
+ */
+
+const INHALT = Buffer.from('Bescheid des Sozialamts vom 3. Maerz, Seite 1 von 2.', 'utf8')
+const ORT = 'betreute/abc123/dokumente/eins.pdf'
+
+describe('Umschlag um abgelegte Dateien', () => {
+  it('geht wieder auf', () => {
+    const zu = verschluesselnBinaer(INHALT, ORT)
+
+    expect(entschluesselnBinaer(zu, ORT).equals(INHALT)).toBe(true)
+  })
+
+  it('sieht dem Geheimtext den Klartext nicht an', () => {
+    const zu = verschluesselnBinaer(INHALT, ORT)
+
+    expect(zu.includes(Buffer.from('Sozialamt', 'utf8'))).toBe(false)
+    expect(istVerschluesselt(zu)).toBe(true)
+    expect(zu.length).toBe(KOPF_LAENGE + INHALT.length)
+  })
+
+  it('erzeugt bei gleichem Inhalt zwei verschiedene Geheimtexte', () => {
+    // Sonst liesse sich an zwei gleich aussehenden Objekten ablesen, dass
+    // dasselbe Dokument zweimal in der Akte liegt.
+    const a = verschluesselnBinaer(INHALT, ORT)
+    const b = verschluesselnBinaer(INHALT, ORT)
+
+    expect(a.equals(b)).toBe(false)
+    expect(entschluesselnBinaer(a, ORT).equals(entschluesselnBinaer(b, ORT))).toBe(true)
+  })
+
+  it('merkt, wenn am Geheimtext gedreht wurde', () => {
+    const zu = verschluesselnBinaer(INHALT, ORT)
+    const letzte = zu.length - 1
+    zu.writeUInt8(zu.readUInt8(letzte) ^ 0x01, letzte)
+
+    expect(() => entschluesselnBinaer(zu, ORT)).toThrow()
+  })
+
+  it('merkt, wenn am Kopf gedreht wurde', () => {
+    const zu = verschluesselnBinaer(INHALT, ORT)
+    // Ein Bit im IV.
+    zu.writeUInt8(zu.readUInt8(8) ^ 0x01, 8)
+
+    expect(() => entschluesselnBinaer(zu, ORT)).toThrow()
+  })
+
+  describe('Bindung an den Ablageort', () => {
+    it('laesst sich nicht unter einem anderen Namen auspacken', () => {
+      // Der Angriff dahinter: Wer Schreibrechte auf den Eimer hat, legt die
+      // Bytes von Dokument A unter dem Namen von Dokument B ab. Ohne die
+      // Bindung lieferte die Anwendung anschliessend den falschen Bescheid
+      // aus - und zwar mit gueltiger Pruefsumme fuer den falschen Inhalt.
+      const zu = verschluesselnBinaer(INHALT, ORT)
+
+      expect(() =>
+        entschluesselnBinaer(zu, 'betreute/abc123/dokumente/zwei.pdf'),
+      ).toThrow()
+    })
+
+    it('laesst sich nicht in eine fremde Akte verschieben', () => {
+      const zu = verschluesselnBinaer(INHALT, ORT)
+
+      expect(() => entschluesselnBinaer(zu, 'betreute/xyz789/dokumente/eins.pdf')).toThrow()
+    })
+  })
+
+  describe('Rueckwaertsvertraeglichkeit', () => {
+    it('reicht Inhalte ohne Umschlag unveraendert durch', () => {
+      // Genau der Zustand, in dem die Objekte im Speicher liegen, bis der
+      // Migrationslauf sie umgeschrieben hat. Wuerde hier geworfen, waere
+      // nach dem Update kein einziges altes Dokument mehr abrufbar.
+      const roh = Buffer.from('%PDF-1.4 ganz gewoehnlich', 'utf8')
+
+      expect(istVerschluesselt(roh)).toBe(false)
+      expect(entschluesselnBinaer(roh, ORT).equals(roh)).toBe(true)
+    })
+
+    it('haelt auch etwas fuer unverpackt, das zufaellig kurz ist', () => {
+      const winzig = Buffer.from('abc', 'utf8')
+
+      expect(istVerschluesselt(winzig)).toBe(false)
+      expect(entschluesselnBinaer(winzig, ORT).equals(winzig)).toBe(true)
+    })
+
+    it('oeffnet einen Umschlag, der noch ohne Ortsbindung geschrieben wurde', () => {
+      // So hat der Dateitreiber bis v1.10.2 geschrieben. Diese Dateien
+      // muessen weiter aufgehen, sonst waere die Verbesserung ein
+      // Datenverlust.
+      const alt = verschluesselnBinaer(INHALT)
+
+      expect(entschluesselnBinaer(alt, ORT).equals(INHALT)).toBe(true)
+      expect(entschluesselnBinaer(alt).equals(INHALT)).toBe(true)
+    })
+  })
+
+  it('kommt mit einer leeren Datei zurecht', () => {
+    const leer = Buffer.alloc(0)
+    const zu = verschluesselnBinaer(leer, ORT)
+
+    expect(entschluesselnBinaer(zu, ORT).length).toBe(0)
+  })
+
+  it('kommt mit einer groesseren Datei zurecht', () => {
+    const gross = Buffer.alloc(3 * 1024 * 1024, 0x41)
+    const zu = verschluesselnBinaer(gross, ORT)
+
+    expect(entschluesselnBinaer(zu, ORT).equals(gross)).toBe(true)
+  })
+})

tests/totp-wiederverwendung.test.ts

@@ -0,0 +1,190 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type { User } from '@prisma/client'
+
+/**
+ * Ein TOTP-Code gilt genau einmal.
+ *
+ * Ein Code ist 30 Sekunden gueltig, mit der Toleranz von einem Fenster bis
+ * zu 90. In dieser Zeit liess er sich beliebig oft einloesen: abgelesen
+ * ueber die Schulter, mitgeschrieben von einem Zwischenglied, oder aus einem
+ * Formular im Browserverlauf. Der Kommentar in totp.ts versprach von Anfang
+ * an, der Aufrufer speichere das getroffene Fenster - getan hat es niemand.
+ *
+ * Geprueft wird gegen eine Attrappe der Datenbank, die das WHERE von
+ * updateMany nachbildet. Genau darauf beruht die Einmalverwendung: Die
+ * Bedingung steht in der Abfrage, nicht in einem if davor.
+ */
+
+let benutzer: User
+let updateAufrufe = 0
+
+function passtSchritt(bedingung: Record<string, unknown>, wert: number | null): boolean {
+  if ('OR' in bedingung) {
+    const zweige = bedingung.OR as Record<string, unknown>[]
+    return zweige.some((zweig) => passtSchritt(zweig, wert))
+  }
+  if ('totpLetzterSchritt' in bedingung) {
+    const erwartet = bedingung.totpLetzterSchritt
+    if (erwartet === null) return wert === null
+    if (typeof erwartet === 'object' && erwartet !== null && 'lt' in erwartet) {
+      return wert !== null && wert < (erwartet as { lt: number }).lt
+    }
+  }
+  return true
+}
+
+vi.mock('@/lib/db', () => ({
+  db: {
+    user: {
+      updateMany: async ({
+        where,
+        data,
+      }: {
+        where: Record<string, unknown>
+        data: Partial<User>
+      }) => {
+        updateAufrufe += 1
+
+        if (where.id !== benutzer.id) return { count: 0 }
+
+        // Die Liste der Wiederherstellungscodes muss noch die sein, die der
+        // Aufrufer gesehen hat - sonst war jemand schneller.
+        if ('wiederherstellungscodes' in where) {
+          const erwartet = (where.wiederherstellungscodes as { equals: string[] }).equals
+          const gleich =
+            erwartet.length === benutzer.wiederherstellungscodes.length &&
+            erwartet.every((wert, i) => wert === benutzer.wiederherstellungscodes[i])
+          if (!gleich) return { count: 0 }
+        }
+
+        if (('OR' in where || 'totpLetzterSchritt' in where) && !passtSchritt(where, benutzer.totpLetzterSchritt)) {
+          return { count: 0 }
+        }
+
+        benutzer = { ...benutzer, ...data }
+        return { count: 1 }
+      },
+    },
+  },
+}))
+
+const { zweitenFaktorEinloesen } = await import('@/lib/auth/zweiter-faktor')
+const { totpAktuellerCode, totpSchritt, totpSecretErzeugen, totpSecretVerschluesseln } =
+  await import('@/lib/crypto/totp')
+const { wiederherstellungscodeHashen, wiederherstellungscodesErzeugen } = await import(
+  '@/lib/crypto/hash'
+)
+
+const EMAIL = 'betreuer@example.de'
+const SECRET = totpSecretErzeugen()
+
+function grundstand(): User {
+  return {
+    id: 'benutzer-1',
+    email: EMAIL,
+    totpSecretVerschluesselt: totpSecretVerschluesseln(SECRET),
+    totpAktiviertAm: new Date('2026-01-01T00:00:00Z'),
+    totpLetzterSchritt: null,
+    wiederherstellungscodes: [],
+  } as unknown as User
+}
+
+describe('Zweiten Faktor einloesen', () => {
+  beforeEach(() => {
+    benutzer = grundstand()
+    updateAufrufe = 0
+    vi.useFakeTimers()
+    vi.setSystemTime(new Date('2026-08-24T12:00:15Z'))
+  })
+
+  it('nimmt einen gueltigen Code an und haelt das Fenster fest', async () => {
+    const code = totpAktuellerCode(SECRET, EMAIL)
+
+    const ergebnis = await zweitenFaktorEinloesen(benutzer, code)
+
+    expect(ergebnis).toEqual({ ok: true, art: 'totp' })
+    expect(benutzer.totpLetzterSchritt).toBe(totpSchritt(0))
+  })
+
+  it('lehnt denselben Code beim zweiten Mal ab', async () => {
+    const code = totpAktuellerCode(SECRET, EMAIL)
+
+    expect(await zweitenFaktorEinloesen(benutzer, code)).toEqual({ ok: true, art: 'totp' })
+
+    // Noch im selben Fenster - der Code waere rechnerisch weiter richtig.
+    vi.setSystemTime(new Date('2026-08-24T12:00:25Z'))
+    expect(await zweitenFaktorEinloesen(benutzer, code)).toEqual({
+      ok: false,
+      grund: 'wiederverwendet',
+    })
+  })
+
+  it('lehnt ihn auch im Toleranzfenster danach ab', async () => {
+    const code = totpAktuellerCode(SECRET, EMAIL)
+    await zweitenFaktorEinloesen(benutzer, code)
+
+    // Ein Fenster weiter: Die Toleranz liesse den alten Code noch gelten.
+    vi.setSystemTime(new Date('2026-08-24T12:00:45Z'))
+    expect(await zweitenFaktorEinloesen(benutzer, code)).toEqual({
+      ok: false,
+      grund: 'wiederverwendet',
+    })
+  })
+
+  it('nimmt den naechsten Code an', async () => {
+    await zweitenFaktorEinloesen(benutzer, totpAktuellerCode(SECRET, EMAIL))
+    const vorher = benutzer.totpLetzterSchritt
+
+    vi.setSystemTime(new Date('2026-08-24T12:00:45Z'))
+    const naechster = totpAktuellerCode(SECRET, EMAIL)
+    expect(await zweitenFaktorEinloesen(benutzer, naechster)).toEqual({ ok: true, art: 'totp' })
+    expect(benutzer.totpLetzterSchritt!).toBeGreaterThan(vorher!)
+  })
+
+  it('lehnt einen falschen Code ab, ohne zu schreiben', async () => {
+    expect(await zweitenFaktorEinloesen(benutzer, '000000')).toEqual({
+      ok: false,
+      grund: 'falsch',
+    })
+    expect(updateAufrufe).toBe(0)
+    expect(benutzer.totpLetzterSchritt).toBeNull()
+  })
+
+  it('toleriert Leerzeichen und Bindestriche in der Eingabe', async () => {
+    const code = totpAktuellerCode(SECRET, EMAIL)
+    const zerlegt = `${code.slice(0, 3)} ${code.slice(3)}`
+
+    expect(await zweitenFaktorEinloesen(benutzer, zerlegt)).toEqual({ ok: true, art: 'totp' })
+  })
+
+  it('loest einen Wiederherstellungscode genau einmal ein', async () => {
+    const codes = wiederherstellungscodesErzeugen(3)
+    benutzer = {
+      ...grundstand(),
+      wiederherstellungscodes: await Promise.all(codes.map(wiederherstellungscodeHashen)),
+    } as User
+
+    const erster = codes[0]!
+    expect(await zweitenFaktorEinloesen(benutzer, erster)).toEqual({
+      ok: true,
+      art: 'wiederherstellungscode',
+    })
+    expect(benutzer.wiederherstellungscodes).toHaveLength(2)
+
+    // Derselbe Code noch einmal: Er steht nicht mehr in der Liste.
+    expect(await zweitenFaktorEinloesen(benutzer, erster)).toEqual({
+      ok: false,
+      grund: 'falsch',
+    })
+    expect(benutzer.wiederherstellungscodes).toHaveLength(2)
+  })
+
+  it('haelt die Reihenfolge der Zeitschritte ein', () => {
+    const frueh = totpSchritt(0, Date.parse('2026-08-24T12:00:00Z'))
+    const spaet = totpSchritt(0, Date.parse('2026-08-24T12:00:30Z'))
+
+    expect(spaet).toBe(frueh + 1)
+    // Das Delta verschiebt um ganze Fenster, nicht um Sekunden.
+    expect(totpSchritt(1, Date.parse('2026-08-24T12:00:00Z'))).toBe(spaet)
+  })
+})

tests/wiederkehrend.test.ts

@@ -75,6 +75,17 @@ describe('Schreibweisen vergleichbar machen', () => {
     expect(normalisieren('Debeka AG')).toBe(normalisieren('Debeka'))
   })
 
+  it('kennt die gGmbH', () => {
+    // Heime, Sozialdienste und Träger sind fast durchweg gGmbH — ohne
+    // sie zerfiele die Zusammenfassung genau dort, wo sie zählt.
+    expect(normalisieren('Seniorenzentrum St. Katharina gGmbH')).toBe(
+      normalisieren('Seniorenzentrum St. Katharina'),
+    )
+    expect(normalisieren('SENIORENZENTRUM ST KATHARINA GGMBH')).toBe(
+      normalisieren('Seniorenzentrum St. Katharina'),
+    )
+  })
+
   it('entfernt auch mehrteilige Rechtsformen', () => {
     expect(normalisieren('Stadtwerke Bamberg GmbH & Co KG')).toBe(
       normalisieren('Stadtwerke Bamberg'),