Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 Florian Wilde
|
c38c988c3c | ||
|
Florian Wilde
|
9603917a86 | ||
|
Florian Wilde
|
42eb242767 | ||
|
Florian Wilde
|
7780739a1a | ||
|
Florian Wilde
|
9365645f72 | ||
|
Florian Wilde
|
232543e2aa | ||
|
Florian Wilde
|
5ee3275112 | ||
|
Florian Wilde
|
9df6419a68 | ||
|
Florian Wilde
|
7633603a2a | ||
|
Florian Wilde
|
c35fc16133 | ||
|
Florian Wilde
|
89bc5fe5a8 | ||
|
Florian Wilde
|
0e7da42f27 |
+33
-1
@@ -16,9 +16,41 @@ DATABASE_URL="postgresql://cockpit:bitte-aendern@localhost:5432/betreuungs_cockp
|
||||
AUTH_SECRET=
|
||||
# Oeffentliche Basis-URL der Anwendung (ohne abschliessenden Slash).
|
||||
AUTH_URL=http://localhost:3000
|
||||
# Hinter einem Reverse Proxy (Caddy) auf true setzen.
|
||||
# Hinter einem Reverse Proxy auf true setzen.
|
||||
AUTH_TRUST_HOST=true
|
||||
|
||||
# --- Erreichbarkeit: HIER MUSST DU DICH ENTSCHEIDEN -------------------------
|
||||
#
|
||||
# Auf welcher Adresse soll die Anwendung erreichbar sein? Das haengt davon
|
||||
# ab, WO dein Reverse Proxy laeuft. Waehl genau eine Zeile aus:
|
||||
#
|
||||
# Proxy auf DEMSELBEN Server
|
||||
# APP_BIND=127.0.0.1
|
||||
# Von aussen kommt niemand heran, nur der Proxy nebenan. Sicherste
|
||||
# Variante - aber ein Proxy auf einem anderen Rechner erreicht die
|
||||
# Anwendung damit NICHT.
|
||||
#
|
||||
# Proxy auf einem ANDEREN Server, privates Netz oder WireGuard vorhanden
|
||||
# APP_BIND=10.0.0.5 <- die Adresse DIESES Servers in dem Netz
|
||||
# Erste Wahl, wenn der Proxy woanders steht.
|
||||
#
|
||||
# Proxy auf einem ANDEREN Server, kein privates Netz
|
||||
# APP_BIND=0.0.0.0
|
||||
# Nur zusammen mit einer Firewallregel, die den Port ausschliesslich
|
||||
# fuer die IP des Proxy-Servers oeffnet:
|
||||
# ufw allow from <IP-des-Proxys> to any port 3000 proto tcp
|
||||
# ufw deny 3000/tcp
|
||||
#
|
||||
# Zwischen Proxy und Anwendung laeuft unverschluesseltes HTTP - die
|
||||
# Anwendung beendet kein TLS. Dieser Weg darf nie durchs offene Netz gehen.
|
||||
# Einzelheiten: docs/INSTALLATION.md, Schritt 7.
|
||||
APP_BIND=127.0.0.1
|
||||
APP_PORT=3000
|
||||
|
||||
# Die Konsole des mitgelieferten Objektspeichers. Nur noetig, wenn auf dem
|
||||
# Server schon etwas auf 9001 laeuft.
|
||||
MINIO_KONSOLE_PORT=9001
|
||||
|
||||
# --- Anwendungsseitige Feldverschluesselung ---------------------------------
|
||||
# AES-256-GCM. 32 Bytes, base64. OHNE DIESEN SCHLUESSEL SIND DIE VERSCHLUESSELTEN
|
||||
# FELDER UNWIEDERBRINGLICH VERLOREN - unbedingt getrennt vom Backup sichern!
|
||||
|
||||
+285
-1
@@ -26,6 +26,284 @@ Wiederherstellung*.
|
||||
|
||||
_Noch nichts._
|
||||
|
||||
## [1.1.0] – 2026-08-22
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **Anmelden mit Passkey.** Auf der Anmeldeseite steht jetzt unter dem
|
||||
Formular ein zweiter Weg: *Mit Passkey anmelden*. Ein Fingerabdruck, ein
|
||||
Blick in die Kamera oder die Geräte-PIN — keine E-Mail, kein Passwort,
|
||||
kein abgetippter Code.
|
||||
|
||||
**Der Passkey ersetzt den zweiten Faktor, er kommt nicht zusätzlich.**
|
||||
Das ist kein Nachlassen: Ein Passkey verlangt den Besitz des Geräts
|
||||
*und* dessen Entsperrung, das sind dieselben zwei Faktoren wie vorher.
|
||||
Die Anwendung fordert die Nutzerverifikation ausdrücklich an und weist
|
||||
eine Antwort ohne sie zurück. Ein Gerät, das auf blosses Antippen hin
|
||||
signiert, kommt nicht herein.
|
||||
|
||||
In einem Punkt ist er dem bisherigen Weg sogar überlegen: Ein Passkey
|
||||
ist an die Adresse gebunden, unter der er eingerichtet wurde. Auf einer
|
||||
nachgebauten Anmeldeseite funktioniert er nicht — und Phishing ist der
|
||||
übliche Weg, an einen TOTP-Code zu kommen.
|
||||
|
||||
**Die Authenticator-App muss trotzdem eingerichtet sein**, bevor sich
|
||||
ein Passkey anlegen lässt. Ein Passkey hängt an einem Gerät. Ginge das
|
||||
verloren und wäre er der einzige Weg hinein, käme niemand mehr an die
|
||||
Akte — und darin stehen Unterlagen, die eine betreute Person braucht.
|
||||
Der Passkey ist die bequeme Tür, nicht die einzige.
|
||||
|
||||
Verwaltet werden sie unter **Mein Konto → Passkeys**: einrichten,
|
||||
benennen, entfernen. Die Liste zeigt, wann ein Gerät zuletzt benutzt
|
||||
wurde und ob der Schlüssel gesichert ist (iCloud, Google, Bitwarden)
|
||||
oder nur auf diesem einen Gerät liegt. Einrichten und Entfernen stehen
|
||||
im Protokoll, jede Anmeldung nennt den verwendeten Passkey namentlich.
|
||||
|
||||
- **Bestätigen mit Passkey.** Export, endgültiges Löschen und die
|
||||
Benutzerverwaltung verlangen eine frische Anmeldung. Auch die geht jetzt
|
||||
mit dem Passkey. Geprüft wird zusätzlich, dass er zum angemeldeten
|
||||
Zugang gehört — sonst liesse sich mit dem eigenen Finger eine fremde,
|
||||
offen stehende Sitzung freischalten. Genau der Fall, gegen den diese
|
||||
Zwischenfrage gebaut ist.
|
||||
|
||||
### Zu beachten
|
||||
|
||||
- **Passkeys brauchen `https`.** Der Browser gibt das Verfahren nur in
|
||||
einem sicheren Kontext frei. Läuft die Anwendung ohne TLS, erscheint der
|
||||
Knopf gar nicht erst, statt beim Klick mit einer kryptischen Meldung
|
||||
abzubrechen.
|
||||
|
||||
- **`AUTH_URL` muss stimmen — jetzt noch mehr als vorher.** Aus ihr wird
|
||||
die Kennung abgeleitet, an die der Authenticator den Schlüssel bindet.
|
||||
Steht dort eine andere Adresse als die im Browser, lässt sich zwar ein
|
||||
Passkey einrichten, aber nie wieder verwenden.
|
||||
|
||||
**Ein Wechsel der Domain macht alle Passkeys unbrauchbar.** Das ist
|
||||
keine Panne, sondern der Phishingschutz. Nach einem Umzug richtet man
|
||||
sie neu ein; die Anmeldung mit Passwort und Code bleibt währenddessen
|
||||
offen.
|
||||
|
||||
- **Eine Datenbank-Migration ist nötig** (`20260822160000_passkey_anmeldung`).
|
||||
Sie läuft beim Start des Behälters automatisch mit. Bestehende Zugänge
|
||||
sind nicht betroffen: Ohne eingerichteten Passkey ändert sich nichts.
|
||||
|
||||
### Geprüft
|
||||
|
||||
- 21 neue Prüfungen (`tests/passkey.test.ts`), vor allem für die Herleitung
|
||||
von Kennung und Herkunft aus `AUTH_URL`: Port, Schrägstrich am Ende,
|
||||
Unterdomain, `http` gegen `https`, `localhost`. Das ist die Stelle, an
|
||||
der eine Installation still kaputtginge — dieselbe Fehlerklasse wie
|
||||
seinerzeit bei `APP_BIND` und `ENC_KEY_V2`.
|
||||
- Drei End-to-End-Tests gegen einen echten Browser (`e2e/passkey.spec.ts`),
|
||||
mit Chromiums virtuellem Authenticator: einrichten, abmelden, mit Passkey
|
||||
anmelden, Benutzung vermerkt, entfernen. Dazu die Bestätigung vor dem
|
||||
Vollexport und der Fall, dass ein Gerät ohne Nutzerverifikation nicht
|
||||
hereinkommt.
|
||||
|
||||
## [1.0.5] – 2026-08-22
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **`scripts/update.sh`** — aktualisiert die Anwendung mit einem Befehl.
|
||||
|
||||
```bash
|
||||
./scripts/update.sh # auf die neueste Fassung
|
||||
./scripts/update.sh --pruefen # nur nachsehen, nichts ändern
|
||||
./scripts/update.sh v1.2.0 # auf eine bestimmte Fassung
|
||||
```
|
||||
|
||||
Es nimmt die Schritte ab, die man von Hand vergisst: Sicherung
|
||||
anstoßen und bei Misserfolg **abbrechen**, den Changelog zwischen altem
|
||||
und neuem Stand anzeigen, umschalten, neu bauen, warten bis die
|
||||
Anwendung antwortet, **die beiden SQL-Skripte ausführen** und zum
|
||||
Schluss prüfen, ob wirklich die neue Fassung läuft.
|
||||
|
||||
Zwei Eigenschaften, die dabei zählen:
|
||||
|
||||
**Bis zur Rückfrage wird nichts verändert.** Bricht etwas vorher ab —
|
||||
Server nicht erreichbar, falsche Versionsangabe — findest du alles so
|
||||
vor wie zuvor. Kein Halbzustand.
|
||||
|
||||
**Eigene Änderungen an versionierten Dateien blockieren nicht.** Im
|
||||
Betrieb passt man die `docker-compose.yml` an, bis etwas läuft; genau
|
||||
diese Anpassungen sind später oft schon eingearbeitet. Das Skript legt
|
||||
sie vor dem Umschalten mit `git stash` beiseite und sagt, wie man sie
|
||||
zurückholt. Mit `--verwerfen` werden sie stattdessen weggeworfen. Die
|
||||
`.env` bleibt immer unangetastet — sie ist nicht versioniert.
|
||||
|
||||
Schlägt der Bau fehl, nennt das Skript den Weg zurück auf den
|
||||
vorherigen Stand.
|
||||
|
||||
### Behoben
|
||||
|
||||
- **Der Port der MinIO-Konsole ließ sich nicht ändern.** Er stand fest auf
|
||||
`9001`; lief dort schon etwas, startete der ganze Stapel nicht
|
||||
(`port is already allocated`). Jetzt über `MINIO_KONSOLE_PORT` in der
|
||||
`.env` einstellbar — dieselbe Möglichkeit, die `APP_PORT` schon hatte.
|
||||
|
||||
## [1.0.4] – 2026-08-22
|
||||
|
||||
### Behoben
|
||||
|
||||
- **Die Ersteinrichtung ließ sich nicht abschließen.** Schritt 3 meldete
|
||||
„Bitte prüfe die markierten Felder" — markierte aber keines. Man kam an
|
||||
dieser Stelle nicht weiter.
|
||||
|
||||
Ursache: Das kurze Formular der Ersteinrichtung schickt neun Felder, das
|
||||
vollständige unter *Stammdaten* alle. Beide gehen durch dasselbe Schema,
|
||||
und die optionalen Felder waren zwar `nullable`, aber nicht `optional` —
|
||||
ein Feld, das gar nicht abgeschickt wurde, ist `undefined`, nicht
|
||||
`null`. Beanstandet wurden also zwei Dutzend Felder, die auf dem
|
||||
Bildschirm nie standen.
|
||||
|
||||
- **Eine Meldung ohne zugehöriges Feld kann nicht mehr unsichtbar
|
||||
bleiben.** Beanstandet die Prüfung ein Feld, das das Formular gar nicht
|
||||
gesendet hat, sagt die Anwendung das jetzt ausdrücklich und schreibt es
|
||||
ins Serverlog — statt es als Eingabefehler auszugeben, den niemand
|
||||
finden kann. Das ist ein Fehler im Programm, und er soll auch so
|
||||
aussehen.
|
||||
|
||||
- **Eine betreute Person ließ sich nicht endgültig löschen.** Beim Löschen
|
||||
setzt Postgres den Verweis im Audit-Log auf NULL (`ON DELETE SET NULL`),
|
||||
und genau dieses UPDATE hat der Unveränderlichkeits-Trigger abgewiesen.
|
||||
Betroffen war damit auch das Leeren des Papierkorbs nach 30 Tagen und
|
||||
das Entfernen des Demofalls.
|
||||
|
||||
Der Trigger erlaubt jetzt genau eine Ausnahme: das Nullen der beiden
|
||||
Fremdschlüssel `betreuteId` und `userId`. Jede andere Änderung bleibt
|
||||
verboten, auch das Setzen eines Fremdschlüssels auf einen **anderen**
|
||||
Wert. Der Nachweis bleibt vollständig — Zeitpunkt, Aktion, Bezeichnung,
|
||||
die verschlüsselte Änderung und die Momentaufnahmen von Name und
|
||||
E-Mail sind unberührt. Es verschwindet nur der Verweis auf einen
|
||||
Datensatz, den es nicht mehr gibt.
|
||||
|
||||
**Beim Update nötig:** das SQL-Skript erneut ausführen, sonst bleibt der
|
||||
alte Trigger stehen.
|
||||
|
||||
```bash
|
||||
docker compose exec app node node_modules/prisma/build/index.js db execute --schema prisma/schema.prisma --file prisma/sql/audit-schutz.sql
|
||||
```
|
||||
|
||||
### Geprüft
|
||||
|
||||
- Sieben neue Tests (`tests/stammdaten.test.ts`) prüfen genau die
|
||||
Formularinhalte der Ersteinrichtung, dazu das vollständige Formular mit
|
||||
leeren Feldern und die weiterhin verlangten Pflichtangaben.
|
||||
- Der Ablauf ist zusätzlich im Browser durchgespielt worden: Anmeldung,
|
||||
zweiter Faktor, Schritt 3, Landung auf dem Dashboard — und die daraus
|
||||
abgeleiteten Pflichtfristen samt Ausschlussfrist für die
|
||||
Aufwandspauschale.
|
||||
- Der geänderte Trigger ist gegen eine laufende Datenbank geprüft:
|
||||
Löschen gelingt, Fälschen und Löschen von Einträgen scheitert weiterhin.
|
||||
|
||||
## [1.0.3] – 2026-08-22
|
||||
|
||||
Keine Änderung am Programm — nur an der Konfigurationsvorlage und der
|
||||
Anleitung. Ein Neubau des Abbilds ist nicht nötig.
|
||||
|
||||
### Behoben
|
||||
|
||||
- **`.env.example` band die Anwendung stillschweigend an `127.0.0.1`.**
|
||||
Der Wert stand dort als fertig ausgefüllte Zeile zwischen lauter anderen
|
||||
fertigen Zeilen. Wer die Datei kopiert hat und seinen Reverse Proxy auf
|
||||
einem **anderen** Server betreibt, kam nicht an die Anwendung heran —
|
||||
und der Fehler sah aus, als läge es am Proxy.
|
||||
|
||||
Jetzt steht dort eine Entscheidung mit drei benannten Fällen statt eines
|
||||
Vorgabewerts. Der sichere Standard bleibt `127.0.0.1`; er wird nur nicht
|
||||
mehr als „schon erledigt" präsentiert.
|
||||
|
||||
Für bestehende Installationen genügt eine Zeile in der `.env`:
|
||||
|
||||
```bash
|
||||
APP_BIND=10.0.0.5 # Adresse, über die der Proxy diesen Server erreicht
|
||||
docker compose up -d
|
||||
```
|
||||
|
||||
### Geändert
|
||||
|
||||
- **`docs/INSTALLATION.md`** nennt `APP_BIND` jetzt schon in Schritt 3, wo
|
||||
die `.env` ausgefüllt wird — nicht erst in Schritt 7, wo der Proxy
|
||||
drankommt. Dazu ein eigener Abschnitt in der Fehlersuche: „Der Proxy
|
||||
erreicht die Anwendung nicht", mit den zwei `curl`-Proben, die den
|
||||
Unterschied zwischen falscher Bindeadresse und Firewall zeigen.
|
||||
|
||||
## [1.0.2] – 2026-08-22
|
||||
|
||||
### Behoben
|
||||
|
||||
- **Die Einrichtung des zweiten Faktors brach mit einem Serverfehler ab**
|
||||
(„Application error: a server-side exception has occurred"). Im
|
||||
Serverlog stand `Umgebungsvariable ENC_KEY_V2 fehlt` — obwohl niemand
|
||||
einen zweiten Schlüssel wollte.
|
||||
|
||||
Ursache: `docker-compose.yml` reicht `ENC_KEY_V2` immer an den Behälter
|
||||
durch, mit **leerem Wert**, wenn in der `.env` keiner steht. Die
|
||||
Anwendung erkannte Schlüssel aber am Variablennamen statt am Inhalt,
|
||||
fand also ein leeres `ENC_KEY_V2` und brach ab. Leere
|
||||
Schlüsselvariablen werden jetzt übersprungen.
|
||||
|
||||
Betroffen war jede Stelle, die verschlüsselte Felder schreibt oder
|
||||
liest — also praktisch alles außer der reinen Anmeldung. Die Anmeldung
|
||||
ging durch, weil sie ohne Verschlüsselung auskommt; der Fehler trat
|
||||
deshalb erst auf der nächsten Seite auf.
|
||||
|
||||
- **Die Meldung beim Schlüsselwechsel** nennt jetzt, welche Versionen
|
||||
tatsächlich vorhanden sind, und die richtige Reihenfolge: erst den
|
||||
neuen Schlüssel eintragen, dann `ENC_KEY_AKTIV` umstellen.
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **`scripts/anmeldung-pruefen.mjs`** — beantwortet die Frage, warum eine
|
||||
Anmeldung nicht klappt. Das Formular sagt bewusst nicht, woran es lag,
|
||||
sonst ließe sich daran ablesen, welche Adressen es gibt. Auf dem Server
|
||||
darf man es wissen: Jeder Versuch wird mit Grund protokolliert, und das
|
||||
Skript liest ihn vor — dazu den Zustand des Zugangs, den Stand der
|
||||
Login-Sperre und die eingestellte `AUTH_URL`.
|
||||
|
||||
```bash
|
||||
docker compose exec app node scripts/anmeldung-pruefen.mjs deine@adresse.de
|
||||
```
|
||||
|
||||
Es ändert nichts, es liest nur.
|
||||
|
||||
### Geprüft
|
||||
|
||||
- Sieben neue Tests (`tests/umgebung.test.ts`) decken die
|
||||
Schlüsselauswertung ab, darunter genau die Konstellation aus dem
|
||||
Fehlerbericht: gesetztes `ENC_KEY_V1`, leeres `ENC_KEY_V2`.
|
||||
|
||||
## [1.0.1] – 2026-08-22
|
||||
|
||||
### Behoben
|
||||
|
||||
- **Betriebsskripte fehlten im Docker-Abbild.** Das Verzeichnis `scripts/`
|
||||
wurde beim Bauen nie in die Laufzeitstufe übernommen. `docker compose
|
||||
exec app node scripts/totp-geheimnis.mjs …` endete deshalb mit
|
||||
`Cannot find module`. Betroffen waren alle Skripte, die im laufenden
|
||||
Behälter gedacht sind — auch `wartungsschluessel.mjs` und
|
||||
`schluessel-erzeugen.mjs`.
|
||||
|
||||
Nach dem Update funktioniert der Befehl wie dokumentiert. Wer nicht
|
||||
gleich aktualisieren will, kommt einmalig auch so an das Skript:
|
||||
|
||||
```bash
|
||||
docker compose cp scripts/totp-geheimnis.mjs app:/app/totp-geheimnis.mjs
|
||||
docker compose exec app node totp-geheimnis.mjs deine@adresse.de
|
||||
```
|
||||
|
||||
### Hinzugefügt
|
||||
|
||||
- **`scripts/totp-geheimnis.mjs`** — liest das TOTP-Geheimnis eines Zugangs
|
||||
aus, um denselben Zugang auf einem zweiten Gerät einzurichten (Handy und
|
||||
Tablet, oder ein Ersatzgerät). Die Anwendung zeigt das Geheimnis sonst
|
||||
nur einmal an, beim Einrichten; bisher blieb nur, den zweiten Faktor
|
||||
zurückzusetzen und alle Wiederherstellungscodes neu zu erzeugen.
|
||||
|
||||
Das Skript läuft nur auf dem Server und nur mit Zugriff auf die Datenbank
|
||||
**und** auf `ENC_KEY_V1`. Wer beides hat, kann ohnehin alles lesen — es
|
||||
ist also keine Hintertür, sondern erspart eine unnötige Neueinrichtung.
|
||||
|
||||
## [1.0.0] – 2026-08-22
|
||||
|
||||
Erste vollständige Fassung. Alle acht Etappen umgesetzt, alle
|
||||
@@ -188,5 +466,11 @@ Was davon wann angegangen wird, steht in [`docs/ROADMAP.md`](docs/ROADMAP.md).
|
||||
|
||||
---
|
||||
|
||||
[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.0...HEAD
|
||||
[Unveröffentlicht]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.1.0...HEAD
|
||||
[1.1.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.5...v1.1.0
|
||||
[1.0.5]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.4...v1.0.5
|
||||
[1.0.4]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.3...v1.0.4
|
||||
[1.0.3]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.2...v1.0.3
|
||||
[1.0.2]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.1...v1.0.2
|
||||
[1.0.1]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/compare/v1.0.0...v1.0.1
|
||||
[1.0.0]: https://git.wilde-server.de/florian.wilde/betreuungs-cockpit/releases/tag/v1.0.0
|
||||
|
||||
+11
@@ -95,6 +95,17 @@ COPY --from=bau --chown=cockpit:cockpit /app/node_modules/.prisma ./node_modules
|
||||
COPY --from=bau --chown=cockpit:cockpit /app/node_modules/@prisma ./node_modules/@prisma
|
||||
COPY --from=bau --chown=cockpit:cockpit /app/node_modules/prisma ./node_modules/prisma
|
||||
|
||||
# Betriebsskripte, die im laufenden Behaelter gebraucht werden:
|
||||
# totp-geheimnis.mjs zweites Geraet fuer den Zweitfaktor einrichten
|
||||
# wartungsschluessel.mjs Schluessel fuer /api/wartung ausrechnen
|
||||
# schluessel-erzeugen.mjs neue Schluessel fuer die Rotation
|
||||
#
|
||||
# Das ganze Verzeichnis, nicht einzelne Dateien: sonst faellt beim
|
||||
# naechsten Betriebsskript wieder auf, dass es fehlt - und zwar erst dann,
|
||||
# wenn man es braucht. Die Entwicklungsskripte darin laufen hier mangels
|
||||
# Werkzeugen nicht, kosten aber auch nur ein paar Kilobyte.
|
||||
COPY --from=bau --chown=cockpit:cockpit /app/scripts ./scripts
|
||||
|
||||
# Ablage fuer den Dateitreiber, falls kein Objektspeicher benutzt wird.
|
||||
RUN mkdir -p /app/daten/dokumente && chown -R cockpit:cockpit /app/daten
|
||||
|
||||
|
||||
@@ -15,6 +15,7 @@ eines Angehörigen: Fristen, Vorgänge, Belege, Vermögen, Sozialhilfe, Berichte
|
||||
## Inhalt
|
||||
|
||||
- [Was die Anwendung kann](#was-die-anwendung-kann)
|
||||
- [Die drei Dokumente, die du wirklich brauchst](#die-drei-dokumente-die-du-wirklich-brauchst)
|
||||
- [Schnellstart zum Ausprobieren](#schnellstart-zum-ausprobieren)
|
||||
- [Produktivbetrieb mit Docker Compose](#produktivbetrieb-mit-docker-compose)
|
||||
- [Reverse Proxy](#reverse-proxy)
|
||||
@@ -46,6 +47,23 @@ eines Angehörigen: Fristen, Vorgänge, Belege, Vermögen, Sozialhilfe, Berichte
|
||||
|
||||
---
|
||||
|
||||
## Die drei Dokumente, die du wirklich brauchst
|
||||
|
||||
| Wofür | Wo |
|
||||
|---|---|
|
||||
| **Die Anwendung aufsetzen** — auf einem Server, der Docker und einen Proxy schon hat, mit Kontrolle nach jedem Schritt | [`docs/INSTALLATION.md`](docs/INSTALLATION.md) |
|
||||
| **Täglich damit arbeiten** — die zwölf Handgriffe, der Jahresrhythmus, was tun wenn etwas schiefgeht | [`docs/ANLEITUNG.md`](docs/ANLEITUNG.md), in der Anwendung unter `/anleitung` |
|
||||
| **Wissen, was sich ändert** — was neu ist, was du vor einem Update beachten musst | [`CHANGELOG.md`](CHANGELOG.md) |
|
||||
|
||||
Dazu: [`docs/ROADMAP.md`](docs/ROADMAP.md) für das, was als Nächstes
|
||||
kommt, und [`docs/BAUPROTOKOLL.md`](docs/BAUPROTOKOLL.md) für die Frage,
|
||||
wie das hier entstanden ist.
|
||||
|
||||
Der Rest dieser Datei ist die Kurzfassung für alle, die schon wissen, was
|
||||
sie tun.
|
||||
|
||||
---
|
||||
|
||||
## Schnellstart zum Ausprobieren
|
||||
|
||||
Voraussetzungen: **Node.js ≥ 20.11**, **Docker** und **Git**.
|
||||
@@ -113,6 +131,10 @@ laufender Antrag beim Bezirk Oberfranken mit acht Nachforderungen.
|
||||
|
||||
## Produktivbetrieb mit Docker Compose
|
||||
|
||||
> **Zum ersten Mal?** Nimm die [Schritt-für-Schritt-Anleitung](docs/INSTALLATION.md).
|
||||
> Sie fängt beim leeren Server an, hat nach jedem Abschnitt eine Kontrolle
|
||||
> und endet mit einer Abnahmeliste. Was hier steht, ist die Kurzfassung.
|
||||
|
||||
Das Compose-Setup bringt drei Dienste mit: die Anwendung, PostgreSQL und
|
||||
MinIO als S3-kompatiblen Objektspeicher, dazu einen Sicherungsdienst.
|
||||
|
||||
@@ -155,72 +177,62 @@ existiert.
|
||||
### Aktualisieren
|
||||
|
||||
```bash
|
||||
git pull
|
||||
docker compose up -d --build
|
||||
./scripts/update.sh
|
||||
```
|
||||
|
||||
Die Migrationen laufen beim Start des Anwendungsbehälters mit. **Vorher ein
|
||||
Backup anstoßen** (siehe unten) — eine Migration lässt sich nicht zurückrollen.
|
||||
Das Skript sichert zuerst, zeigt den Changelog zwischen altem und neuem
|
||||
Stand, fragt nach, schaltet um, baut neu und führt danach die beiden
|
||||
SQL-Skripte aus. Schlägt die Sicherung fehl, wird nicht aktualisiert.
|
||||
|
||||
`--pruefen` sieht nur nach, ohne etwas zu ändern. Eigene Änderungen an
|
||||
versionierten Dateien werden vor dem Umschalten beiseite gelegt
|
||||
(`git stash`), die `.env` bleibt unangetastet.
|
||||
|
||||
Einzelheiten und der Weg von Hand: [`docs/INSTALLATION.md`](docs/INSTALLATION.md).
|
||||
|
||||
---
|
||||
|
||||
## Reverse Proxy
|
||||
|
||||
Die Anwendung erwartet, dass der Proxy TLS beendet und die echte Client-IP
|
||||
weiterreicht. Sie liest `X-Forwarded-For` bzw. `X-Real-IP` für das
|
||||
Rate-Limiting am Login und für das Audit-Log (dort nur als Hash).
|
||||
Die Anwendung **beendet selbst kein TLS** und bringt keinen Proxy mit. Sie
|
||||
horcht standardmäßig auf `127.0.0.1:3000`.
|
||||
|
||||
**Caddy**
|
||||
**Läuft der Proxy auf demselben Server**, ist damit alles gesagt: Er zeigt
|
||||
auf `127.0.0.1:3000`, fertig.
|
||||
|
||||
```caddyfile
|
||||
cockpit.example.de {
|
||||
encode zstd gzip
|
||||
reverse_proxy 127.0.0.1:3000
|
||||
**Läuft er auf einem anderen Server**, setz in der `.env` die Adresse, über
|
||||
die er herankommt — am besten die eines privaten Netzes oder eines
|
||||
WireGuard-Tunnels:
|
||||
|
||||
# Uploads: Fotos von Behördenschreiben können groß sein.
|
||||
request_body {
|
||||
max_size 30MB
|
||||
}
|
||||
}
|
||||
```bash
|
||||
APP_BIND=10.0.0.5
|
||||
APP_PORT=3000
|
||||
```
|
||||
|
||||
**nginx**
|
||||
`0.0.0.0` nur, wenn eine Firewall den Port ausschließlich für die IP des
|
||||
Proxy-Servers öffnet. Zwischen Proxy und Anwendung läuft unverschlüsseltes
|
||||
HTTP — dieser Weg darf nie durchs offene Netz gehen.
|
||||
|
||||
```nginx
|
||||
server {
|
||||
listen 443 ssl http2;
|
||||
server_name cockpit.example.de;
|
||||
### Was der Proxy leisten muss
|
||||
|
||||
ssl_certificate /etc/letsencrypt/live/cockpit.example.de/fullchain.pem;
|
||||
ssl_certificate_key /etc/letsencrypt/live/cockpit.example.de/privkey.pem;
|
||||
| Anforderung | Was ohne sie passiert |
|
||||
|---|---|
|
||||
| TLS beenden | Der Browser lehnt Cookies mit `Secure`-Kennzeichen ab, die Anmeldung schlägt stumm fehl |
|
||||
| `Host` durchreichen | Auth.js vergleicht ihn mit `AUTH_URL` und weist die Anmeldung ab |
|
||||
| `X-Forwarded-Proto: https` | Die Anwendung baut Adressen mit `http` |
|
||||
| `X-Forwarded-For` | Die Login-Sperre zählt alle Zugriffe als denselben Anschluss |
|
||||
| Uploads ≥ 30 MB | Fotos mehrseitiger Bescheide werden abgeschnitten |
|
||||
| Zeitgrenze ≥ 10 Minuten | Belegmappe, Rechnungslegung und Vollexport brechen ab |
|
||||
| Antwort nicht puffern | Der Vollexport kommt als Strom |
|
||||
|
||||
client_max_body_size 30M;
|
||||
**Keine eigenen Sicherheitskopfzeilen setzen.** CSP, `X-Frame-Options`,
|
||||
`nosniff` und HSTS kommen aus der Anwendung. Die CSP enthält eine Nonce,
|
||||
die pro Anfrage neu ist — eine feste CSP aus dem Proxy blockiert die
|
||||
eigenen Skripte.
|
||||
|
||||
location / {
|
||||
proxy_pass http://127.0.0.1:3000;
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Forwarded-Proto $scheme;
|
||||
proxy_set_header Upgrade $http_upgrade;
|
||||
proxy_set_header Connection "upgrade";
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
**Traefik** (Labels am `app`-Dienst)
|
||||
|
||||
```yaml
|
||||
labels:
|
||||
- traefik.enable=true
|
||||
- traefik.http.routers.cockpit.rule=Host(`cockpit.example.de`)
|
||||
- traefik.http.routers.cockpit.tls.certresolver=letsencrypt
|
||||
- traefik.http.services.cockpit.loadbalancer.server.port=3000
|
||||
```
|
||||
|
||||
In allen Fällen muss `AUTH_URL` in der `.env` auf die öffentliche Adresse
|
||||
zeigen (`https://cockpit.example.de`), sonst schlägt die Anmeldung fehl.
|
||||
**Fertige Konfigurationen** für Caddy, nginx und Traefik, mit Zeitgrenzen
|
||||
und den Gegenproben, stehen in
|
||||
[`docs/INSTALLATION.md`](docs/INSTALLATION.md), Schritt 7.
|
||||
|
||||
---
|
||||
|
||||
@@ -281,6 +293,15 @@ entscheiden kann. Was dafür umgesetzt ist:
|
||||
- Passwörter mit **Argon2id** (19 MiB, t=2, p=1 — OWASP-Empfehlung).
|
||||
- **Zweiter Faktor ist Pflicht** und lässt sich nicht abschalten. TOTP nach
|
||||
RFC 6238, kompatibel mit Aegis, 2FAS, Bitwarden, 1Password.
|
||||
- **Passkeys** (WebAuthn/FIDO2) als zweiter Anmeldeweg — auch für die
|
||||
erneute Bestätigung vor sensiblen Aktionen. Sie *ersetzen* den zweiten
|
||||
Faktor, statt zu ihm hinzuzukommen: Nutzerverifikation wird verlangt
|
||||
(`userVerification: 'required'`) und serverseitig nachgeprüft, ein
|
||||
Schlüssel ohne sie wird abgewiesen. Damit sind es dieselben zwei
|
||||
Faktoren — Besitz des Geräts und dessen Entsperrung —, nur an die Domain
|
||||
gebunden und deshalb nicht abphishbar. TOTP muss trotzdem eingerichtet
|
||||
sein, bevor sich ein Passkey anlegen lässt: Er hängt an einem Gerät und
|
||||
darf nicht der einzige Weg hinein sein.
|
||||
- **Rate-Limiting** am Login, nach E-Mail *und* nach Anschluss. Die Sperre
|
||||
wird geprüft, bevor Argon2 überhaupt rechnet.
|
||||
- Die Antwortzeit ist auf eine Mindestdauer gestreckt, damit sie nicht
|
||||
@@ -479,6 +500,7 @@ npm test # Vitest: Fachlogik
|
||||
npm run test:e2e # Playwright: kritische Abläufe
|
||||
npm run db:studio # Prisma Studio
|
||||
npm run protokoll # Bauprotokoll aus der Git-Historie
|
||||
npm run version -- patch # Version anheben, Changelog vorbereiten
|
||||
```
|
||||
|
||||
Konventionen — verbindlich für alle Beiträge:
|
||||
@@ -546,14 +568,17 @@ Fehler, die während des Baus aufgefallen sind.
|
||||
|
||||
## Stand
|
||||
|
||||
| | |
|
||||
|---|---:|
|
||||
| Zeilen TypeScript/TSX | 71.051 |
|
||||
| Prisma-Modelle | 24 |
|
||||
| Seiten | 46 |
|
||||
| Unit-Tests (Vitest) | 458 |
|
||||
| End-to-End-Tests (Playwright) | 34 |
|
||||
| TypeScript-Fehler | 0 |
|
||||
| | | nachzuzählen mit |
|
||||
|---|---:|---|
|
||||
| Zeilen TypeScript/TSX | 72.080 | `git ls-files "*.ts" "*.tsx" \| xargs wc -l` |
|
||||
| Prisma-Modelle | 33 | `grep -c '^model ' prisma/schema.prisma` |
|
||||
| Seiten | 79 | `find src/app -name page.tsx \| wc -l` |
|
||||
| Unit-Tests (Vitest) | 496 | `npm test` |
|
||||
| End-to-End-Tests (Playwright) | 37 | `npm run test:e2e` |
|
||||
| TypeScript-Fehler | 0 | `npm run typecheck` |
|
||||
|
||||
Die Befehle stehen dabei, weil die Zahlen sonst altern, ohne dass es
|
||||
jemandem auffällt — bei den Modellen und Seiten war genau das passiert.
|
||||
|
||||
Alle acht Etappen sind umgesetzt. Der Produktionsbuild ist gegen den
|
||||
fertigen Standalone-Server geprüft: strenge CSP aktiv, keine
|
||||
|
||||
+27
-9
@@ -4,10 +4,13 @@
|
||||
#
|
||||
# docker compose up -d --build
|
||||
#
|
||||
# Kein Reverse Proxy in dieser Datei: der ist auf dem Server bereits
|
||||
# vorhanden. Die Anwendung horcht nur auf 127.0.0.1:3000 - von aussen
|
||||
# erreichbar wird sie ausschliesslich ueber den vorhandenen Proxy, der
|
||||
# auch TLS beendet. Siehe README, Abschnitt "Reverse Proxy".
|
||||
# Kein Reverse Proxy in dieser Datei: der ist bereits vorhanden. Die
|
||||
# Anwendung beendet selbst kein TLS und horcht standardmaessig nur auf
|
||||
# 127.0.0.1:3000.
|
||||
#
|
||||
# Liegt der Proxy auf einem anderen Server, setze APP_BIND in der .env auf
|
||||
# die Adresse, ueber die er herankommt - siehe docs/INSTALLATION.md,
|
||||
# Schritt 7.
|
||||
#
|
||||
# Die Datenbank hat bewusst KEINE Portfreigabe. Sie ist nur ueber das
|
||||
# interne Docker-Netz erreichbar. Wer mit psql heran muss, geht ueber
|
||||
@@ -63,7 +66,10 @@ services:
|
||||
ports:
|
||||
# Nur an die Loopback-Adresse gebunden. Die Konsole erreichst du
|
||||
# ueber einen SSH-Tunnel oder ueber deinen vorhandenen Proxy.
|
||||
- '127.0.0.1:9001:9001'
|
||||
#
|
||||
# Laeuft auf dem Server schon etwas auf 9001, weich in der .env aus:
|
||||
# MINIO_KONSOLE_PORT=9011
|
||||
- '${MINIO_KONSOLE_BIND:-127.0.0.1}:${MINIO_KONSOLE_PORT:-9001}:9001'
|
||||
networks: [intern]
|
||||
|
||||
app:
|
||||
@@ -88,7 +94,9 @@ services:
|
||||
AUTH_URL: ${AUTH_URL:?AUTH_URL fehlt in der .env}
|
||||
AUTH_TRUST_HOST: 'true'
|
||||
ENC_KEY_V1: ${ENC_KEY_V1:?ENC_KEY_V1 fehlt in der .env - ohne ihn sind die verschluesselten Felder nicht lesbar}
|
||||
ENC_KEY_V2: ${ENC_KEY_V2:-}
|
||||
# Bleibt leer, solange nicht rotiert wird. Die Anwendung ueberspringt
|
||||
# leere Schluesselvariablen - siehe src/lib/env.ts.
|
||||
# ENC_KEY_V2: ${ENC_KEY_V2:-}
|
||||
ENC_KEY_AKTIV: ${ENC_KEY_AKTIV:-1}
|
||||
INDEX_KEY: ${INDEX_KEY:?INDEX_KEY fehlt in der .env}
|
||||
SESSION_MAX_AGE: ${SESSION_MAX_AGE:-1800}
|
||||
@@ -111,9 +119,19 @@ services:
|
||||
SMTP_FROM: ${SMTP_FROM:-}
|
||||
TZ: Europe/Berlin
|
||||
ports:
|
||||
# Nur Loopback. Der vorhandene Reverse Proxy auf dem Host reicht
|
||||
# von aussen hierher durch und beendet TLS.
|
||||
- '127.0.0.1:${APP_PORT:-3000}:3000'
|
||||
# Standard ist die Loopback-Adresse: dann erreicht die Anwendung nur
|
||||
# ein Proxy, der auf demselben Rechner laeuft.
|
||||
#
|
||||
# Liegt der Reverse Proxy auf einem ANDEREN Server, muss hier die
|
||||
# Adresse stehen, ueber die er herankommt - am besten die eines
|
||||
# privaten Netzes oder eines WireGuard-Tunnels:
|
||||
#
|
||||
# APP_BIND=10.0.0.5
|
||||
#
|
||||
# 0.0.0.0 nur setzen, wenn eine Firewall den Port ausschliesslich
|
||||
# fuer die IP des Proxy-Servers oeffnet. Die Anwendung beendet kein
|
||||
# TLS und gehoert nie unverschluesselt ins offene Netz.
|
||||
- '${APP_BIND:-127.0.0.1}:${APP_PORT:-3000}:3000'
|
||||
networks: [intern]
|
||||
healthcheck:
|
||||
test: ['CMD', 'node', '-e', "fetch('http://127.0.0.1:3000/api/gesundheit').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"]
|
||||
|
||||
@@ -0,0 +1,535 @@
|
||||
# Bedienungsanleitung
|
||||
|
||||
Für dich als ehrenamtlichen Betreuer. Kein Handbuch zum Durchlesen —
|
||||
sondern eine Sammlung der Handgriffe, die du tatsächlich brauchst, in der
|
||||
Reihenfolge, in der sie im Alltag vorkommen.
|
||||
|
||||
> Diese Anwendung ist ein **Arbeits- und Dokumentationswerkzeug**. Sie
|
||||
> rechnet Fristen aus und sortiert Unterlagen. Sie erteilt **keine
|
||||
> Rechtsberatung** und kennt deinen Einzelfall nicht. Wo ein Paragraph
|
||||
> steht, steht daneben der Hinweis, dass er die Rückfrage bei Gericht,
|
||||
> Bezirk oder Anwalt nicht ersetzt. Nimm den ernst.
|
||||
|
||||
---
|
||||
|
||||
## Der Grundgedanke in drei Sätzen
|
||||
|
||||
Du trägst einmal ein, was passiert ist — ein Schreiben, ein Besuch, eine
|
||||
Überweisung. Die Anwendung merkt sich, wann daraus etwas folgt, und
|
||||
erinnert dich rechtzeitig. Am Ende des Betreuungsjahres erzeugt sie aus
|
||||
demselben Bestand die Berichte, die Gericht und Bezirk von dir wollen.
|
||||
|
||||
Das heißt umgekehrt: **Was du nicht einträgst, steht später nicht im
|
||||
Bericht.** Der Aufwand liegt vorn, der Gewinn hinten.
|
||||
|
||||
---
|
||||
|
||||
## Der erste Tag
|
||||
|
||||
Beim allerersten Aufruf führt dich ein Assistent durch drei Schritte.
|
||||
|
||||
**Schritt 1 — Dein Zugang.** Name, E-Mail, Passwort. Nimm vier zufällige
|
||||
Wörter statt eines kurzen Kunstworts: *Kastanie-Waschbär-Turm-Grün* ist
|
||||
leichter zu merken und deutlich schwerer zu knacken. Noch besser ist ein
|
||||
Passwortmanager.
|
||||
|
||||
**Schritt 2 — Der zweite Faktor.** Installiere eine Authenticator-App —
|
||||
**Aegis** (Android) oder **2FAS** (iOS) sind quelloffen und brauchen kein
|
||||
Konto. Scanne den Code, tippe die sechs Ziffern ein.
|
||||
|
||||
Danach bekommst du **acht Wiederherstellungscodes**. Die sind der einzige
|
||||
Weg zurück, wenn dein Handy verloren geht. Druck sie aus und leg sie zu
|
||||
deinen Betreuungsunterlagen — **nicht** auf dasselbe Gerät wie die App.
|
||||
Sie werden dir nie wieder angezeigt.
|
||||
|
||||
**Schritt 3 — Die betreute Person.** Nur das Nötigste. Ein Feld ist dabei
|
||||
wichtiger als alle anderen:
|
||||
|
||||
> **Das Bestellungsdatum.** Es steht in deiner Bestellungsurkunde. Daraus
|
||||
> berechnet die Anwendung dein Betreuungsjahr — und damit, wann
|
||||
> Anfangsbericht, Vermögensverzeichnis, Jahresbericht und die
|
||||
> Aufwandspauschale fällig sind. Ist es falsch, ist alles falsch.
|
||||
|
||||
Alles Weitere trägst du später unter **Stammdaten → Bearbeiten** in Ruhe
|
||||
nach. Das lohnt sich: Was dort steht, taucht in jedem Bericht und in jedem
|
||||
Anschreiben wieder auf.
|
||||
|
||||
**Zum Schluss:** Geh auf **Fristen** und klicke einmal auf
|
||||
*Pflichtfristen ableiten*. Danach stehen deine gesetzlichen Termine drin.
|
||||
|
||||
Und wenn du magst: Richte unter **Mein Konto → Passkeys** einen Passkey
|
||||
ein. Dann meldest du dich künftig mit dem Finger an, statt drei Felder
|
||||
auszufüllen. Wie das geht, steht gleich im nächsten Abschnitt.
|
||||
|
||||
---
|
||||
|
||||
## Der Morgen: die Seite „Heute"
|
||||
|
||||
Diese eine Seite beantwortet die Frage, was ansteht. Von oben nach unten:
|
||||
|
||||
| Kachel | Was sie dir sagt |
|
||||
|---|---|
|
||||
| **Fristen** | Was überfällig ist (rot), was diese Woche fällig wird (orange), was diesen Monat (gelb) |
|
||||
| **Wartet auf andere** | Vorgänge, bei denen die Gegenstelle am Zug ist — mit Tagen seit dem letzten Kontakt |
|
||||
| **Nachforderungen des Trägers** | Was der Bezirk noch von dir will, mit Fortschrittsbalken |
|
||||
| **Ungeprüfter Posteingang** | Neu hochgeladene Schreiben, die noch niemand zugeordnet hat |
|
||||
| **Unverbuchte Belege** | Rechnungen ohne Buchung und Buchungen ohne Beleg |
|
||||
| **Wo stehen wir?** | Vermögen zum letzten Stichtag, Heimkosten gegen Deckung, Tage bis zum Jahresbericht |
|
||||
|
||||
Jede Kachel endet in einer Handlung. Wenn irgendwo nichts steht, ist dort
|
||||
auch nichts zu tun.
|
||||
|
||||
**Ist eine Kachel leer, obwohl du Daten erwartest?** Dann fehlt meist ein
|
||||
Eintrag: keine Fristen ohne Bestellungsdatum, keine Deckungslücke ohne
|
||||
erfassten Heimkostenmonat.
|
||||
|
||||
---
|
||||
|
||||
## Die zwölf häufigsten Handgriffe
|
||||
|
||||
### 1. Ein Behördenschreiben aufnehmen
|
||||
|
||||
**Dokumente → Aufnehmen**, oder unterwegs über den runden Knopf unten
|
||||
rechts → *Beleg fotografieren*.
|
||||
|
||||
1. Foto machen oder PDF wählen — mehrere auf einmal sind ausdrücklich
|
||||
erwünscht.
|
||||
2. Warten, bis die Datei angenommen ist. Geprüft wird der **Inhalt**, nicht
|
||||
die Endung: eine Datei, die sich nur als PDF ausgibt, wird abgelehnt.
|
||||
3. Titel eintragen (oder leer lassen — die Erkennung schlägt einen vor).
|
||||
4. **Eingangsdatum** setzen. Das ist wichtiger, als es aussieht: Bei
|
||||
Bescheiden läuft die Widerspruchsfrist ab dem Zugang, nicht ab dem
|
||||
Datum auf dem Brief.
|
||||
5. Vorgang auswählen.
|
||||
6. *In die Akte übernehmen*.
|
||||
|
||||
Danach liest der Server den Text (Texterkennung auf Deutsch) und schlägt
|
||||
dir **Absender, Datum, Aktenzeichen, Dokumentart und eine im Text genannte
|
||||
Frist** vor. Die Textstelle steht daneben — prüf sie, bevor du übernimmst.
|
||||
Nichts davon wird automatisch angelegt.
|
||||
|
||||
**Trag ein, wo das Papier liegt.** Es gibt ein Feld für Ordner und
|
||||
Register. Wenn der Rechtspfleger das Original sehen will, findest du es
|
||||
dann in zehn Sekunden.
|
||||
|
||||
### 2. Aus einem Schreiben eine Frist machen
|
||||
|
||||
Öffne das Dokument. Steht unter den Vorschlägen eine erkannte Frist,
|
||||
genügt ein Klick auf *Als Frist übernehmen*. Sonst: **Fristen → Neu**,
|
||||
Datum eintragen, Vorgang zuordnen.
|
||||
|
||||
Setz bei behördlichen Fristen die Vorwarnung großzügig. Der Standard ist
|
||||
60/30/7/1 Tage vorher.
|
||||
|
||||
### 3. Einen Besuch festhalten — in zwanzig Sekunden
|
||||
|
||||
Runder Knopf unten rechts → *Notiz / Kontakt festhalten*.
|
||||
|
||||
Datum ist auf heute vorbelegt, die Art wählst du aus einer Knopfreihe, die
|
||||
Dauer per Schnellwahl. Ein Freitextfeld, fertig.
|
||||
|
||||
Zwei Felder lohnen die zusätzlichen Sekunden:
|
||||
|
||||
- **„Persönlicher Kontakt zur betreuten Person"** — dieses Häkchen zählt
|
||||
direkt in den Jahresbericht. Es ist bewusst **nicht** vorbelegt: ein
|
||||
versehentlich gesetztes Häkchen wäre eine falsche Angabe gegenüber dem
|
||||
Gericht.
|
||||
- **Geäußerte Wünsche** — seit der Reform 2023 ist der Wille der betreuten
|
||||
Person die Leitschnur deines Handelns (§ 1821 BGB). Was du hier
|
||||
festhältst, landet im Jahresbericht und trägt deine Entscheidungen.
|
||||
|
||||
Das ist der Handgriff, der sich am meisten auszahlt. Ein Jahresbericht aus
|
||||
vierzig kurzen Notizen schreibt sich fast von selbst; einer aus der
|
||||
Erinnerung ist eine Qual.
|
||||
|
||||
### 4. Eine Buchung erfassen
|
||||
|
||||
**Vermögen & Kasse → Buchungen → Neu**, oder über den runden Knopf.
|
||||
|
||||
Wichtig ist die Trennung: **Betrifft die Buchung die betreute Person oder
|
||||
ist es deine eigene Auslage?** Läuft eine Buchung auf ein als privat
|
||||
markiertes Konto und ist trotzdem als „betrifft die Betreute"
|
||||
gekennzeichnet, warnt die Anwendung. Das ist der Fehler, der einem in der
|
||||
Rechnungslegung um die Ohren fliegt.
|
||||
|
||||
**Belege.** Eine Buchung ohne Beleg wird in der Liste markiert. Das ist
|
||||
kein Verbot — manchmal gibt es keinen. Dann trag eine Begründung ein, dann
|
||||
ist die Zeile sauber und du weißt später noch, warum.
|
||||
|
||||
### 5. Einen Vorgang anlegen
|
||||
|
||||
**Vorgänge → Neuer Vorgang.** Nimm eine Vorlage, wenn eine passt:
|
||||
|
||||
Heimeinzug · Antrag Hilfe zur Pflege · Wohnungsauflösung · Hausverkauf ·
|
||||
Darlehen § 91 SGB XII · Versicherungsverwertung · Pflegegrad-Höherstufung ·
|
||||
Steuererklärung · Widerspruch gegen Bescheid
|
||||
|
||||
Jede bringt eine durchdachte Aufgabenliste in der richtigen Reihenfolge
|
||||
mit. Bei den genehmigungspflichtigen erzwingt sie die Reihenfolge
|
||||
**Mitteilung → Genehmigung → Rechtsgeschäft**.
|
||||
|
||||
Ein Feld solltest du immer pflegen: **Nächster Schritt.** Es steht auf dem
|
||||
Dashboard und beantwortet dir in vier Wochen die Frage, was du dir dabei
|
||||
gedacht hast.
|
||||
|
||||
### 6. Ein genehmigungspflichtiges Geschäft
|
||||
|
||||
Hausverkauf, Wohnungskündigung, Kreditaufnahme, Verwertung einer
|
||||
Lebensversicherung — dafür brauchst du das Betreuungsgericht.
|
||||
|
||||
Markiere den Vorgang als genehmigungspflichtig und wähle die
|
||||
Rechtsgrundlage. Die Anwendung zeigt dann eine feste Stufenfolge:
|
||||
|
||||
**Mitteilung ans Gericht → Antrag gestellt → Anhörung → Beschluss →
|
||||
Rechtskraft → Vollzug**
|
||||
|
||||
> Die Stufe **Vollzug lässt sich erst setzen, wenn ein Beschlussdokument
|
||||
> hinterlegt ist.** Das ist Absicht: Nach § 1858 BGB muss die Genehmigung
|
||||
> **vor** dem Rechtsgeschäft vorliegen. Ein Vertrag, den du vorher
|
||||
> unterschreibst, ist schwebend unwirksam.
|
||||
|
||||
Sprich vorher mit dem Rechtspfleger. Die Anwendung ersetzt das Gespräch
|
||||
nicht, sie erinnert dich nur daran.
|
||||
|
||||
### 7. Eine Nachforderung des Bezirks abarbeiten
|
||||
|
||||
**Sozialhilfe → Akte öffnen.** Jede angeforderte Unterlage steht als
|
||||
eigene Zeile mit Status und Frist. Der Fortschrittsbalken zeigt „x von y
|
||||
Unterlagen geliefert".
|
||||
|
||||
Beim Anlegen des Antrags kannst du die **Checkliste der Standardunterlagen**
|
||||
übernehmen — Rentenbescheide, Kontoauszüge, Versicherungsunterlagen,
|
||||
notarielle Übertragungsverträge, Pflegegradbescheid, Heimvertrag,
|
||||
Grundbuchauszug. Zu jeder steht dabei, **warum** der Träger sie will. Das
|
||||
erspart Rückfragen.
|
||||
|
||||
Gibt es eine Unterlage nicht, setz den Status auf *nicht vorhanden* und
|
||||
schreib eine Begründung dazu. Die geht später mit ins Unterlagenpaket —
|
||||
besser als kommentarloses Schweigen.
|
||||
|
||||
Wenn alles beisammen ist: **Berichte → Unterlagenpaket**. Das macht aus
|
||||
den markierten Dokumenten **eine** PDF mit Anschreiben, laufender Nummer
|
||||
und Inhaltsverzeichnis.
|
||||
|
||||
### 8. Einen Bescheid prüfen
|
||||
|
||||
**Sozialhilfe → Akte → Bescheide → Neu.**
|
||||
|
||||
Trag das **Zugangsdatum** ein, nicht das Datum auf dem Bescheid. Die
|
||||
Widerspruchsfrist läuft ab Bekanntgabe.
|
||||
|
||||
Die Anwendung rechnet die Frist aus — mit Wochenende, bayerischen
|
||||
Feiertagen und dem Sonderfall, dass bei fehlender oder falscher
|
||||
Rechtsbehelfsbelehrung ein Jahr statt eines Monats gilt (§ 66 SGG). Der
|
||||
Rechenweg wird ausgegeben, damit du ihn nachvollziehen kannst. Aus dem
|
||||
Ergebnis entsteht automatisch die Frist *Widerspruch möglich bis*.
|
||||
|
||||
**Rechne im Zweifel nach oder frag beim Bezirk.** Eine verstrichene
|
||||
Widerspruchsfrist bekommst du nicht zurück.
|
||||
|
||||
### 9. Einen Rückkaufswert anfordern
|
||||
|
||||
**Verträge → Vertrag öffnen → Rückkaufswert anfordern.** Es entsteht ein
|
||||
Anschreiben zum Kopieren, und die Anwendung legt eine **Wiedervorlage in
|
||||
vier Wochen** an. Versicherer antworten selten von selbst.
|
||||
|
||||
### 10. Einen Vertrag kündigen
|
||||
|
||||
**Verträge → Vertrag öffnen → Kündigen.**
|
||||
|
||||
Der Rechner nennt dir den **spätesten Absendetag**, nicht den Fristablauf —
|
||||
eine Kündigung wirkt mit dem Zugang, nicht mit dem Abschicken. Drei Tage
|
||||
Postlauf sind eingerechnet.
|
||||
|
||||
Der Assistent fragt dich nach der Genehmigung. Er beantwortet die Frage
|
||||
nicht, und das soll er auch nicht: Ob die Verwertung einer
|
||||
Lebensversicherung genehmigungspflichtig ist, entscheidet der
|
||||
Rechtspfleger. Der **Versandnachweis** (Einschreiben, Faxprotokoll) ist
|
||||
Pflichtfeld — ohne ihn geht die Kündigung nicht durch.
|
||||
|
||||
### 11. Einen Wertstand nachtragen
|
||||
|
||||
**Vermögen & Kasse → Vermögen → Posten öffnen → Wert eintragen.**
|
||||
|
||||
Stichtag, Betrag und **Wertquelle** — letztere ist Pflicht. „Eigene
|
||||
Schätzung" ist eine zulässige Antwort, „keine Angabe" nicht: Im
|
||||
Vermögensverzeichnis steht die Quelle mit dabei, und das Gericht darf
|
||||
wissen, woher die Zahl kommt.
|
||||
|
||||
Alte Werte werden **nie überschrieben**. Jede Vermögensübersicht bleibt
|
||||
später reproduzierbar.
|
||||
|
||||
### 12. Etwas versehentlich Gelöschtes zurückholen
|
||||
|
||||
**Einstellungen → Papierkorb.** Gelöschtes bleibt 30 Tage liegen und lässt
|
||||
sich mit einem Klick zurückholen. Erst danach ist es wirklich weg.
|
||||
|
||||
Endgültiges Löschen verlangt eine erneute Anmeldung.
|
||||
|
||||
---
|
||||
|
||||
## Das Betreuungsjahr
|
||||
|
||||
Dein Jahr läuft **ab dem Tag der Bestellung**, nicht ab dem 1. Januar. Wer
|
||||
am 14. Februar bestellt wurde, hat sein erstes Betreuungsjahr bis zum
|
||||
13. Februar des Folgejahres.
|
||||
|
||||
| Wann | Was | Grundlage |
|
||||
|---|---|---|
|
||||
| 3 Monate nach Bestellung | Vermögensverzeichnis und Anfangsbericht | §§ 1835, 1863 BGB |
|
||||
| Zum Ende jedes Betreuungsjahres | Jahresbericht und Vermögensübersicht | §§ 1859, 1863 BGB |
|
||||
| Bis 6 Monate danach | **Aufwandspauschale beantragen** | § 1878 BGB |
|
||||
| Jährlich bis 31.12. | Bayerisches Landespflegegeld | BayLPflGG |
|
||||
| Jährlich | Zuzahlungsbefreiung der Krankenkasse | § 62 SGB V |
|
||||
| Jährlich | Rückkaufswerte aller Versicherungen aktualisieren | — |
|
||||
|
||||
> **Die Aufwandspauschale ist eine Ausschlussfrist.** Läuft sie ab, ist
|
||||
> der Anspruch ersatzlos weg — keine Nachsicht, keine Wiedereinsetzung.
|
||||
> Die Anwendung warnt deshalb schon 90 Tage vorher und markiert sie rot.
|
||||
|
||||
---
|
||||
|
||||
## Die Berichte
|
||||
|
||||
Alle unter **Berichte**, die beiden Finanzberichte unter **Vermögen &
|
||||
Kasse → Berichte**. Jeder trägt Kopf mit Aktenzeichen, Fußzeile mit
|
||||
Seitenzahl und ein Unterschriftenfeld.
|
||||
|
||||
**Vermögensverzeichnis (§ 1835 BGB).** Stichtag wählen, Knopf drücken.
|
||||
Aktiva nach Gruppen, Passiva, laufende Einnahmen und Ausgaben,
|
||||
Belegverweise. Hat ein Posten zum Stichtag keinen Wert, erscheint er als
|
||||
**Lücke** — nicht als 0,00 €. Das ist ehrlicher und fällt dir auf.
|
||||
|
||||
**Vermögensübersicht / Rechnungslegung (§§ 1859, 1865 BGB).**
|
||||
Betreuungsjahr wählen. Anfangsbestand, geordnete Einnahmen und Ausgaben,
|
||||
Endbestand, Belegliste.
|
||||
|
||||
Zwei Varianten: die knappe Übersicht für **befreite Betreuer** (§ 1859 BGB
|
||||
— als Angehöriger bist du das in der Regel) und die vollständige
|
||||
Rechnungslegung.
|
||||
|
||||
> Geht die Rechenprobe nicht auf, wird die **Differenz im Bericht
|
||||
> ausgewiesen** und jeder fehlende Saldostand benannt. Das ist Absicht.
|
||||
> Eine still geglättete Rechnungslegung ist gegenüber dem Gericht wertlos —
|
||||
> und meistens fehlt einfach ein Kontoauszug.
|
||||
|
||||
**Jahresbericht (§ 1863 BGB).** Die Anwendung erzeugt einen **Entwurf** aus
|
||||
deinen Kontaktprotokollen, Gesundheitsereignissen und Vorgängen, gegliedert
|
||||
nach dem, was das Gericht sehen will. Du überarbeitest ihn im Browser
|
||||
(wird automatisch zwischengespeichert) und gibst ihn dann als PDF oder DOCX
|
||||
aus.
|
||||
|
||||
> Es ist ein Entwurf, kein fertiger Bericht. Lies ihn durch, bevor du ihn
|
||||
> abgibst. Was dort steht, verantwortest du.
|
||||
|
||||
**Belegmappe.** Alle Dokumente eines Vorgangs oder Zeitraums als eine
|
||||
chronologisch sortierte, paginierte PDF mit Deckblatt und
|
||||
Inhaltsverzeichnis. Genau das, was Gericht und Bezirk haben wollen.
|
||||
|
||||
**Vollexport.** Ein ZIP mit allen Originaldateien, allen Daten als
|
||||
lesbarem JSON, den Berichten und Prüfsummen. Damit kannst du diese
|
||||
Anwendung jederzeit verlassen. Verlangt eine erneute Anmeldung.
|
||||
|
||||
---
|
||||
|
||||
## Anmelden mit dem Finger: Passkeys
|
||||
|
||||
Drei Felder auszufüllen, nur um kurz eine Frist nachzusehen, ist lästig —
|
||||
und lästige Sicherheit wird umgangen. Ein Passkey macht daraus einen
|
||||
Handgriff.
|
||||
|
||||
### Einrichten
|
||||
|
||||
**Mein Konto → Passkeys.** Gib dem Gerät einen Namen, an dem du es später
|
||||
wiedererkennst („iPhone", „Laptop Büro"), und klicke auf *Passkey
|
||||
einrichten*. Dein Gerät fragt nach Fingerabdruck, Gesicht oder PIN —
|
||||
fertig.
|
||||
|
||||
Mach das auf **jedem Gerät**, mit dem du arbeitest. Sie stören sich nicht
|
||||
gegenseitig.
|
||||
|
||||
### Anmelden
|
||||
|
||||
Auf der Anmeldeseite steht unter dem Formular *Mit Passkey anmelden*. Ein
|
||||
Klick, ein Finger, drin. Keine E-Mail, kein Passwort, kein Code.
|
||||
|
||||
### Warum das nicht unsicherer ist
|
||||
|
||||
Es sieht nach weniger aus, ist aber dasselbe — zweimal:
|
||||
|
||||
| | Bisher | Mit Passkey |
|
||||
|---|---|---|
|
||||
| Erster Faktor | Passwort (Wissen) | Das Gerät selbst (Besitz) |
|
||||
| Zweiter Faktor | Code aus der App (Besitz) | Fingerabdruck, Gesicht oder PIN |
|
||||
|
||||
Der entscheidende Zusatz: **Ein Passkey ist an die Adresse gebunden**,
|
||||
unter der du ihn eingerichtet hast. Landest du auf einer nachgebauten
|
||||
Anmeldeseite, funktioniert er dort schlicht nicht — er lässt sich nicht
|
||||
abtippen und nicht weitergeben. Genau das ist der übliche Weg, an einen
|
||||
Code aus der Authenticator-App zu kommen.
|
||||
|
||||
Ein Gerät, das den Passkey ohne Fingerabdruck oder PIN freigibt, wird
|
||||
abgewiesen. Das wäre nur ein Faktor, und dafür ist hier zu viel zu
|
||||
verlieren.
|
||||
|
||||
### Die Authenticator-App bleibt
|
||||
|
||||
Du kannst sie nicht abschaffen, und das ist Absicht. **Ein Passkey hängt
|
||||
an einem Gerät.** Geht das Handy in der Donau baden und wäre der Passkey
|
||||
der einzige Weg hinein, käme niemand mehr an die Akte — auch der Bezirk
|
||||
nicht, auch das Gericht nicht.
|
||||
|
||||
Deshalb: erst Authenticator-App und Wiederherstellungscodes, dann Passkeys.
|
||||
Die Anmeldung mit E-Mail, Passwort und Code bleibt daneben immer offen.
|
||||
|
||||
### Was in der Liste steht
|
||||
|
||||
Unter **Mein Konto → Passkeys** siehst du zu jedem Gerät, wann es
|
||||
eingerichtet und wann es zuletzt benutzt wurde. **Sieh da gelegentlich
|
||||
hinein.** Ein Eintrag, den du nicht zuordnen kannst, gehört sofort
|
||||
entfernt — und danach das Passwort gewechselt.
|
||||
|
||||
Steht bei einem Eintrag *gesichert*, wird der Schlüssel vom Anbieter
|
||||
mitgesichert (iCloud-Schlüsselbund, Google, Bitwarden) und taucht auf
|
||||
einem neuen Gerät von selbst wieder auf. Ohne diesen Vermerk liegt er nur
|
||||
auf diesem einen Gerät.
|
||||
|
||||
### Wenn ein Gerät verloren geht
|
||||
|
||||
1. Auf einem anderen Gerät mit E-Mail, Passwort und Code anmelden.
|
||||
2. **Mein Konto → Passkeys**, den Eintrag des verlorenen Geräts entfernen.
|
||||
3. Fertig — der Schlüssel auf dem Gerät ist damit wertlos.
|
||||
|
||||
Ein Passkey allein reicht ohnehin niemandem, der das Gerät findet: Ohne
|
||||
Fingerabdruck oder PIN gibt das Gerät ihn nicht heraus.
|
||||
|
||||
### Wenn der Knopf gar nicht erscheint
|
||||
|
||||
Dann bietet der Server Passkeys nicht an — das Verfahren verlangt eine
|
||||
verschlüsselte Verbindung (`https`). Oder der Browser ist zu alt. Melde
|
||||
dich mit E-Mail, Passwort und Code an; alles andere funktioniert
|
||||
unverändert.
|
||||
|
||||
---
|
||||
|
||||
## Am Handy
|
||||
|
||||
Die Anwendung ist am Telefon vollwertig bedienbar — sie ist dafür gebaut,
|
||||
nicht dafür angepasst.
|
||||
|
||||
- Menü über das Symbol links oben, schließt mit Wischen oder Escape.
|
||||
- Der **runde Knopf unten rechts** ist immer erreichbar: Beleg
|
||||
fotografieren, Notiz festhalten, Frist anlegen, Buchung erfassen.
|
||||
- Tabellen scrollen in ihrem eigenen Rahmen, nie die ganze Seite.
|
||||
- Zoomen ist erlaubt und abgeschaltet wird es nie.
|
||||
|
||||
Der typische Fall: Du sitzt im Heim, fotografierst die Heimrechnung,
|
||||
ordnest sie dem Vorgang zu, hältst den Besuch fest — drei Minuten, und
|
||||
abends musst du nichts nacharbeiten.
|
||||
|
||||
---
|
||||
|
||||
## Wenn etwas schiefgeht
|
||||
|
||||
**Ich will den Zugang auf ein zweites Gerät legen.**
|
||||
Das Geheimnis wird nur einmal angezeigt, beim Einrichten. Wer es später
|
||||
noch einmal braucht — Handy und Tablet, oder ein Ersatzgerät im Schrank —
|
||||
liest es auf dem Server aus:
|
||||
|
||||
```bash
|
||||
docker compose exec app node scripts/totp-geheimnis.mjs deine@adresse.de
|
||||
```
|
||||
|
||||
Läuft der Behälter noch mit einer Fassung vor 1.0.1, fehlt das Skript im
|
||||
Abbild (`Cannot find module`). Dann entweder aktualisieren, oder einmalig:
|
||||
|
||||
```bash
|
||||
docker compose cp scripts/totp-geheimnis.mjs app:/app/totp-geheimnis.mjs
|
||||
docker compose exec app node totp-geheimnis.mjs deine@adresse.de
|
||||
```
|
||||
|
||||
Das ist keine Hintertür: Es läuft nur mit Zugriff auf die Datenbank **und**
|
||||
auf `ENC_KEY_V1`. Wer beides hat, kommt ohnehin an alles. Die Ausgabe
|
||||
gehört trotzdem in kein Protokoll und in keine E-Mail.
|
||||
|
||||
**Ich habe mein Handy mit der Authenticator-App verloren.**
|
||||
Melde dich mit einem deiner Wiederherstellungscodes an — statt der sechs
|
||||
Ziffern gibst du den Code im Format `XXXX-XXXX-XXXX` ein. Jeder
|
||||
funktioniert einmal. Danach unter **Konto → Zweiter Faktor** neu
|
||||
einrichten und **neue Codes erzeugen**.
|
||||
|
||||
**Ich habe auch die Wiederherstellungscodes verloren.**
|
||||
Dann kommt nur noch jemand mit Zugriff auf den Server weiter, indem er den
|
||||
zweiten Faktor in der Datenbank zurücksetzt. Genau deshalb: Codes
|
||||
ausdrucken.
|
||||
|
||||
**Der Code wird nicht angenommen.**
|
||||
Fast immer geht die Uhr des Telefons falsch. TOTP-Codes hängen an der
|
||||
Uhrzeit. Stell die automatische Zeitsynchronisierung ein.
|
||||
|
||||
**„Zu viele Fehlversuche."**
|
||||
Nach fünf Fehlversuchen wird für eine Viertelstunde gesperrt. Warte ab —
|
||||
das gilt auch dann, wenn du selbst es warst.
|
||||
|
||||
**Ich habe mein Passwort geändert und bin überall abgemeldet.**
|
||||
So gewollt. Ein Passwortwechsel beendet alle Sitzungen, auch auf Geräten,
|
||||
an denen du gerade nicht sitzt.
|
||||
|
||||
**Eine Frist stimmt nicht.**
|
||||
Prüf zuerst das Bestellungsdatum unter **Stammdaten**. Änderst du es,
|
||||
werden die Pflichtfristen neu berechnet. Erledigte Fristen bleiben dabei
|
||||
unangetastet.
|
||||
|
||||
**Ein Bericht zeigt eine Differenz.**
|
||||
Meistens fehlt ein Saldostand. Der Bericht sagt dir, welcher. Trag ihn
|
||||
unter **Vermögen & Kasse → Konten** nach und erzeuge neu.
|
||||
|
||||
**Die Texterkennung findet nichts.**
|
||||
Sie braucht Tesseract auf dem Server. Fehlt es, funktioniert der Upload
|
||||
trotzdem — nur ohne Volltextsuche. Titel und Absender kannst du von Hand
|
||||
eintragen.
|
||||
|
||||
---
|
||||
|
||||
## Was diese Anwendung nicht tut
|
||||
|
||||
Damit du dich nicht darauf verlässt:
|
||||
|
||||
- **Sie berät dich nicht.** Sie rechnet Fristen und schlägt Einordnungen
|
||||
vor. Ob dein Fall eine Ausnahme ist, weiß sie nicht.
|
||||
- **Sie entscheidet nicht, was Schonvermögen ist.** Sie gibt dir
|
||||
Argumentationshilfen zu § 90 SGB XII zum Übernehmen. Entscheiden tun der
|
||||
Träger und notfalls das Sozialgericht.
|
||||
- **Sie schätzt keine Bewilligungschancen.**
|
||||
- **Sie holt keine Kontoauszüge ab.** Kontobewegungen kommen per
|
||||
CSV-Import oder von Hand.
|
||||
- **Sie verschickt nichts.** Anschreiben entstehen als Text zum Kopieren,
|
||||
Berichte als PDF. Absenden musst du selbst — und den Versandnachweis
|
||||
hochladen.
|
||||
- **Sie ersetzt deine Papierablage nicht.** Originale bleiben Originale.
|
||||
Deshalb gibt es das Feld für den Ablageort.
|
||||
|
||||
---
|
||||
|
||||
## Zwei Gewohnheiten, die sich lohnen
|
||||
|
||||
**Jeden Kontakt festhalten, sofort.** Auch das kurze Telefonat. Zwanzig
|
||||
Sekunden jetzt sparen dir im Januar einen halben Tag.
|
||||
|
||||
**Einmal im Jahr die Wiederherstellung üben.** Ein Backup, das nie
|
||||
zurückgespielt wurde, ist kein Backup. Die Anleitung steht in der README
|
||||
unter *Sicherung und Wiederherstellung*. Zwanzig Minuten, einmal im Jahr.
|
||||
|
||||
---
|
||||
|
||||
## Wo du weiterkommst
|
||||
|
||||
- **Hinweise** in der Anwendung — 37 Karten zu den häufigen Fallstricken,
|
||||
jede mit Rechtsgrundlage und Link zum Gesetzestext.
|
||||
- **Protokoll** — jede Änderung, lückenlos und unveränderlich. Dein
|
||||
Nachweis gegenüber Gericht und möglichen Miterben.
|
||||
- Dein **Rechtspfleger** beim Betreuungsgericht. Er ist zuständig und
|
||||
antwortet. Bei allem, was genehmigungspflichtig sein könnte: vorher
|
||||
fragen, nicht nachher.
|
||||
- Die örtliche **Betreuungsbehörde** und die Betreuungsvereine beraten
|
||||
ehrenamtliche Betreuer kostenlos.
|
||||
File diff suppressed because it is too large
Load Diff
+294
@@ -0,0 +1,294 @@
|
||||
# Roadmap
|
||||
|
||||
Was als Nächstes drankommt, und warum in dieser Reihenfolge.
|
||||
|
||||
**Maßstab ist der Alltag, nicht die Vollständigkeit.** Ein Punkt steht
|
||||
weit oben, wenn er entweder etwas Falsches richtigstellt oder jeden Monat
|
||||
Zeit spart. Er steht weit unten, wenn er nur schön wäre.
|
||||
|
||||
Diese Datei ist eine Absichtserklärung, kein Vertrag. Was sich im Betrieb
|
||||
als wichtiger herausstellt, rutscht nach oben.
|
||||
|
||||
Stand: 22.08.2026 · Aktuelle Fassung: **1.1.0** ([CHANGELOG](../CHANGELOG.md))
|
||||
|
||||
---
|
||||
|
||||
## Woher die Punkte kommen
|
||||
|
||||
Beim Bauen sind **44 Schema-Wünsche** aufgelaufen — Stellen, an denen das
|
||||
Datenmodell etwas nicht abbildet, was die Fachlogik gebraucht hätte. Sie
|
||||
liegen einzeln und begründet in [`schema-wuensche/`](schema-wuensche/),
|
||||
nach Modul getrennt. Diese Roadmap sortiert sie nach Dringlichkeit und
|
||||
bündelt sie zu Releases, die sich in einem Rutsch migrieren lassen.
|
||||
|
||||
Dazu kommen die bekannten Einschränkungen aus dem Changelog und das, was
|
||||
sich im Betrieb noch zeigen wird.
|
||||
|
||||
---
|
||||
|
||||
## 1.1 — Was heute noch falsch sein kann
|
||||
|
||||
**Ziel:** Kein Wert in der Anwendung soll unter ungünstigen Umständen
|
||||
falsch sein, ohne dass man es merkt. Das ist die einzige Art von Fehler,
|
||||
die man einem Betreuungsgericht nicht erklären kann.
|
||||
|
||||
### Kostenkonto der Immobilie richtigstellen
|
||||
|
||||
`Buchung` hat kein `immobilieId`. Das Kostenkonto wertet deshalb über
|
||||
Buchungskategorien aus — bei **einem** Grundstück richtig, bei einem
|
||||
zweiten still falsch. Die Oberfläche sagt das derzeit an der Auswertung
|
||||
dazu; das ist ein Pflaster, keine Lösung.
|
||||
|
||||
*Aufwand: klein. Migration: ein Feld, ein Index.*
|
||||
|
||||
### Umbuchungen kennen ihr Gegenkonto
|
||||
|
||||
Eine Umbuchung zwischen zwei Konten erscheint heute als zwei unverbundene
|
||||
Buchungen. In der Rechnungslegung sieht das aus wie eine Ausgabe und eine
|
||||
Einnahme — und wer nachrechnet, fragt zu Recht nach.
|
||||
|
||||
*Aufwand: klein. Migration: ein selbstbezüglicher Fremdschlüssel.*
|
||||
|
||||
### Dublettenschutz beim Import ohne Konto
|
||||
|
||||
Der Schutz vor Doppelbuchungen greift über `(kontoId, importReferenz)`.
|
||||
Ist kein Konto zugeordnet, greift er nicht — ein zweimal eingelesener
|
||||
Auszug erzeugt dann doppelte Buchungen.
|
||||
|
||||
*Aufwand: klein. Migration: partieller eindeutiger Index.*
|
||||
|
||||
### Rückkaufswert am Vertrag
|
||||
|
||||
Der Wert hängt heute am Vermögensposten. In der Vertragsübersicht steht
|
||||
deshalb kein Betrag — ausgerechnet dort, wo man ihn beim Telefonat mit dem
|
||||
Versicherer braucht.
|
||||
|
||||
*Aufwand: klein.*
|
||||
|
||||
### Genau eine Zielspalte je Dokumentverknüpfung
|
||||
|
||||
`DokumentVerknuepfung` hat zwölf mögliche Zielspalten; dass genau eine
|
||||
gesetzt ist, erzwingt bisher nur die Anwendung. Ein CHECK-Constraint macht
|
||||
daraus eine Zusage, die auch bei direktem Datenbankzugriff hält.
|
||||
|
||||
*Aufwand: klein. Migration: ein Constraint.*
|
||||
|
||||
### Papierkorb für Saldo- und Wertstände
|
||||
|
||||
Beide Modelle haben kein `geloeschtAm`. Ein versehentlich eingetragener
|
||||
Kontostand lässt sich nur endgültig löschen — was der Zusage widerspricht,
|
||||
dass Löschen 30 Tage rückgängig zu machen ist.
|
||||
|
||||
*Aufwand: klein.*
|
||||
|
||||
### Aufgaben aus Vorlagen entfernen können
|
||||
|
||||
Passt eine Aufgabe aus einer Vorgangs-Vorlage im Einzelfall nicht, bleibt
|
||||
sie dauerhaft offen stehen und verfälscht jede Fortschrittsanzeige.
|
||||
|
||||
*Aufwand: klein.*
|
||||
|
||||
---
|
||||
|
||||
## 1.2 — Weniger tippen
|
||||
|
||||
**Ziel:** Die Handgriffe, die sich jeden Monat wiederholen, kürzer machen.
|
||||
|
||||
### Nachforderungen mit stabilem Schlüssel
|
||||
|
||||
Der Dublettenschutz beim Übernehmen der Standardcheckliste läuft über die
|
||||
Bezeichnung. Wer eine Zeile umbenennt, bekommt sie beim nächsten Mal
|
||||
doppelt.
|
||||
|
||||
### Bescheid und Frist verbinden
|
||||
|
||||
Aus einem Bescheid entsteht die Widerspruchsfrist heute über einen
|
||||
Textschlüssel statt über einen Fremdschlüssel. Ändert sich das
|
||||
Zugangsdatum, wandert die Frist nicht mit.
|
||||
|
||||
### Statuswechsel eines Vorgangs als eigene Tabelle
|
||||
|
||||
Der Zeitstrahl liest Statuswechsel aus dem entschlüsselten Audit-Log. Das
|
||||
funktioniert, ist aber langsam und hängt an einem Format, das eigentlich
|
||||
nur Nachweis sein soll.
|
||||
|
||||
### Wer hat was erfasst
|
||||
|
||||
Fristen, Saldo- und Wertstände tragen kein Feld für den erfassenden
|
||||
Benutzer. Bei einer Betreuung zu zweit ist das die erste Frage.
|
||||
|
||||
### Ansprechpartner am Vorgang
|
||||
|
||||
Die Sachstandsanfrage kann namentlich anreden, bekommt den Ansprechpartner
|
||||
mangels Feld aber nicht übergeben.
|
||||
|
||||
### Inventarliste als eigenes Modell
|
||||
|
||||
Wertgegenstände hängen heute an Freitext und Fotos. Für die
|
||||
Wohnungsauflösung wäre eine Liste mit Bezeichnung, Raum, geschätztem Wert
|
||||
und Verbleib das richtige Werkzeug.
|
||||
|
||||
### Pflegegrad-Historie
|
||||
|
||||
Der Pflegegrad steht als einzelnes Feld in den Stammdaten. Frühere Grade
|
||||
mit ihren Zeiträumen gehören in eine Historie — sie werden im
|
||||
Jahresbericht und bei einer Höherstufung gebraucht.
|
||||
|
||||
---
|
||||
|
||||
## 1.2b — Passkeys abrunden
|
||||
|
||||
Der Grundstock steht seit 1.1.0. Was noch fehlt, ist Bequemlichkeit, nicht
|
||||
Sicherheit.
|
||||
|
||||
### Passkey direkt im Anmeldefeld anbieten
|
||||
|
||||
Browser können einen Passkey im Ausfüllvorschlag des E-Mail-Feldes
|
||||
anbieten (*conditional UI*), statt hinter einem eigenen Knopf. Ein Schritt
|
||||
weniger. Braucht einen zweiten Challenge-Weg und sorgfältiges Abbrechen,
|
||||
wenn stattdessen doch das Passwort getippt wird.
|
||||
|
||||
### Passkey umbenennen
|
||||
|
||||
Heute geht nur anlegen und entfernen. Wer sein Gerät „Handy" genannt hat
|
||||
und inzwischen zwei hat, muss den Passkey neu einrichten.
|
||||
|
||||
### Warnen, wenn der letzte Passkey nur auf einem Gerät liegt
|
||||
|
||||
Die Liste sagt bereits, ob ein Schlüssel gesichert ist. Wer ausschließlich
|
||||
ungesicherte Passkeys hat und dazu keine Wiederherstellungscodes mehr,
|
||||
sollte das deutlicher zu sehen bekommen als in einer Zeile Kleingedrucktem.
|
||||
|
||||
---
|
||||
|
||||
## 1.3 — Belastbarkeit
|
||||
|
||||
**Ziel:** Die Stellen absichern, die bisher nur unter Laborbedingungen
|
||||
geprüft sind.
|
||||
|
||||
### Texterkennung gegen echtes Tesseract
|
||||
|
||||
Bisher ist nur der Weg „nicht verfügbar, Upload funktioniert trotzdem"
|
||||
getestet. Ein Test im Container gegen echte Schreiben — auch schlechte
|
||||
Handyfotos, auch mehrseitige Bescheide — fehlt.
|
||||
|
||||
### CAMT.053 gegen einen echten Bankauszug
|
||||
|
||||
Der Leser ist gegen selbst gebaute Beispiele geprüft. Ein echter Auszug
|
||||
der Sparkasse ist der eigentliche Test.
|
||||
|
||||
### Suche und Belegmappe gegen Postgres
|
||||
|
||||
Beide sind nur in Einzelteilen geprüft, nicht end-to-end gegen die
|
||||
Datenbank mit einigen hundert Dokumenten.
|
||||
|
||||
### Wiederherstellung als Test
|
||||
|
||||
Die Anleitung dafür steht in der README. Ein Skript, das sie einmal im
|
||||
Monat automatisch durchspielt — Sicherung zurückspielen, Diagnosen im
|
||||
Klartext prüfen, Testdatenbank verwerfen — wäre der Beweis statt der
|
||||
Absichtserklärung.
|
||||
|
||||
### Passkey-Ablehnung ohne Browser nachstellen
|
||||
|
||||
Die Prüfung „Passkey ohne Nutzerverifikation wird abgewiesen" ist im Code
|
||||
doppelt abgesichert und im Browsertest belegt — dort weist allerdings
|
||||
schon der Browser ab, der Server kommt gar nicht dran. Ein Test, der die
|
||||
Antwort von Hand baut und den Browser umgeht, würde den serverseitigen
|
||||
Rückhalt tatsächlich beweisen.
|
||||
|
||||
### Barrierefreiheits-Durchgang mit einem Screenreader
|
||||
|
||||
Semantik, Fokusreihenfolge und Kontraste sind beim Bauen beachtet und in
|
||||
Teilen getestet. Ein Durchgang mit NVDA oder VoiceOver ist etwas anderes
|
||||
als eine Testzusicherung.
|
||||
|
||||
### `@react-pdf/renderer` ohne Krücke
|
||||
|
||||
`src/lib/pdf/standardschrift.ts` gleicht aus, dass die Unterabhängigkeiten
|
||||
für Standardschriften kein Schriftobjekt mehr liefern. Ein `overrides`-
|
||||
Eintrag in der `package.json` oder eine neuere Fassung macht die Datei
|
||||
überflüssig — sie baut sich dann selbst ab.
|
||||
|
||||
---
|
||||
|
||||
## 2.0 — Mehr als eine Betreuung
|
||||
|
||||
**Ziel:** Was sich nur mit einem Bruch lösen lässt. Deshalb eine eigene
|
||||
Hauptversion — und deshalb nicht vorher.
|
||||
|
||||
### Zweite betreute Person im Alltag erprobt
|
||||
|
||||
Das Datenmodell trägt es von Anfang an: Alles hängt an einer `betreuteId`,
|
||||
der Zugriff wird gegen sie geprüft, die Auswahl steht in der Seitenleiste.
|
||||
**Gelaufen ist es bisher nur mit einer.** Was fehlt, ist Erfahrung — und
|
||||
vermutlich ein Dashboard, das über beide hinwegsieht.
|
||||
|
||||
### Heimkostenmodell entwirren
|
||||
|
||||
Der einrichtungseinheitliche Eigenanteil auf der Heimrechnung ist bereits
|
||||
um die Leistung der Pflegekasse gekürzt. Das Modul rechnet deshalb
|
||||
ausdrücklich nach der Lesart `EIGENANTEIL_NETTO` und warnt, wenn die
|
||||
Pflegekassenleistung zusätzlich erfasst wird.
|
||||
|
||||
Sauberer wäre, die beiden Lesarten im Modell zu trennen, statt sie im Kopf
|
||||
auseinanderzuhalten. Das ändert bestehende Datensätze — also 2.0.
|
||||
|
||||
### Mehrere Fassungen je Bericht
|
||||
|
||||
Heute verdrängt die DOCX-Ausgabe die abgegebene PDF-Fassung. Was einmal
|
||||
beim Gericht lag, sollte unverändert nachweisbar bleiben.
|
||||
|
||||
### Verschlüsselte Ablage auch bei S3
|
||||
|
||||
Beim Dateitreiber liegen Dokumente zusätzlich AES-256-GCM-verschlüsselt.
|
||||
Bei S3 geht das nicht, weil signierte URLs am Server vorbei ausgeliefert
|
||||
werden. Der Ausweg wäre, Dateien durch die Anwendung zu reichen — das
|
||||
kostet Durchsatz und ist eine bewusste Abwägung, keine Selbstverständlichkeit.
|
||||
|
||||
---
|
||||
|
||||
## Später, ohne Datum
|
||||
|
||||
Sinnvoll, aber nicht dringend:
|
||||
|
||||
- **Kalendarische Wiedervorlage per E-Mail als Wochenübersicht** statt
|
||||
einzelner Erinnerungen.
|
||||
- **Vorlagen für eigene Anschreiben**, über die mitgelieferten hinaus.
|
||||
- **Import eines Grundbuchauszugs** als strukturierte Daten statt als PDF.
|
||||
- **Mehrere Betreuungsgerichte** je betreuter Person (bei Umzug).
|
||||
- **Zwei-Personen-Prinzip** für besonders sensible Aktionen — technisch
|
||||
vorbereitet durch die erneute Anmeldung, fachlich noch nicht gebraucht.
|
||||
- **Statistik über mehrere Betreuungsjahre** für den eigenen Überblick.
|
||||
|
||||
---
|
||||
|
||||
## Bewusst nicht geplant
|
||||
|
||||
Damit klar ist, worauf niemand warten muss:
|
||||
|
||||
| Was | Warum nicht |
|
||||
|---|---|
|
||||
| **Automatische Rechtsberatung** | Die Anwendung kennt den Einzelfall nicht. Sie rechnet und dokumentiert; entscheiden tun Gericht, Träger und im Zweifel das Sozialgericht. |
|
||||
| **Prognosen zu Bewilligungschancen** | Eine Zahl, die niemand belegen kann, wird trotzdem geglaubt. Das ist schlimmer als keine Zahl. |
|
||||
| **Direkte Bankanbindung** | Ein dauerhafter Kontozugriff ist ein Risiko, das der Bequemlichkeit nicht wert ist. CSV und CAMT reichen. |
|
||||
| **Mehrmandantenfähigkeit für fremde Betreuungen** | Sobald mehrere Betreuer mit fremden Fällen auf derselben Installation arbeiten, ändert sich die datenschutzrechtliche Lage grundlegend. Mehrere Betreute **einer** Person bleiben möglich. |
|
||||
| **Native App für Handy und Tablet** | Die Web-Anwendung ist am Telefon vollwertig bedienbar. Eine zweite Oberfläche wäre eine zweite Oberfläche, die veraltet. |
|
||||
| **Cloud-Angebot für andere Betreuer** | Dann wäre ich Auftragsverarbeiter für fremde Gesundheitsdaten. Eine andere Aufgabe als die, für die das hier gebaut wurde. |
|
||||
| **KI-Auswertung der Akte** | Gesundheitsdaten einer nicht entscheidungsfähigen Person verlassen diesen Server nicht. Die Texterkennung läuft lokal, und dabei bleibt es. |
|
||||
|
||||
---
|
||||
|
||||
## Wie hier priorisiert wird
|
||||
|
||||
Drei Fragen, in dieser Reihenfolge:
|
||||
|
||||
1. **Kann daraus ein falscher Wert in einem Bericht ans Gericht werden?**
|
||||
Dann sofort — auch wenn es unbequem ist.
|
||||
2. **Kostet es jeden Monat Zeit?** Dann bald.
|
||||
3. **Wäre es schön?** Dann irgendwann, und ehrlich gesagt vielleicht nie.
|
||||
|
||||
Fällt ein Punkt in Kategorie 1 und wird trotzdem nicht sofort behoben,
|
||||
steht der Grund dabei — und die Oberfläche sagt an der betroffenen Stelle,
|
||||
worauf man achten muss. Ein stillschweigend falscher Wert ist das
|
||||
Schlimmste, was diese Anwendung produzieren kann.
|
||||
@@ -0,0 +1,188 @@
|
||||
import { expect, test } from '@playwright/test'
|
||||
import type { BrowserContext, CDPSession, Page } from '@playwright/test'
|
||||
import { anmelden, fehlversucheLoeschen } from './hilfen'
|
||||
|
||||
/**
|
||||
* Passkeys gegen einen echten Browser.
|
||||
*
|
||||
* WebAuthn laesst sich nicht sinnvoll mit Einheitstests pruefen: Was zaehlt,
|
||||
* passiert zwischen Browser und Authenticator. Chromium bringt dafuer einen
|
||||
* virtuellen Authenticator mit, der ueber das Debugprotokoll gesteuert wird -
|
||||
* er signiert echt, nur ohne Fingerabdrucksensor.
|
||||
*
|
||||
* Damit laesst sich der Ablauf vollstaendig durchspielen: einrichten,
|
||||
* abmelden, mit Passkey anmelden, entfernen. Und, wichtiger, der Fall, den
|
||||
* die Zusage dieser Anwendung traegt - ein Geraet OHNE Nutzerverifikation
|
||||
* darf nicht hereinkommen.
|
||||
*/
|
||||
|
||||
type VirtuellerAuthenticator = {
|
||||
cdp: CDPSession
|
||||
id: string
|
||||
}
|
||||
|
||||
async function authenticatorAnlegen(
|
||||
kontext: BrowserContext,
|
||||
seite: Page,
|
||||
verifiziert = true,
|
||||
): Promise<VirtuellerAuthenticator> {
|
||||
const cdp = await kontext.newCDPSession(seite)
|
||||
await cdp.send('WebAuthn.enable')
|
||||
|
||||
const { authenticatorId } = await cdp.send('WebAuthn.addVirtualAuthenticator', {
|
||||
options: {
|
||||
protocol: 'ctap2',
|
||||
// "internal" = im Geraet verbaut, wie Face ID oder Windows Hello.
|
||||
transport: 'internal',
|
||||
// Auffindbarer Schluessel - Voraussetzung fuer die Anmeldung ohne
|
||||
// vorherige Eingabe der E-Mail-Adresse.
|
||||
hasResidentKey: true,
|
||||
hasUserVerification: true,
|
||||
isUserVerified: verifiziert,
|
||||
automaticPresenceSimulation: true,
|
||||
},
|
||||
})
|
||||
|
||||
return { cdp, id: authenticatorId }
|
||||
}
|
||||
|
||||
async function passkeyEinrichten(seite: Page, name: string): Promise<void> {
|
||||
await seite.goto('/konto')
|
||||
await seite.getByLabel('Neues Gerät').fill(name)
|
||||
await seite.getByRole('button', { name: 'Passkey einrichten' }).click()
|
||||
await expect(seite.getByText(`„${name}“ ist eingerichtet.`)).toBeVisible()
|
||||
}
|
||||
|
||||
test.describe('Passkey', () => {
|
||||
test.beforeEach(async () => {
|
||||
await fehlversucheLoeschen()
|
||||
})
|
||||
|
||||
test('richtet einen Passkey ein und meldet sich anschliessend damit an', async ({
|
||||
page,
|
||||
context,
|
||||
}) => {
|
||||
const authenticator = await authenticatorAnlegen(context, page)
|
||||
|
||||
// --- 1. Auf dem gewoehnlichen Weg herein --------------------------------
|
||||
await anmelden(page)
|
||||
|
||||
// --- 2. Passkey einrichten ---------------------------------------------
|
||||
await passkeyEinrichten(page, 'Testgerät')
|
||||
|
||||
// Er steht in der Liste, mit Datum und dem Hinweis "noch nicht benutzt".
|
||||
const eintrag = page.locator('li', { hasText: 'Testgerät' })
|
||||
await expect(eintrag).toBeVisible()
|
||||
await expect(eintrag).toContainText('noch nicht benutzt')
|
||||
|
||||
// --- 3. Abmelden --------------------------------------------------------
|
||||
await context.clearCookies()
|
||||
await page.goto('/anmelden')
|
||||
await expect(page.getByRole('button', { name: 'Mit Passkey anmelden' })).toBeVisible()
|
||||
|
||||
// --- 4. Mit Passkey anmelden -------------------------------------------
|
||||
await Promise.all([
|
||||
page.waitForURL((url) => !url.pathname.startsWith('/anmelden'), { timeout: 45_000 }),
|
||||
page.getByRole('button', { name: 'Mit Passkey anmelden' }).click(),
|
||||
])
|
||||
|
||||
// Kein zweiter Schritt: Der Passkey IST der zweite Faktor. Wer hier auf
|
||||
// der Einrichtungsseite fuer TOTP landet, hat einen Fehler im Ablauf.
|
||||
expect(new URL(page.url()).pathname).not.toContain('/zwei-faktor')
|
||||
|
||||
// --- 5. Die Benutzung ist vermerkt -------------------------------------
|
||||
await page.goto('/konto')
|
||||
await expect(page.locator('li', { hasText: 'Testgerät' })).toContainText('zuletzt benutzt')
|
||||
|
||||
// --- 6. Wieder entfernen, damit der naechste Lauf sauber startet -------
|
||||
await page.locator('li', { hasText: 'Testgerät' }).getByRole('button').click()
|
||||
await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
|
||||
await expect(page.getByText('„Testgerät“ wurde entfernt.')).toBeVisible()
|
||||
|
||||
await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
|
||||
authenticatorId: authenticator.id,
|
||||
})
|
||||
})
|
||||
|
||||
test('laesst ein Geraet ohne Nutzerverifikation nicht herein', async ({ page, context }) => {
|
||||
// Das ist die Zusage, auf der alles steht: Ein Passkey darf den zweiten
|
||||
// Faktor nur ersetzen, wenn das Geraet den Benutzer wirklich verifiziert
|
||||
// hat - Fingerabdruck, Gesicht oder PIN. Ein Schluessel, der auf blosses
|
||||
// Antippen hin signiert, ist ein Faktor, kein zweiter.
|
||||
//
|
||||
// Was dieser Test belegt: Die Anforderung erreicht das Geraet, und ein
|
||||
// Geraet ohne Verifikation kommt nicht herein. Abgewiesen wird dabei
|
||||
// schon vom Browser - im Protokoll steht deshalb kein fehlgeschlagener
|
||||
// Versuch. Die Pruefung auf dem Server (requireUserVerification und die
|
||||
// ausdrueckliche Abfrage von userVerified in anmeldungPruefen) ist der
|
||||
// Rueckhalt fuer den Fall, dass jemand die Antwort von Hand baut und den
|
||||
// Browser umgeht. Der laesst sich hier nicht nachstellen.
|
||||
const authenticator = await authenticatorAnlegen(context, page, true)
|
||||
|
||||
await anmelden(page)
|
||||
await passkeyEinrichten(page, 'Ungesichertes Gerät')
|
||||
|
||||
// Jetzt die Verifikation abschalten - so verhaelt sich ein Geraet ohne
|
||||
// eingerichtete Bildschirmsperre.
|
||||
await authenticator.cdp.send('WebAuthn.setUserVerified', {
|
||||
authenticatorId: authenticator.id,
|
||||
isUserVerified: false,
|
||||
})
|
||||
|
||||
await context.clearCookies()
|
||||
await page.goto('/anmelden')
|
||||
await page.getByRole('button', { name: 'Mit Passkey anmelden' }).click()
|
||||
|
||||
// Entscheidend ist nicht der Wortlaut, sondern: Es geht nicht herein.
|
||||
await expect(page.getByRole('alert')).toBeVisible({ timeout: 30_000 })
|
||||
await page.waitForTimeout(1000)
|
||||
expect(new URL(page.url()).pathname).toBe('/anmelden')
|
||||
|
||||
// Aufraeumen: wieder verifizieren, anmelden, Passkey entfernen.
|
||||
await authenticator.cdp.send('WebAuthn.setUserVerified', {
|
||||
authenticatorId: authenticator.id,
|
||||
isUserVerified: true,
|
||||
})
|
||||
await fehlversucheLoeschen()
|
||||
await anmelden(page)
|
||||
await page.goto('/konto')
|
||||
await page.locator('li', { hasText: 'Ungesichertes Gerät' }).getByRole('button').click()
|
||||
await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
|
||||
await expect(page.getByText('„Ungesichertes Gerät“ wurde entfernt.')).toBeVisible()
|
||||
|
||||
await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
|
||||
authenticatorId: authenticator.id,
|
||||
})
|
||||
})
|
||||
|
||||
test('bestaetigt eine sensible Aktion mit dem Passkey statt mit Passwort und Code', async ({
|
||||
page,
|
||||
context,
|
||||
}) => {
|
||||
const authenticator = await authenticatorAnlegen(context, page)
|
||||
|
||||
await anmelden(page)
|
||||
await passkeyEinrichten(page, 'Bestätigungsgerät')
|
||||
|
||||
// Der Vollexport verlangt eine frische Anmeldung.
|
||||
await page.goto('/berichte/export')
|
||||
await page.waitForURL(/\/(bestaetigen|berichte)/)
|
||||
|
||||
if (new URL(page.url()).pathname === '/bestaetigen') {
|
||||
await Promise.all([
|
||||
page.waitForURL((url) => url.pathname !== '/bestaetigen', { timeout: 45_000 }),
|
||||
page.getByRole('button', { name: 'Mit Passkey bestätigen' }).click(),
|
||||
])
|
||||
expect(new URL(page.url()).pathname).toContain('/berichte/export')
|
||||
}
|
||||
|
||||
await page.goto('/konto')
|
||||
await page.locator('li', { hasText: 'Bestätigungsgerät' }).getByRole('button').click()
|
||||
await page.getByRole('button', { name: 'Wirklich entfernen' }).click()
|
||||
await expect(page.getByText('„Bestätigungsgerät“ wurde entfernt.')).toBeVisible()
|
||||
|
||||
await authenticator.cdp.send('WebAuthn.removeVirtualAuthenticator', {
|
||||
authenticatorId: authenticator.id,
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -6,6 +6,16 @@ const nextConfig = {
|
||||
poweredByHeader: false,
|
||||
// Argon2 ist eine native Bibliothek und darf nicht gebundelt werden.
|
||||
serverExternalPackages: ['@node-rs/argon2'],
|
||||
|
||||
// Zwei Seiten lesen zur Laufzeit eine Markdown-Datei aus docs/:
|
||||
// die Datenschutzhinweise und die Bedienungsanleitung. Der Pfad wird
|
||||
// erst zur Laufzeit gebaut, die Dateiverfolgung von Next.js kann ihn
|
||||
// also nicht erkennen - ohne diesen Eintrag fehlten beide Dateien im
|
||||
// Standalone-Build, und im Behaelter waeren die Seiten leer.
|
||||
outputFileTracingIncludes: {
|
||||
'/datenschutz': ['./docs/datenschutzhinweise.md'],
|
||||
'/anleitung': ['./docs/ANLEITUNG.md'],
|
||||
},
|
||||
eslint: {
|
||||
ignoreDuringBuilds: false,
|
||||
},
|
||||
|
||||
Generated
+298
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "betreuungs-cockpit",
|
||||
"version": "0.1.0",
|
||||
"version": "1.0.5",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "betreuungs-cockpit",
|
||||
"version": "0.1.0",
|
||||
"version": "1.0.5",
|
||||
"hasInstallScript": true,
|
||||
"dependencies": {
|
||||
"@aws-sdk/client-s3": "3.735.0",
|
||||
@@ -18,6 +18,8 @@
|
||||
"@radix-ui/react-label": "2.1.1",
|
||||
"@radix-ui/react-slot": "1.1.1",
|
||||
"@react-pdf/renderer": "4.1.6",
|
||||
"@simplewebauthn/browser": "13.3.0",
|
||||
"@simplewebauthn/server": "13.3.2",
|
||||
"archiver": "7.0.1",
|
||||
"class-variance-authority": "0.7.1",
|
||||
"clsx": "2.1.1",
|
||||
@@ -1573,6 +1575,12 @@
|
||||
"integrity": "sha512-HpCo8tmWzLVad5s2d19EhAz5zqrrQ6s69qd6moPMQvkOuSwDT1YgRfWSVuc4ennqrgv3OHppiOGMQ7oC13yIww==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@hexagon/base64": {
|
||||
"version": "1.1.28",
|
||||
"resolved": "https://registry.npmjs.org/@hexagon/base64/-/base64-1.1.28.tgz",
|
||||
"integrity": "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@humanfs/core": {
|
||||
"version": "0.19.2",
|
||||
"resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
|
||||
@@ -2161,6 +2169,12 @@
|
||||
"@jridgewell/sourcemap-codec": "^1.4.14"
|
||||
}
|
||||
},
|
||||
"node_modules/@levischuck/tiny-cbor": {
|
||||
"version": "0.2.11",
|
||||
"resolved": "https://registry.npmjs.org/@levischuck/tiny-cbor/-/tiny-cbor-0.2.11.tgz",
|
||||
"integrity": "sha512-llBRm4dT4Z89aRsm6u2oEZ8tfwL/2l6BwpZ7JcyieouniDECM5AqNgr/y08zalEIvW3RSK4upYyybDcmjXqAow==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@napi-rs/lzma-linux-x64-gnu": {
|
||||
"version": "1.5.1",
|
||||
"resolved": "https://registry.npmjs.org/@napi-rs/lzma-linux-x64-gnu/-/lzma-linux-x64-gnu-1.5.1.tgz",
|
||||
@@ -2706,6 +2720,207 @@
|
||||
"pako": "^1.0.10"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-android": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-android/-/asn1-android-2.9.4.tgz",
|
||||
"integrity": "sha512-SYHm4SoWSI0nRCoos6jpGusIqhPH9bbGBqv7ohlZ+H6BunrDzzQPk2ePgDuEUzV82OdvbLgtW4twUDwhU9P3YQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-cms": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.9.4.tgz",
|
||||
"integrity": "sha512-cben7oxmQsUGZqotus7yt0srYdncOT6RNWcTQ77T2RFOXejYVYkXadrfePdRcrVpO9K95IRLKKglG2k38jKXuw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"@peculiar/asn1-x509-attr": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-csr": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.9.4.tgz",
|
||||
"integrity": "sha512-xd4YN4vpRjkDAQWVfZZkeu12IEND7DOpkqaHSIHxZl1uggUNa9Ju0QxY2jHvDAS9pP0zhRBytg8ifsnGo3V0jw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-ecc": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.9.4.tgz",
|
||||
"integrity": "sha512-JJXefFshRAuVAjWQo/39bkg1ywc1VaiO44S8RRC+Ykvf/u2KDmYffoDb0ZBPCR5uJy4AGKQhl8mX+Q8ShcWaXQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-pfx": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.9.4.tgz",
|
||||
"integrity": "sha512-khuGzHTzNzk4GDlIBEILyIs6Lce0yn0ZBdoI9v93kmNncfZRhD+AQ5ODFqdhvoE8cMJF/JMTQ8yA+t1D14kqCw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-cms": "^2.9.4",
|
||||
"@peculiar/asn1-pkcs8": "^2.9.4",
|
||||
"@peculiar/asn1-rsa": "^2.9.4",
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-pkcs8": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.9.4.tgz",
|
||||
"integrity": "sha512-duRdotlUx9eDZe6QrQpQKl61RbWykCHBCkKayP8V8XdEFwlKHZ8qGGDMyS6Pye7OX7nLFttTTpRkJeet78ckwQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-pkcs9": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.9.4.tgz",
|
||||
"integrity": "sha512-kaL4cNxBpdQE2dKlyZBqz4ygCrwffO+8wfoxTEqM1Z8RadvCeELBRzcv0dzM8aY9azHMwODO5nxU65zXmhToOQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-cms": "^2.9.4",
|
||||
"@peculiar/asn1-pfx": "^2.9.4",
|
||||
"@peculiar/asn1-pkcs8": "^2.9.4",
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"@peculiar/asn1-x509-attr": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-rsa": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.9.4.tgz",
|
||||
"integrity": "sha512-pZ96eD1PptovcWQ/GSmuNFXd/7EQJNlKfDaNCyE2rx3W0v6QFelkzquVqRSRyyDXXCYD69ZXJDzZ8GhIiQzKoA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-schema": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.9.4.tgz",
|
||||
"integrity": "sha512-GjzePcT9Iw8NzeOPf73iNS9xM+TBhd/FilAfP+RQGkTMQJTVWtytN3JHJACCjf/ABNau5S7mS3g+DcuxmRgYEg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/utils": "^2.0.2",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-x509": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.9.4.tgz",
|
||||
"integrity": "sha512-CxhBo/RdEbMMob7T31ZdQjGuoyRFLVwrDzTn25bihzBasRg9kRm/0IxIPvhgQtcK/9dNcO1XQL2fuPugwELL0Q==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/utils": "^2.0.2",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/asn1-x509-attr": {
|
||||
"version": "2.9.4",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.9.4.tgz",
|
||||
"integrity": "sha512-ehQXbpQaQYycgu8OrvigwSPTFfVRcu0ECNYCWw+yzBp02Lw5paRqzzhUpfOgO2K38+WfFZuEz/0RPtam5g0OMg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-schema": "^2.9.4",
|
||||
"@peculiar/asn1-x509": "^2.9.4",
|
||||
"asn1js": "^3.0.10",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=14"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/utils": {
|
||||
"version": "2.0.3",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.3.tgz",
|
||||
"integrity": "sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"tslib": "^2.8.1"
|
||||
}
|
||||
},
|
||||
"node_modules/@peculiar/x509": {
|
||||
"version": "1.14.3",
|
||||
"resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-1.14.3.tgz",
|
||||
"integrity": "sha512-C2Xj8FZ0uHWeCXXqX5B4/gVFQmtSkiuOolzAgutjTfseNOHT3pUjljDZsTSxXFGgio54bCzVFqmEOUrIVk8RDA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@peculiar/asn1-cms": "^2.6.0",
|
||||
"@peculiar/asn1-csr": "^2.6.0",
|
||||
"@peculiar/asn1-ecc": "^2.6.0",
|
||||
"@peculiar/asn1-pkcs9": "^2.6.0",
|
||||
"@peculiar/asn1-rsa": "^2.6.0",
|
||||
"@peculiar/asn1-schema": "^2.6.0",
|
||||
"@peculiar/asn1-x509": "^2.6.0",
|
||||
"pvtsutils": "^1.3.6",
|
||||
"reflect-metadata": "^0.2.2",
|
||||
"tslib": "^2.8.1",
|
||||
"tsyringe": "^4.10.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=20.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@pkgjs/parseargs": {
|
||||
"version": "0.11.0",
|
||||
"resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
|
||||
@@ -4033,6 +4248,31 @@
|
||||
"dev": true,
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@simplewebauthn/browser": {
|
||||
"version": "13.3.0",
|
||||
"resolved": "https://registry.npmjs.org/@simplewebauthn/browser/-/browser-13.3.0.tgz",
|
||||
"integrity": "sha512-BE/UWv6FOToAdVk0EokzkqQQDOWtNydYlY6+OrmiZ5SCNmb41VehttboTetUM3T/fr6EAFYVXjz4My2wg230rQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@simplewebauthn/server": {
|
||||
"version": "13.3.2",
|
||||
"resolved": "https://registry.npmjs.org/@simplewebauthn/server/-/server-13.3.2.tgz",
|
||||
"integrity": "sha512-KEDhfcGP1PAKRVSDjA3npTQFqS2b/srm+ipoNBNHdkzrHAlaRQUTE+a5f4ywsx6thxAw1NU2rYcLEY1949RGbQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@hexagon/base64": "^1.1.27",
|
||||
"@levischuck/tiny-cbor": "^0.2.2",
|
||||
"@peculiar/asn1-android": "^2.6.0",
|
||||
"@peculiar/asn1-ecc": "^2.6.1",
|
||||
"@peculiar/asn1-rsa": "^2.6.1",
|
||||
"@peculiar/asn1-schema": "^2.6.0",
|
||||
"@peculiar/asn1-x509": "^2.6.1",
|
||||
"@peculiar/x509": "^1.14.3"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=20.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@smithy/config-resolver": {
|
||||
"version": "4.7.2",
|
||||
"resolved": "https://registry.npmjs.org/@smithy/config-resolver/-/config-resolver-4.7.2.tgz",
|
||||
@@ -5855,6 +6095,20 @@
|
||||
"url": "https://github.com/sponsors/ljharb"
|
||||
}
|
||||
},
|
||||
"node_modules/asn1js": {
|
||||
"version": "3.0.10",
|
||||
"resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
|
||||
"integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
|
||||
"license": "BSD-3-Clause",
|
||||
"dependencies": {
|
||||
"pvtsutils": "^1.3.6",
|
||||
"pvutils": "^1.1.5",
|
||||
"tslib": "^2.8.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=12.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/assertion-error": {
|
||||
"version": "2.0.1",
|
||||
"resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
|
||||
@@ -10192,6 +10446,24 @@
|
||||
"node": ">=6"
|
||||
}
|
||||
},
|
||||
"node_modules/pvtsutils": {
|
||||
"version": "1.3.6",
|
||||
"resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
|
||||
"integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"tslib": "^2.8.1"
|
||||
}
|
||||
},
|
||||
"node_modules/pvutils": {
|
||||
"version": "1.2.0",
|
||||
"resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.2.0.tgz",
|
||||
"integrity": "sha512-BbubeCEyTuQjVMakvJQ/Sxbc93F2pwmbsxONT/ZRrwU7Ua38d8unYTwXpTVLAKJ4BDuH9IGztCjQcd/N/39Dvg==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=16.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/qrcode": {
|
||||
"version": "1.5.4",
|
||||
"resolved": "https://registry.npmjs.org/qrcode/-/qrcode-1.5.4.tgz",
|
||||
@@ -10398,6 +10670,12 @@
|
||||
"node": ">=8.10.0"
|
||||
}
|
||||
},
|
||||
"node_modules/reflect-metadata": {
|
||||
"version": "0.2.2",
|
||||
"resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
|
||||
"integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
|
||||
"license": "Apache-2.0"
|
||||
},
|
||||
"node_modules/reflect.getprototypeof": {
|
||||
"version": "1.0.10",
|
||||
"resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
|
||||
@@ -11687,6 +11965,24 @@
|
||||
"fsevents": "~2.3.3"
|
||||
}
|
||||
},
|
||||
"node_modules/tsyringe": {
|
||||
"version": "4.10.0",
|
||||
"resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz",
|
||||
"integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"tslib": "^1.9.3"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 6.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/tsyringe/node_modules/tslib": {
|
||||
"version": "1.14.1",
|
||||
"resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
|
||||
"integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
|
||||
"license": "0BSD"
|
||||
},
|
||||
"node_modules/type-check": {
|
||||
"version": "0.4.0",
|
||||
"resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
|
||||
|
||||
+9
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betreuungs-cockpit",
|
||||
"version": "1.0.0",
|
||||
"version": "1.1.0",
|
||||
"private": true,
|
||||
"description": "Arbeits- und Dokumentationswerkzeug fuer die ehrenamtliche rechtliche Betreuung",
|
||||
"engines": {
|
||||
@@ -44,6 +44,8 @@
|
||||
"@radix-ui/react-label": "2.1.1",
|
||||
"@radix-ui/react-slot": "1.1.1",
|
||||
"@react-pdf/renderer": "4.1.6",
|
||||
"@simplewebauthn/browser": "13.3.0",
|
||||
"@simplewebauthn/server": "13.3.2",
|
||||
"archiver": "7.0.1",
|
||||
"class-variance-authority": "0.7.1",
|
||||
"clsx": "2.1.1",
|
||||
@@ -90,5 +92,11 @@
|
||||
"prisma@6.3.1": true,
|
||||
"sharp@0.33.5": true,
|
||||
"unrs-resolver@1.12.2": true
|
||||
},
|
||||
"overrides": {
|
||||
"next-auth": {
|
||||
"@simplewebauthn/server": "$@simplewebauthn/server",
|
||||
"@simplewebauthn/browser": "$@simplewebauthn/browser"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,67 @@
|
||||
-- Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
|
||||
--
|
||||
-- ACHTUNG beim Erzeugen weiterer Migrationen: "prisma migrate diff" wollte
|
||||
-- hier zusaetzlich die Trigramm-Indizes "dokument_absender_trgm" und
|
||||
-- "vorgang_titel_trgm" loeschen. Die stammen aus prisma/sql/suche.sql und
|
||||
-- sind Prisma unbekannt - ein DROP haette die unscharfe Suche stillgelegt,
|
||||
-- ohne dass irgendetwas fehlgeschlagen waere. Solche Zeilen gehoeren aus
|
||||
-- jeder erzeugten Migration entfernt.
|
||||
|
||||
-- CreateEnum
|
||||
CREATE TYPE "PasskeyAnfrageArt" AS ENUM ('REGISTRIERUNG', 'ANMELDUNG');
|
||||
|
||||
-- AlterEnum
|
||||
-- This migration adds more than one value to an enum.
|
||||
-- With PostgreSQL versions 11 and earlier, this is not possible
|
||||
-- in a single migration. This can be worked around by creating
|
||||
-- multiple migrations, each migration adding only one value to
|
||||
-- the enum.
|
||||
|
||||
|
||||
ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_REGISTRIERT';
|
||||
ALTER TYPE "AuditAktion" ADD VALUE 'PASSKEY_ENTFERNT';
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "passkey" (
|
||||
"id" TEXT NOT NULL,
|
||||
"userId" TEXT NOT NULL,
|
||||
"credentialId" TEXT NOT NULL,
|
||||
"publicKey" BYTEA NOT NULL,
|
||||
"counter" BIGINT NOT NULL DEFAULT 0,
|
||||
"transports" TEXT[] DEFAULT ARRAY[]::TEXT[],
|
||||
"name" TEXT NOT NULL,
|
||||
"geraeteArt" TEXT,
|
||||
"gesichert" BOOLEAN NOT NULL DEFAULT false,
|
||||
"erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
"zuletztBenutztAm" TIMESTAMP(3),
|
||||
|
||||
CONSTRAINT "passkey_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateTable
|
||||
CREATE TABLE "passkey_anfrage" (
|
||||
"id" TEXT NOT NULL,
|
||||
"challenge" TEXT NOT NULL,
|
||||
"art" "PasskeyAnfrageArt" NOT NULL,
|
||||
"userId" TEXT,
|
||||
"ablaufAm" TIMESTAMP(3) NOT NULL,
|
||||
"erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
|
||||
CONSTRAINT "passkey_anfrage_pkey" PRIMARY KEY ("id")
|
||||
);
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "passkey_credentialId_key" ON "passkey"("credentialId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "passkey_userId_idx" ON "passkey"("userId");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE UNIQUE INDEX "passkey_anfrage_challenge_key" ON "passkey_anfrage"("challenge");
|
||||
|
||||
-- CreateIndex
|
||||
CREATE INDEX "passkey_anfrage_ablaufAm_idx" ON "passkey_anfrage"("ablaufAm");
|
||||
|
||||
-- AddForeignKey
|
||||
ALTER TABLE "passkey" ADD CONSTRAINT "passkey_userId_fkey" FOREIGN KEY ("userId") REFERENCES "benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;
|
||||
|
||||
@@ -89,6 +89,7 @@ model User {
|
||||
geloeschtAm DateTime?
|
||||
|
||||
zugaenge BetreuungsZugang[]
|
||||
passkeys Passkey[]
|
||||
auditEintraege AuditLog[]
|
||||
angelegteVorgaenge Vorgang[] @relation("VorgangAngelegtVon")
|
||||
berichte Bericht[]
|
||||
@@ -135,6 +136,91 @@ model LoginVersuch {
|
||||
@@map("login_versuch")
|
||||
}
|
||||
|
||||
/// Ein registrierter Passkey (WebAuthn/FIDO2).
|
||||
///
|
||||
/// Der private Schluessel verlaesst das Geraet nie - hier liegt nur der
|
||||
/// oeffentliche Teil. Ein gestohlener Datenbankabzug erlaubt deshalb keine
|
||||
/// Anmeldung, anders als bei einem Passworthash, den man offline angreifen
|
||||
/// kann.
|
||||
///
|
||||
/// Ein Passkey zaehlt bei uns als ZWEI Faktoren: Besitz des Geraets plus
|
||||
/// die Nutzerverifikation darauf (Fingerabdruck, Gesicht oder Geraete-PIN).
|
||||
/// Deshalb wird bei der Anmeldung "userVerified" erzwungen - siehe
|
||||
/// src/lib/auth/passkey.ts. Ohne diese Pruefung waere es nur ein Faktor.
|
||||
model Passkey {
|
||||
id String @id @default(cuid())
|
||||
|
||||
userId String
|
||||
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
|
||||
|
||||
/// Kennung des Authenticators, base64url. Eindeutig ueber alle Benutzer -
|
||||
/// derselbe Schluessel darf nicht an zwei Zugaengen haengen.
|
||||
credentialId String @unique
|
||||
|
||||
/// Oeffentlicher Schluessel im COSE-Format. Kein Geheimnis.
|
||||
publicKey Bytes
|
||||
|
||||
/// Signaturzaehler des Authenticators. Zaehlt er nicht hoch, obwohl er
|
||||
/// es vorher tat, ist der Schluessel womoeglich geklont worden.
|
||||
/// BigInt, weil der Zaehler bis 2^32-1 geht.
|
||||
counter BigInt @default(0)
|
||||
|
||||
/// "usb", "nfc", "ble", "internal", "hybrid" - hilft dem Browser beim
|
||||
/// naechsten Mal, das richtige Geraet vorzuschlagen.
|
||||
transports String[] @default([])
|
||||
|
||||
/// Vom Benutzer vergeben ("iPhone von Florian"). Bei mehreren Geraeten
|
||||
/// ist das die einzige Moeglichkeit, sie auseinanderzuhalten.
|
||||
name String
|
||||
|
||||
/// "singleDevice" = liegt nur auf diesem Geraet, "multiDevice" = wird vom
|
||||
/// Schluesselbund synchronisiert. Steht in der Uebersicht, weil es den
|
||||
/// Unterschied macht, ob ein verlorenes Geraet den Zugang mitnimmt.
|
||||
geraeteArt String?
|
||||
|
||||
/// Ob der Anbieter den Schluessel gesichert hat (iCloud, Google, Bitwarden).
|
||||
gesichert Boolean @default(false)
|
||||
|
||||
erstelltAm DateTime @default(now())
|
||||
zuletztBenutztAm DateTime?
|
||||
|
||||
@@index([userId])
|
||||
@@map("passkey")
|
||||
}
|
||||
|
||||
enum PasskeyAnfrageArt {
|
||||
REGISTRIERUNG
|
||||
ANMELDUNG
|
||||
}
|
||||
|
||||
/// Kurzlebiger Speicher fuer die Challenge einer laufenden Passkey-Aktion.
|
||||
///
|
||||
/// Die Challenge muss serverseitig liegen und genau einmal gelten, sonst
|
||||
/// liesse sich eine mitgeschnittene Antwort erneut einspielen. Verbraucht
|
||||
/// wird sie durch DELETE - dass genau eine Zeile geloescht wurde, ist der
|
||||
/// Beweis, dass sie noch nicht benutzt war.
|
||||
///
|
||||
/// Bewusst ohne Fremdschluessel auf User: die Zeile lebt fuenf Minuten und
|
||||
/// ist kein Fachdatum. Der Wartungslauf raeumt Liegengebliebenes weg.
|
||||
model PasskeyAnfrage {
|
||||
id String @id @default(cuid())
|
||||
|
||||
/// base64url, zufaellig. Eindeutig, damit das Verbrauchen atomar ist.
|
||||
challenge String @unique
|
||||
|
||||
art PasskeyAnfrageArt
|
||||
|
||||
/// Bei der Registrierung bekannt. Bei der Anmeldung nicht - dort weiss
|
||||
/// der Server erst nach der Antwort, wer sich anmeldet.
|
||||
userId String?
|
||||
|
||||
ablaufAm DateTime
|
||||
erstelltAm DateTime @default(now())
|
||||
|
||||
@@index([ablaufAm])
|
||||
@@map("passkey_anfrage")
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// Betreute Person
|
||||
// =============================================================================
|
||||
@@ -1527,6 +1613,8 @@ enum AuditAktion {
|
||||
ANMELDUNG_FEHLGESCHLAGEN
|
||||
ABMELDUNG
|
||||
ZWEITER_FAKTOR_EINGERICHTET
|
||||
PASSKEY_REGISTRIERT
|
||||
PASSKEY_ENTFERNT
|
||||
PASSWORT_GEAENDERT
|
||||
ROLLE_GEAENDERT
|
||||
FREIGABE_GEAENDERT
|
||||
|
||||
@@ -25,6 +25,42 @@ BEGIN
|
||||
RETURN OLD;
|
||||
END IF;
|
||||
|
||||
/*
|
||||
* Eine einzige Ausnahme beim UPDATE: das Nullen der beiden
|
||||
* Fremdschluessel.
|
||||
*
|
||||
* Wird eine betreute Person oder ein Benutzer endgueltig geloescht
|
||||
* (Papierkorb nach 30 Tagen), setzt Postgres wegen ON DELETE SET NULL
|
||||
* die Spalten betreuteId bzw. userId auf NULL. Ohne diese Ausnahme
|
||||
* scheitert das Loeschen - und der Papierkorb liesse sich nie leeren.
|
||||
*
|
||||
* Der Nachweis bleibt dabei vollstaendig: Zeitpunkt, Aktion, Entitaet,
|
||||
* Bezeichnung und die verschluesselte Aenderung sind unberuehrt, ebenso
|
||||
* die Momentaufnahmen userEmail und userName. Es verschwindet nur der
|
||||
* Verweis auf einen Datensatz, den es nicht mehr gibt.
|
||||
*
|
||||
* Jede andere Aenderung wird abgewiesen - auch das Zurueckschreiben
|
||||
* eines Fremdschluessels auf einen anderen Wert.
|
||||
*/
|
||||
IF TG_OP = 'UPDATE'
|
||||
AND NEW.id = OLD.id
|
||||
AND NEW.zeitpunkt = OLD.zeitpunkt
|
||||
AND NEW.aktion = OLD.aktion
|
||||
AND NEW.entitaet = OLD.entitaet
|
||||
AND NEW."entitaetId" IS NOT DISTINCT FROM OLD."entitaetId"
|
||||
AND NEW.bezeichnung IS NOT DISTINCT FROM OLD.bezeichnung
|
||||
AND NEW."userEmail" IS NOT DISTINCT FROM OLD."userEmail"
|
||||
AND NEW."userName" IS NOT DISTINCT FROM OLD."userName"
|
||||
AND NEW."aenderungVerschluesselt" IS NOT DISTINCT FROM OLD."aenderungVerschluesselt"
|
||||
AND NEW."ipHash" IS NOT DISTINCT FROM OLD."ipHash"
|
||||
AND NEW."userAgent" IS NOT DISTINCT FROM OLD."userAgent"
|
||||
-- Die beiden Fremdschluessel duerfen sich aendern, aber NUR nach NULL.
|
||||
AND (NEW."betreuteId" IS NULL OR NEW."betreuteId" IS NOT DISTINCT FROM OLD."betreuteId")
|
||||
AND (NEW."userId" IS NULL OR NEW."userId" IS NOT DISTINCT FROM OLD."userId")
|
||||
THEN
|
||||
RETURN NEW;
|
||||
END IF;
|
||||
|
||||
RAISE EXCEPTION
|
||||
'Das Audit-Log ist unveraenderlich. % auf audit_log ist nicht zulaessig.',
|
||||
TG_OP
|
||||
|
||||
@@ -0,0 +1,165 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Warum klappt die Anmeldung nicht?
|
||||
*
|
||||
* node --env-file=.env scripts/anmeldung-pruefen.mjs <e-mail>
|
||||
* docker compose exec app node scripts/anmeldung-pruefen.mjs <e-mail>
|
||||
*
|
||||
* Die Anwendung sagt am Anmeldeformular bewusst nicht, woran es lag - sonst
|
||||
* liesse sich daran ablesen, welche Adressen es gibt. Auf dem Server darf
|
||||
* man es wissen: Jeder Versuch wird mit Grund protokolliert, und dieses
|
||||
* Skript liest ihn vor.
|
||||
*
|
||||
* Es aendert nichts. Es liest nur.
|
||||
*/
|
||||
import { PrismaClient } from '@prisma/client'
|
||||
|
||||
const email = (process.argv[2] ?? '').trim().toLowerCase()
|
||||
|
||||
if (!email) {
|
||||
console.error('Aufruf: node scripts/anmeldung-pruefen.mjs <e-mail>')
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
const db = new PrismaClient()
|
||||
|
||||
function zeit(d) {
|
||||
return d ? new Date(d).toLocaleString('de-DE') : '—'
|
||||
}
|
||||
|
||||
/** Klartext zu den Gruenden, die src/auth.ts protokolliert. */
|
||||
const GRUND = {
|
||||
unbekannt: 'Diese E-Mail-Adresse gibt es nicht (Tippfehler? andere Adresse?)',
|
||||
'passwort-falsch': 'Das Passwort stimmt nicht',
|
||||
'code-falsch': 'Der Code aus der Authenticator-App stimmt nicht',
|
||||
gesperrt: 'Abgewiesen, weil zu diesem Zeitpunkt bereits gesperrt war',
|
||||
'konto-inaktiv': 'Der Zugang ist deaktiviert oder im Papierkorb',
|
||||
}
|
||||
|
||||
try {
|
||||
const benutzer = await db.user.findUnique({ where: { email } })
|
||||
|
||||
console.log('\n══ Zugang ' + '═'.repeat(50))
|
||||
|
||||
if (!benutzer) {
|
||||
console.log(` Es gibt KEINEN Zugang mit der Adresse ${email}.`)
|
||||
const alle = await db.user.findMany({
|
||||
select: { email: true, aktiv: true, geloeschtAm: true },
|
||||
orderBy: { erstelltAm: 'asc' },
|
||||
})
|
||||
console.log(
|
||||
alle.length
|
||||
? '\n Vorhandene Adressen:\n' +
|
||||
alle.map((u) => ` ${u.email}${u.geloeschtAm ? ' (im Papierkorb)' : u.aktiv ? '' : ' (deaktiviert)'}`).join('\n')
|
||||
: '\n Es gibt ueberhaupt keinen Zugang. Leg ihn im Browser unter /ersteinrichtung an.',
|
||||
)
|
||||
} else {
|
||||
const zweiterFaktor = benutzer.totpAktiviertAm
|
||||
? `eingerichtet am ${zeit(benutzer.totpAktiviertAm)}`
|
||||
: benutzer.totpSecretVerschluesselt
|
||||
? 'vorbereitet, aber NICHT bestaetigt - beim Anmelden wird noch kein Code verlangt'
|
||||
: 'noch nicht eingerichtet - beim Anmelden wird noch kein Code verlangt'
|
||||
|
||||
console.log(` Name: ${benutzer.name}`)
|
||||
console.log(` Rolle: ${benutzer.rolle}`)
|
||||
console.log(` Aktiv: ${benutzer.aktiv ? 'ja' : 'NEIN - Anmeldung nicht moeglich'}`)
|
||||
console.log(` Papierkorb: ${benutzer.geloeschtAm ? 'JA seit ' + zeit(benutzer.geloeschtAm) : 'nein'}`)
|
||||
console.log(` Zweiter Faktor: ${zweiterFaktor}`)
|
||||
console.log(` Wiederherstellung: ${benutzer.wiederherstellungscodes.length} Codes uebrig`)
|
||||
console.log(` Passwort gesetzt: ${zeit(benutzer.passwortGeaendertAm)}`)
|
||||
console.log(` Letzte Anmeldung: ${zeit(benutzer.letzteAnmeldung)}`)
|
||||
|
||||
const zugaenge = await db.betreuungsZugang.count({ where: { userId: benutzer.id } })
|
||||
const betreute = await db.betreute.count({ where: { geloeschtAm: null } })
|
||||
console.log(` Betreute Personen: ${zugaenge} zugeordnet, ${betreute} insgesamt angelegt`)
|
||||
|
||||
if (zugaenge === 0 && betreute === 0) {
|
||||
console.log(
|
||||
'\n Hinweis: Nach dem Anmelden landest du zuerst bei der\n' +
|
||||
' Ersteinrichtung - erst zweiter Faktor, dann betreute Person.',
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Versuche der letzten Tage -------------------------------------------
|
||||
const versuche = await db.loginVersuch.findMany({
|
||||
where: { email },
|
||||
orderBy: { zeitpunkt: 'desc' },
|
||||
take: 15,
|
||||
})
|
||||
|
||||
console.log('\n══ Letzte Anmeldeversuche ' + '═'.repeat(35))
|
||||
|
||||
if (versuche.length === 0) {
|
||||
console.log(
|
||||
' Keine. Es ist also NIE ein Versuch beim Server angekommen.\n\n' +
|
||||
' Das heisst: Das Formular hat gar nicht abgeschickt, oder es lief\n' +
|
||||
' auf eine andere Adresse. Pruef AUTH_URL - siehe unten.',
|
||||
)
|
||||
} else {
|
||||
for (const v of versuche) {
|
||||
const kennzeichen = v.erfolg ? 'OK ' : 'FEHLER'
|
||||
const grund = v.erfolg ? 'angemeldet' : (GRUND[v.grund] ?? v.grund ?? 'unbekannter Grund')
|
||||
console.log(` ${zeit(v.zeitpunkt).padEnd(20)} ${kennzeichen} ${grund}`)
|
||||
}
|
||||
}
|
||||
|
||||
// --- Sperre ---------------------------------------------------------------
|
||||
const fenster = Number.parseInt(process.env.LOGIN_FENSTER_SEKUNDEN ?? '900', 10)
|
||||
const grenze = Number.parseInt(process.env.LOGIN_MAX_VERSUCHE ?? '5', 10)
|
||||
const seit = new Date(Date.now() - fenster * 1000)
|
||||
|
||||
const offen = await db.loginVersuch.count({
|
||||
where: { email, erfolg: false, zeitpunkt: { gte: seit } },
|
||||
})
|
||||
|
||||
console.log('\n══ Sperre ' + '═'.repeat(51))
|
||||
console.log(` ${offen} von ${grenze} Fehlversuchen im laufenden Fenster (${fenster / 60} Minuten)`)
|
||||
|
||||
if (offen >= grenze) {
|
||||
console.log(
|
||||
'\n GESPERRT. Warte das Fenster ab, oder setz die Zaehler zurueck:\n' +
|
||||
' docker compose exec db psql -U cockpit betreuungs_cockpit \\\n' +
|
||||
' -c "DELETE FROM login_versuch WHERE erfolg = false;"',
|
||||
)
|
||||
}
|
||||
|
||||
// --- Umgebung -------------------------------------------------------------
|
||||
console.log('\n══ Umgebung ' + '═'.repeat(49))
|
||||
console.log(` AUTH_URL: ${process.env.AUTH_URL ?? 'NICHT GESETZT'}`)
|
||||
console.log(
|
||||
'\n Diese Adresse muss EXAKT die sein, die du im Browser aufrufst -\n' +
|
||||
' gleiches Schema (https), gleicher Hostname, kein Schraegstrich am\n' +
|
||||
' Ende. Weicht sie ab, wird das Sitzungs-Cookie fuer die falsche\n' +
|
||||
' Herkunft gesetzt: Die Anmeldung landet ohne Fehlermeldung wieder\n' +
|
||||
' auf dem Formular, und oben steht kein einziger Fehlversuch.\n',
|
||||
)
|
||||
} catch (fehler) {
|
||||
// Ein Prisma-Stacktrace hilft hier niemandem weiter.
|
||||
const meldung = fehler instanceof Error ? fehler.message : String(fehler)
|
||||
|
||||
if (/Can't reach database server|ECONNREFUSED/i.test(meldung)) {
|
||||
// Das Passwort in der Verbindungszeichenkette gehoert nicht auf den Schirm.
|
||||
const url = (process.env.DATABASE_URL ?? 'NICHT GESETZT').replace(/:[^:@/]+@/, ':***@')
|
||||
console.error(
|
||||
[
|
||||
'',
|
||||
'Die Datenbank ist nicht erreichbar.',
|
||||
'',
|
||||
` DATABASE_URL: ${url}`,
|
||||
'',
|
||||
' Im Docker-Betrieb gehoert dieses Skript IN den Behaelter:',
|
||||
' docker compose exec app node scripts/anmeldung-pruefen.mjs <e-mail>',
|
||||
'',
|
||||
' Laeuft die Datenbank ueberhaupt?',
|
||||
' docker compose ps',
|
||||
'',
|
||||
].join('\n'),
|
||||
)
|
||||
} else {
|
||||
console.error(`\nFehler: ${meldung}\n`)
|
||||
}
|
||||
process.exitCode = 1
|
||||
} finally {
|
||||
await db.$disconnect()
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* Das TOTP-Geheimnis eines Zugangs auslesen.
|
||||
*
|
||||
* node --env-file=.env scripts/totp-geheimnis.mjs <e-mail>
|
||||
*
|
||||
* Wofuer das gut ist: Die Anwendung zeigt das Geheimnis genau einmal an,
|
||||
* beim Einrichten. Wer den Zugang auf ein zweites Geraet legen will -
|
||||
* Handy und Tablet, oder ein Ersatzgeraet im Schrank - braucht es noch
|
||||
* einmal. Ohne dieses Skript bliebe nur, den zweiten Faktor zurueckzusetzen
|
||||
* und alle Wiederherstellungscodes neu zu erzeugen.
|
||||
*
|
||||
* Was es NICHT ist: eine Hintertuer. Es laeuft nur auf dem Server, nur mit
|
||||
* Zugriff auf die Datenbank UND auf ENC_KEY_V1 aus der Umgebung. Wer beides
|
||||
* hat, kann ohnehin alles lesen. Genau deshalb liegt der Schluessel nicht
|
||||
* in der Datenbank.
|
||||
*
|
||||
* Im Docker-Betrieb:
|
||||
*
|
||||
* docker compose exec app node scripts/totp-geheimnis.mjs fw@example.de
|
||||
*
|
||||
* Die Ausgabe gehoert nicht in ein Protokoll und nicht in eine E-Mail.
|
||||
*/
|
||||
import { PrismaClient } from '@prisma/client'
|
||||
import { createDecipheriv } from 'node:crypto'
|
||||
|
||||
const email = (process.argv[2] ?? '').trim().toLowerCase()
|
||||
|
||||
if (!email) {
|
||||
console.error('Aufruf: node --env-file=.env scripts/totp-geheimnis.mjs <e-mail>')
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
/**
|
||||
* Entschluesselt einen Umschlag aus src/lib/crypto/feld.ts.
|
||||
* Format: bc1.<version>.<iv>.<tag>.<geheimtext>, alles base64url.
|
||||
*/
|
||||
function entschluesseln(umschlag, kontext) {
|
||||
const teile = umschlag.split('.')
|
||||
if (teile.length !== 5 || teile[0] !== 'bc1') {
|
||||
throw new Error('Der gespeicherte Wert hat nicht das erwartete Format.')
|
||||
}
|
||||
|
||||
const version = Number.parseInt(teile[1], 10)
|
||||
const roh = process.env[`ENC_KEY_V${version}`]
|
||||
if (!roh) {
|
||||
throw new Error(
|
||||
`ENC_KEY_V${version} ist nicht gesetzt. Ohne diesen Schluessel laesst ` +
|
||||
`sich der Wert nicht lesen - auch nicht aus einem Backup.`,
|
||||
)
|
||||
}
|
||||
|
||||
const decipher = createDecipheriv(
|
||||
'aes-256-gcm',
|
||||
Buffer.from(roh, 'base64'),
|
||||
Buffer.from(teile[2], 'base64url'),
|
||||
{ authTagLength: 16 },
|
||||
)
|
||||
// Der Feldname wird mitauthentifiziert - er muss exakt stimmen.
|
||||
decipher.setAAD(Buffer.from(`bc1:${version}:${kontext}`, 'utf8'))
|
||||
decipher.setAuthTag(Buffer.from(teile[3], 'base64url'))
|
||||
|
||||
return Buffer.concat([
|
||||
decipher.update(Buffer.from(teile[4], 'base64url')),
|
||||
decipher.final(),
|
||||
]).toString('utf8')
|
||||
}
|
||||
|
||||
/** Base32 in Vierergruppen - so tippt es sich von Hand deutlich sicherer. */
|
||||
function gruppiert(text) {
|
||||
return text.replace(/(.{4})/g, '$1 ').trim()
|
||||
}
|
||||
|
||||
const db = new PrismaClient()
|
||||
|
||||
try {
|
||||
const benutzer = await db.user.findUnique({
|
||||
where: { email },
|
||||
select: {
|
||||
email: true,
|
||||
name: true,
|
||||
totpSecretVerschluesselt: true,
|
||||
totpAktiviertAm: true,
|
||||
wiederherstellungscodes: true,
|
||||
},
|
||||
})
|
||||
|
||||
if (!benutzer) {
|
||||
console.error(`Kein Zugang mit der Adresse ${email}.`)
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
if (!benutzer.totpSecretVerschluesselt) {
|
||||
console.error(
|
||||
`Fuer ${email} ist noch kein zweiter Faktor eingerichtet. ` +
|
||||
`Das passiert beim ersten Anmelden.`,
|
||||
)
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
const secret = entschluesseln(benutzer.totpSecretVerschluesselt, 'totpSecretVerschluesselt')
|
||||
const uri =
|
||||
`otpauth://totp/Betreuungs-Cockpit:${encodeURIComponent(benutzer.email)}` +
|
||||
`?secret=${secret}&issuer=Betreuungs-Cockpit&algorithm=SHA1&digits=6&period=30`
|
||||
|
||||
console.log(`
|
||||
Zugang: ${benutzer.name} <${benutzer.email}>
|
||||
Aktiv seit: ${benutzer.totpAktiviertAm?.toLocaleString('de-DE') ?? 'noch nicht bestaetigt'}
|
||||
Codes uebrig: ${benutzer.wiederherstellungscodes.length}
|
||||
|
||||
Geheimnis zum Abtippen:
|
||||
${gruppiert(secret)}
|
||||
|
||||
Zum Einscannen (in einen QR-Code-Erzeuger auf DIESEM Rechner geben,
|
||||
niemals in einen Dienst im Netz):
|
||||
${uri}
|
||||
|
||||
Diese Ausgabe gehoert nicht in ein Protokoll und nicht in eine E-Mail.
|
||||
`)
|
||||
} finally {
|
||||
await db.$disconnect()
|
||||
}
|
||||
@@ -0,0 +1,385 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# Betreuungs-Cockpit aktualisieren.
|
||||
#
|
||||
# ./scripts/update.sh auf die neueste veroeffentlichte Fassung
|
||||
# ./scripts/update.sh v1.2.0 auf eine bestimmte Fassung
|
||||
# ./scripts/update.sh --ja ohne Rueckfrage (fuer cron)
|
||||
# ./scripts/update.sh --pruefen nur nachsehen, nichts aendern
|
||||
# ./scripts/update.sh --verwerfen eigene Aenderungen an versionierten
|
||||
# Dateien wegwerfen statt beiseitelegen
|
||||
#
|
||||
# Was das Skript tut, in dieser Reihenfolge:
|
||||
#
|
||||
# 1. Voraussetzungen pruefen (Verzeichnis, git, docker, .env)
|
||||
# 2. Fassungen holen und vergleichen
|
||||
# 3. Zeigen, was sich aendert (Changelog-Abschnitte dazwischen)
|
||||
# 4. Nachfragen
|
||||
# 5. SICHERUNG anstossen - und abbrechen, wenn sie nicht klappt
|
||||
# 6. Eigene Aenderungen beiseitelegen, umschalten, neu bauen, starten
|
||||
# 7. Die beiden SQL-Skripte ausfuehren (sie sind idempotent)
|
||||
# 8. Pruefen, ob die neue Fassung wirklich laeuft
|
||||
#
|
||||
# Die Reihenfolge ist Absicht: Bis einschliesslich Schritt 4 wird nichts
|
||||
# veraendert. Wer vorher abbricht - oder wobei etwas schiefgeht -, findet
|
||||
# alles so vor wie zuvor. Erst danach wird angefasst.
|
||||
#
|
||||
# Schritt 5 ist der wichtigste: Eine Datenbank-Migration laesst sich nicht
|
||||
# zurueckrollen. Ohne Sicherung wird hier nichts aktualisiert.
|
||||
#
|
||||
# Schritt 7 ebenfalls: Die SQL-Skripte laufen NICHT mit den Migrationen
|
||||
# mit. Wer sie vergisst, hat einen veralteten Trigger und merkt es erst,
|
||||
# wenn etwas nicht geht.
|
||||
#
|
||||
# Die .env wird nie angefasst - sie ist nicht versioniert.
|
||||
|
||||
# Die geschweiften Klammern sorgen dafuer, dass bash die ganze Datei liest,
|
||||
# bevor sie irgendetwas ausfuehrt. Ohne sie koennte der git-checkout weiter
|
||||
# unten das Skript unter den eigenen Fuessen austauschen.
|
||||
{
|
||||
set -euo pipefail
|
||||
|
||||
# --- Ausgabe -----------------------------------------------------------------
|
||||
|
||||
if [ -t 1 ]; then
|
||||
ROT=$'\033[31m'; GRUEN=$'\033[32m'; GELB=$'\033[33m'; FETT=$'\033[1m'; AUS=$'\033[0m'
|
||||
else
|
||||
ROT=''; GRUEN=''; GELB=''; FETT=''; AUS=''
|
||||
fi
|
||||
|
||||
schritt() { printf '\n%s==> %s%s\n' "$FETT" "$1" "$AUS"; }
|
||||
gut() { printf ' %s%s%s\n' "$GRUEN" "$1" "$AUS"; }
|
||||
warnung() { printf ' %s%s%s\n' "$GELB" "$1" "$AUS"; }
|
||||
abbruch() { printf '\n%sAbbruch: %s%s\n\n' "$ROT" "$1" "$AUS" >&2; exit 1; }
|
||||
|
||||
# --- Aufrufparameter ---------------------------------------------------------
|
||||
|
||||
ZIEL=""
|
||||
OHNE_RUECKFRAGE=0
|
||||
NUR_PRUEFEN=0
|
||||
OHNE_SICHERUNG=0
|
||||
VERWERFEN=0
|
||||
ENTSCHEIDUNG=""
|
||||
|
||||
for arg in "$@"; do
|
||||
case "$arg" in
|
||||
--ja|-j) OHNE_RUECKFRAGE=1 ;;
|
||||
--pruefen|-p) NUR_PRUEFEN=1 ;;
|
||||
--ohne-sicherung) OHNE_SICHERUNG=1 ;;
|
||||
--verwerfen) VERWERFEN=1 ;;
|
||||
--hilfe|-h)
|
||||
sed -n '2,34p' "$0" | sed 's/^#\s\?//'
|
||||
exit 0 ;;
|
||||
-*) abbruch "Unbekannte Angabe: $arg (--hilfe zeigt die Moeglichkeiten)" ;;
|
||||
*) ZIEL="$arg" ;;
|
||||
esac
|
||||
done
|
||||
|
||||
# --- 1. Voraussetzungen ------------------------------------------------------
|
||||
|
||||
schritt "Voraussetzungen"
|
||||
|
||||
cd "$(dirname "$0")/.." || abbruch "Das Projektverzeichnis ist nicht erreichbar."
|
||||
PROJEKT="$(pwd)"
|
||||
|
||||
[ -f docker-compose.yml ] || abbruch "Hier liegt keine docker-compose.yml: $PROJEKT"
|
||||
[ -f .env ] || abbruch "Es gibt keine .env. Ohne sie startet die Anwendung nicht."
|
||||
command -v git >/dev/null || abbruch "git ist nicht installiert."
|
||||
docker compose version >/dev/null 2>&1 || abbruch "docker compose (v2) ist nicht verfuegbar."
|
||||
|
||||
gut "Verzeichnis: $PROJEKT"
|
||||
|
||||
# Nur nachsehen - angefasst wird die Arbeitskopie erst kurz vor dem
|
||||
# Umschalten, wenn Sicherung und Rueckfrage durch sind. Ein Abbruch
|
||||
# dazwischen darf keinen Halbzustand hinterlassen.
|
||||
SCHMUTZIG=""
|
||||
if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
|
||||
SCHMUTZIG="ja"
|
||||
warnung "Es gibt eigene Aenderungen an versionierten Dateien."
|
||||
git status --short --untracked-files=no | sed 's/^/ /'
|
||||
printf ' Sie werden vor dem Umschalten beiseite gelegt.\n'
|
||||
else
|
||||
gut "Arbeitskopie ist sauber"
|
||||
fi
|
||||
|
||||
# --- 2. Was ist da, was kommt ------------------------------------------------
|
||||
|
||||
schritt "Fassungen"
|
||||
|
||||
if ! git fetch --tags --quiet origin; then
|
||||
abbruch "Konnte die Fassungen nicht vom Server holen.
|
||||
Erreichst du ihn? Stimmen die Zugangsdaten?
|
||||
Es wurde nichts geaendert."
|
||||
fi
|
||||
|
||||
JETZT="$(git describe --tags --exact-match 2>/dev/null || git rev-parse --short HEAD)"
|
||||
NEUESTE="$(git tag --list 'v*' --sort=-v:refname | head -1)"
|
||||
|
||||
[ -n "$NEUESTE" ] || abbruch "Es gibt keine veroeffentlichte Fassung (kein Tag)."
|
||||
|
||||
if [ -z "$ZIEL" ]; then
|
||||
ZIEL="$NEUESTE"
|
||||
fi
|
||||
|
||||
git rev-parse --verify --quiet "$ZIEL^{commit}" >/dev/null \
|
||||
|| abbruch "Die Fassung '$ZIEL' gibt es nicht. Vorhanden:
|
||||
$(git tag --list 'v*' --sort=-v:refname | head -5 | sed 's/^/ /')"
|
||||
|
||||
printf ' Jetzt: %s\n' "$JETZT"
|
||||
printf ' Ziel: %s%s%s\n' "$FETT" "$ZIEL" "$AUS"
|
||||
|
||||
if [ "$(git rev-parse HEAD)" = "$(git rev-parse "$ZIEL^{commit}")" ]; then
|
||||
gut "Bereits auf dem gewuenschten Stand - nichts zu tun."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# --- 3. Was aendert sich -----------------------------------------------------
|
||||
|
||||
schritt "Was sich aendert"
|
||||
|
||||
# Der Changelog muss aus der ZIELfassung kommen: Der laufende Stand kennt
|
||||
# die neuen Abschnitte ja noch gar nicht.
|
||||
CHANGELOG="$(git show "$ZIEL:CHANGELOG.md" 2>/dev/null || true)"
|
||||
|
||||
if [ -n "$CHANGELOG" ]; then
|
||||
# Alle Abschnitte zwischen dem laufenden und dem gewuenschten Stand.
|
||||
JETZT_NR="${JETZT#v}"
|
||||
printf '%s
|
||||
' "$CHANGELOG" | awk -v jetzt="$JETZT_NR" '
|
||||
/^## \[/ {
|
||||
nummer = $0
|
||||
sub(/^## \[/, "", nummer); sub(/\].*/, "", nummer)
|
||||
if (nummer == jetzt) exit
|
||||
drucken = (nummer != "Unveröffentlicht")
|
||||
}
|
||||
drucken { print " " $0 }
|
||||
' | head -60
|
||||
else
|
||||
warnung "Kein CHANGELOG.md in $ZIEL gefunden."
|
||||
fi
|
||||
|
||||
printf '\n'
|
||||
git log --oneline --no-decorate "HEAD..$ZIEL" | head -15 | sed 's/^/ /'
|
||||
|
||||
if [ "$NUR_PRUEFEN" = "1" ]; then
|
||||
printf '\n'
|
||||
gut "Nur geprueft - es wurde nichts geaendert."
|
||||
[ -n "$SCHMUTZIG" ] && warnung "Beim echten Lauf wuerden deine Aenderungen beiseite gelegt."
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# --- 4. Nachfragen -----------------------------------------------------------
|
||||
|
||||
if [ "$OHNE_RUECKFRAGE" != "1" ]; then
|
||||
printf '\n%sJetzt aktualisieren auf %s? [j/N] %s' "$FETT" "$ZIEL" "$AUS"
|
||||
read -r antwort </dev/tty || antwort=""
|
||||
case "$antwort" in
|
||||
[jJ]|[jJ][aA]) ;;
|
||||
*) printf '\n'; warnung "Abgebrochen, nichts geaendert."; exit 0 ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
# --- 5. Sicherung ------------------------------------------------------------
|
||||
|
||||
if [ "$OHNE_SICHERUNG" = "1" ]; then
|
||||
schritt "Sicherung wird uebersprungen"
|
||||
warnung "Auf eigene Gefahr - eine Migration laesst sich nicht zurueckrollen."
|
||||
else
|
||||
schritt "Sicherung"
|
||||
|
||||
if docker compose ps --status running --services 2>/dev/null | grep -qx sicherung; then
|
||||
if docker compose exec -T sicherung /bin/sh /sicherung.sh; then
|
||||
gut "Sicherung angelegt und selbst geprueft."
|
||||
else
|
||||
abbruch "Die Sicherung ist fehlgeschlagen. Es wird nichts aktualisiert.
|
||||
Mit --ohne-sicherung laesst sich das uebergehen - aber ueberleg
|
||||
dir das zweimal."
|
||||
fi
|
||||
else
|
||||
warnung "Der Dienst 'sicherung' laeuft nicht - es wurde nichts gesichert."
|
||||
if [ "$OHNE_RUECKFRAGE" != "1" ]; then
|
||||
printf '\n %sTrotzdem weitermachen? [j/N] %s' "$FETT" "$AUS"
|
||||
read -r weiter </dev/tty || weiter=""
|
||||
case "$weiter" in [jJ]|[jJ][aA]) ;; *) abbruch "Abgebrochen." ;; esac
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# --- 6. Umschalten und bauen -------------------------------------------------
|
||||
|
||||
# Aenderungen an versionierten Dateien blockieren das Umschalten.
|
||||
#
|
||||
# Im Betrieb ist das der Normalfall: Man passt die docker-compose.yml an,
|
||||
# bis etwas laeuft. Genau diese Anpassungen sind spaeter oft schon
|
||||
# eingearbeitet - das Skript soll sie also nicht zum Hindernis machen.
|
||||
#
|
||||
# Verworfen wird trotzdem nichts stillschweigend. Standard ist "beiseite
|
||||
# legen": git stash macht es rueckholbar. Wer sie wirklich weghaben will,
|
||||
# nimmt --verwerfen.
|
||||
#
|
||||
# Die .env ist nie betroffen - sie ist nicht versioniert.
|
||||
schritt "Eigene Aenderungen"
|
||||
|
||||
if [ -n "$(git status --porcelain --untracked-files=no)" ]; then
|
||||
printf '\n Diese versionierten Dateien sind veraendert:\n\n'
|
||||
git status --short --untracked-files=no | sed 's/^/ /'
|
||||
printf '\n'
|
||||
|
||||
if [ "$VERWERFEN" = "1" ]; then
|
||||
ENTSCHEIDUNG="verwerfen"
|
||||
elif [ "$OHNE_RUECKFRAGE" = "1" ]; then
|
||||
# Ohne jemanden zum Fragen: die sichere Variante.
|
||||
ENTSCHEIDUNG="beiseite"
|
||||
else
|
||||
printf ' %s[b]%s eiseite legen (git stash, spaeter rueckholbar)\n' "$FETT" "$AUS"
|
||||
printf ' %s[v]%s erwerfen (endgueltig weg)\n' "$FETT" "$AUS"
|
||||
printf ' %s[a]%s bbrechen\n\n' "$FETT" "$AUS"
|
||||
printf ' Was soll damit geschehen? [b/v/a] '
|
||||
read -r wahl </dev/tty || wahl=""
|
||||
case "$wahl" in
|
||||
[bB]|'') ENTSCHEIDUNG="beiseite" ;;
|
||||
[vV]) ENTSCHEIDUNG="verwerfen" ;;
|
||||
*) abbruch "Abgebrochen, nichts geaendert." ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
if [ "$ENTSCHEIDUNG" = "verwerfen" ]; then
|
||||
git checkout -- .
|
||||
warnung "Aenderungen verworfen."
|
||||
else
|
||||
STASH_NAME="vor Update $(date +%Y-%m-%d_%H%M)"
|
||||
git stash push --quiet --message "$STASH_NAME" -- . \
|
||||
|| abbruch "Konnte die Aenderungen nicht beiseite legen."
|
||||
gut "Beiseite gelegt als: $STASH_NAME"
|
||||
printf ' Ansehen: git stash list\n'
|
||||
printf ' Zurueck: git stash pop\n'
|
||||
printf ' Wegwerfen: git stash drop\n'
|
||||
fi
|
||||
else
|
||||
gut "Arbeitskopie ist sauber"
|
||||
fi
|
||||
|
||||
schritt "Umschalten auf $ZIEL"
|
||||
|
||||
# Eine unversionierte Datei kann im Weg stehen, wenn die Zielfassung sie
|
||||
# fuehrt. Das passiert beim Update auf die Fassung, die dieses Skript
|
||||
# eingefuehrt hat: Man hat es sich von Hand geholt, jetzt gehoert es dazu.
|
||||
# Solche Dateien werden nicht weggeworfen, sondern beiseite geschoben.
|
||||
if ! git checkout --quiet "$ZIEL" 2>/dev/null; then
|
||||
IM_WEG="$(git checkout "$ZIEL" 2>&1 | sed -n '/would be overwritten/,/^Aborting/p' | grep -E '^\s' | tr -d ' ' | grep -v '^$' || true)"
|
||||
|
||||
if [ -n "$IM_WEG" ]; then
|
||||
ZEIT="$(date +%Y%m%d-%H%M%S)"
|
||||
printf ' Diese unversionierten Dateien stehen im Weg:
|
||||
'
|
||||
for datei in $IM_WEG; do
|
||||
[ -e "$datei" ] || continue
|
||||
mv "$datei" "${datei}.vor-update-${ZEIT}"
|
||||
printf ' %s -> %s.vor-update-%s
|
||||
' "$datei" "$datei" "$ZEIT"
|
||||
done
|
||||
git checkout --quiet "$ZIEL" || abbruch "Das Umschalten auf $ZIEL ist fehlgeschlagen.
|
||||
Deine Aenderungen liegen im Stash: git stash list"
|
||||
else
|
||||
abbruch "Das Umschalten auf $ZIEL ist fehlgeschlagen.
|
||||
$([ -n "$SCHMUTZIG" ] && printf ' Deine Aenderungen liegen im Stash: git stash list')"
|
||||
fi
|
||||
fi
|
||||
|
||||
gut "$(git describe --tags --always)"
|
||||
|
||||
schritt "Bauen und starten"
|
||||
printf ' Das dauert beim ersten Mal einige Minuten.\n\n'
|
||||
|
||||
if ! GIT_COMMIT="$(git rev-parse --short HEAD)" \
|
||||
BUILD_ZEIT="$(date -Iseconds)" \
|
||||
docker compose up -d --build; then
|
||||
printf '\n'
|
||||
abbruch "Bauen oder Starten ist fehlgeschlagen.
|
||||
Die Quellen stehen jetzt auf $ZIEL, die Anwendung laeuft aber
|
||||
noch mit dem alten Abbild - oder gar nicht.
|
||||
|
||||
Zurueck auf den vorherigen Stand:
|
||||
git checkout $JETZT && docker compose up -d --build
|
||||
$([ -n "$SCHMUTZIG" ] && printf '\n Deine Aenderungen liegen im Stash: git stash list')"
|
||||
fi
|
||||
|
||||
# --- 7. Warten, bis die Anwendung antwortet ----------------------------------
|
||||
|
||||
schritt "Warten auf die Anwendung"
|
||||
|
||||
# Adresse und Port stehen in der .env - Standard ist die Loopback-Adresse.
|
||||
ADRESSE="$(grep -E '^APP_BIND=' .env | tail -1 | cut -d= -f2- | tr -d '"' || true)"
|
||||
PORT="$(grep -E '^APP_PORT=' .env | tail -1 | cut -d= -f2- | tr -d '"' || true)"
|
||||
[ -n "$ADRESSE" ] || ADRESSE="127.0.0.1"
|
||||
[ -n "$PORT" ] || PORT="3000"
|
||||
# Auf 0.0.0.0 kann man nicht zugreifen - dann ueber die Loopback-Adresse.
|
||||
[ "$ADRESSE" = "0.0.0.0" ] && ADRESSE="127.0.0.1"
|
||||
|
||||
GESUND="http://${ADRESSE}:${PORT}/api/gesundheit"
|
||||
ANTWORT=""
|
||||
|
||||
for _ in $(seq 1 60); do
|
||||
ANTWORT="$(curl -fsS --max-time 5 "$GESUND" 2>/dev/null || true)"
|
||||
case "$ANTWORT" in *'"bereit"'*) break ;; esac
|
||||
printf '.'
|
||||
sleep 3
|
||||
done
|
||||
printf '\n'
|
||||
|
||||
case "$ANTWORT" in
|
||||
*'"bereit"'*) gut "Die Anwendung antwortet." ;;
|
||||
*)
|
||||
printf '\n'
|
||||
docker compose logs app --tail 40 | sed 's/^/ /'
|
||||
abbruch "Die Anwendung antwortet nicht unter $GESUND.
|
||||
Die letzten Zeilen aus dem Log stehen oben.
|
||||
Zurueck geht es mit: git checkout $JETZT && docker compose up -d --build"
|
||||
;;
|
||||
esac
|
||||
|
||||
# --- 8. SQL-Skripte ----------------------------------------------------------
|
||||
|
||||
schritt "Volltextsuche und Audit-Schutz"
|
||||
printf ' Diese beiden laufen nicht mit den Migrationen mit.\n'
|
||||
printf ' Sie sind idempotent - mehrfaches Ausfuehren schadet nicht.\n\n'
|
||||
|
||||
PRISMA="node node_modules/prisma/build/index.js"
|
||||
|
||||
for skript in volltextsuche audit-schutz; do
|
||||
if docker compose exec -T app $PRISMA db execute \
|
||||
--schema prisma/schema.prisma --file "prisma/sql/${skript}.sql" >/dev/null 2>&1; then
|
||||
gut "${skript}.sql ausgefuehrt"
|
||||
else
|
||||
warnung "${skript}.sql ist fehlgeschlagen - bitte von Hand nachholen:"
|
||||
printf ' docker compose exec app %s db execute \\\n' "$PRISMA"
|
||||
printf ' --schema prisma/schema.prisma --file prisma/sql/%s.sql\n' "$skript"
|
||||
fi
|
||||
done
|
||||
|
||||
# --- 9. Nachschau ------------------------------------------------------------
|
||||
|
||||
schritt "Ergebnis"
|
||||
|
||||
LAEUFT="$(printf '%s' "$ANTWORT" | sed -n 's/.*"version":"\([^"]*\)".*/\1/p')"
|
||||
ERWARTET="${ZIEL#v}"
|
||||
|
||||
printf ' Erwartet: %s\n' "$ERWARTET"
|
||||
printf ' Laeuft: %s\n' "${LAEUFT:-unbekannt}"
|
||||
|
||||
if [ "$LAEUFT" = "$ERWARTET" ]; then
|
||||
printf '\n'
|
||||
gut "Fertig. Version $ERWARTET laeuft."
|
||||
else
|
||||
printf '\n'
|
||||
warnung "Die laufende Fassung stimmt nicht mit der erwarteten ueberein."
|
||||
warnung "Vermutlich hat der Bau den alten Behaelter stehen lassen:"
|
||||
printf ' docker compose up -d --build --force-recreate app\n'
|
||||
fi
|
||||
|
||||
printf '\n Zustand: docker compose ps\n'
|
||||
printf ' Log: docker compose logs app --tail 50\n'
|
||||
printf ' Zurueck: git checkout %s && docker compose up -d --build\n\n' "$JETZT"
|
||||
|
||||
exit 0
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
import type { Metadata } from 'next'
|
||||
import { readFile } from 'node:fs/promises'
|
||||
import path from 'node:path'
|
||||
import { BookOpen } from 'lucide-react'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { MarkdownSeite } from '@/components/markdown-seite'
|
||||
import { DruckKnopf } from '@/components/druck-knopf'
|
||||
import { erfordereBenutzer } from '@/lib/auth/sitzung'
|
||||
|
||||
export const metadata: Metadata = { title: 'Anleitung' }
|
||||
export const dynamic = 'force-dynamic'
|
||||
|
||||
/**
|
||||
* Die Bedienungsanleitung, gelesen aus docs/ANLEITUNG.md.
|
||||
*
|
||||
* Dieselbe Datei, die auch im Repository liegt und sich ausdrucken laesst -
|
||||
* zwei Fassungen desselben Textes waeren zwei Fassungen, die auseinander-
|
||||
* laufen. Wer im Heim steht und nicht weiterweiss, hat sie damit auf dem
|
||||
* Telefon dabei.
|
||||
*/
|
||||
export default async function AnleitungSeite() {
|
||||
await erfordereBenutzer()
|
||||
|
||||
const pfad = path.join(process.cwd(), 'docs', 'ANLEITUNG.md')
|
||||
let inhalt: string
|
||||
|
||||
try {
|
||||
inhalt = await readFile(pfad, 'utf8')
|
||||
} catch {
|
||||
inhalt = ''
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="max-w-3xl space-y-6">
|
||||
<SeitenKopf
|
||||
titel="Bedienungsanleitung"
|
||||
beschreibung="Die Handgriffe, die du tatsächlich brauchst — in der Reihenfolge, in der sie im Alltag vorkommen."
|
||||
aktionen={<DruckKnopf beschriftung="Anleitung drucken" />}
|
||||
/>
|
||||
|
||||
{inhalt === '' ? (
|
||||
<Alert variant="warnung">
|
||||
<BookOpen aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Die Anleitung konnte nicht geladen werden. Sie liegt im Projekt unter{' '}
|
||||
<code>docs/ANLEITUNG.md</code>.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
) : (
|
||||
<MarkdownSeite inhalt={inhalt} />
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -1,9 +1,16 @@
|
||||
'use client'
|
||||
|
||||
import { useActionState } from 'react'
|
||||
import { useActionState, useEffect, useState } from 'react'
|
||||
import { useFormStatus } from 'react-dom'
|
||||
import { AlertCircle, Loader2, ShieldCheck } from 'lucide-react'
|
||||
import { useRouter } from 'next/navigation'
|
||||
import { AlertCircle, Fingerprint, Loader2, ShieldCheck } from 'lucide-react'
|
||||
import { anmeldungBestaetigen, type BestaetigenZustand } from '@/server/actions/bestaetigen'
|
||||
import { passkeyBestaetigen, passkeyBestaetigungStarten } from '@/server/actions/passkey'
|
||||
import {
|
||||
browserSupportsWebAuthn,
|
||||
passkeyBrowserfehler,
|
||||
startAuthentication,
|
||||
} from '@/lib/passkey-browser'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Input } from '@/components/ui/input'
|
||||
@@ -19,10 +26,17 @@ function Absenden() {
|
||||
)
|
||||
}
|
||||
|
||||
export function BestaetigenFormular({ weiter }: { weiter: string }) {
|
||||
export function BestaetigenFormular({
|
||||
weiter,
|
||||
passkeysMoeglich,
|
||||
}: {
|
||||
weiter: string
|
||||
passkeysMoeglich: boolean
|
||||
}) {
|
||||
const [zustand, aktion] = useActionState<BestaetigenZustand, FormData>(anmeldungBestaetigen, {})
|
||||
|
||||
return (
|
||||
<div className="space-y-5">
|
||||
<form action={aktion} className="space-y-4" noValidate>
|
||||
<input type="hidden" name="weiter" value={weiter} />
|
||||
|
||||
@@ -50,5 +64,95 @@ export function BestaetigenFormular({ weiter }: { weiter: string }) {
|
||||
|
||||
<Absenden />
|
||||
</form>
|
||||
|
||||
{passkeysMoeglich && <PasskeyBestaetigung weiter={weiter} />}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Bestaetigung mit Passkey statt mit Passwort und Code.
|
||||
*
|
||||
* Geprueft wird zusaetzlich, dass der Passkey zum angemeldeten Benutzer
|
||||
* gehoert - sonst koennte jemand mit dem eigenen Finger eine fremde,
|
||||
* offen stehende Sitzung freischalten. Genau der Fall, gegen den diese
|
||||
* Seite gebaut ist.
|
||||
*/
|
||||
function PasskeyBestaetigung({ weiter }: { weiter: string }) {
|
||||
const router = useRouter()
|
||||
const [browserKann, setBrowserKann] = useState(false)
|
||||
const [laeuft, setLaeuft] = useState(false)
|
||||
const [fehler, setFehler] = useState<string | null>(null)
|
||||
|
||||
useEffect(() => {
|
||||
setBrowserKann(browserSupportsWebAuthn())
|
||||
}, [])
|
||||
|
||||
async function bestaetigen() {
|
||||
setFehler(null)
|
||||
setLaeuft(true)
|
||||
|
||||
try {
|
||||
const start = await passkeyBestaetigungStarten()
|
||||
if (!start.ok) {
|
||||
setFehler(start.fehler)
|
||||
return
|
||||
}
|
||||
|
||||
const antwort = await startAuthentication({ optionsJSON: start.optionen })
|
||||
const ergebnis = await passkeyBestaetigen(JSON.stringify(antwort))
|
||||
|
||||
if (!ergebnis.ok) {
|
||||
setFehler(ergebnis.fehler)
|
||||
return
|
||||
}
|
||||
|
||||
router.replace(weiter)
|
||||
router.refresh()
|
||||
} catch (ausnahme) {
|
||||
setFehler(passkeyBrowserfehler(ausnahme))
|
||||
} finally {
|
||||
setLaeuft(false)
|
||||
}
|
||||
}
|
||||
|
||||
if (!browserKann) return null
|
||||
|
||||
return (
|
||||
<div className="space-y-3">
|
||||
<div className="flex items-center gap-3">
|
||||
<span className="h-px flex-1 bg-border" />
|
||||
<span className="text-xs uppercase tracking-wide text-muted-foreground">oder</span>
|
||||
<span className="h-px flex-1 bg-border" />
|
||||
</div>
|
||||
|
||||
{fehler && (
|
||||
<Alert variant="fehler">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>{fehler}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
<Button
|
||||
type="button"
|
||||
variant="outline"
|
||||
size="lg"
|
||||
className="w-full"
|
||||
onClick={() => void bestaetigen()}
|
||||
disabled={laeuft}
|
||||
>
|
||||
{laeuft ? (
|
||||
<>
|
||||
<Loader2 className="animate-spin" aria-hidden="true" />
|
||||
Warte auf das Gerät …
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<Fingerprint aria-hidden="true" />
|
||||
Mit Passkey bestätigen
|
||||
</>
|
||||
)}
|
||||
</Button>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
|
||||
@@ -3,6 +3,7 @@ import { ShieldAlert } from 'lucide-react'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { erfordereBenutzer } from '@/lib/auth/sitzung'
|
||||
import { passkeysMoeglich } from '@/lib/auth/passkey'
|
||||
import { BestaetigenFormular } from './formular'
|
||||
|
||||
export const metadata: Metadata = { title: 'Bestätigen' }
|
||||
@@ -26,7 +27,7 @@ export default async function BestaetigenSeite({
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<BestaetigenFormular weiter={weiter} />
|
||||
<BestaetigenFormular weiter={weiter} passkeysMoeglich={passkeysMoeglich()} />
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
|
||||
@@ -1,11 +1,13 @@
|
||||
import type { Metadata } from 'next'
|
||||
import Link from 'next/link'
|
||||
import { KeyRound, ShieldCheck } from 'lucide-react'
|
||||
import { Fingerprint, KeyRound, ShieldCheck } from 'lucide-react'
|
||||
import { Badge } from '@/components/ui/badge'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { SeitenKopf } from '@/components/seiten-kopf'
|
||||
import { erfordereBenutzer } from '@/lib/auth/sitzung'
|
||||
import { passkeysDesBenutzers, passkeysMoeglich } from '@/lib/auth/passkey'
|
||||
import { PasskeyVerwaltung } from '@/components/konto/passkey-verwaltung'
|
||||
import { ROLLEN_BESCHRIFTUNG, ROLLEN_ERKLAERUNG } from '@/lib/auth/rollen'
|
||||
import { formatDatumZeit } from '@/lib/utils'
|
||||
import { PasswortFormular } from './passwort-formular'
|
||||
@@ -16,10 +18,11 @@ export const dynamic = 'force-dynamic'
|
||||
export default async function KontoSeite() {
|
||||
const benutzer = await erfordereBenutzer()
|
||||
const codesUebrig = benutzer.wiederherstellungscodes.length
|
||||
const passkeys = await passkeysDesBenutzers(benutzer.id)
|
||||
|
||||
return (
|
||||
<div className="max-w-2xl space-y-6">
|
||||
<SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten und zweiter Faktor." />
|
||||
<SeitenKopf titel="Mein Konto" beschreibung="Zugangsdaten, zweiter Faktor und Passkeys." />
|
||||
|
||||
<Card>
|
||||
<CardHeader className="pb-3">
|
||||
@@ -89,6 +92,28 @@ export default async function KontoSeite() {
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
<Card>
|
||||
<CardHeader className="pb-3">
|
||||
<CardTitle className="flex items-center gap-2 text-base">
|
||||
<Fingerprint className="size-5" aria-hidden="true" />
|
||||
Passkeys
|
||||
</CardTitle>
|
||||
<CardDescription>
|
||||
Anmelden mit Fingerabdruck, Gesicht oder Geräte-PIN — ohne E-Mail, Passwort und Code.
|
||||
Ein Passkey gilt als zweiter Faktor, weil er Besitz des Geräts und dessen Entsperrung
|
||||
verlangt. Er ist an diese Adresse gebunden: Auf einer nachgebauten Anmeldeseite
|
||||
funktioniert er nicht.
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<PasskeyVerwaltung
|
||||
passkeys={passkeys}
|
||||
zweiterFaktorAktiv={Boolean(benutzer.totpAktiviertAm)}
|
||||
moeglich={passkeysMoeglich()}
|
||||
/>
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
<Card>
|
||||
<CardHeader className="pb-3">
|
||||
<CardTitle className="flex items-center gap-2 text-base">
|
||||
|
||||
@@ -34,6 +34,8 @@ const AKTION_BESCHRIFTUNG: Record<AuditAktion, string> = {
|
||||
ANMELDUNG_FEHLGESCHLAGEN: 'Anmeldung fehlgeschlagen',
|
||||
ABMELDUNG: 'abgemeldet',
|
||||
ZWEITER_FAKTOR_EINGERICHTET: 'zweiter Faktor eingerichtet',
|
||||
PASSKEY_REGISTRIERT: 'Passkey eingerichtet',
|
||||
PASSKEY_ENTFERNT: 'Passkey entfernt',
|
||||
PASSWORT_GEAENDERT: 'Passwort geändert',
|
||||
ROLLE_GEAENDERT: 'Rolle geändert',
|
||||
FREIGABE_GEAENDERT: 'Freigabe geändert',
|
||||
@@ -41,7 +43,8 @@ const AKTION_BESCHRIFTUNG: Record<AuditAktion, string> = {
|
||||
|
||||
function variante(aktion: AuditAktion) {
|
||||
if (aktion === 'ANMELDUNG_FEHLGESCHLAGEN' || aktion === 'ENDGUELTIG_GELOESCHT') return 'rot'
|
||||
if (aktion === 'GELOESCHT' || aktion === 'EXPORTIERT') return 'orange'
|
||||
if (aktion === 'GELOESCHT' || aktion === 'EXPORTIERT' || aktion === 'PASSKEY_ENTFERNT')
|
||||
return 'orange'
|
||||
if (aktion === 'ERSTELLT') return 'gruen'
|
||||
return 'secondary'
|
||||
}
|
||||
|
||||
@@ -4,6 +4,8 @@ import { ShieldCheck } from 'lucide-react'
|
||||
import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
|
||||
import { aktuellerBenutzer } from '@/lib/auth/sitzung'
|
||||
import { db } from '@/lib/db'
|
||||
import { passkeysMoeglich } from '@/lib/auth/passkey'
|
||||
import { PasskeyAnmeldung } from '@/components/passkey-anmeldung'
|
||||
import { AnmeldeFormular } from './formular'
|
||||
|
||||
export const metadata: Metadata = { title: 'Anmelden' }
|
||||
@@ -32,10 +34,14 @@ export default async function AnmeldenSeite({
|
||||
<CardTitle>Anmelden</CardTitle>
|
||||
<CardDescription>
|
||||
E-Mail, Passwort und der Code aus deiner Authenticator-App — alle drei zusammen.
|
||||
{passkeysMoeglich() && ' Oder in einem Schritt mit deinem Passkey.'}
|
||||
</CardDescription>
|
||||
</CardHeader>
|
||||
<CardContent>
|
||||
<CardContent className="space-y-5">
|
||||
<AnmeldeFormular weiter={weiter} />
|
||||
{/* Nur wenn der Server ueber https laeuft - sonst gibt der
|
||||
Browser WebAuthn gar nicht frei. */}
|
||||
{passkeysMoeglich() && <PasskeyAnmeldung weiter={weiter} />}
|
||||
</CardContent>
|
||||
</Card>
|
||||
|
||||
@@ -43,7 +49,9 @@ export default async function AnmeldenSeite({
|
||||
<ShieldCheck className="mt-0.5 size-4 shrink-0" aria-hidden="true" />
|
||||
<p>
|
||||
Hier liegen Gesundheits- und Vermögensdaten einer betreuten Person. Der zweite Faktor ist
|
||||
deshalb Pflicht und lässt sich nicht abschalten.
|
||||
deshalb Pflicht und lässt sich nicht abschalten. Ein Passkey erfüllt ihn ebenfalls: Er
|
||||
verlangt Fingerabdruck, Gesicht oder Geräte-PIN — und lässt sich, anders als ein
|
||||
abgetippter Code, nicht auf einer nachgebauten Seite abgreifen.
|
||||
</p>
|
||||
</div>
|
||||
</>
|
||||
|
||||
@@ -2,6 +2,7 @@ import type { Metadata } from 'next'
|
||||
import Link from 'next/link'
|
||||
import { readFile } from 'node:fs/promises'
|
||||
import path from 'node:path'
|
||||
import { MarkdownSeite } from '@/components/markdown-seite'
|
||||
|
||||
export const metadata: Metadata = { title: 'Datenschutz' }
|
||||
|
||||
@@ -11,83 +12,7 @@ export const metadata: Metadata = { title: 'Datenschutz' }
|
||||
* Der Text kommt aus docs/datenschutzhinweise.md - dieselbe Datei, die man
|
||||
* auch ausdrucken und der betreuten Person aushaendigen kann. Zwei Quellen
|
||||
* fuer denselben Text waeren zwei Quellen fuer Fehler.
|
||||
*
|
||||
* Die Umsetzung ist bewusst schlicht: keine Markdown-Bibliothek, nur die
|
||||
* wenigen Auszeichnungen, die im Dokument wirklich vorkommen.
|
||||
*/
|
||||
function alsAbsaetze(markdown: string) {
|
||||
const zeilen = markdown.split(/\r?\n/)
|
||||
const bloecke: React.ReactNode[] = []
|
||||
let absatz: string[] = []
|
||||
|
||||
const absatzSchliessen = (schluessel: number) => {
|
||||
if (absatz.length === 0) return
|
||||
bloecke.push(
|
||||
<p key={`p-${schluessel}`} className="leading-relaxed">
|
||||
{absatz.join(' ')}
|
||||
</p>,
|
||||
)
|
||||
absatz = []
|
||||
}
|
||||
|
||||
zeilen.forEach((zeile, i) => {
|
||||
const roh = zeile.trim()
|
||||
|
||||
// Der Hinweisblock fuer den Ausfuellenden gehoert nicht auf die Seite.
|
||||
if (roh.startsWith('>')) return
|
||||
|
||||
if (roh === '' || roh === '---') {
|
||||
absatzSchliessen(i)
|
||||
return
|
||||
}
|
||||
if (roh.startsWith('## ')) {
|
||||
absatzSchliessen(i)
|
||||
bloecke.push(
|
||||
<h2 key={i} className="mt-8 text-xl font-semibold">
|
||||
{roh.slice(3)}
|
||||
</h2>,
|
||||
)
|
||||
return
|
||||
}
|
||||
if (roh.startsWith('# ')) {
|
||||
absatzSchliessen(i)
|
||||
bloecke.push(
|
||||
<h1 key={i} className="text-2xl font-semibold">
|
||||
{roh.slice(2)}
|
||||
</h1>,
|
||||
)
|
||||
return
|
||||
}
|
||||
if (roh.startsWith('- ')) {
|
||||
absatzSchliessen(i)
|
||||
bloecke.push(
|
||||
<li key={i} className="ml-5 list-disc leading-relaxed">
|
||||
{roh.slice(2)}
|
||||
</li>,
|
||||
)
|
||||
return
|
||||
}
|
||||
// Tabellenzeilen werden als einfache Aufzaehlung dargestellt.
|
||||
if (roh.startsWith('|')) {
|
||||
absatzSchliessen(i)
|
||||
const spalten = roh.split('|').map((s) => s.trim()).filter(Boolean)
|
||||
if (spalten.every((s) => /^-+$/.test(s))) return
|
||||
bloecke.push(
|
||||
<div key={i} className="flex flex-col gap-0.5 border-l-2 py-1 pl-3 sm:flex-row sm:gap-3">
|
||||
<span className="min-w-56 font-medium">{spalten[0]}</span>
|
||||
<span className="text-muted-foreground">{spalten.slice(1).join(' · ')}</span>
|
||||
</div>,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
absatz.push(roh)
|
||||
})
|
||||
|
||||
absatzSchliessen(zeilen.length)
|
||||
return bloecke
|
||||
}
|
||||
|
||||
export default async function DatenschutzSeite() {
|
||||
const pfad = path.join(process.cwd(), 'docs', 'datenschutzhinweise.md')
|
||||
let inhalt: string
|
||||
@@ -95,14 +20,24 @@ export default async function DatenschutzSeite() {
|
||||
try {
|
||||
inhalt = await readFile(pfad, 'utf8')
|
||||
} catch {
|
||||
inhalt =
|
||||
'# Datenschutzhinweise\n\nDer Text konnte nicht geladen werden. ' +
|
||||
'Er liegt in docs/datenschutzhinweise.md.'
|
||||
inhalt = ''
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="mx-auto max-w-3xl px-4 py-10 sm:px-6">
|
||||
<article className="space-y-3 [&_strong]:font-semibold">{alsAbsaetze(inhalt)}</article>
|
||||
<h1 className="text-2xl font-semibold">Datenschutzhinweise</h1>
|
||||
<p className="mt-1 text-sm text-muted-foreground">nach Art. 13 und 14 DSGVO</p>
|
||||
|
||||
<div className="mt-8">
|
||||
{inhalt === '' ? (
|
||||
<p className="text-muted-foreground">
|
||||
Der Text konnte nicht geladen werden. Er liegt im Projekt unter{' '}
|
||||
<code className="rounded bg-muted px-1.5 py-0.5">docs/datenschutzhinweise.md</code>.
|
||||
</p>
|
||||
) : (
|
||||
<MarkdownSeite inhalt={inhalt} />
|
||||
)}
|
||||
</div>
|
||||
|
||||
<p className="mt-10 border-t pt-6 text-sm text-muted-foreground">
|
||||
<Link href="/anmelden" className="underline hover:no-underline">
|
||||
|
||||
+112
@@ -12,6 +12,8 @@ import {
|
||||
versuchFesthalten,
|
||||
} from '@/lib/auth/ratelimit'
|
||||
import { protokollieren } from '@/lib/audit'
|
||||
import { PasskeyFehler, anmeldungPruefen } from '@/lib/auth/passkey'
|
||||
import type { AuthenticationResponseJSON } from '@simplewebauthn/server'
|
||||
|
||||
/**
|
||||
* Anmeldung: E-Mail + Passwort + TOTP - alle drei zusammen, in einem Schritt.
|
||||
@@ -30,6 +32,8 @@ export type AnmeldeGrund =
|
||||
| 'gesperrt'
|
||||
| 'konto-inaktiv'
|
||||
| 'code-falsch'
|
||||
/** Passkey-Fehler; der genaue Grund haengt mit Doppelpunkt daran. */
|
||||
| 'passkey'
|
||||
|
||||
/**
|
||||
* Auth.js transportiert Fehler aus authorize() nur ueber das Feld "code".
|
||||
@@ -45,6 +49,19 @@ export class AnmeldeFehler extends CredentialsSignin {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Wie AnmeldeFehler, nur fuer Passkeys: der Grund wird als "passkey:<grund>"
|
||||
* kodiert, damit die Anmeldeseite die passende Erklaerung zeigen kann.
|
||||
*/
|
||||
export class PasskeyAnmeldeFehler extends CredentialsSignin {
|
||||
code: string
|
||||
|
||||
constructor(grund: string) {
|
||||
super(grund)
|
||||
this.code = `passkey:${grund}`
|
||||
}
|
||||
}
|
||||
|
||||
function ipAusAnfrage(anfrage: Request | undefined): string | null {
|
||||
if (!anfrage) return null
|
||||
const weitergeleitet = anfrage.headers.get('x-forwarded-for')?.split(',')[0]?.trim()
|
||||
@@ -203,6 +220,101 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
|
||||
}
|
||||
},
|
||||
}),
|
||||
|
||||
/**
|
||||
* Anmeldung mit Passkey - ein Schritt, ohne E-Mail und ohne Passwort.
|
||||
*
|
||||
* Die vollstaendige Pruefung laeuft hier drin und nicht in der Server
|
||||
* Action davor. Das ist Absicht: Wuerde die Action pruefen und das
|
||||
* Ergebnis anschliessend an signIn() weiterreichen, gaebe es einen
|
||||
* Zwischenzustand, dem authorize() glauben muesste. Genau solche
|
||||
* "war schon geprueft"-Uebergaben sind die Stelle, an der sich
|
||||
* Anmeldungen faelschen lassen. Hier gibt es sie nicht.
|
||||
*/
|
||||
Credentials({
|
||||
id: 'passkey',
|
||||
name: 'Passkey',
|
||||
credentials: {
|
||||
antwort: { label: 'Antwort des Authenticators', type: 'text' },
|
||||
},
|
||||
|
||||
async authorize(daten, anfrage) {
|
||||
const ip = ipAusAnfrage(anfrage)
|
||||
|
||||
let antwort: AuthenticationResponseJSON
|
||||
try {
|
||||
antwort = JSON.parse(String(daten?.antwort ?? '')) as AuthenticationResponseJSON
|
||||
} catch {
|
||||
throw new PasskeyAnmeldeFehler('ungueltig')
|
||||
}
|
||||
|
||||
let geprueft
|
||||
try {
|
||||
geprueft = await anmeldungPruefen(antwort)
|
||||
} catch (fehler) {
|
||||
// Fehlversuche zaehlen mit, auch wenn der Zugang unbekannt ist -
|
||||
// sonst waere der Passkey-Weg ein Schlupfloch an der Sperre vorbei.
|
||||
await versuchFesthalten('(passkey)', ip, false, 'passkey-ungueltig')
|
||||
await protokollieren({
|
||||
aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
|
||||
entitaet: 'User',
|
||||
userEmail: '(passkey)',
|
||||
bezeichnung:
|
||||
fehler instanceof PasskeyFehler ? `Passkey: ${fehler.grund}` : 'Passkey abgewiesen',
|
||||
})
|
||||
throw new PasskeyAnmeldeFehler(
|
||||
fehler instanceof PasskeyFehler ? fehler.grund : 'ungueltig',
|
||||
)
|
||||
}
|
||||
|
||||
const { benutzer, passkey } = geprueft
|
||||
|
||||
// Die Sperre gilt fuer den Zugang, nicht fuer das Verfahren. Sie
|
||||
// wird erst hier geprueft, weil vorher niemand weiss, wer sich
|
||||
// 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')
|
||||
throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
|
||||
}
|
||||
|
||||
if (!benutzer.aktiv || benutzer.geloeschtAm) {
|
||||
await versuchFesthalten(benutzer.email, ip, false, 'konto-inaktiv')
|
||||
throw new AnmeldeFehler('konto-inaktiv')
|
||||
}
|
||||
|
||||
await Promise.all([
|
||||
versuchFesthalten(benutzer.email, ip, true, 'passkey'),
|
||||
fehlversucheZuruecksetzen(benutzer.email),
|
||||
db.user.update({
|
||||
where: { id: benutzer.id },
|
||||
data: { letzteAnmeldung: new Date() },
|
||||
}),
|
||||
protokollieren({
|
||||
aktion: 'ANMELDUNG',
|
||||
entitaet: 'User',
|
||||
entitaetId: benutzer.id,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
bezeichnung: `Mit Passkey „${passkey.name}“`,
|
||||
}),
|
||||
])
|
||||
|
||||
return {
|
||||
id: benutzer.id,
|
||||
email: benutzer.email,
|
||||
name: benutzer.name,
|
||||
rolle: benutzer.rolle,
|
||||
sitzungsGeneration: benutzer.sitzungsGeneration,
|
||||
// Ein Passkey mit Nutzerverifikation IST der zweite Faktor. Ohne
|
||||
// eingerichtetes TOTP laesst er sich gar nicht erst anlegen, das
|
||||
// Flag ist hier also immer wahr - es wird trotzdem aus dem
|
||||
// Benutzer gelesen und nicht fest gesetzt.
|
||||
zweiterFaktorAktiv: Boolean(benutzer.totpAktiviertAm),
|
||||
}
|
||||
},
|
||||
}),
|
||||
],
|
||||
|
||||
callbacks: {
|
||||
|
||||
@@ -3,7 +3,16 @@
|
||||
import * as React from 'react'
|
||||
import Link from 'next/link'
|
||||
import { signOut } from 'next-auth/react'
|
||||
import { LogOut, Monitor, Moon, Settings, ShieldCheck, Sun, User as UserIcon } from 'lucide-react'
|
||||
import {
|
||||
BookOpen,
|
||||
LogOut,
|
||||
Monitor,
|
||||
Moon,
|
||||
Settings,
|
||||
ShieldCheck,
|
||||
Sun,
|
||||
User as UserIcon,
|
||||
} from 'lucide-react'
|
||||
import {
|
||||
DropdownMenu,
|
||||
DropdownMenuContent,
|
||||
@@ -96,6 +105,12 @@ export function BenutzerMenue({
|
||||
Einstellungen
|
||||
</Link>
|
||||
</DropdownMenuItem>
|
||||
<DropdownMenuItem asChild>
|
||||
<Link href="/anleitung">
|
||||
<BookOpen className="size-4" />
|
||||
Anleitung
|
||||
</Link>
|
||||
</DropdownMenuItem>
|
||||
|
||||
<DropdownMenuSeparator />
|
||||
<DropdownMenuLabel className="text-xs font-normal text-muted-foreground">
|
||||
|
||||
@@ -0,0 +1,20 @@
|
||||
'use client'
|
||||
|
||||
import { Printer } from 'lucide-react'
|
||||
import { Button } from '@/components/ui/button'
|
||||
|
||||
/**
|
||||
* Druckt die aktuelle Seite.
|
||||
*
|
||||
* Muss eine Client-Komponente sein - window.print() gibt es auf dem
|
||||
* Server nicht. Der Knopf selbst traegt "no-print", damit er auf dem
|
||||
* Ausdruck nicht auftaucht.
|
||||
*/
|
||||
export function DruckKnopf({ beschriftung = 'Drucken' }: { beschriftung?: string }) {
|
||||
return (
|
||||
<Button variant="outline" className="no-print" onClick={() => window.print()}>
|
||||
<Printer aria-hidden="true" />
|
||||
{beschriftung}
|
||||
</Button>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,277 @@
|
||||
'use client'
|
||||
|
||||
import { useEffect, useState } from 'react'
|
||||
import { useRouter } from 'next/navigation'
|
||||
import {
|
||||
AlertCircle,
|
||||
CheckCircle2,
|
||||
Fingerprint,
|
||||
Loader2,
|
||||
Plus,
|
||||
Smartphone,
|
||||
Trash2,
|
||||
} from 'lucide-react'
|
||||
import {
|
||||
passkeyEinrichtungAbschliessen,
|
||||
passkeyEinrichtungStarten,
|
||||
passkeyEntfernen,
|
||||
} from '@/server/actions/passkey'
|
||||
import {
|
||||
browserSupportsWebAuthn,
|
||||
passkeyBrowserfehler,
|
||||
startRegistration,
|
||||
} from '@/lib/passkey-browser'
|
||||
import type { PasskeyUebersicht } from '@/lib/auth/passkey'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Badge } from '@/components/ui/badge'
|
||||
import { Button } from '@/components/ui/button'
|
||||
import { Input } from '@/components/ui/input'
|
||||
import { Feld } from '@/components/feld'
|
||||
import { formatDatum, formatDatumZeit } from '@/lib/utils'
|
||||
|
||||
/**
|
||||
* Verwaltung der eigenen Passkeys unter "Mein Konto".
|
||||
*
|
||||
* Die Liste kommt vom Server; nach jeder Aenderung wird die Seite neu
|
||||
* geladen (router.refresh) statt den Zustand hier mitzufuehren. Bei einer
|
||||
* Handvoll Eintraegen ist das die ehrlichere Loesung: Was auf dem Bildschirm
|
||||
* steht, steht auch so in der Datenbank.
|
||||
*/
|
||||
export function PasskeyVerwaltung({
|
||||
passkeys,
|
||||
zweiterFaktorAktiv,
|
||||
moeglich,
|
||||
}: {
|
||||
passkeys: PasskeyUebersicht[]
|
||||
zweiterFaktorAktiv: boolean
|
||||
/** Ob der Server Passkeys ueberhaupt anbieten kann (https). */
|
||||
moeglich: boolean
|
||||
}) {
|
||||
const router = useRouter()
|
||||
const [browserKann, setBrowserKann] = useState(false)
|
||||
const [name, setName] = useState('')
|
||||
const [laeuft, setLaeuft] = useState(false)
|
||||
const [entfernt, setEntfernt] = useState<string | null>(null)
|
||||
const [fehler, setFehler] = useState<string | null>(null)
|
||||
const [erfolg, setErfolg] = useState<string | null>(null)
|
||||
const [nachfrage, setNachfrage] = useState<string | null>(null)
|
||||
|
||||
useEffect(() => {
|
||||
setBrowserKann(browserSupportsWebAuthn())
|
||||
}, [])
|
||||
|
||||
async function einrichten() {
|
||||
setFehler(null)
|
||||
setErfolg(null)
|
||||
|
||||
if (name.trim() === '') {
|
||||
setFehler('Bitte gib dem Gerät zuerst einen Namen.')
|
||||
return
|
||||
}
|
||||
|
||||
setLaeuft(true)
|
||||
try {
|
||||
const start = await passkeyEinrichtungStarten()
|
||||
if (!start.ok) {
|
||||
setFehler(start.fehler)
|
||||
return
|
||||
}
|
||||
|
||||
const antwort = await startRegistration({ optionsJSON: start.optionen })
|
||||
const ergebnis = await passkeyEinrichtungAbschliessen(name, JSON.stringify(antwort))
|
||||
|
||||
if (!ergebnis.ok) {
|
||||
setFehler(ergebnis.fehler)
|
||||
return
|
||||
}
|
||||
|
||||
setName('')
|
||||
setErfolg(ergebnis.meldung ?? 'Passkey eingerichtet.')
|
||||
router.refresh()
|
||||
} catch (ausnahme) {
|
||||
setFehler(passkeyBrowserfehler(ausnahme, true))
|
||||
} finally {
|
||||
setLaeuft(false)
|
||||
}
|
||||
}
|
||||
|
||||
async function entfernen(id: string) {
|
||||
setFehler(null)
|
||||
setErfolg(null)
|
||||
setNachfrage(null)
|
||||
setEntfernt(id)
|
||||
|
||||
try {
|
||||
const ergebnis = await passkeyEntfernen(id)
|
||||
if (!ergebnis.ok) {
|
||||
setFehler(ergebnis.fehler)
|
||||
return
|
||||
}
|
||||
setErfolg(ergebnis.meldung ?? 'Passkey entfernt.')
|
||||
router.refresh()
|
||||
} finally {
|
||||
setEntfernt(null)
|
||||
}
|
||||
}
|
||||
|
||||
if (!moeglich) {
|
||||
return (
|
||||
<Alert variant="hinweis">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Passkeys brauchen eine verschlüsselte Verbindung. Diese Installation ist nicht über
|
||||
<code className="mx-1 rounded bg-muted px-1 py-0.5 text-xs">https</code>
|
||||
erreichbar — sobald sie es ist, erscheint hier die Verwaltung.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)
|
||||
}
|
||||
|
||||
if (!zweiterFaktorAktiv) {
|
||||
return (
|
||||
<Alert variant="hinweis">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Richte zuerst die Authenticator-App ein. Ein Passkey hängt an einem Gerät — ginge das
|
||||
verloren und wäre er der einzige Weg hinein, käme niemand mehr an die Akte. Der Passkey
|
||||
ist die bequeme Tür, nicht die einzige.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="space-y-4">
|
||||
{fehler && (
|
||||
<Alert variant="fehler">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>{fehler}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{erfolg && (
|
||||
<Alert variant="erfolg">
|
||||
<CheckCircle2 aria-hidden="true" />
|
||||
<AlertDescription>{erfolg}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
{passkeys.length === 0 ? (
|
||||
<p className="text-sm text-muted-foreground">
|
||||
Noch kein Passkey eingerichtet. Du meldest dich weiterhin mit E-Mail, Passwort und Code an
|
||||
— das bleibt auch danach möglich.
|
||||
</p>
|
||||
) : (
|
||||
<ul className="divide-y rounded-md border">
|
||||
{passkeys.map((passkey) => (
|
||||
<li key={passkey.id} className="flex flex-wrap items-start gap-3 p-3">
|
||||
<Smartphone
|
||||
className="mt-0.5 size-5 shrink-0 text-muted-foreground"
|
||||
aria-hidden="true"
|
||||
/>
|
||||
|
||||
<div className="min-w-0 flex-1">
|
||||
<p className="font-medium">{passkey.name}</p>
|
||||
<p className="text-xs text-muted-foreground">
|
||||
Eingerichtet am {formatDatum(passkey.erstelltAm)}
|
||||
{passkey.zuletztBenutztAm
|
||||
? ` · zuletzt benutzt ${formatDatumZeit(passkey.zuletztBenutztAm)}`
|
||||
: ' · noch nicht benutzt'}
|
||||
</p>
|
||||
{passkey.geraeteArt === 'singleDevice' && (
|
||||
<p className="mt-1 text-xs text-muted-foreground">
|
||||
Liegt nur auf diesem Gerät. Geht es verloren, ist auch der Passkey weg.
|
||||
</p>
|
||||
)}
|
||||
</div>
|
||||
|
||||
{passkey.gesichert && (
|
||||
<Badge variant="secondary" className="shrink-0">
|
||||
gesichert
|
||||
</Badge>
|
||||
)}
|
||||
|
||||
{nachfrage === passkey.id ? (
|
||||
<div className="flex shrink-0 items-center gap-2">
|
||||
<Button
|
||||
type="button"
|
||||
variant="destructive"
|
||||
size="sm"
|
||||
onClick={() => void entfernen(passkey.id)}
|
||||
disabled={entfernt === passkey.id}
|
||||
>
|
||||
{entfernt === passkey.id ? (
|
||||
<Loader2 className="animate-spin" aria-hidden="true" />
|
||||
) : null}
|
||||
Wirklich entfernen
|
||||
</Button>
|
||||
<Button
|
||||
type="button"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
onClick={() => setNachfrage(null)}
|
||||
>
|
||||
Abbrechen
|
||||
</Button>
|
||||
</div>
|
||||
) : (
|
||||
<Button
|
||||
type="button"
|
||||
variant="ghost"
|
||||
size="sm"
|
||||
className="shrink-0"
|
||||
onClick={() => setNachfrage(passkey.id)}
|
||||
aria-label={`Passkey „${passkey.name}“ entfernen`}
|
||||
>
|
||||
<Trash2 aria-hidden="true" />
|
||||
Entfernen
|
||||
</Button>
|
||||
)}
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
)}
|
||||
|
||||
{browserKann ? (
|
||||
<div className="space-y-3 rounded-md border border-dashed p-3">
|
||||
<Feld
|
||||
id="passkey-name"
|
||||
beschriftung="Neues Gerät"
|
||||
erklaerung="Ein Name, an dem du es später wiedererkennst — etwa „iPhone“ oder „Laptop Büro“."
|
||||
>
|
||||
<Input
|
||||
id="passkey-name"
|
||||
value={name}
|
||||
onChange={(ereignis) => setName(ereignis.target.value)}
|
||||
maxLength={60}
|
||||
placeholder="iPhone"
|
||||
autoComplete="off"
|
||||
/>
|
||||
</Feld>
|
||||
|
||||
<Button type="button" onClick={() => void einrichten()} disabled={laeuft}>
|
||||
{laeuft ? (
|
||||
<>
|
||||
<Loader2 className="animate-spin" aria-hidden="true" />
|
||||
Warte auf das Gerät …
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<Plus aria-hidden="true" />
|
||||
Passkey einrichten
|
||||
</>
|
||||
)}
|
||||
</Button>
|
||||
</div>
|
||||
) : (
|
||||
<Alert variant="hinweis">
|
||||
<Fingerprint aria-hidden="true" />
|
||||
<AlertDescription>
|
||||
Dieser Browser kann keine Passkeys. Auf einem anderen Gerät klappt es vermutlich — die
|
||||
bereits eingerichteten bleiben davon unberührt.
|
||||
</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,324 @@
|
||||
import * as React from 'react'
|
||||
|
||||
/**
|
||||
* Anzeige einer Markdown-Datei aus dem docs-Verzeichnis.
|
||||
*
|
||||
* Bewusst ohne Markdown-Bibliothek: Die Anwendung zeigt genau zwei solche
|
||||
* Dokumente an - die Datenschutzhinweise und die Anleitung. Beide schreibe
|
||||
* ich selbst, ich weiss also, welche Auszeichnungen darin vorkommen. Eine
|
||||
* Bibliothek waere hier vor allem zusaetzliche Abhaengigkeit und
|
||||
* zusaetzliche Angriffsflaeche.
|
||||
*
|
||||
* Unterstuetzt: Ueberschriften, Absaetze, Aufzaehlungen (auch nummeriert),
|
||||
* Tabellen, Zitatbloecke, Codebloecke, Trennlinien sowie **fett**,
|
||||
* `Code` und [Links](ziel) im Fliesstext.
|
||||
*
|
||||
* Nicht unterstuetzt und auch nicht noetig: eingebettetes HTML, Bilder,
|
||||
* Fussnoten. Rohes HTML wird NICHT durchgereicht - der Text wird immer als
|
||||
* Text ausgegeben, nie als Markup.
|
||||
*/
|
||||
|
||||
type Block =
|
||||
| { art: 'ueberschrift'; ebene: 2 | 3 | 4; text: string }
|
||||
| { art: 'absatz'; text: string }
|
||||
| { art: 'liste'; nummeriert: boolean; punkte: string[] }
|
||||
| { art: 'tabelle'; kopf: string[]; zeilen: string[][] }
|
||||
| { art: 'zitat'; zeilen: string[] }
|
||||
| { art: 'code'; zeilen: string[] }
|
||||
| { art: 'trenner' }
|
||||
|
||||
/** Zerlegt den Fliesstext in fett, Code und Links. */
|
||||
function inline(text: string, schluessel: string): React.ReactNode[] {
|
||||
const teile: React.ReactNode[] = []
|
||||
// Reihenfolge zaehlt: Code zuerst, damit Sternchen darin nicht greifen.
|
||||
const muster = /(`[^`]+`)|(\*\*[^*]+\*\*)|(\[[^\]]+\]\([^)]+\))/g
|
||||
|
||||
let letzte = 0
|
||||
let treffer: RegExpExecArray | null
|
||||
let nummer = 0
|
||||
|
||||
while ((treffer = muster.exec(text)) !== null) {
|
||||
if (treffer.index > letzte) {
|
||||
teile.push(text.slice(letzte, treffer.index))
|
||||
}
|
||||
|
||||
const stueck = treffer[0]
|
||||
const id = `${schluessel}-${nummer++}`
|
||||
|
||||
if (stueck.startsWith('`')) {
|
||||
teile.push(
|
||||
<code key={id} className="rounded bg-muted px-1.5 py-0.5 font-mono text-[0.9em]">
|
||||
{stueck.slice(1, -1)}
|
||||
</code>,
|
||||
)
|
||||
} else if (stueck.startsWith('**')) {
|
||||
teile.push(
|
||||
<strong key={id} className="font-semibold">
|
||||
{stueck.slice(2, -2)}
|
||||
</strong>,
|
||||
)
|
||||
} else {
|
||||
const beschriftung = stueck.slice(1, stueck.indexOf(']'))
|
||||
const ziel = stueck.slice(stueck.indexOf('](') + 2, -1)
|
||||
const extern = /^https?:\/\//.test(ziel)
|
||||
teile.push(
|
||||
<a
|
||||
key={id}
|
||||
href={ziel}
|
||||
className="text-primary underline underline-offset-2 hover:no-underline"
|
||||
{...(extern ? { target: '_blank', rel: 'noreferrer noopener' } : {})}
|
||||
>
|
||||
{beschriftung}
|
||||
</a>,
|
||||
)
|
||||
}
|
||||
|
||||
letzte = treffer.index + stueck.length
|
||||
}
|
||||
|
||||
if (letzte < text.length) teile.push(text.slice(letzte))
|
||||
return teile
|
||||
}
|
||||
|
||||
function zerlegen(markdown: string, ohneTitel: boolean): Block[] {
|
||||
const zeilen = markdown.split(/\r?\n/)
|
||||
const bloecke: Block[] = []
|
||||
let absatz: string[] = []
|
||||
|
||||
const absatzSchliessen = () => {
|
||||
if (absatz.length === 0) return
|
||||
bloecke.push({ art: 'absatz', text: absatz.join(' ') })
|
||||
absatz = []
|
||||
}
|
||||
|
||||
for (let i = 0; i < zeilen.length; i++) {
|
||||
const roh = zeilen[i] ?? ''
|
||||
const zeile = roh.trimEnd()
|
||||
const gekuerzt = zeile.trim()
|
||||
|
||||
// --- Codeblock ---------------------------------------------------------
|
||||
if (gekuerzt.startsWith('```')) {
|
||||
absatzSchliessen()
|
||||
const inhalt: string[] = []
|
||||
i += 1
|
||||
while (i < zeilen.length && !(zeilen[i] ?? '').trim().startsWith('```')) {
|
||||
inhalt.push(zeilen[i] ?? '')
|
||||
i += 1
|
||||
}
|
||||
bloecke.push({ art: 'code', zeilen: inhalt })
|
||||
continue
|
||||
}
|
||||
|
||||
if (gekuerzt === '') {
|
||||
absatzSchliessen()
|
||||
continue
|
||||
}
|
||||
|
||||
if (/^-{3,}$/.test(gekuerzt) || /^\*{3,}$/.test(gekuerzt)) {
|
||||
absatzSchliessen()
|
||||
bloecke.push({ art: 'trenner' })
|
||||
continue
|
||||
}
|
||||
|
||||
// --- Ueberschriften ----------------------------------------------------
|
||||
const ueberschrift = gekuerzt.match(/^(#{1,4})\s+(.*)$/)
|
||||
if (ueberschrift) {
|
||||
absatzSchliessen()
|
||||
const ebene = ueberschrift[1]!.length
|
||||
// Die H1 ist der Dokumenttitel - den setzt die Seite selbst.
|
||||
if (ebene === 1 && ohneTitel) continue
|
||||
bloecke.push({
|
||||
art: 'ueberschrift',
|
||||
ebene: (Math.min(Math.max(ebene, 2), 4) as 2 | 3 | 4),
|
||||
text: ueberschrift[2]!,
|
||||
})
|
||||
continue
|
||||
}
|
||||
|
||||
// --- Zitatblock --------------------------------------------------------
|
||||
if (gekuerzt.startsWith('>')) {
|
||||
absatzSchliessen()
|
||||
const inhalt: string[] = []
|
||||
while (i < zeilen.length && (zeilen[i] ?? '').trim().startsWith('>')) {
|
||||
inhalt.push((zeilen[i] ?? '').trim().replace(/^>\s?/, ''))
|
||||
i += 1
|
||||
}
|
||||
i -= 1
|
||||
bloecke.push({ art: 'zitat', zeilen: [inhalt.join(' ')] })
|
||||
continue
|
||||
}
|
||||
|
||||
// --- Tabelle -----------------------------------------------------------
|
||||
if (gekuerzt.startsWith('|')) {
|
||||
absatzSchliessen()
|
||||
const spalten = (z: string) =>
|
||||
z
|
||||
.trim()
|
||||
.replace(/^\|/, '')
|
||||
.replace(/\|$/, '')
|
||||
.split('|')
|
||||
.map((s) => s.trim())
|
||||
|
||||
const kopf = spalten(gekuerzt)
|
||||
i += 1 // Trennzeile ueberspringen
|
||||
const zeilenInhalt: string[][] = []
|
||||
while (i + 1 < zeilen.length && (zeilen[i + 1] ?? '').trim().startsWith('|')) {
|
||||
i += 1
|
||||
zeilenInhalt.push(spalten(zeilen[i] ?? ''))
|
||||
}
|
||||
bloecke.push({ art: 'tabelle', kopf, zeilen: zeilenInhalt })
|
||||
continue
|
||||
}
|
||||
|
||||
// --- Aufzaehlung -------------------------------------------------------
|
||||
const punkt = gekuerzt.match(/^(?:[-*]|\d+\.)\s+(.*)$/)
|
||||
if (punkt) {
|
||||
absatzSchliessen()
|
||||
const nummeriert = /^\d+\./.test(gekuerzt)
|
||||
const punkte: string[] = [punkt[1]!]
|
||||
|
||||
while (i + 1 < zeilen.length) {
|
||||
const naechste = (zeilen[i + 1] ?? '').trim()
|
||||
const weiterer = naechste.match(/^(?:[-*]|\d+\.)\s+(.*)$/)
|
||||
if (weiterer && /^\d+\./.test(naechste) === nummeriert) {
|
||||
punkte.push(weiterer[1]!)
|
||||
i += 1
|
||||
continue
|
||||
}
|
||||
// Eingerueckte Fortsetzung gehoert zum letzten Punkt.
|
||||
if (naechste !== '' && /^\s{2,}\S/.test(zeilen[i + 1] ?? '')) {
|
||||
punkte[punkte.length - 1] += ` ${naechste}`
|
||||
i += 1
|
||||
continue
|
||||
}
|
||||
break
|
||||
}
|
||||
|
||||
bloecke.push({ art: 'liste', nummeriert, punkte })
|
||||
continue
|
||||
}
|
||||
|
||||
absatz.push(gekuerzt)
|
||||
}
|
||||
|
||||
absatzSchliessen()
|
||||
return bloecke
|
||||
}
|
||||
|
||||
export function MarkdownSeite({
|
||||
inhalt,
|
||||
ohneTitel = true,
|
||||
className,
|
||||
}: {
|
||||
inhalt: string
|
||||
/** Die erste H1 weglassen - die Seite setzt ihre Ueberschrift selbst. */
|
||||
ohneTitel?: boolean
|
||||
className?: string
|
||||
}) {
|
||||
const bloecke = zerlegen(inhalt, ohneTitel)
|
||||
|
||||
return (
|
||||
<article className={className}>
|
||||
{bloecke.map((block, i) => {
|
||||
switch (block.art) {
|
||||
case 'ueberschrift': {
|
||||
const Tag = `h${block.ebene}` as 'h2' | 'h3' | 'h4'
|
||||
const groesse =
|
||||
block.ebene === 2
|
||||
? 'mt-10 text-xl font-semibold'
|
||||
: block.ebene === 3
|
||||
? 'mt-7 text-lg font-semibold'
|
||||
: 'mt-5 text-base font-semibold'
|
||||
return (
|
||||
<Tag key={i} className={`${groesse} scroll-mt-20 first:mt-0`}>
|
||||
{block.text}
|
||||
</Tag>
|
||||
)
|
||||
}
|
||||
|
||||
case 'absatz':
|
||||
return (
|
||||
<p key={i} className="mt-3 leading-relaxed">
|
||||
{inline(block.text, String(i))}
|
||||
</p>
|
||||
)
|
||||
|
||||
case 'liste': {
|
||||
const Tag = block.nummeriert ? 'ol' : 'ul'
|
||||
return (
|
||||
<Tag
|
||||
key={i}
|
||||
className={`mt-3 space-y-1.5 pl-6 ${
|
||||
block.nummeriert ? 'list-decimal' : 'list-disc'
|
||||
}`}
|
||||
>
|
||||
{block.punkte.map((punkt, j) => (
|
||||
<li key={j} className="leading-relaxed">
|
||||
{inline(punkt, `${i}-${j}`)}
|
||||
</li>
|
||||
))}
|
||||
</Tag>
|
||||
)
|
||||
}
|
||||
|
||||
case 'tabelle':
|
||||
return (
|
||||
// Tabellen scrollen im eigenen Rahmen - am Handy darf nie die
|
||||
// ganze Seite seitlich wandern.
|
||||
<div key={i} className="mt-4 w-full overflow-x-auto rounded-lg border">
|
||||
<table className="w-full text-sm">
|
||||
<thead>
|
||||
<tr className="border-b bg-muted/50">
|
||||
{block.kopf.map((spalte, j) => (
|
||||
<th key={j} className="px-3 py-2 text-left font-semibold">
|
||||
{inline(spalte, `${i}-k-${j}`)}
|
||||
</th>
|
||||
))}
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{block.zeilen.map((zeile, j) => (
|
||||
<tr key={j} className="border-b last:border-0">
|
||||
{zeile.map((zelle, k) => (
|
||||
<td key={k} className="px-3 py-2 align-top">
|
||||
{inline(zelle, `${i}-${j}-${k}`)}
|
||||
</td>
|
||||
))}
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
)
|
||||
|
||||
case 'zitat':
|
||||
return (
|
||||
<blockquote
|
||||
key={i}
|
||||
className="mt-4 rounded-r-md border-l-4 border-primary/40 bg-muted/40 py-3 pl-4 pr-3"
|
||||
>
|
||||
{block.zeilen.map((zeile, j) => (
|
||||
<p key={j} className="leading-relaxed">
|
||||
{inline(zeile, `${i}-${j}`)}
|
||||
</p>
|
||||
))}
|
||||
</blockquote>
|
||||
)
|
||||
|
||||
case 'code':
|
||||
return (
|
||||
<pre
|
||||
key={i}
|
||||
className="mt-4 overflow-x-auto rounded-lg border bg-muted/60 p-3 text-sm"
|
||||
>
|
||||
<code className="font-mono">{block.zeilen.join('\n')}</code>
|
||||
</pre>
|
||||
)
|
||||
|
||||
case 'trenner':
|
||||
return <hr key={i} className="my-8" />
|
||||
}
|
||||
})}
|
||||
</article>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
'use client'
|
||||
|
||||
import { useEffect, useState } from 'react'
|
||||
import { AlertCircle, Fingerprint, Loader2 } from 'lucide-react'
|
||||
import { passkeyAnmeldungAbschliessen, passkeyAnmeldungStarten } from '@/server/actions/passkey'
|
||||
import {
|
||||
browserSupportsWebAuthn,
|
||||
passkeyBrowserfehler,
|
||||
startAuthentication,
|
||||
} from '@/lib/passkey-browser'
|
||||
import { Alert, AlertDescription } from '@/components/ui/alert'
|
||||
import { Button } from '@/components/ui/button'
|
||||
|
||||
/**
|
||||
* Knopf "Mit Passkey anmelden" auf der Anmeldeseite.
|
||||
*
|
||||
* Der Ablauf ist dreiteilig: Optionen vom Server holen, das Geraet fragen,
|
||||
* die Antwort zurueckschicken. Gelingt der letzte Schritt, leitet die Server
|
||||
* Action weiter - dieser Baustein sieht das Ergebnis dann gar nicht mehr.
|
||||
*
|
||||
* Sichtbar ist der Knopf nur, wenn der Server ihn anbietet (https) UND der
|
||||
* Browser WebAuthn kann. Die zweite Pruefung laeuft erst nach dem ersten
|
||||
* Rendern: Auf dem Server gibt es kein navigator-Objekt, und ein Knopf, der
|
||||
* beim Laden verschwindet, ist unangenehmer als einer, der kurz spaeter
|
||||
* erscheint.
|
||||
*/
|
||||
export function PasskeyAnmeldung({ weiter }: { weiter: string }) {
|
||||
const [laeuft, setLaeuft] = useState(false)
|
||||
const [fehler, setFehler] = useState<string | null>(null)
|
||||
const [browserKann, setBrowserKann] = useState(false)
|
||||
|
||||
useEffect(() => {
|
||||
setBrowserKann(browserSupportsWebAuthn())
|
||||
}, [])
|
||||
|
||||
async function anmelden() {
|
||||
setFehler(null)
|
||||
setLaeuft(true)
|
||||
|
||||
try {
|
||||
const start = await passkeyAnmeldungStarten()
|
||||
if (!start.ok) {
|
||||
setFehler(start.fehler)
|
||||
return
|
||||
}
|
||||
|
||||
const antwort = await startAuthentication({
|
||||
optionsJSON: start.optionen,
|
||||
})
|
||||
|
||||
const ergebnis = await passkeyAnmeldungAbschliessen(JSON.stringify(antwort), weiter)
|
||||
// Bei Erfolg wird gar nichts zurueckgegeben - die Action leitet weiter.
|
||||
if (!ergebnis.ok) setFehler(ergebnis.fehler)
|
||||
} catch (ausnahme) {
|
||||
setFehler(passkeyBrowserfehler(ausnahme))
|
||||
} finally {
|
||||
setLaeuft(false)
|
||||
}
|
||||
}
|
||||
|
||||
if (!browserKann) return null
|
||||
|
||||
return (
|
||||
<div className="space-y-3">
|
||||
<div className="flex items-center gap-3">
|
||||
<span className="h-px flex-1 bg-border" />
|
||||
<span className="text-xs uppercase tracking-wide text-muted-foreground">oder</span>
|
||||
<span className="h-px flex-1 bg-border" />
|
||||
</div>
|
||||
|
||||
{fehler && (
|
||||
<Alert variant="fehler">
|
||||
<AlertCircle aria-hidden="true" />
|
||||
<AlertDescription>{fehler}</AlertDescription>
|
||||
</Alert>
|
||||
)}
|
||||
|
||||
<Button
|
||||
type="button"
|
||||
variant="outline"
|
||||
size="lg"
|
||||
className="w-full"
|
||||
onClick={anmelden}
|
||||
disabled={laeuft}
|
||||
>
|
||||
{laeuft ? (
|
||||
<>
|
||||
<Loader2 className="animate-spin" aria-hidden="true" />
|
||||
Warte auf das Gerät …
|
||||
</>
|
||||
) : (
|
||||
<>
|
||||
<Fingerprint aria-hidden="true" />
|
||||
Mit Passkey anmelden
|
||||
</>
|
||||
)}
|
||||
</Button>
|
||||
|
||||
<p className="text-center text-xs text-muted-foreground">
|
||||
Fingerabdruck, Gesicht oder Geräte-PIN — ohne E-Mail und Passwort.
|
||||
</p>
|
||||
</div>
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,464 @@
|
||||
import 'server-only'
|
||||
import {
|
||||
generateAuthenticationOptions,
|
||||
generateRegistrationOptions,
|
||||
verifyAuthenticationResponse,
|
||||
verifyRegistrationResponse,
|
||||
} from '@simplewebauthn/server'
|
||||
import type {
|
||||
AuthenticationResponseJSON,
|
||||
AuthenticatorTransportFuture,
|
||||
PublicKeyCredentialCreationOptionsJSON,
|
||||
PublicKeyCredentialRequestOptionsJSON,
|
||||
RegistrationResponseJSON,
|
||||
} from '@simplewebauthn/server'
|
||||
import type { Passkey, PasskeyAnfrageArt, User } from '@prisma/client'
|
||||
import { db } from '@/lib/db'
|
||||
import { env } from '@/lib/env'
|
||||
|
||||
/**
|
||||
* Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg.
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* Warum ein Passkey hier den zweiten Faktor ERSETZEN darf
|
||||
* ---------------------------------------------------------------------------
|
||||
*
|
||||
* Die Zusage dieser Anwendung lautet: zwei Faktoren, nicht abschaltbar. Ein
|
||||
* Passkey sieht auf den ersten Blick nach einem einzigen Klick aus - er ist
|
||||
* aber zwei Faktoren, sofern der Authenticator die Nutzerverifikation
|
||||
* durchfuehrt:
|
||||
*
|
||||
* 1. Besitz - der private Schluessel liegt im Sicherheitsbaustein des
|
||||
* Geraets und laesst sich nicht auslesen.
|
||||
* 2. Wissen - Geraete-PIN
|
||||
* oder Sein - Fingerabdruck, Gesicht.
|
||||
*
|
||||
* Diese Bedingung wird nicht gehofft, sondern erzwungen: bei der Anmeldung
|
||||
* ebenso wie beim Einrichten steht userVerification auf "required", und die
|
||||
* Pruefung laeuft mit requireUserVerification. Ein Authenticator, der nur
|
||||
* Anwesenheit meldet (blosses Antippen), wird abgewiesen.
|
||||
*
|
||||
* Zusaetzlich ist ein Passkey dem Zahlenkomma aus Passwort + TOTP in einem
|
||||
* Punkt ueberlegen: Er ist an die Domain gebunden. Eine nachgebaute
|
||||
* Anmeldeseite bekommt keine Signatur - Phishing, der haeufigste Weg an
|
||||
* einen TOTP-Code zu kommen, laeuft ins Leere.
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* Warum TOTP trotzdem zuerst eingerichtet sein muss
|
||||
* ---------------------------------------------------------------------------
|
||||
*
|
||||
* Ein Passkey haengt am Geraet. Geht das Handy verloren und ist es der
|
||||
* einzige Zugangsweg, ist die Akte zu - und in ihr stehen Unterlagen, die
|
||||
* eine betreute Person braucht. Deshalb laesst sich ein Passkey erst
|
||||
* anlegen, wenn der zweite Faktor samt Wiederherstellungscodes steht. Der
|
||||
* Passkey ist die bequeme Tuer, nicht die einzige.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Wie lange eine begonnene Passkey-Aktion abgeschlossen werden kann.
|
||||
*
|
||||
* Fuenf Minuten sind reichlich fuer "Handy suchen, Finger auflegen" und
|
||||
* kurz genug, dass eine abgefangene Challenge nichts mehr wert ist.
|
||||
*/
|
||||
export const ANFRAGE_GUELTIG_SEKUNDEN = 300
|
||||
|
||||
/**
|
||||
* Obergrenze je Benutzer. Nicht aus technischen Gruenden - die Liste soll
|
||||
* uebersichtlich bleiben, damit ein fremder Eintrag auffaellt.
|
||||
*/
|
||||
export const MAX_PASSKEYS_JE_BENUTZER = 10
|
||||
|
||||
/**
|
||||
* Obergrenze fuer gleichzeitig offene Anmeldeversuche.
|
||||
*
|
||||
* Eine Anmeldung darf jeder beginnen, auch ohne angemeldet zu sein - anders
|
||||
* ginge es nicht. Damit daraus kein Weg wird, die Tabelle vollzuschreiben,
|
||||
* gilt eine Decke. Fuer eine Handvoll Benutzer ist sie unerreichbar; fuer
|
||||
* ein Skript ist sie schnell erreicht, und dann ist Schluss.
|
||||
*/
|
||||
export const MAX_OFFENE_ANMELDUNGEN = 200
|
||||
|
||||
export type PasskeyGrund =
|
||||
| 'nicht-verfuegbar'
|
||||
| 'anfrage-abgelaufen'
|
||||
| 'unbekannt'
|
||||
| 'nicht-verifiziert'
|
||||
| 'geklont'
|
||||
| 'bereits-vorhanden'
|
||||
| 'zu-viele'
|
||||
| 'zweiter-faktor-fehlt'
|
||||
| 'zu-viele-anfragen'
|
||||
| 'ungueltig'
|
||||
|
||||
/** Traegt einen Grund, damit die Oberflaeche einen brauchbaren Satz daraus macht. */
|
||||
export class PasskeyFehler extends Error {
|
||||
constructor(
|
||||
readonly grund: PasskeyGrund,
|
||||
nachricht?: string,
|
||||
) {
|
||||
super(nachricht ?? grund)
|
||||
this.name = 'PasskeyFehler'
|
||||
}
|
||||
}
|
||||
|
||||
export const PASSKEY_MELDUNG: Record<PasskeyGrund, string> = {
|
||||
'nicht-verfuegbar':
|
||||
'Passkeys brauchen eine verschlüsselte Verbindung. Diese Installation läuft nicht über https — ' +
|
||||
'melde dich mit Passwort und Code an.',
|
||||
'anfrage-abgelaufen':
|
||||
'Das hat zu lange gedauert. Bitte klicke noch einmal auf „Mit Passkey anmelden“.',
|
||||
unbekannt:
|
||||
'Dieser Passkey ist hier nicht hinterlegt. Vielleicht gehört er zu einer anderen Adresse ' +
|
||||
'oder wurde inzwischen entfernt.',
|
||||
'nicht-verifiziert':
|
||||
'Dein Gerät hat den Passkey ohne Fingerabdruck, Gesichtserkennung oder PIN freigegeben. ' +
|
||||
'Das wäre nur ein Faktor — und hier liegen Gesundheitsdaten. Bitte richte die Gerätesperre ein.',
|
||||
geklont:
|
||||
'Der Zähler dieses Passkeys ist nicht weitergelaufen. Das kann auf eine Kopie hindeuten. ' +
|
||||
'Der Passkey wurde nicht akzeptiert — bitte entferne ihn und richte einen neuen ein.',
|
||||
'bereits-vorhanden': 'Dieser Passkey ist bereits hinterlegt.',
|
||||
'zu-viele': `Es sind höchstens ${MAX_PASSKEYS_JE_BENUTZER} Passkeys möglich. Entferne zuerst einen alten.`,
|
||||
'zweiter-faktor-fehlt':
|
||||
'Richte zuerst die Authenticator-App ein. Ein Passkey hängt an einem Gerät — ohne einen ' +
|
||||
'zweiten Weg wäre der Zugang bei Verlust zu.',
|
||||
'zu-viele-anfragen':
|
||||
'Gerade laufen ungewöhnlich viele Anmeldeversuche. Bitte versuche es in ein paar Minuten ' +
|
||||
'noch einmal oder melde dich mit Passwort und Code an.',
|
||||
ungueltig: 'Der Passkey konnte nicht geprüft werden. Bitte versuche es noch einmal.',
|
||||
}
|
||||
|
||||
/**
|
||||
* Kopiert Bytes in ein Uint8Array mit eigenem, nicht geteiltem Puffer.
|
||||
*
|
||||
* Prisma liefert einen Buffer, TextEncoder ein Uint8Array<ArrayBufferLike> -
|
||||
* die Bibliothek verlangt ausdruecklich Uint8Array<ArrayBuffer>. Der
|
||||
* Unterschied ist nicht kosmetisch: ArrayBufferLike schliesst
|
||||
* SharedArrayBuffer ein, und auf geteiltem Speicher darf keine
|
||||
* Signaturpruefung arbeiten, weil sich der Inhalt waehrenddessen aendern
|
||||
* koennte.
|
||||
*/
|
||||
function alsUint8(daten: Uint8Array): Uint8Array<ArrayBuffer> {
|
||||
const kopie = new Uint8Array(new ArrayBuffer(daten.byteLength))
|
||||
kopie.set(daten)
|
||||
return kopie
|
||||
}
|
||||
|
||||
/**
|
||||
* Holt die Challenge aus der Antwort des Browsers.
|
||||
*
|
||||
* Sie steckt in den clientData, die der Authenticator mitsigniert hat. Wir
|
||||
* lesen sie hier nur, um die passende Zeile zu finden - geprueft wird sie
|
||||
* anschliessend von der Bibliothek gegen genau diesen Wert.
|
||||
*
|
||||
* Exportiert, damit sie sich ohne Datenbank pruefen laesst.
|
||||
*/
|
||||
export function challengeAusAntwort(clientDataJSON: string): string {
|
||||
try {
|
||||
const roh = Buffer.from(clientDataJSON, 'base64url').toString('utf8')
|
||||
const gelesen: unknown = JSON.parse(roh)
|
||||
const challenge =
|
||||
typeof gelesen === 'object' && gelesen !== null && 'challenge' in gelesen
|
||||
? (gelesen as { challenge: unknown }).challenge
|
||||
: null
|
||||
if (typeof challenge !== 'string' || challenge.length === 0) {
|
||||
throw new PasskeyFehler('ungueltig')
|
||||
}
|
||||
return challenge
|
||||
} catch (fehler) {
|
||||
if (fehler instanceof PasskeyFehler) throw fehler
|
||||
throw new PasskeyFehler('ungueltig')
|
||||
}
|
||||
}
|
||||
|
||||
/** Legt eine Challenge ab. Nur der Server kennt sie, bis der Browser antwortet. */
|
||||
async function anfrageMerken(
|
||||
challenge: string,
|
||||
art: PasskeyAnfrageArt,
|
||||
userId: string | null,
|
||||
): Promise<void> {
|
||||
await db.passkeyAnfrage.create({
|
||||
data: {
|
||||
challenge,
|
||||
art,
|
||||
userId,
|
||||
ablaufAm: new Date(Date.now() + ANFRAGE_GUELTIG_SEKUNDEN * 1000),
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
/**
|
||||
* Verbraucht eine Challenge - und zwar genau einmal.
|
||||
*
|
||||
* Das DELETE ist der eigentliche Schutz gegen das erneute Einspielen einer
|
||||
* mitgeschnittenen Antwort: Die Datenbank entscheidet, wer die Zeile
|
||||
* bekommt. Wurde keine Zeile geloescht, war sie schon verbraucht oder
|
||||
* abgelaufen - beides fuehrt zum Abbruch.
|
||||
*/
|
||||
async function anfrageVerbrauchen(
|
||||
challenge: string,
|
||||
art: PasskeyAnfrageArt,
|
||||
userId?: string,
|
||||
): Promise<void> {
|
||||
const { count } = await db.passkeyAnfrage.deleteMany({
|
||||
where: {
|
||||
challenge,
|
||||
art,
|
||||
ablaufAm: { gt: new Date() },
|
||||
...(userId ? { userId } : {}),
|
||||
},
|
||||
})
|
||||
if (count !== 1) throw new PasskeyFehler('anfrage-abgelaufen')
|
||||
}
|
||||
|
||||
/** Wirft, wenn die Installation gar nicht ueber https erreichbar ist. */
|
||||
function verfuegbarkeitPruefen(): void {
|
||||
if (!env.passkey.sicherAufrufbar) throw new PasskeyFehler('nicht-verfuegbar')
|
||||
}
|
||||
|
||||
/** Ob Passkeys unter der aktuellen Adresse ueberhaupt angeboten werden koennen. */
|
||||
export function passkeysMoeglich(): boolean {
|
||||
return env.passkey.sicherAufrufbar
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Einrichten
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export async function registrierungVorbereiten(
|
||||
benutzer: User,
|
||||
): Promise<PublicKeyCredentialCreationOptionsJSON> {
|
||||
verfuegbarkeitPruefen()
|
||||
|
||||
// Ohne Authenticator-App kein Passkey - siehe Kopfkommentar.
|
||||
if (!benutzer.totpAktiviertAm) throw new PasskeyFehler('zweiter-faktor-fehlt')
|
||||
|
||||
const vorhandene = await db.passkey.findMany({
|
||||
where: { userId: benutzer.id },
|
||||
select: { credentialId: true, transports: true },
|
||||
})
|
||||
|
||||
if (vorhandene.length >= MAX_PASSKEYS_JE_BENUTZER) throw new PasskeyFehler('zu-viele')
|
||||
|
||||
const optionen = await generateRegistrationOptions({
|
||||
rpName: env.passkey.rpName,
|
||||
rpID: env.passkey.rpId,
|
||||
// Stabil aus der Benutzer-ID. Damit erkennt ein Geraet beim zweiten
|
||||
// Einrichten, dass es derselbe Zugang ist, und ersetzt den Eintrag,
|
||||
// statt einen zweiten anzulegen.
|
||||
userID: alsUint8(new TextEncoder().encode(benutzer.id)),
|
||||
userName: benutzer.email,
|
||||
userDisplayName: benutzer.name,
|
||||
// Keine Attestierung anfordern: Wir wollen nicht wissen, welches
|
||||
// Fabrikat der Benutzer benutzt. Das ist ein Datum, das uns nichts
|
||||
// angeht, und es macht den Ablauf auf manchen Geraeten umstaendlicher.
|
||||
attestationType: 'none',
|
||||
// Schon hinterlegte Schluessel ausschliessen, sonst legt dasselbe
|
||||
// Geraet stillschweigend einen zweiten an.
|
||||
excludeCredentials: vorhandene.map((eintrag) => ({
|
||||
id: eintrag.credentialId,
|
||||
transports: eintrag.transports as AuthenticatorTransportFuture[],
|
||||
})),
|
||||
authenticatorSelection: {
|
||||
// "required": der Schluessel wird auf dem Geraet auffindbar
|
||||
// gespeichert. Nur dann geht die Anmeldung ohne vorherige Eingabe
|
||||
// der E-Mail-Adresse.
|
||||
residentKey: 'required',
|
||||
requireResidentKey: true,
|
||||
// Der Punkt, an dem aus einem Faktor zwei werden.
|
||||
userVerification: 'required',
|
||||
},
|
||||
timeout: ANFRAGE_GUELTIG_SEKUNDEN * 1000,
|
||||
})
|
||||
|
||||
await anfrageMerken(optionen.challenge, 'REGISTRIERUNG', benutzer.id)
|
||||
return optionen
|
||||
}
|
||||
|
||||
export async function registrierungPruefen(
|
||||
benutzer: User,
|
||||
name: string,
|
||||
antwort: RegistrationResponseJSON,
|
||||
): Promise<Passkey> {
|
||||
verfuegbarkeitPruefen()
|
||||
if (!benutzer.totpAktiviertAm) throw new PasskeyFehler('zweiter-faktor-fehlt')
|
||||
|
||||
const challenge = challengeAusAntwort(antwort.response.clientDataJSON)
|
||||
await anfrageVerbrauchen(challenge, 'REGISTRIERUNG', benutzer.id)
|
||||
|
||||
let ergebnis
|
||||
try {
|
||||
ergebnis = await verifyRegistrationResponse({
|
||||
response: antwort,
|
||||
expectedChallenge: challenge,
|
||||
expectedOrigin: env.passkey.herkunft,
|
||||
expectedRPID: env.passkey.rpId,
|
||||
requireUserVerification: true,
|
||||
})
|
||||
} catch {
|
||||
throw new PasskeyFehler('ungueltig')
|
||||
}
|
||||
|
||||
if (!ergebnis.verified) throw new PasskeyFehler('ungueltig')
|
||||
|
||||
const { credential, credentialDeviceType, credentialBackedUp, userVerified } =
|
||||
ergebnis.registrationInfo
|
||||
|
||||
// Doppelte Absicherung: die Bibliothek prueft es bereits, aber diese
|
||||
// Zusage ist zu wichtig, um sie an einer Voreinstellung haengen zu lassen.
|
||||
if (!userVerified) throw new PasskeyFehler('nicht-verifiziert')
|
||||
|
||||
const schonDa = await db.passkey.findUnique({
|
||||
where: { credentialId: credential.id },
|
||||
select: { id: true },
|
||||
})
|
||||
if (schonDa) throw new PasskeyFehler('bereits-vorhanden')
|
||||
|
||||
return db.passkey.create({
|
||||
data: {
|
||||
userId: benutzer.id,
|
||||
credentialId: credential.id,
|
||||
publicKey: Buffer.from(credential.publicKey),
|
||||
counter: BigInt(credential.counter),
|
||||
transports: credential.transports ?? [],
|
||||
name,
|
||||
geraeteArt: credentialDeviceType,
|
||||
gesichert: credentialBackedUp,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Anmelden
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export async function anmeldungVorbereiten(): Promise<PublicKeyCredentialRequestOptionsJSON> {
|
||||
verfuegbarkeitPruefen()
|
||||
|
||||
// Erst aufraeumen, dann die Decke pruefen: Abgelaufenes soll nicht als
|
||||
// laufender Versuch zaehlen.
|
||||
await abgelaufeneAnfragenEntfernen()
|
||||
const offen = await db.passkeyAnfrage.count({ where: { art: 'ANMELDUNG' } })
|
||||
if (offen >= MAX_OFFENE_ANMELDUNGEN) throw new PasskeyFehler('zu-viele-anfragen')
|
||||
|
||||
const optionen = await generateAuthenticationOptions({
|
||||
rpID: env.passkey.rpId,
|
||||
// Bewusst ohne allowCredentials: Der Server soll vor der Anmeldung
|
||||
// nicht verraten, welche Schluessel es zu einer Adresse gibt - und der
|
||||
// Benutzer soll seine E-Mail gar nicht erst eintippen muessen. Das
|
||||
// Geraet weiss selbst, welchen Schluessel es fuer diese Domain hat.
|
||||
userVerification: 'required',
|
||||
timeout: ANFRAGE_GUELTIG_SEKUNDEN * 1000,
|
||||
})
|
||||
|
||||
await anfrageMerken(optionen.challenge, 'ANMELDUNG', null)
|
||||
return optionen
|
||||
}
|
||||
|
||||
export type PasskeyAnmeldung = {
|
||||
benutzer: User
|
||||
passkey: Passkey
|
||||
}
|
||||
|
||||
/**
|
||||
* Prueft eine Anmeldeantwort vollstaendig und meldet, wem sie gehoert.
|
||||
*
|
||||
* Alles, was hier durchgeht, ist kryptografisch belegt: die Signatur passt
|
||||
* zum hinterlegten oeffentlichen Schluessel, die Challenge war frisch und
|
||||
* genau einmal gueltig, die Domain stimmt, und das Geraet hat den Benutzer
|
||||
* verifiziert.
|
||||
*
|
||||
* Rate-Limiting und Audit-Log passieren NICHT hier, sondern beim Aufrufer -
|
||||
* dort ist bekannt, ob es eine Anmeldung oder eine erneute Bestaetigung ist.
|
||||
*/
|
||||
export async function anmeldungPruefen(
|
||||
antwort: AuthenticationResponseJSON,
|
||||
): Promise<PasskeyAnmeldung> {
|
||||
verfuegbarkeitPruefen()
|
||||
|
||||
const challenge = challengeAusAntwort(antwort.response.clientDataJSON)
|
||||
await anfrageVerbrauchen(challenge, 'ANMELDUNG')
|
||||
|
||||
const passkey = await db.passkey.findUnique({
|
||||
where: { credentialId: antwort.id },
|
||||
include: { user: true },
|
||||
})
|
||||
|
||||
if (!passkey) throw new PasskeyFehler('unbekannt')
|
||||
|
||||
let ergebnis
|
||||
try {
|
||||
ergebnis = await verifyAuthenticationResponse({
|
||||
response: antwort,
|
||||
expectedChallenge: challenge,
|
||||
expectedOrigin: env.passkey.herkunft,
|
||||
expectedRPID: env.passkey.rpId,
|
||||
requireUserVerification: true,
|
||||
credential: {
|
||||
id: passkey.credentialId,
|
||||
publicKey: alsUint8(passkey.publicKey),
|
||||
counter: Number(passkey.counter),
|
||||
transports: passkey.transports as AuthenticatorTransportFuture[],
|
||||
},
|
||||
})
|
||||
} catch (fehler) {
|
||||
// Die Bibliothek meldet einen nicht weitergelaufenen Zaehler als
|
||||
// gewoehnlichen Fehler. Der verdient eine eigene Meldung: er ist der
|
||||
// einzige Hinweis auf einen kopierten Schluessel, den wir bekommen.
|
||||
const text = fehler instanceof Error ? fehler.message : ''
|
||||
if (text.includes('counter value')) throw new PasskeyFehler('geklont')
|
||||
throw new PasskeyFehler('ungueltig')
|
||||
}
|
||||
|
||||
if (!ergebnis.verified) throw new PasskeyFehler('ungueltig')
|
||||
if (!ergebnis.authenticationInfo.userVerified) throw new PasskeyFehler('nicht-verifiziert')
|
||||
|
||||
await db.passkey.update({
|
||||
where: { id: passkey.id },
|
||||
data: {
|
||||
counter: BigInt(ergebnis.authenticationInfo.newCounter),
|
||||
zuletztBenutztAm: new Date(),
|
||||
// Beides kann sich nachtraeglich aendern, etwa wenn der Benutzer die
|
||||
// Schluesselbund-Synchronisierung einschaltet.
|
||||
geraeteArt: ergebnis.authenticationInfo.credentialDeviceType,
|
||||
gesichert: ergebnis.authenticationInfo.credentialBackedUp,
|
||||
},
|
||||
})
|
||||
|
||||
return { benutzer: passkey.user, passkey }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Verwalten und Aufraeumen
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export type PasskeyUebersicht = {
|
||||
id: string
|
||||
name: string
|
||||
geraeteArt: string | null
|
||||
gesichert: boolean
|
||||
erstelltAm: Date
|
||||
zuletztBenutztAm: Date | null
|
||||
}
|
||||
|
||||
export async function passkeysDesBenutzers(userId: string): Promise<PasskeyUebersicht[]> {
|
||||
return db.passkey.findMany({
|
||||
where: { userId },
|
||||
orderBy: [{ zuletztBenutztAm: { sort: 'desc', nulls: 'last' } }, { erstelltAm: 'desc' }],
|
||||
select: {
|
||||
id: true,
|
||||
name: true,
|
||||
geraeteArt: true,
|
||||
gesichert: true,
|
||||
erstelltAm: true,
|
||||
zuletztBenutztAm: true,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
/** Raeumt liegengebliebene Challenges weg; wird vom Wartungslauf aufgerufen. */
|
||||
export async function abgelaufeneAnfragenEntfernen(): Promise<number> {
|
||||
const { count } = await db.passkeyAnfrage.deleteMany({
|
||||
where: { ablaufAm: { lt: new Date() } },
|
||||
})
|
||||
return count
|
||||
}
|
||||
+47
-4
@@ -58,14 +58,25 @@ function einmal<T>(fn: () => T): () => T {
|
||||
|
||||
const holeVerschluesselungsschluessel = einmal((): Map<number, Buffer> => {
|
||||
const schluessel = new Map<number, Buffer>()
|
||||
|
||||
// ENC_KEY_V1, ENC_KEY_V2, ... - alte Versionen bleiben zum Entschluesseln
|
||||
// stehen, verschluesselt wird immer mit der aktiven Version.
|
||||
for (const [name] of Object.entries(process.env)) {
|
||||
for (const [name, wert] of Object.entries(process.env)) {
|
||||
const treffer = name.match(/^ENC_KEY_V(\d+)$/)
|
||||
if (treffer) {
|
||||
if (!treffer) continue
|
||||
|
||||
// Eine LEERE Variable ist kein Schluessel.
|
||||
//
|
||||
// docker compose reicht ENC_KEY_V2 immer durch - mit leerem Wert, wenn
|
||||
// in der .env keiner steht. Wuerde hier allein der Name zaehlen, waere
|
||||
// jede Installation ohne zweiten Schluessel kaputt, und zwar mit der
|
||||
// irrefuehrenden Meldung "ENC_KEY_V2 fehlt" - obwohl niemand einen
|
||||
// zweiten Schluessel wollte.
|
||||
if (!wert || wert.trim() === '') continue
|
||||
|
||||
schluessel.set(Number.parseInt(treffer[1]!, 10), schluessel32(name))
|
||||
}
|
||||
}
|
||||
|
||||
if (schluessel.size === 0) {
|
||||
throw new Error(
|
||||
'Kein Verschluesselungsschluessel gefunden. Es muss mindestens ENC_KEY_V1 ' +
|
||||
@@ -78,8 +89,11 @@ const holeVerschluesselungsschluessel = einmal((): Map<number, Buffer> => {
|
||||
const holeAktiveVersion = einmal((): number => {
|
||||
const version = zahl('ENC_KEY_AKTIV', 1)
|
||||
if (!holeVerschluesselungsschluessel().has(version)) {
|
||||
const vorhanden = [...holeVerschluesselungsschluessel().keys()].sort().join(', ')
|
||||
throw new Error(
|
||||
`ENC_KEY_AKTIV=${version}, aber ENC_KEY_V${version} ist nicht gesetzt.`,
|
||||
`ENC_KEY_AKTIV=${version}, aber ENC_KEY_V${version} ist nicht gesetzt oder leer. ` +
|
||||
`Vorhanden sind die Versionen: ${vorhanden}. Beim Rotieren zuerst den ` +
|
||||
`neuen Schluessel eintragen, danach ENC_KEY_AKTIV umstellen.`,
|
||||
)
|
||||
}
|
||||
return version
|
||||
@@ -171,6 +185,35 @@ export const env = {
|
||||
return (process.env.AUTH_URL ?? 'http://localhost:3000').replace(/\/$/, '')
|
||||
},
|
||||
|
||||
/**
|
||||
* Herkunft und Bereichskennung fuer Passkeys (WebAuthn).
|
||||
*
|
||||
* Beides wird aus AUTH_URL abgeleitet und nicht getrennt konfiguriert -
|
||||
* eine zweite Quelle waere eine zweite Gelegenheit, sie auseinanderlaufen
|
||||
* zu lassen.
|
||||
*
|
||||
* Die "rpId" ist der nackte Hostname ohne Schema und ohne Port. An sie
|
||||
* bindet der Authenticator den Schluessel: Ein Passkey fuer
|
||||
* cockpit.example.de funktioniert auf keiner anderen Adresse - genau das
|
||||
* macht ihn gegen Phishing immun. Umgekehrt heisst das: Wer die Domain
|
||||
* wechselt, muss alle Passkeys neu einrichten.
|
||||
*
|
||||
* Der Browser gibt WebAuthn ausserdem nur in einem sicheren Kontext frei -
|
||||
* also unter https oder auf localhost. Hinter einem Proxy, der auf http
|
||||
* weiterreicht, muss AUTH_URL trotzdem die oeffentliche https-Adresse
|
||||
* nennen; verglichen wird gegen das, was im Browser in der Adresszeile
|
||||
* stand.
|
||||
*/
|
||||
get passkey() {
|
||||
const url = new URL(process.env.AUTH_URL ?? 'http://localhost:3000')
|
||||
return {
|
||||
rpId: url.hostname,
|
||||
rpName: 'Betreuungs-Cockpit',
|
||||
herkunft: url.origin,
|
||||
sicherAufrufbar: url.protocol === 'https:' || url.hostname === 'localhost',
|
||||
}
|
||||
},
|
||||
|
||||
get istProduktion() {
|
||||
return process.env.NODE_ENV === 'production'
|
||||
},
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
/**
|
||||
* Browserseitige Hilfen fuer Passkeys.
|
||||
*
|
||||
* Bewusst ohne "server-only" und ohne Datenbankzugriff: Diese Datei laeuft
|
||||
* im Browser. Die eigentliche Pruefung passiert auf dem Server
|
||||
* (src/lib/auth/passkey.ts) - hier geht es nur darum, das Geraet
|
||||
* anzusprechen und seine Fehler in verstaendliche Saetze zu uebersetzen.
|
||||
*/
|
||||
|
||||
import {
|
||||
browserSupportsWebAuthn,
|
||||
startAuthentication,
|
||||
startRegistration,
|
||||
} from '@simplewebauthn/browser'
|
||||
|
||||
export { browserSupportsWebAuthn, startAuthentication, startRegistration }
|
||||
|
||||
/**
|
||||
* Uebersetzt die Ausnahmen der WebAuthn-Schnittstelle.
|
||||
*
|
||||
* Der Browser wirft DOMExceptions mit sehr knappen Namen und einer
|
||||
* englischen Beschreibung, die man niemandem zeigen kann. Vor allem
|
||||
* "NotAllowedError" ist irrefuehrend: Er bedeutet meistens schlicht, dass
|
||||
* der Vorgang abgebrochen wurde oder die Zeit abgelaufen ist - nicht, dass
|
||||
* etwas verboten waere.
|
||||
*/
|
||||
export function passkeyBrowserfehler(fehler: unknown, beimEinrichten = false): string {
|
||||
const name = fehler instanceof Error ? fehler.name : ''
|
||||
|
||||
switch (name) {
|
||||
case 'NotAllowedError':
|
||||
return 'Abgebrochen oder zu lange gewartet. Du kannst es gleich noch einmal versuchen.'
|
||||
|
||||
case 'InvalidStateError':
|
||||
return beimEinrichten
|
||||
? 'Für dieses Gerät ist hier bereits ein Passkey hinterlegt. Ein zweiter bringt nichts — ' +
|
||||
'nimm ein anderes Gerät oder entferne zuerst den vorhandenen.'
|
||||
: 'Dieses Gerät kann den Passkey gerade nicht verwenden.'
|
||||
|
||||
case 'SecurityError':
|
||||
return (
|
||||
'Die Adresse im Browser passt nicht zu der, für die der Passkey ausgestellt wurde. ' +
|
||||
'Das ist genau der Schutz, der Phishing verhindert — prüfe die Adresszeile.'
|
||||
)
|
||||
|
||||
case 'NotSupportedError':
|
||||
return 'Dieses Gerät unterstützt keine Passkeys mit Fingerabdruck, Gesicht oder PIN.'
|
||||
|
||||
case 'AbortError':
|
||||
return 'Abgebrochen.'
|
||||
|
||||
default:
|
||||
return 'Der Passkey konnte nicht verwendet werden. Bitte versuche es noch einmal.'
|
||||
}
|
||||
}
|
||||
@@ -8,21 +8,36 @@ import { z } from 'zod'
|
||||
* ist, nicht was falsch war.
|
||||
*/
|
||||
|
||||
/** Leere Zeichenketten aus einem Formular sollen zu null werden, nicht zu "". */
|
||||
/**
|
||||
* Optionales Textfeld.
|
||||
*
|
||||
* Drei Eingaben muessen zu null werden:
|
||||
* "" das Feld war da, blieb aber leer
|
||||
* null ausdruecklich geleert
|
||||
* undefined das Feld war im Formular ueberhaupt nicht dabei
|
||||
*
|
||||
* Der letzte Fall ist der wichtige: Das kurze Formular der Ersteinrichtung
|
||||
* schickt nur eine Handvoll Felder, das vollstaendige unter Stammdaten
|
||||
* alle. Beide gehen durch dasselbe Schema. Ohne .optional() wuerde die
|
||||
* Ersteinrichtung an zwei Dutzend Feldern scheitern, die gar nicht auf dem
|
||||
* Bildschirm stehen - und die Meldung liesse sich keinem Feld zuordnen.
|
||||
*/
|
||||
const optionalerText = (max = 200) =>
|
||||
z
|
||||
.string()
|
||||
.trim()
|
||||
.max(max, `Bitte höchstens ${max} Zeichen.`)
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.optional()
|
||||
.nullable()
|
||||
.transform((wert) => (wert === undefined || wert === '' ? null : wert))
|
||||
|
||||
/** HTML-Datumsfelder liefern "" oder "2026-01-15". */
|
||||
/** HTML-Datumsfelder liefern "" oder "2026-01-15" - oder gar nichts. */
|
||||
const optionalesDatum = z
|
||||
.string()
|
||||
.trim()
|
||||
.transform((wert) => (wert === '' ? null : wert))
|
||||
.optional()
|
||||
.nullable()
|
||||
.transform((wert) => (wert === undefined || wert === '' ? null : wert))
|
||||
.refine((wert) => wert === null || /^\d{4}-\d{2}-\d{2}$/.test(wert), {
|
||||
message: 'Bitte ein Datum im Format TT.MM.JJJJ wählen.',
|
||||
})
|
||||
|
||||
+1
-1
@@ -17,7 +17,7 @@
|
||||
*/
|
||||
|
||||
/** Muss zur "version" in der package.json passen. */
|
||||
export const VERSION = '1.0.0'
|
||||
export const VERSION = '1.1.0'
|
||||
|
||||
/**
|
||||
* Kurzer Git-Stand, beim Bauen hineingereicht:
|
||||
|
||||
@@ -3,6 +3,7 @@ import { db, papierkorbGrenze } from '@/lib/db'
|
||||
import { env } from '@/lib/env'
|
||||
import { fristErinnerung, mailSenden } from '@/lib/mail'
|
||||
import { alteVersucheEntfernen } from '@/lib/auth/ratelimit'
|
||||
import { abgelaufeneAnfragenEntfernen } from '@/lib/auth/passkey'
|
||||
|
||||
/**
|
||||
* Taeglicher Wartungslauf.
|
||||
@@ -14,6 +15,7 @@ import { alteVersucheEntfernen } from '@/lib/auth/ratelimit'
|
||||
* 2. Papierkorb leeren (30 Tage)
|
||||
* 3. Alte Anmeldeversuche entfernen (30 Tage)
|
||||
* 4. Altes Audit-Log entfernen (10 Jahre, ueber die DB-Funktion)
|
||||
* 5. Liegengebliebene Passkey-Challenges entfernen (5 Minuten)
|
||||
*
|
||||
* Jeder Schritt faengt seine Fehler selbst ab. Faellt die Mail aus, soll
|
||||
* trotzdem aufgeraeumt werden - sonst laeuft die Datenbank voll, weil ein
|
||||
@@ -25,6 +27,7 @@ export type Wartungsergebnis = {
|
||||
papierkorbGeleert: number
|
||||
loginversucheEntfernt: number
|
||||
auditEintraegeEntfernt: number
|
||||
passkeyAnfragenEntfernt: number
|
||||
fehler: string[]
|
||||
}
|
||||
|
||||
@@ -56,6 +59,7 @@ export async function wartungslauf(): Promise<Wartungsergebnis> {
|
||||
papierkorbGeleert: 0,
|
||||
loginversucheEntfernt: 0,
|
||||
auditEintraegeEntfernt: 0,
|
||||
passkeyAnfragenEntfernt: 0,
|
||||
fehler: [],
|
||||
}
|
||||
|
||||
@@ -93,6 +97,15 @@ export async function wartungslauf(): Promise<Wartungsergebnis> {
|
||||
ergebnis.fehler.push(`Audit-Log: ${beschreiben(fehler)}`)
|
||||
}
|
||||
|
||||
// --- 5. Passkey-Challenges ----------------------------------------------
|
||||
try {
|
||||
// Normalerweise raeumt jede Anmeldung selbst auf. Bleibt der letzte
|
||||
// Versuch des Tages liegen, faengt es dieser Lauf ab.
|
||||
ergebnis.passkeyAnfragenEntfernt = await abgelaufeneAnfragenEntfernen()
|
||||
} catch (fehler) {
|
||||
ergebnis.fehler.push(`Passkey-Anfragen: ${beschreiben(fehler)}`)
|
||||
}
|
||||
|
||||
return ergebnis
|
||||
}
|
||||
|
||||
|
||||
@@ -53,6 +53,49 @@ function felderAusFehler(fehler: z.ZodError): Record<string, string> {
|
||||
return ergebnis
|
||||
}
|
||||
|
||||
/**
|
||||
* Baut die Antwort auf einen Pruefungsfehler.
|
||||
*
|
||||
* Der wichtige Teil ist die Unterscheidung: Beanstandet die Pruefung ein
|
||||
* Feld, das gar nicht abgeschickt wurde, dann passt das Formular nicht zum
|
||||
* Schema - und die Meldung liesse sich auf dem Bildschirm keinem Feld
|
||||
* zuordnen. Der Nutzer saehe "Bitte pruefe die markierten Felder", ohne
|
||||
* dass irgendetwas markiert waere, und kaeme nie weiter.
|
||||
*
|
||||
* Das ist ein Fehler im Programm, keiner in der Eingabe. Er wird deshalb
|
||||
* benannt und ins Serverlog geschrieben, statt ihn dem Nutzer als
|
||||
* Eingabefehler unterzuschieben.
|
||||
*/
|
||||
function antwortAufFehler(fehler: z.ZodError, formular: FormData): BetreuteZustand {
|
||||
const felder = felderAusFehler(fehler)
|
||||
const gesendet = new Set(formular.keys())
|
||||
const nichtZuordenbar = Object.entries(felder).filter(([feld]) => !gesendet.has(feld))
|
||||
|
||||
if (nichtZuordenbar.length > 0) {
|
||||
const liste = nichtZuordenbar.map(([feld, meldung]) => `${feld}: ${meldung}`).join('; ')
|
||||
console.error(
|
||||
`[stammdaten] Das Formular passt nicht zum Schema. Beanstandet wurden ` +
|
||||
`Felder, die es gar nicht abgeschickt hat: ${liste}`,
|
||||
)
|
||||
return {
|
||||
fehler:
|
||||
'Das Formular passt nicht zur Prüfung — betroffen sind Felder, die ' +
|
||||
'hier gar nicht stehen: ' +
|
||||
nichtZuordenbar.map(([feld]) => feld).join(', ') +
|
||||
'. Das ist ein Fehler in der Anwendung, nicht in deiner Eingabe. ' +
|
||||
'Einzelheiten stehen im Serverlog.',
|
||||
felder,
|
||||
werte: werteMerken(formular),
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
fehler: 'Bitte prüfe die markierten Felder.',
|
||||
felder,
|
||||
werte: werteMerken(formular),
|
||||
}
|
||||
}
|
||||
|
||||
function werteMerken(formular: FormData): Record<string, string> {
|
||||
const werte: Record<string, string> = {}
|
||||
for (const [name, wert] of formular.entries()) {
|
||||
@@ -77,13 +120,7 @@ export async function betreuteAnlegen(
|
||||
}
|
||||
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(formular))
|
||||
if (!gelesen.success) {
|
||||
return {
|
||||
fehler: 'Bitte prüfe die markierten Felder.',
|
||||
felder: felderAusFehler(gelesen.error),
|
||||
werte: werteMerken(formular),
|
||||
}
|
||||
}
|
||||
if (!gelesen.success) return antwortAufFehler(gelesen.error, formular)
|
||||
|
||||
const { offen, verschluesselt } = aufteilen(gelesen.data)
|
||||
|
||||
@@ -134,13 +171,7 @@ export async function betreuteAendern(
|
||||
const { benutzer, betreute } = await erfordereZugang(betreuteId, 'STAMMDATEN', 'schreiben')
|
||||
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(formular))
|
||||
if (!gelesen.success) {
|
||||
return {
|
||||
fehler: 'Bitte prüfe die markierten Felder.',
|
||||
felder: felderAusFehler(gelesen.error),
|
||||
werte: werteMerken(formular),
|
||||
}
|
||||
}
|
||||
if (!gelesen.success) return antwortAufFehler(gelesen.error, formular)
|
||||
|
||||
const { offen, verschluesselt } = aufteilen(gelesen.data)
|
||||
|
||||
|
||||
@@ -0,0 +1,313 @@
|
||||
'use server'
|
||||
|
||||
import { AuthError } from 'next-auth'
|
||||
import { revalidatePath } from 'next/cache'
|
||||
import { z } from 'zod'
|
||||
import type {
|
||||
AuthenticationResponseJSON,
|
||||
PublicKeyCredentialCreationOptionsJSON,
|
||||
PublicKeyCredentialRequestOptionsJSON,
|
||||
RegistrationResponseJSON,
|
||||
} from '@simplewebauthn/server'
|
||||
import { signIn } from '@/auth'
|
||||
import { db } from '@/lib/db'
|
||||
import { protokollieren } from '@/lib/audit'
|
||||
import {
|
||||
PASSKEY_MELDUNG,
|
||||
PasskeyFehler,
|
||||
anmeldungPruefen,
|
||||
anmeldungVorbereiten,
|
||||
registrierungPruefen,
|
||||
registrierungVorbereiten,
|
||||
} from '@/lib/auth/passkey'
|
||||
import { erfordereBenutzer, reauthBestaetigen } from '@/lib/auth/sitzung'
|
||||
|
||||
/**
|
||||
* Server Actions rund um Passkeys.
|
||||
*
|
||||
* Ein Passkey-Vorgang besteht immer aus zwei Aufrufen: erst holt der Browser
|
||||
* die Optionen samt Challenge, dann schickt er die Antwort des Geraets
|
||||
* zurueck. Dazwischen liegt der Griff zum Fingerabdrucksensor, und der
|
||||
* dauert unbestimmt lange - deshalb zwei Schritte und keine Sitzungsvariable.
|
||||
*
|
||||
* Die Antworten des Authenticators kommen als JSON-Zeichenkette herein, nicht
|
||||
* als Objekt. Grund: Was ueber die Grenze zum Server geht, wird hier
|
||||
* ausdruecklich geparst und geprueft, statt sich auf die Serialisierung von
|
||||
* React zu verlassen.
|
||||
*/
|
||||
|
||||
/** Ergebnis eines Schritts, der Optionen liefert. */
|
||||
export type PasskeyStart<T> = { ok: true; optionen: T } | { ok: false; fehler: string }
|
||||
|
||||
/** Ergebnis eines abschliessenden Schritts. */
|
||||
export type PasskeyErgebnis = { ok: true; meldung?: string } | { ok: false; fehler: string }
|
||||
|
||||
function alsFehler(fehler: unknown): { ok: false; fehler: string } {
|
||||
if (fehler instanceof PasskeyFehler) {
|
||||
return { ok: false, fehler: PASSKEY_MELDUNG[fehler.grund] }
|
||||
}
|
||||
console.error('[passkey] Unerwarteter Fehler:', fehler)
|
||||
return { ok: false, fehler: PASSKEY_MELDUNG.ungueltig }
|
||||
}
|
||||
|
||||
/**
|
||||
* Parst die Antwort des Browsers.
|
||||
*
|
||||
* Absichtlich nur eine grobe Formpruefung: Was zaehlt, prueft anschliessend
|
||||
* die Bibliothek kryptografisch. Hier geht es nur darum, dass kein
|
||||
* offensichtlicher Unsinn bis dorthin durchlaeuft.
|
||||
*/
|
||||
const AntwortSchema = z.object({
|
||||
id: z.string().min(1),
|
||||
rawId: z.string().min(1),
|
||||
type: z.literal('public-key'),
|
||||
response: z.object({ clientDataJSON: z.string().min(1) }).passthrough(),
|
||||
})
|
||||
|
||||
function antwortLesen<T>(roh: string): T {
|
||||
const gelesen = AntwortSchema.safeParse(JSON.parse(roh))
|
||||
if (!gelesen.success) throw new PasskeyFehler('ungueltig')
|
||||
return gelesen.data as T
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Einrichten (angemeldet, unter "Mein Konto")
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export async function passkeyEinrichtungStarten(): Promise<
|
||||
PasskeyStart<PublicKeyCredentialCreationOptionsJSON>
|
||||
> {
|
||||
try {
|
||||
const benutzer = await erfordereBenutzer()
|
||||
return { ok: true, optionen: await registrierungVorbereiten(benutzer) }
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
}
|
||||
|
||||
const NameSchema = z
|
||||
.string()
|
||||
.trim()
|
||||
.min(1, 'Bitte gib dem Gerät einen Namen.')
|
||||
.max(60, 'Bitte höchstens 60 Zeichen.')
|
||||
|
||||
export async function passkeyEinrichtungAbschliessen(
|
||||
name: string,
|
||||
antwortJson: string,
|
||||
): Promise<PasskeyErgebnis> {
|
||||
try {
|
||||
const benutzer = await erfordereBenutzer()
|
||||
|
||||
const geprueft = NameSchema.safeParse(name)
|
||||
if (!geprueft.success) {
|
||||
return {
|
||||
ok: false,
|
||||
fehler: geprueft.error.issues[0]?.message ?? 'Der Name passt nicht.',
|
||||
}
|
||||
}
|
||||
|
||||
const antwort = antwortLesen<RegistrationResponseJSON>(antwortJson)
|
||||
const passkey = await registrierungPruefen(benutzer, geprueft.data, antwort)
|
||||
|
||||
await protokollieren({
|
||||
aktion: 'PASSKEY_REGISTRIERT',
|
||||
entitaet: 'Passkey',
|
||||
entitaetId: passkey.id,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
bezeichnung: passkey.name,
|
||||
})
|
||||
|
||||
revalidatePath('/konto')
|
||||
return { ok: true, meldung: `„${passkey.name}“ ist eingerichtet.` }
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Verwalten
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export async function passkeyEntfernen(id: string): Promise<PasskeyErgebnis> {
|
||||
try {
|
||||
const benutzer = await erfordereBenutzer()
|
||||
|
||||
// Zeilenweise Pruefung: Es genuegt nicht, dass die ID existiert - sie
|
||||
// muss zu DIESEM Benutzer gehoeren. deleteMany mit userId im WHERE
|
||||
// erledigt Pruefung und Loeschen in einem Zug; ein fremder Passkey
|
||||
// trifft dann auf null Zeilen.
|
||||
const passkey = await db.passkey.findFirst({
|
||||
where: { id, userId: benutzer.id },
|
||||
select: { id: true, name: true },
|
||||
})
|
||||
if (!passkey)
|
||||
return {
|
||||
ok: false,
|
||||
fehler: 'Dieser Passkey gehört nicht zu deinem Zugang.',
|
||||
}
|
||||
|
||||
await db.passkey.delete({ where: { id: passkey.id } })
|
||||
|
||||
await protokollieren({
|
||||
aktion: 'PASSKEY_ENTFERNT',
|
||||
entitaet: 'Passkey',
|
||||
entitaetId: passkey.id,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
userName: benutzer.name,
|
||||
bezeichnung: passkey.name,
|
||||
})
|
||||
|
||||
revalidatePath('/konto')
|
||||
return { ok: true, meldung: `„${passkey.name}“ wurde entfernt.` }
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Anmelden (nicht angemeldet)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export async function passkeyAnmeldungStarten(): Promise<
|
||||
PasskeyStart<PublicKeyCredentialRequestOptionsJSON>
|
||||
> {
|
||||
try {
|
||||
return { ok: true, optionen: await anmeldungVorbereiten() }
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
}
|
||||
|
||||
/** Verhindert offene Weiterleitungen auf fremde Seiten. */
|
||||
function sicheresZiel(ziel: string): string {
|
||||
if (!ziel.startsWith('/') || ziel.startsWith('//')) return '/heute'
|
||||
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
|
||||
* gewoehnlichen Anmeldeweg.
|
||||
*/
|
||||
function fehlertext(code: string): string {
|
||||
const [art, wert] = code.split(':')
|
||||
|
||||
if (art === 'passkey') {
|
||||
const grund = wert as keyof typeof PASSKEY_MELDUNG
|
||||
return PASSKEY_MELDUNG[grund] ?? PASSKEY_MELDUNG.ungueltig
|
||||
}
|
||||
if (art === 'gesperrt') {
|
||||
const minuten = Math.ceil(Number.parseInt(wert ?? '0', 10) / 60)
|
||||
return (
|
||||
`Zu viele Fehlversuche. Aus Sicherheitsgründen ist die Anmeldung für ` +
|
||||
`${minuten > 1 ? `etwa ${minuten} Minuten` : 'kurze Zeit'} gesperrt.`
|
||||
)
|
||||
}
|
||||
if (art === 'konto-inaktiv') {
|
||||
return 'Dieser Zugang ist deaktiviert. Bitte wende dich an den Administrator.'
|
||||
}
|
||||
return PASSKEY_MELDUNG.ungueltig
|
||||
}
|
||||
|
||||
export async function passkeyAnmeldungAbschliessen(
|
||||
antwortJson: string,
|
||||
weiter: string,
|
||||
): Promise<PasskeyErgebnis> {
|
||||
try {
|
||||
// Nur die Form pruefen; signIn() macht die eigentliche Arbeit.
|
||||
antwortLesen<AuthenticationResponseJSON>(antwortJson)
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
|
||||
try {
|
||||
await signIn('passkey', {
|
||||
antwort: antwortJson,
|
||||
redirectTo: sicheresZiel(weiter),
|
||||
})
|
||||
} catch (fehler) {
|
||||
// Bei Erfolg wirft signIn eine Weiterleitung - die muss durch.
|
||||
if (istWeiterleitung(fehler)) throw fehler
|
||||
|
||||
if (fehler instanceof AuthError) {
|
||||
const code =
|
||||
'code' in fehler && typeof fehler.code === 'string' ? fehler.code : 'passkey:ungueltig'
|
||||
return { ok: false, fehler: fehlertext(code) }
|
||||
}
|
||||
|
||||
throw fehler
|
||||
}
|
||||
|
||||
// Wird nicht erreicht - signIn leitet weiter.
|
||||
return { ok: true }
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Erneut bestaetigen (angemeldet, vor sensiblen Aktionen)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
export async function passkeyBestaetigungStarten(): Promise<
|
||||
PasskeyStart<PublicKeyCredentialRequestOptionsJSON>
|
||||
> {
|
||||
try {
|
||||
await erfordereBenutzer()
|
||||
return { ok: true, optionen: await anmeldungVorbereiten() }
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Bestaetigt die laufende Sitzung mit einem Passkey.
|
||||
*
|
||||
* Wichtig ist die letzte Pruefung: Der Passkey muss dem angemeldeten
|
||||
* Benutzer gehoeren. Sonst koennte jemand mit seinem eigenen Passkey die
|
||||
* fremde Sitzung freischalten, die auf einem unbeaufsichtigten Rechner
|
||||
* offen steht - genau der Fall, gegen den die erneute Bestaetigung da ist.
|
||||
*/
|
||||
export async function passkeyBestaetigen(antwortJson: string): Promise<PasskeyErgebnis> {
|
||||
try {
|
||||
const benutzer = await erfordereBenutzer()
|
||||
const antwort = antwortLesen<AuthenticationResponseJSON>(antwortJson)
|
||||
|
||||
const { benutzer: eigentuemer } = await anmeldungPruefen(antwort)
|
||||
|
||||
if (eigentuemer.id !== benutzer.id) {
|
||||
await protokollieren({
|
||||
aktion: 'ANMELDUNG_FEHLGESCHLAGEN',
|
||||
entitaet: 'User',
|
||||
entitaetId: benutzer.id,
|
||||
userId: benutzer.id,
|
||||
userEmail: benutzer.email,
|
||||
bezeichnung: 'Bestätigung mit fremdem Passkey',
|
||||
})
|
||||
return {
|
||||
ok: false,
|
||||
fehler: 'Dieser Passkey gehört zu einem anderen Zugang als dem gerade angemeldeten.',
|
||||
}
|
||||
}
|
||||
|
||||
await reauthBestaetigen(benutzer.id)
|
||||
return { ok: true }
|
||||
} catch (fehler) {
|
||||
return alsFehler(fehler)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
|
||||
import {
|
||||
MAX_PASSKEYS_JE_BENUTZER,
|
||||
PASSKEY_MELDUNG,
|
||||
PasskeyFehler,
|
||||
challengeAusAntwort,
|
||||
passkeysMoeglich,
|
||||
} from '@/lib/auth/passkey'
|
||||
import { passkeyBrowserfehler } from '@/lib/passkey-browser'
|
||||
import { env } from '@/lib/env'
|
||||
|
||||
/**
|
||||
* Passkeys — die Teile, die sich ohne Datenbank und ohne Browser prüfen
|
||||
* lassen.
|
||||
*
|
||||
* Der Schwerpunkt liegt auf der Herleitung von `rpId` und Herkunft aus
|
||||
* `AUTH_URL`. Das ist bei WebAuthn die Stelle, an der eine Installation
|
||||
* still kaputtgeht: Stimmt die Bereichskennung nicht, lässt sich zwar ein
|
||||
* Passkey einrichten, aber nie wieder verwenden — und die Fehlermeldung des
|
||||
* Browsers zeigt auf alles Mögliche, nur nicht auf die Konfiguration.
|
||||
*
|
||||
* Dieselbe Fehlerklasse hat uns bei `APP_BIND` und `ENC_KEY_V2` schon zwei
|
||||
* Fassungen gekostet: eine Umgebungsvariable, die falsch ausgewertet wird,
|
||||
* und ein Fehlerbild, das woandershin zeigt.
|
||||
*/
|
||||
|
||||
let vorher: string | undefined
|
||||
|
||||
beforeEach(() => {
|
||||
vorher = process.env.AUTH_URL
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
if (vorher === undefined) delete process.env.AUTH_URL
|
||||
else process.env.AUTH_URL = vorher
|
||||
})
|
||||
|
||||
describe('Bereichskennung aus AUTH_URL', () => {
|
||||
it('nimmt den nackten Hostnamen als rpId, ohne Schema und ohne Port', () => {
|
||||
process.env.AUTH_URL = 'https://cockpit.example.de'
|
||||
expect(env.passkey.rpId).toBe('cockpit.example.de')
|
||||
expect(env.passkey.herkunft).toBe('https://cockpit.example.de')
|
||||
})
|
||||
|
||||
it('lässt den Port in der Herkunft stehen, aber nicht in der rpId', () => {
|
||||
// Die Herkunft wird zeichengenau mit dem verglichen, was im Browser in
|
||||
// der Adresszeile stand - der Port gehoert dazu. Die rpId ist dagegen
|
||||
// die Domain, an die der Schluessel gebunden wird; ein Port darf dort
|
||||
// nicht auftauchen, sonst weist der Authenticator sie zurueck.
|
||||
process.env.AUTH_URL = 'https://cockpit.example.de:8443'
|
||||
expect(env.passkey.rpId).toBe('cockpit.example.de')
|
||||
expect(env.passkey.herkunft).toBe('https://cockpit.example.de:8443')
|
||||
})
|
||||
|
||||
it('verträgt einen Schrägstrich am Ende', () => {
|
||||
process.env.AUTH_URL = 'https://cockpit.example.de/'
|
||||
expect(env.passkey.herkunft).toBe('https://cockpit.example.de')
|
||||
})
|
||||
|
||||
it('erkennt eine Unterdomain als eigene Kennung', () => {
|
||||
// Ein Passkey fuer betreuung.example.de gilt NICHT fuer example.de -
|
||||
// genau das ist der Phishingschutz.
|
||||
process.env.AUTH_URL = 'https://betreuung.example.de'
|
||||
expect(env.passkey.rpId).toBe('betreuung.example.de')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Verfügbarkeit', () => {
|
||||
it('bietet Passkeys über https an', () => {
|
||||
process.env.AUTH_URL = 'https://cockpit.example.de'
|
||||
expect(env.passkey.sicherAufrufbar).toBe(true)
|
||||
expect(passkeysMoeglich()).toBe(true)
|
||||
})
|
||||
|
||||
it('bietet sie auf localhost an, auch ohne https', () => {
|
||||
// Der Browser wertet localhost als sicheren Kontext - sonst liesse
|
||||
// sich in der Entwicklung nichts ausprobieren.
|
||||
process.env.AUTH_URL = 'http://localhost:3000'
|
||||
expect(env.passkey.sicherAufrufbar).toBe(true)
|
||||
})
|
||||
|
||||
it('bietet sie NICHT über einfaches http an', () => {
|
||||
// Wichtig, dass das der Server entscheidet und nicht der Browser: Ein
|
||||
// Knopf, der beim Klick eine kryptische DOMException wirft, ist
|
||||
// schlechter als gar kein Knopf.
|
||||
process.env.AUTH_URL = 'http://cockpit.example.de'
|
||||
expect(env.passkey.sicherAufrufbar).toBe(false)
|
||||
expect(passkeysMoeglich()).toBe(false)
|
||||
})
|
||||
|
||||
it('bietet sie auch über eine nackte IP ohne https nicht an', () => {
|
||||
process.env.AUTH_URL = 'http://10.0.0.5:3000'
|
||||
expect(env.passkey.sicherAufrufbar).toBe(false)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Challenge aus der Antwort des Browsers', () => {
|
||||
function clientData(inhalt: unknown): string {
|
||||
return Buffer.from(JSON.stringify(inhalt), 'utf8').toString('base64url')
|
||||
}
|
||||
|
||||
it('liest die Challenge aus den clientData', () => {
|
||||
const daten = clientData({
|
||||
type: 'webauthn.get',
|
||||
challenge: 'AbCdEf-1234_xyz',
|
||||
origin: 'https://cockpit.example.de',
|
||||
})
|
||||
expect(challengeAusAntwort(daten)).toBe('AbCdEf-1234_xyz')
|
||||
})
|
||||
|
||||
it('weist eine Antwort ohne Challenge ab', () => {
|
||||
const daten = clientData({ type: 'webauthn.get', origin: 'https://cockpit.example.de' })
|
||||
expect(() => challengeAusAntwort(daten)).toThrowError(PasskeyFehler)
|
||||
})
|
||||
|
||||
it('weist eine leere Challenge ab', () => {
|
||||
expect(() => challengeAusAntwort(clientData({ challenge: '' }))).toThrowError(PasskeyFehler)
|
||||
})
|
||||
|
||||
it('weist eine Challenge ab, die keine Zeichenkette ist', () => {
|
||||
expect(() => challengeAusAntwort(clientData({ challenge: 42 }))).toThrowError(PasskeyFehler)
|
||||
})
|
||||
|
||||
it('weist Unsinn ab, statt daran abzustürzen', () => {
|
||||
expect(() => challengeAusAntwort('das ist kein base64url-JSON')).toThrowError(PasskeyFehler)
|
||||
expect(() => challengeAusAntwort('')).toThrowError(PasskeyFehler)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Meldungen', () => {
|
||||
it('hat zu jedem Grund einen Satz, den man jemandem zeigen kann', () => {
|
||||
// Ein fehlender Eintrag wuerde als "undefined" auf dem Bildschirm
|
||||
// landen. Der Typ verhindert das beim Uebersetzen; hier wird geprueft,
|
||||
// dass auch nichts Leeres durchrutscht.
|
||||
for (const [grund, text] of Object.entries(PASSKEY_MELDUNG)) {
|
||||
expect(text.length, `Meldung für "${grund}"`).toBeGreaterThan(20)
|
||||
expect(text, `Meldung für "${grund}"`).not.toMatch(/undefined/)
|
||||
}
|
||||
})
|
||||
|
||||
it('nennt in der Obergrenze die tatsächliche Zahl', () => {
|
||||
expect(PASSKEY_MELDUNG['zu-viele']).toContain(String(MAX_PASSKEYS_JE_BENUTZER))
|
||||
})
|
||||
|
||||
it('erklärt bei fehlender Nutzerverifikation, warum abgelehnt wird', () => {
|
||||
// Das ist die Meldung, die am ehesten nach Schikane aussieht. Sie muss
|
||||
// den Grund nennen, sonst haelt man sie fuer einen Fehler.
|
||||
expect(PASSKEY_MELDUNG['nicht-verifiziert']).toMatch(/Fingerabdruck|PIN/)
|
||||
})
|
||||
})
|
||||
|
||||
describe('Fehler des Browsers', () => {
|
||||
function dom(name: string): Error {
|
||||
const fehler = new Error('irgendwas Englisches')
|
||||
fehler.name = name
|
||||
return fehler
|
||||
}
|
||||
|
||||
it('deutet NotAllowedError als Abbruch, nicht als Verbot', () => {
|
||||
// Der Name ist irrefuehrend: Er kommt auch, wenn schlicht niemand den
|
||||
// Finger aufgelegt hat. "Nicht erlaubt" waere die falsche Auskunft.
|
||||
const text = passkeyBrowserfehler(dom('NotAllowedError'))
|
||||
expect(text).toMatch(/Abgebrochen/)
|
||||
expect(text).not.toMatch(/verboten|nicht erlaubt/i)
|
||||
})
|
||||
|
||||
it('erklärt beim Einrichten, dass dieses Gerät schon einen Passkey hat', () => {
|
||||
expect(passkeyBrowserfehler(dom('InvalidStateError'), true)).toMatch(/bereits/)
|
||||
})
|
||||
|
||||
it('sagt bei SecurityError, dass die Adresse nicht passt', () => {
|
||||
expect(passkeyBrowserfehler(dom('SecurityError'))).toMatch(/Adress/)
|
||||
})
|
||||
|
||||
it('fällt bei unbekannten Fehlern auf einen brauchbaren Satz zurück', () => {
|
||||
expect(passkeyBrowserfehler(dom('VoellingNeuerFehler'))).toMatch(/noch einmal/)
|
||||
expect(passkeyBrowserfehler('gar kein Fehlerobjekt')).toMatch(/noch einmal/)
|
||||
expect(passkeyBrowserfehler(undefined)).toMatch(/noch einmal/)
|
||||
})
|
||||
|
||||
it('gibt nie die englische Originalmeldung weiter', () => {
|
||||
for (const name of [
|
||||
'NotAllowedError',
|
||||
'InvalidStateError',
|
||||
'SecurityError',
|
||||
'NotSupportedError',
|
||||
'AbortError',
|
||||
'Unbekannt',
|
||||
]) {
|
||||
expect(passkeyBrowserfehler(dom(name))).not.toContain('irgendwas Englisches')
|
||||
}
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,137 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { BetreuteSchema, formularLesen } from '@/lib/validierung/betreute'
|
||||
|
||||
/**
|
||||
* Eingabepruefung der Stammdaten.
|
||||
*
|
||||
* Anlass für diese Datei war ein Fehler im Betrieb: Die Ersteinrichtung
|
||||
* ließ sich nicht abschließen. Das Formular meldete „Bitte prüfe die
|
||||
* markierten Felder", markierte aber keines — weil die Meldungen zu
|
||||
* Feldern gehörten, die dort gar nicht stehen.
|
||||
*
|
||||
* Ursache: Das kurze Formular der Ersteinrichtung schickt neun Felder,
|
||||
* das vollständige unter Stammdaten alle. Beide gehen durch dasselbe
|
||||
* Schema, und die optionalen Felder waren zwar `nullable`, aber nicht
|
||||
* `optional` — ein fehlendes Feld ist `undefined`, nicht `null`.
|
||||
*/
|
||||
|
||||
/** Die Felder, die das kurze Formular der Ersteinrichtung tatsächlich schickt. */
|
||||
function ersteinrichtungsFormular(): FormData {
|
||||
const f = new FormData()
|
||||
f.set('vorname', 'Franziska')
|
||||
f.set('nachname', 'Wilde')
|
||||
f.set('geburtsdatum', '1963-09-23')
|
||||
f.set('betreuungsgericht', 'Lichtenfels')
|
||||
f.set('aktenzeichenGericht', 'XVII 355/25')
|
||||
f.set('bestellungAm', '2025-11-07')
|
||||
f.append('aufgabenkreise', 'VERMOEGENSSORGE')
|
||||
f.append('aufgabenkreise', 'GESUNDHEITSSORGE')
|
||||
f.set('befreiterBetreuer', 'on')
|
||||
f.set('ehrenamtlich', 'on')
|
||||
return f
|
||||
}
|
||||
|
||||
describe('Ersteinrichtung', () => {
|
||||
it('nimmt das kurze Formular an, obwohl es die meisten Felder nicht schickt', () => {
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(ersteinrichtungsFormular()))
|
||||
|
||||
if (!gelesen.success) {
|
||||
const felder = Object.keys(gelesen.error.flatten().fieldErrors).join(', ')
|
||||
throw new Error(`Abgelehnt wegen: ${felder}`)
|
||||
}
|
||||
|
||||
expect(gelesen.data.vorname).toBe('Franziska')
|
||||
expect(gelesen.data.nachname).toBe('Wilde')
|
||||
expect(gelesen.data.geburtsdatum.toISOString()).toBe('1963-09-23T00:00:00.000Z')
|
||||
expect(gelesen.data.bestellungAm?.toISOString()).toBe('2025-11-07T00:00:00.000Z')
|
||||
expect(gelesen.data.aufgabenkreise).toEqual(['VERMOEGENSSORGE', 'GESUNDHEITSSORGE'])
|
||||
expect(gelesen.data.befreiterBetreuer).toBe(true)
|
||||
expect(gelesen.data.ehrenamtlich).toBe(true)
|
||||
})
|
||||
|
||||
it('macht aus nicht gesendeten Feldern null, nicht undefined', () => {
|
||||
const gelesen = BetreuteSchema.parse(formularLesen(ersteinrichtungsFormular()))
|
||||
|
||||
// Diese Felder standen nie auf dem Bildschirm. Sie muessen als null in
|
||||
// der Datenbank landen, sonst schreibt Prisma sie gar nicht.
|
||||
expect(gelesen.heimName).toBeNull()
|
||||
expect(gelesen.diagnosen).toBeNull()
|
||||
expect(gelesen.geburtsname).toBeNull()
|
||||
expect(gelesen.heimEinzugAm).toBeNull()
|
||||
expect(gelesen.bestellungBis).toBeNull()
|
||||
expect(gelesen.aktenzeichenBezirk).toBeNull()
|
||||
expect(gelesen.pflegegrad).toBeNull()
|
||||
expect(gelesen.schwerbehinderungGdB).toBeNull()
|
||||
})
|
||||
|
||||
it('haelt auch das vollstaendige Formular aus', () => {
|
||||
const f = ersteinrichtungsFormular()
|
||||
// So kommt es aus dem Bearbeitungsformular: alle Felder da, viele leer.
|
||||
for (const feld of [
|
||||
'anrede', 'geburtsname', 'geburtsort',
|
||||
'heimName', 'heimStrasse', 'heimPlz', 'heimOrt', 'heimZimmer', 'heimTelefon',
|
||||
'fruehereStrasse', 'frueherePlz', 'fruehererOrt',
|
||||
'krankenkasse', 'krankenversichertennummer', 'pflegekasse',
|
||||
'schwerbehinderungMerkzeichen', 'diagnosen', 'ermittelterWille',
|
||||
'aufgabenkreiseFreitext', 'aktenzeichenBezirk', 'aktenzeichenSozialamt',
|
||||
'rentenversicherungsnummer', 'steuerId', 'notizen',
|
||||
]) {
|
||||
f.set(feld, '')
|
||||
}
|
||||
for (const feld of ['heimEinzugAm', 'pflegegradSeit', 'pflegegradBescheidVom', 'bestellungBis']) {
|
||||
f.set(feld, '')
|
||||
}
|
||||
f.set('pflegegrad', '')
|
||||
f.set('schwerbehinderungGdB', '')
|
||||
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(f))
|
||||
expect(gelesen.success, 'Leere Felder duerfen nicht abgelehnt werden').toBe(true)
|
||||
})
|
||||
|
||||
it('nimmt ausgefuellte Angaben unveraendert an', () => {
|
||||
const f = ersteinrichtungsFormular()
|
||||
f.set('heimName', ' Seniorenzentrum St. Katharina ')
|
||||
f.set('pflegegrad', '3')
|
||||
f.set('diagnosen', 'COPD GOLD III')
|
||||
|
||||
const gelesen = BetreuteSchema.parse(formularLesen(f))
|
||||
// Fuehrende und nachlaufende Leerzeichen fliegen raus.
|
||||
expect(gelesen.heimName).toBe('Seniorenzentrum St. Katharina')
|
||||
expect(gelesen.pflegegrad).toBe(3)
|
||||
expect(gelesen.diagnosen).toBe('COPD GOLD III')
|
||||
})
|
||||
|
||||
it('besteht weiterhin auf Vorname, Nachname und Geburtsdatum', () => {
|
||||
const f = new FormData()
|
||||
f.set('vorname', '')
|
||||
f.set('nachname', '')
|
||||
f.set('geburtsdatum', '')
|
||||
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(f))
|
||||
expect(gelesen.success).toBe(false)
|
||||
|
||||
if (!gelesen.success) {
|
||||
const felder = gelesen.error.flatten().fieldErrors
|
||||
expect(Object.keys(felder).sort()).toEqual(['geburtsdatum', 'nachname', 'vorname'])
|
||||
}
|
||||
})
|
||||
|
||||
it('weist ein Geburtsdatum in der Zukunft ab', () => {
|
||||
const f = ersteinrichtungsFormular()
|
||||
f.set('geburtsdatum', '2099-01-01')
|
||||
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(f))
|
||||
expect(gelesen.success).toBe(false)
|
||||
if (!gelesen.success) {
|
||||
expect(gelesen.error.flatten().fieldErrors.geburtsdatum?.[0]).toMatch(/Zukunft/)
|
||||
}
|
||||
})
|
||||
|
||||
it('weist ein unfertiges Datum ab, statt es stillschweigend zu verwerfen', () => {
|
||||
const f = ersteinrichtungsFormular()
|
||||
f.set('bestellungAm', '2025-11')
|
||||
|
||||
const gelesen = BetreuteSchema.safeParse(formularLesen(f))
|
||||
expect(gelesen.success).toBe(false)
|
||||
})
|
||||
})
|
||||
@@ -0,0 +1,105 @@
|
||||
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
|
||||
|
||||
/**
|
||||
* Auswertung der Umgebungsvariablen.
|
||||
*
|
||||
* Der Anlass für diese Datei war ein Fehler im Betrieb: docker compose
|
||||
* reicht `ENC_KEY_V2` immer durch — mit leerem Wert, wenn in der .env
|
||||
* keiner steht. Die Schlüsselsammlung erkannte Schlüssel aber am
|
||||
* Variablennamen statt am Inhalt, fand also ein leeres `ENC_KEY_V2` und
|
||||
* brach ab. Die Meldung lautete „ENC_KEY_V2 fehlt", obwohl niemand einen
|
||||
* zweiten Schlüssel wollte.
|
||||
*
|
||||
* Jede Prüfung hier lädt `@/lib/env` frisch, weil die Werte beim ersten
|
||||
* Zugriff gemerkt werden.
|
||||
*/
|
||||
|
||||
const ECHT = Buffer.alloc(32, 7).toString('base64')
|
||||
const ECHT_ZWEI = Buffer.alloc(32, 9).toString('base64')
|
||||
|
||||
let vorher: NodeJS.ProcessEnv
|
||||
|
||||
async function frischesEnv() {
|
||||
// Leert die Modulregistrierung, damit der naechste Import das Modul neu
|
||||
// auswertet - die Schluessel werden sonst nur beim ersten Mal gelesen.
|
||||
vi.resetModules()
|
||||
const { env } = await import('@/lib/env')
|
||||
return env
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
vorher = { ...process.env }
|
||||
for (const name of Object.keys(process.env)) {
|
||||
if (/^ENC_KEY_V\d+$/.test(name)) delete process.env[name]
|
||||
}
|
||||
delete process.env.ENC_KEY_AKTIV
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
process.env = vorher
|
||||
})
|
||||
|
||||
describe('Verschlüsselungsschlüssel aus der Umgebung', () => {
|
||||
it('nimmt einen einzelnen Schlüssel an', async () => {
|
||||
process.env.ENC_KEY_V1 = ECHT
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
|
||||
expect(env.aktiveSchluesselversion).toBe(1)
|
||||
})
|
||||
|
||||
it('überspringt eine leere Schlüsselvariable', async () => {
|
||||
// Genau das setzt docker compose, wenn in der .env kein zweiter
|
||||
// Schlüssel steht: ENC_KEY_V2: ${ENC_KEY_V2:-}
|
||||
process.env.ENC_KEY_V1 = ECHT
|
||||
process.env.ENC_KEY_V2 = ''
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
|
||||
expect(env.aktiveSchluesselversion).toBe(1)
|
||||
})
|
||||
|
||||
it('überspringt eine Variable, in der nur Leerzeichen stehen', async () => {
|
||||
process.env.ENC_KEY_V1 = ECHT
|
||||
process.env.ENC_KEY_V2 = ' '
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect([...env.verschluesselungsschluessel.keys()]).toEqual([1])
|
||||
})
|
||||
|
||||
it('nimmt beide Schlüssel an, wenn wirklich rotiert wird', async () => {
|
||||
process.env.ENC_KEY_V1 = ECHT
|
||||
process.env.ENC_KEY_V2 = ECHT_ZWEI
|
||||
process.env.ENC_KEY_AKTIV = '2'
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect([...env.verschluesselungsschluessel.keys()].sort()).toEqual([1, 2])
|
||||
expect(env.aktiveSchluesselversion).toBe(2)
|
||||
})
|
||||
|
||||
it('sagt beim Rotieren deutlich, wenn der neue Schlüssel fehlt', async () => {
|
||||
process.env.ENC_KEY_V1 = ECHT
|
||||
process.env.ENC_KEY_V2 = ''
|
||||
process.env.ENC_KEY_AKTIV = '2'
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect(() => env.aktiveSchluesselversion).toThrow(/ENC_KEY_AKTIV=2/)
|
||||
// Die Meldung nennt, was da ist, und die richtige Reihenfolge.
|
||||
expect(() => env.aktiveSchluesselversion).toThrow(/Vorhanden sind die Versionen: 1/)
|
||||
expect(() => env.aktiveSchluesselversion).toThrow(/zuerst den neuen Schluessel/)
|
||||
})
|
||||
|
||||
it('beschwert sich, wenn gar kein Schlüssel gesetzt ist', async () => {
|
||||
process.env.ENC_KEY_V2 = ''
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect(() => env.verschluesselungsschluessel).toThrow(/mindestens ENC_KEY_V1/)
|
||||
})
|
||||
|
||||
it('weist einen Schlüssel falscher Länge ab', async () => {
|
||||
process.env.ENC_KEY_V1 = Buffer.alloc(16, 1).toString('base64')
|
||||
|
||||
const env = await frischesEnv()
|
||||
expect(() => env.verschluesselungsschluessel).toThrow(/32 Bytes/)
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user