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/lib/auth/passkey.ts

@@ -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
+}

src/lib/env.ts

@@ -185,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'
   },

src/lib/passkey-browser.ts

@@ -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.'
+  }
+}

src/lib/version.ts

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

src/lib/wartung.ts

@@ -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
 }