feat(auth): Zwei-Faktor-Anmeldung per TOTP

Ein Einmalkennwort zusaetzlich zum Passwort, mit QR-Code zum Einrichten und zehn Wiederherstellungscodes fuer den Fall, dass das Geraet verloren geht. Die Rechnung nach RFC 6238 steht in lib/auth/totp.ts statt in einer Abhaengigkeit. Es sind wenige Zeilen, das Verfahren liegt seit 2011 fest, und der RFC bringt Testvektoren mit - die Richtigkeit ist damit belegt und nicht nur behauptet. Fuer den QR-Code kommt qrcode dazu; ihn selbst zu zeichnen waere unverhaeltnismaessig. Einrichtung in zwei Schritten: der Schluessel wird hinterlegt, aber erst ein bestaetigter Code schaltet ihn scharf. Wer den QR-Code nicht scannen konnte und abbricht, sperrt sich sonst beim naechsten Anmelden selbst aus. Zwischen Passwort und Code steht ein eigenes Modell statt einer halbfertigen Sitzung. Eine Sitzungszeile mit einem "noch nicht gueltig"-Merker waere eine Zeile, die bei einem vergessenen Filter irgendwo doch als Anmeldung durchgeht; dieses Versehen kann hier nicht passieren. Nach fuenf Fehlversuchen ist der Vorgang verbrannt, damit sechs Stellen nicht in Ruhe durchprobiert werden. Die Wiederherstellungscodes liegen als SHA-256 statt als scrypt: sie sind zufaellig erzeugt und lang genug, dass Raten aussichtslos ist - ein langsames Verfahren brauchte bei jeder Anmeldung zehn teure Vergleiche und kaufte nichts dafuer. Das Alphabet laesst O, I und B weg, weil die Codes von Hand abgeschrieben werden. Abschalten und Neuerzeugen verlangen das Passwort. Ein unbeaufsichtigter Rechner mit offener Sitzung soll den zweiten Faktor nicht im Vorbeigehen entfernen koennen. Nachgewiesen im Browser: Einrichtung, Anmeldung mit Code, Anmeldung mit Wiederherstellungscode, derselbe Code ein zweites Mal abgelehnt, Abschalten mit falschem und richtigem Passwort. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
2026-07-26 12:36:37 +02:00
parent af562584ad
commit 2bff6faf3d
17 changed files with 1729 additions and 5 deletions
@@ -0,0 +1,128 @@
+import { createHash, randomBytes } from "node:crypto";
+import { cookies } from "next/headers";
+import type { NextResponse } from "next/server";
+import { COOKIES_SECURE, MFA_COOKIE, MFA_TTL_MS } from "@/lib/config";
+import { tryDecryptSecret } from "@/lib/crypto";
+import { prisma } from "@/lib/db";
+
+/**
+ * Der Zwischenzustand zwischen Passwort und zweitem Faktor.
+ *
+ * Bewusst nicht als halbfertige Sitzung: eine Sitzungszeile mit einem
+ * "noch nicht gueltig"-Merker waere eine Zeile, die bei einem vergessenen
+ * Filter irgendwo doch als Anmeldung durchgeht. Ein eigenes Modell kann
+ * dieses Versehen nicht passieren.
+ */
+
+/** Nach so vielen Fehlversuchen ist der Vorgang verbrannt. */
+export const MFA_MAX_ATTEMPTS = 5;
+
+function hashToken(token: string): string {
+  return createHash("sha256").update(token).digest("base64url");
+}
+
+export async function createPendingLogin(userId: string): Promise<string> {
+  const token = randomBytes(32).toString("base64url");
+
+  // Aeltere Vorgaenge desselben Kontos verwerfen: es kann nur einen geben,
+  // sonst sammeln sich bei jedem Anlauf neue Rateversuche an.
+  await prisma.pendingLogin.deleteMany({
+    where: { OR: [{ userId }, { expiresAt: { lt: new Date() } }] },
+  });
+
+  await prisma.pendingLogin.create({
+    data: {
+      userId,
+      tokenHash: hashToken(token),
+      expiresAt: new Date(Date.now() + MFA_TTL_MS),
+    },
+  });
+
+  return token;
+}
+
+export function setMfaCookie(response: NextResponse, token: string) {
+  response.cookies.set({
+    name: MFA_COOKIE,
+    value: token,
+    httpOnly: true,
+    sameSite: "lax",
+    secure: COOKIES_SECURE,
+    path: "/",
+    maxAge: Math.floor(MFA_TTL_MS / 1000),
+  });
+}
+
+export function clearMfaCookie(response: NextResponse) {
+  response.cookies.set({
+    name: MFA_COOKIE,
+    value: "",
+    httpOnly: true,
+    sameSite: "lax",
+    secure: COOKIES_SECURE,
+    path: "/",
+    maxAge: 0,
+  });
+}
+
+export interface PendingLoginState {
+  id: string;
+  attempts: number;
+  user: {
+    id: string;
+    username: string;
+    role: "ADMIN" | "USER";
+    isActive: boolean;
+    /** Entschluesselter TOTP-Schluessel; null, wenn er nicht lesbar ist. */
+    totpSecret: string | null;
+  };
+}
+
+/** Liest den laufenden Vorgang aus dem Cookie. */
+export async function readPendingLogin(): Promise<PendingLoginState | null> {
+  const store = await cookies();
+  const token = store.get(MFA_COOKIE)?.value;
+  if (!token) return null;
+
+  const pending = await prisma.pendingLogin.findUnique({
+    where: { tokenHash: hashToken(token) },
+    include: { user: true },
+  });
+  if (!pending) return null;
+
+  if (pending.expiresAt.getTime() <= Date.now()) {
+    await prisma.pendingLogin.delete({ where: { id: pending.id } }).catch(() => undefined);
+    return null;
+  }
+
+  return {
+    id: pending.id,
+    attempts: pending.attempts,
+    user: {
+      id: pending.user.id,
+      username: pending.user.username,
+      role: pending.user.role,
+      isActive: pending.user.isActive,
+      totpSecret: tryDecryptSecret(pending.user.totpSecretCipher),
+    },
+  };
+}
+
+/** Zaehlt einen Fehlversuch. Gibt zurueck, ob noch Versuche offen sind. */
+export async function noteMfaFailure(id: string): Promise<boolean> {
+  const updated = await prisma.pendingLogin.update({
+    where: { id },
+    data: { attempts: { increment: 1 } },
+    select: { attempts: true },
+  });
+
+  if (updated.attempts >= MFA_MAX_ATTEMPTS) {
+    await prisma.pendingLogin.delete({ where: { id } }).catch(() => undefined);
+    return false;
+  }
+  return true;
+}
+
+export async function discardPendingLogin(id: string): Promise<void> {
+  await prisma.pendingLogin.delete({ where: { id } }).catch(() => undefined);
+}