Merge #38: Sicherheitsprüfung abarbeiten (v1.11.0)
This commit was merged in pull request #39.
This commit is contained in:
+29
-2
@@ -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.
|
||||
|
||||
+96
-1
@@ -26,6 +26,100 @@ 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
|
||||
@@ -1171,7 +1265,8 @@ 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.10.2...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
|
||||
|
||||
+17
-4
@@ -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 —
|
||||
und sagt dir beim Start auch, welche.
|
||||
Zehn Zeilen müssen erscheinen. Fehlt eine, startet die Anwendung nicht —
|
||||
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.
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -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.
|
||||
Generated
+1563
-2269
File diff suppressed because it is too large
Load Diff
+18
-14
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betreuungs-cockpit",
|
||||
"version": "1.10.2",
|
||||
"version": "1.11.0",
|
||||
"private": true,
|
||||
"description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
|
||||
"engines": {
|
||||
@@ -18,6 +18,7 @@
|
||||
"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",
|
||||
@@ -37,8 +38,8 @@
|
||||
"seed": "tsx prisma/seed.ts"
|
||||
},
|
||||
"dependencies": {
|
||||
"@aws-sdk/client-s3": "3.735.0",
|
||||
"@aws-sdk/s3-request-presigner": "3.735.0",
|
||||
"@aws-sdk/client-s3": "3.1116.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",
|
||||
@@ -54,9 +55,9 @@
|
||||
"date-fns": "4.1.0",
|
||||
"docx": "9.1.1",
|
||||
"lucide-react": "0.474.0",
|
||||
"next": "15.1.6",
|
||||
"next-auth": "5.0.0-beta.25",
|
||||
"nodemailer": "6.10.0",
|
||||
"next": "15.5.23",
|
||||
"next-auth": "5.0.0-beta.32",
|
||||
"nodemailer": "9.0.5",
|
||||
"otpauth": "9.3.6",
|
||||
"pdf-lib": "1.17.1",
|
||||
"qrcode": "1.5.4",
|
||||
@@ -69,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-config-next": "15.1.6",
|
||||
"postcss": "8.5.1",
|
||||
"eslint": "9.39.1",
|
||||
"eslint-config-next": "15.5.23",
|
||||
"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,
|
||||
@@ -99,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"
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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");
|
||||
@@ -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([])
|
||||
|
||||
@@ -128,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 {
|
||||
|
||||
@@ -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.')
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
})
|
||||
@@ -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)
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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?
|
||||
const benutzer = await aktuellerBenutzer()
|
||||
if (!benutzer) return nurText(401, 'Bitte melde dich an.')
|
||||
// 2. Angemeldet - und mit abgeschlossenem zweitem Faktor.
|
||||
//
|
||||
// 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)
|
||||
|
||||
+19
-33
@@ -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 { totpPruefen, totpSecretEntschluesseln } from '@/lib/crypto/totp'
|
||||
import { hashVeraltet, passwortHashen, passwortPruefen } from '@/lib/crypto/hash'
|
||||
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 weitergeleitet || anfrage.headers.get('x-real-ip') || null
|
||||
return anschlussAus(anfrage.headers)
|
||||
}
|
||||
|
||||
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
|
||||
// zwar herein, das App-Layout schickt ihn aber sofort zur
|
||||
// Einrichtung - er kann nichts anderes tun.
|
||||
// 3. Zweiter Faktor. Ist er noch nicht eingerichtet, kommt der
|
||||
// Benutzer nur bis zur Einrichtungsseite - erzwungen in
|
||||
// erfordereBenutzer(), nicht erst im Layout.
|
||||
if (benutzer.totpSecretVerschluesselt && benutzer.totpAktiviertAm) {
|
||||
const codeOhneTrenner = code.replace(/[\s-]/g, '')
|
||||
let zweiterFaktorOk = false
|
||||
const eingeloest = await zweitenFaktorEinloesen(benutzer, code)
|
||||
|
||||
if (/^\d{6}$/.test(codeOhneTrenner)) {
|
||||
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) {
|
||||
if (!eingeloest.ok) {
|
||||
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)
|
||||
}
|
||||
|
||||
|
||||
@@ -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
|
||||
}
|
||||
+82
-14
@@ -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(
|
||||
email: string,
|
||||
ip: string | null,
|
||||
): Promise<SperrErgebnis> {
|
||||
const seit = fensterStart()
|
||||
export async function anmeldungErlaubt(email: string, ip: string | null): Promise<SperrErgebnis> {
|
||||
const jetzt = Date.now()
|
||||
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) {
|
||||
const juengster = fehlversuche[0]!.zeitpunkt.getTime()
|
||||
const frei = juengster + env.loginSperreSekunden * 1000
|
||||
const nochSekunden = Math.max(1, Math.ceil((frei - Date.now()) / 1000))
|
||||
return { gesperrt: true, nochSekunden }
|
||||
// Von alt nach neu durchgehen und die Runden nachvollziehen: Sobald das
|
||||
// Mass voll ist, beginnt an genau diesem Versuch eine Sperre, und der
|
||||
// Zaehler faengt von vorn an. Ist ihre Frist inzwischen abgelaufen, sind
|
||||
// die Versuche davor abgegolten - sonst bliebe der Zugang bis zum Ende
|
||||
// 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.
|
||||
|
||||
+68
-4
@@ -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
|
||||
* aufgerufen: ohne TOTP kommt niemand an Fachdaten.
|
||||
* Fuer Route Handler: Statt umzuleiten wird abgewiesen.
|
||||
*
|
||||
* 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')
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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' }
|
||||
}
|
||||
+19
-2
@@ -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,
|
||||
|
||||
@@ -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'
|
||||
},
|
||||
|
||||
+50
-5
@@ -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
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+55
-7
@@ -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)
|
||||
if (entpackt) stroeme.push(entpackt.toString('latin1'))
|
||||
const entpackt = flateVersuchen(daten, MAX_GESAMT_BYTES - gesamt)
|
||||
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)
|
||||
if (entpackt) stroeme.push(entpackt.toString('latin1'))
|
||||
const entpackt = flateVersuchen(daten, MAX_GESAMT_BYTES - gesamt)
|
||||
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
|
||||
}
|
||||
|
||||
+17
-54
@@ -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):
|
||||
* "BCD1" | Schluesselversion (uint32 BE) | IV (12) | AuthTag (16) | Geheimtext
|
||||
* Der Umschlag selbst steht in src/lib/speicher/umschlag.ts - der
|
||||
* 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
|
||||
* Symlink-Tricks und Windows-Eigenheiten ab.
|
||||
* streng geprueft, aber diese zweite Sperre kostet nichts.
|
||||
*
|
||||
* 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> {
|
||||
|
||||
+92
-20
@@ -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
|
||||
* Content-Disposition: attachment und einen festen Content-Type, damit der
|
||||
* Objektspeicher eine hochgeladene Datei niemals als HTML im Browser
|
||||
* rendern kann.
|
||||
* ## Anwendungsseitige Verschluesselung
|
||||
*
|
||||
* Frueher stand hier nur ServerSideEncryption: 'AES256'. Das ist
|
||||
* 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,
|
||||
ContentType: mimeTyp,
|
||||
Body: verschluesselnBinaer(inhalt, geprueft),
|
||||
// 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(
|
||||
s3(),
|
||||
new GetObjectCommand({
|
||||
Bucket: eimer(),
|
||||
Key: geprueft,
|
||||
// Die Antwort des Objektspeichers wird hier festgenagelt: Anhang,
|
||||
// niemals HTML, egal was beim Hochladen gemeldet wurde.
|
||||
ResponseContentDisposition: 'attachment',
|
||||
}),
|
||||
{ expiresIn: Math.min(Math.max(Math.floor(sekunden), 1), 60 * 60) },
|
||||
return dateiRoutePfad(zugriffTokenErzeugen(geprueft, sekunden))
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------------
|
||||
// Wartung
|
||||
// -----------------------------------------------------------------------------
|
||||
//
|
||||
// Nur fuer den Migrationslauf, der bestehende Objekte nachtraeglich in den
|
||||
// Umschlag steckt. Bewusst hier und nicht im Skript: Der Zugang zum Eimer
|
||||
// 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())
|
||||
}
|
||||
|
||||
@@ -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.')
|
||||
}
|
||||
+1
-1
@@ -17,7 +17,7 @@
|
||||
*/
|
||||
|
||||
/** Muss zur "version" in der package.json passen. */
|
||||
export const VERSION = '1.10.2'
|
||||
export const VERSION = '1.11.0'
|
||||
|
||||
/**
|
||||
* Kurzer Git-Stand, beim Bauen hineingereicht:
|
||||
|
||||
+16
-3
@@ -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')
|
||||
}
|
||||
|
||||
|
||||
@@ -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 kopf.get('x-forwarded-for')?.split(',')[0]?.trim() || kopf.get('x-real-ip') || null
|
||||
return anschlussAus(await headers())
|
||||
} catch {
|
||||
return null
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
const secret = totpSecretEntschluesseln(frisch.totpSecretVerschluesselt)
|
||||
codeStimmt = totpPruefen(secret, frisch.email, gelesen.data.code).gueltig
|
||||
if (passwortStimmt && frisch.totpSecretVerschluesselt && frisch.totpAktiviertAm) {
|
||||
const eingeloest = await zweitenFaktorEinloesen(frisch, gelesen.data.code)
|
||||
codeStimmt = eingeloest.ok
|
||||
}
|
||||
|
||||
if (!passwortStimmt || !codeStimmt) {
|
||||
|
||||
@@ -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
|
||||
* gibt. Danach sperrt sie sich selbst - sonst koennte sich jemand von
|
||||
* aussen einen Administratorzugang anlegen.
|
||||
* Diese Aktion ist die einzige Stelle der Anwendung, an der jemand ohne
|
||||
* Anmeldung etwas schreiben darf. Entsprechend eng ist sie gebaut - zwei
|
||||
* 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()
|
||||
if (vorhandene > 0) {
|
||||
const begonnen = Date.now()
|
||||
|
||||
// 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,9 +131,26 @@ 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)) {
|
||||
// Dieselbe Mindestdauer wie am Anmeldeformular: Sonst verraet die
|
||||
// Antwortzeit, ob das Geheimnis stimmte und erst das Anlegen scheiterte.
|
||||
await aufMindestdauerWarten(begonnen)
|
||||
return {
|
||||
fehler: 'Das Einrichtungsgeheimnis stimmt nicht.',
|
||||
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,
|
||||
@@ -85,13 +159,22 @@ export async function erstenZugangAnlegen(
|
||||
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,
|
||||
})
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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({
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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')
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -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')
|
||||
})
|
||||
})
|
||||
@@ -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('')
|
||||
})
|
||||
})
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user