feat: Anmelden mit Passkey

Passkeys (WebAuthn/FIDO2) als zweiter Anmeldeweg - auf der Anmeldeseite
und bei der erneuten Bestaetigung vor sensiblen Aktionen. Verwaltet unter
"Mein Konto".

Der Passkey ERSETZT den zweiten Faktor, statt zu ihm hinzuzukommen. Das
ist tragbar, weil er zwei Faktoren in sich vereint: Besitz des Geraets
und dessen Entsperrung. Damit das keine Annahme bleibt, wird die
Nutzerverifikation angefordert (userVerification: 'required') und
serverseitig nachgeprueft - eine Antwort ohne sie wird abgewiesen.

TOTP muss vorher eingerichtet sein. Ein Passkey haengt an einem Geraet;
waere er der einzige Weg hinein, koennte ein verlorenes Handy die Akte
schliessen.

Aufbau:
- Die Pruefung laeuft vollstaendig im Credentials-Provider "passkey",
  nicht in der Server Action davor. Ein "war schon geprueft" ueber die
  Grenze zu reichen waere die Stelle, an der sich Anmeldungen faelschen
  lassen.
- Challenges liegen serverseitig und werden per DELETE genau einmal
  verbraucht - die Datenbank entscheidet, wer sie bekommt.
- Bereichskennung und Herkunft kommen aus AUTH_URL, nicht aus einer
  zweiten Konfigurationsquelle.
- Ohne https wird der Knopf gar nicht erst angeboten.
- Rate-Limiting, Kontosperre und Audit-Log gelten unveraendert; die
  Anmeldung nennt den verwendeten Passkey namentlich.

Zwei Anmerkungen zur Migration:
- "prisma migrate diff" wollte zusaetzlich die Trigramm-Indizes aus
  prisma/sql/suche.sql loeschen, die Prisma nicht kennt. Die Zeilen sind
  entfernt und im Migrationskopf vermerkt - ein DROP haette die unscharfe
  Suche stillgelegt, ohne dass etwas fehlgeschlagen waere.
- "prisma format" hat das Schema durchgaengig neu ausgerichtet. Ohne
  Whitespace betrachtet sind es 88 hinzugefuegte Zeilen und keine
  geloeschte.

Geprueft: 21 Einheitstests, drei End-to-End-Tests gegen Chromiums
virtuellen Authenticator (einrichten, anmelden, bestaetigen, entfernen,
Geraet ohne Verifikation abgewiesen), beide Geraeteprofile. 496 Tests,
null Typfehler, Produktionsbau steht.

Nebenbei: Die Zahlen im README waren veraltet (24 statt 33 Modelle, 46
statt 79 Seiten). Sie stehen jetzt mit dem Befehl daneben, mit dem man
sie nachzaehlt.

src/auth.ts

@@ -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: {