Terminplaner: Zaehler je IP getrennt und Abgelaufene zuerst, Notantwort beim Schreiben, Pruefung aller Antworten auf interne IDs

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

server/services/termine/limits.js

@@ -15,6 +15,12 @@ import { pruefeNow, pruefeText } from './util.js'
  * je IP und je siteKey), darfBuchungsversuch (je IP), darfHaltung (je siteKey), darfWiderrufsversuch (je IP) und darfG01
  * (Bestaetigungsmails je Adresse und Funktion). IPv6-Adressen zaehlen je /64 (ipSchluessel): ein Anschluss bekommt meist
  * ein ganzes /64, die Adresse darin wechselt beliebig.
+ *
+ * Speicher: zwei getrennte Maps mit je hoechstens 10 000 Schluesseln. Die Zaehler je IP (Schluessel mit 'ip:') haben
+ * beliebig viele, von Angreifern frei waehlbare Schluessel; sie duerfen die langlebigen Zaehler je Adresse, Funktion
+ * und siteKey (G01 und G08 einen Tag, Haltungen eine Stunde) nie verdraengen. Ist eine Map voll, werden zuerst alle
+ * abgelaufenen Zaehler entfernt (jeder Eintrag merkt sich das Ende seines Fensters); erst wenn dann noch kein Platz ist,
+ * faellt der aelteste noch laufende Zaehler dieser Map weg.
  */
 
 const MAX_SCHLUESSEL = 10000
@@ -41,15 +47,45 @@ const WIDERRUFE_JE_IP = 10
 /** G01 (Bestaetigungsmail, auch "zu viele"): je Adresse und Funktion und Tag. */
 const G01_JE_ADRESSE = 5
 
-/** schluessel -> { start (ms), n }; die Einfuegereihenfolge ist die Reihenfolge der Fensterbeginne. */
-const zaehler = new Map()
+/**
+ * Eine Map schluessel -> { start, ende (ms), n }; die Einfuegereihenfolge ist die Reihenfolge der Fensterbeginne.
+ * fruehesterAblauf ist eine untere Schranke fuer das kleinste ende: solange nowMs darunter liegt, kann es nichts
+ * Abgelaufenes geben und das Aufraeumen einer vollen Map entfaellt (kein Durchlauf je neuem Schluessel).
+ */
+const neuerSpeicher = () => ({ map: new Map(), fruehesterAblauf: Infinity })
+const ipZaehler = neuerSpeicher()
+const sonstigeZaehler = neuerSpeicher()
+
+/** Zaehler je IP ('ip:...') und alle anderen liegen in getrennten Maps. */
+const speicherFuer = (schluessel) => (schluessel.startsWith('ip:') ? ipZaehler : sonstigeZaehler)
 
 /** Der Zaehler des Schluessels, wenn sein Fenster zum Zeitpunkt nowMs noch laeuft; sonst undefined. */
 function laufend(schluessel, fensterMs, nowMs) {
-  const eintrag = zaehler.get(schluessel)
+  const eintrag = speicherFuer(schluessel).map.get(schluessel)
   return eintrag && nowMs < eintrag.start + fensterMs ? eintrag : undefined
 }
 
+/** Entfernt alle abgelaufenen Zaehler und merkt sich das fruehste Ende der uebrigen. */
+function raeumeAbgelaufene(speicher, nowMs) {
+  let fruehester = Infinity
+  for (const [schluessel, eintrag] of speicher.map) {
+    if (eintrag.ende <= nowMs) speicher.map.delete(schluessel)
+    else if (eintrag.ende < fruehester) fruehester = eintrag.ende
+  }
+  speicher.fruehesterAblauf = fruehester
+}
+
+/** Beginnt ein neues Fenster fuer den Schluessel; macht in einer vollen Map zuerst Platz (abgelaufene, dann der aelteste). */
+function beginne(schluessel, fensterMs, nowMs) {
+  const speicher = speicherFuer(schluessel)
+  speicher.map.delete(schluessel) // neu einfuegen = ans Ende der Reihenfolge
+  if (speicher.map.size >= MAX_SCHLUESSEL && nowMs >= speicher.fruehesterAblauf) raeumeAbgelaufene(speicher, nowMs)
+  if (speicher.map.size >= MAX_SCHLUESSEL) speicher.map.delete(speicher.map.keys().next().value)
+  const ende = nowMs + fensterMs
+  speicher.map.set(schluessel, { start: nowMs, ende, n: 1 })
+  if (ende < speicher.fruehesterAblauf) speicher.fruehesterAblauf = ende
+}
+
 /**
  * Zaehlt ein Ereignis je Regel, aber nur, wenn keine Regel ihre Grenze erreicht hat (alle oder keine).
  * @param {{ schluessel: string, max: number, fensterMs: number }[]} regeln
@@ -66,13 +102,8 @@ export function zaehleAlle(regeln, now) {
   }
   for (const { schluessel, fensterMs } of regeln) {
     const eintrag = laufend(schluessel, fensterMs, nowMs)
-    if (eintrag) {
-      eintrag.n += 1
-      continue
-    }
-    zaehler.delete(schluessel) // neu einfuegen = ans Ende der Reihenfolge
-    if (zaehler.size >= MAX_SCHLUESSEL) zaehler.delete(zaehler.keys().next().value)
-    zaehler.set(schluessel, { start: nowMs, n: 1 })
+    if (eintrag) eintrag.n += 1
+    else beginne(schluessel, fensterMs, nowMs)
   }
   return true
 }
@@ -138,7 +169,7 @@ export function ipSchluessel(ip) {
 
 /** Darf diese IP (IPv6 je /64) jetzt einen lesenden Abruf oder Token-Aufruf machen? Hoechstens 120 je Minute. */
 export function darfAnfrage(ip, now) {
-  return zaehle(`anfrage-ip:${ipSchluessel(ip)}`, ANFRAGEN_JE_IP, MINUTE_MS, now)
+  return zaehle(`ip:anfrage:${ipSchluessel(ip)}`, ANFRAGEN_JE_IP, MINUTE_MS, now)
 }
 
 /** Darf diese Funktion (siteKey) jetzt einen lesenden Abruf beantworten? Hoechstens 600 je Minute fuer alle zusammen. */
@@ -148,7 +179,7 @@ export function darfAnfrageSite(siteKey, now) {
 
 /** Darf diese IP (IPv6 je /64) jetzt ein Buchungsformular abschicken? Hoechstens 10 je 10 Minuten (jeder Versuch zaehlt). */
 export function darfBuchungsversuch(ip, now) {
-  return zaehle(`buchung-ip:${ipSchluessel(ip)}`, BUCHUNGEN_JE_IP, BUCHUNGEN_FENSTER_MS, now)
+  return zaehle(`ip:buchung:${ipSchluessel(ip)}`, BUCHUNGEN_JE_IP, BUCHUNGEN_FENSTER_MS, now)
 }
 
 /** Darf diese Funktion (siteKey) jetzt einen weiteren Termin halten? Hoechstens 60 je Stunde. */
@@ -158,7 +189,7 @@ export function darfHaltung(siteKey, now) {
 
 /** Darf diese IP (IPv6 je /64) jetzt eine Widerrufserklaerung abschicken? Hoechstens 10 je Stunde. */
 export function darfWiderrufsversuch(ip, now) {
-  return zaehle(`widerruf-ip:${ipSchluessel(ip)}`, WIDERRUFE_JE_IP, STUNDE_MS, now)
+  return zaehle(`ip:widerruf:${ipSchluessel(ip)}`, WIDERRUFE_JE_IP, STUNDE_MS, now)
 }
 
 /** Darf an diese (normalisierte) Adresse eine G01 gehen? Hoechstens 5 je Adresse und Funktion und Tag (gehalten wie "zu viele"). */
@@ -168,5 +199,8 @@ export function darfG01(featureId, adresse, now) {
 
 /** Leert alle Zaehler (Tests). */
 export function resetTermineLimitsForTests() {
-  zaehler.clear()
+  for (const speicher of [ipZaehler, sonstigeZaehler]) {
+    speicher.map.clear()
+    speicher.fruehesterAblauf = Infinity
+  }
 }