Anmeldesperre gegen Selbstverlaengerung und Schreiblast sichern

Die Sperre hielt sich selbst am Leben. Jeder Aufruf wurde festgehalten,
auch der, der wegen der laufenden Sperre gar nicht geprueft wurde; die
Frist lief zugleich ab dem juengsten Fehlversuch. Wer also alle zehn
Minuten ein falsches Passwort an eine fremde Adresse schickte, sperrte
deren Inhaber dauerhaft aus - ohne das Passwort zu kennen. Jeder dieser
Aufrufe hinterliess ausserdem eine Zeile, die erst der Wartungslauf nach
30 Tagen wieder los wurde.

Jetzt zwei getrennte Dinge: Ein geprueft fehlgeschlagener Versuch zaehlt
und wird einzeln festgehalten. Ein waehrend der Sperre abgewiesener
Aufruf zaehlt nicht und wird hoechstens einmal je Sperre vermerkt.

Die Auswertung geht die Versuche von alt nach neu durch und zieht die
Runden nach: Ist das Mass voll, beginnt an diesem Versuch eine Sperre
und der Zaehler faengt von vorn an. Damit laeuft die Frist auch dann ab,
wenn die Fehlversuche noch im Zeitfenster stehen - vorher blieb der
Zugang bis zum Fensterende dicht.

Die Tests sind gegen vier Mutationen geprueft; jede wird rot.

Refs #38

src/auth.ts

@@ -9,6 +9,7 @@ import {
   anmeldungErlaubt,
   aufMindestdauerWarten,
   fehlversucheZuruecksetzen,
+  sperreVermerken,
   versuchFesthalten,
 } from '@/lib/auth/ratelimit'
 import { protokollieren } from '@/lib/audit'
@@ -110,7 +111,7 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         // 1. Sperre pruefen, bevor teuer gerechnet wird.
         const sperre = await anmeldungErlaubt(email, ip)
         if (sperre.gesperrt) {
-          await versuchFesthalten(email, ip, false, 'gesperrt')
+          await sperreVermerken(email, ip)
           throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
         }
 
@@ -274,7 +275,7 @@ export const { handlers, signIn, signOut, auth } = NextAuth({
         // anmeldet - erraten laesst sich ein Passkey ohnehin nicht.
         const sperre = await anmeldungErlaubt(benutzer.email, ip)
         if (sperre.gesperrt) {
-          await versuchFesthalten(benutzer.email, ip, false, 'gesperrt')
+          await sperreVermerken(benutzer.email, ip)
           throw new AnmeldeFehler('gesperrt', sperre.nochSekunden)
         }
 

src/lib/auth/ratelimit.ts

@@ -14,8 +14,32 @@ import { ipHashen } from '@/lib/crypto/hash'
  * Gezaehlt wird nach E-Mail UND nach Anschluss (IP-Hash). Damit hilft es
  * weder, dieselbe Adresse von vielen Anschluessen zu probieren, noch viele
  * Adressen von einem Anschluss.
+ *
+ * ## Warum abgewiesene Versuche nicht mitzaehlen
+ *
+ * Frueher wurde jeder Aufruf festgehalten, auch der, der wegen einer
+ * laufenden Sperre gar nicht geprueft wurde. Zusammen mit einer Frist, die
+ * vom juengsten Fehlversuch aus gerechnet wurde, ergab das eine
+ * Rueckkopplung: Jeder abgewiesene Aufruf schob die Frist um die volle
+ * Sperrdauer nach hinten. Wer alle zehn Minuten ein falsches Passwort an
+ * eine fremde Adresse schickte, sperrte deren Inhaber dauerhaft aus - ohne
+ * das Passwort zu kennen. Und jeder dieser Aufrufe hinterliess eine Zeile,
+ * die erst der Wartungslauf nach 30 Tagen wieder los wurde.
+ *
+ * Deshalb jetzt zwei getrennte Dinge:
+ *
+ * - Ein *geprueft* fehlgeschlagener Versuch (falsches Passwort, falscher
+ *   Code, unbekannte Adresse) zaehlt und wird einzeln festgehalten.
+ * - Ein *abgewiesener* Aufruf waehrend der Sperre zaehlt nicht und wird
+ *   hoechstens einmal je Sperre vermerkt.
+ *
+ * Damit steht die Frist fest, sobald sie einmal gesetzt ist, und die
+ * Tabelle waechst nicht mit der Zahl der Angriffsversuche.
  */
 
+/** Grund fuer eine Zeile, die nur den abgewiesenen Aufruf dokumentiert. */
+const GRUND_ABGEWIESEN = 'gesperrt'
+
 export type SperrErgebnis =
   | { gesperrt: false; verbleibendeVersuche: number }
   | { gesperrt: true; nochSekunden: number }
@@ -29,33 +53,49 @@ function fensterStart(): Date {
  * Passwortvergleich aufgerufen - ein gesperrter Zugang soll gar nicht erst
  * Rechenzeit fuer Argon2 kosten.
  */
-export async function anmeldungErlaubt(
-  email: string,
-  ip: string | null,
-): Promise<SperrErgebnis> {
-  const seit = fensterStart()
+export async function anmeldungErlaubt(email: string, ip: string | null): Promise<SperrErgebnis> {
+  const jetzt = Date.now()
   const kennung = email.trim().toLowerCase()
   const ipH = ipHashen(ip)
 
   const fehlversuche = await db.loginVersuch.findMany({
     where: {
       erfolg: false,
-      zeitpunkt: { gte: seit },
+      // Abgewiesene Aufrufe zaehlen nicht mit - sonst haelt sich die Sperre
+      // selbst am Leben, siehe Kopf dieser Datei.
+      grund: { not: GRUND_ABGEWIESEN },
+      zeitpunkt: { gte: new Date(jetzt - env.loginFensterSekunden * 1000) },
       OR: [{ email: kennung }, ...(ipH ? [{ ipHash: ipH }] : [])],
     },
-    orderBy: { zeitpunkt: 'desc' },
+    orderBy: { zeitpunkt: 'asc' },
     select: { zeitpunkt: true },
-    take: env.loginMaxVersuche + 1,
+    // Deckel gegen eine ausufernde Abfrage. Mehr als eine Handvoll Runden
+    // passt ohnehin nicht in ein Zeitfenster, in dem jede Runde gesperrt
+    // wird.
+    take: 200,
   })
 
-  if (fehlversuche.length >= env.loginMaxVersuche) {
-    const juengster = fehlversuche[0]!.zeitpunkt.getTime()
-    const frei = juengster + env.loginSperreSekunden * 1000
-    const nochSekunden = Math.max(1, Math.ceil((frei - Date.now()) / 1000))
-    return { gesperrt: true, nochSekunden }
+  // Von alt nach neu durchgehen und die Runden nachvollziehen: Sobald das
+  // Mass voll ist, beginnt an genau diesem Versuch eine Sperre, und der
+  // Zaehler faengt von vorn an. Ist ihre Frist inzwischen abgelaufen, sind
+  // die Versuche davor abgegolten - sonst bliebe der Zugang bis zum Ende
+  // des Zeitfensters dicht, obwohl die Sperre laengst um ist.
+  let zaehler = 0
+  let sperreBis = 0
+
+  for (const versuch of fehlversuche) {
+    zaehler += 1
+    if (zaehler >= env.loginMaxVersuche) {
+      sperreBis = versuch.zeitpunkt.getTime() + env.loginSperreSekunden * 1000
+      zaehler = 0
+    }
   }
 
-  return { gesperrt: false, verbleibendeVersuche: env.loginMaxVersuche - fehlversuche.length }
+  if (sperreBis > jetzt) {
+    return { gesperrt: true, nochSekunden: Math.max(1, Math.ceil((sperreBis - jetzt) / 1000)) }
+  }
+
+  return { gesperrt: false, verbleibendeVersuche: env.loginMaxVersuche - zaehler }
 }
 
 /** Haelt einen Versuch fest. Der Grund hilft spaeter beim Nachvollziehen. */
@@ -75,6 +115,34 @@ export async function versuchFesthalten(
   })
 }
 
+/**
+ * Vermerkt einen abgewiesenen Aufruf - aber nur den ersten je Sperre.
+ *
+ * Dass eine Sperre gegriffen hat, will man im Protokoll sehen. Wie oft
+ * dagegen geklopft wurde, ist die Information nicht wert: Sie kostet eine
+ * Zeile pro Anfrage, und genau daraus laesst sich die Tabelle vollschreiben.
+ * Eine Zeile je Sperre reicht, um den Vorgang zu erkennen.
+ *
+ * @returns true, wenn tatsaechlich vermerkt wurde.
+ */
+export async function sperreVermerken(email: string, ip: string | null): Promise<boolean> {
+  const kennung = email.trim().toLowerCase()
+  const vorhanden = await db.loginVersuch.findFirst({
+    where: {
+      email: kennung,
+      erfolg: false,
+      grund: GRUND_ABGEWIESEN,
+      zeitpunkt: { gte: fensterStart() },
+    },
+    select: { id: true },
+  })
+
+  if (vorhanden) return false
+
+  await versuchFesthalten(kennung, ip, false, GRUND_ABGEWIESEN)
+  return true
+}
+
 /**
  * Nach einer erfolgreichen Anmeldung werden die Fehlversuche dieser
  * Adresse geloescht - sonst bliebe der Zaehler bis zum Fensterende stehen.