feat: Phase 5 — Härtung (CSRF, Rate-Limit, Validation, Error Boundary, README)

Schritt 28 — CSRF-Schutz (Double Submit Cookie Pattern):
- server/middleware/csrf.js: generiert 32-Byte-Token, speichert in Session + Cookie;
  validiert X-CSRF-Token-Header auf POST/PUT/PATCH/DELETE via timingSafeEqual
- server/auth.js: CSRF-Token beim Login erzeugen und als Cookie setzen
- public/api.js: getCsrfToken() liest Cookie; apiFetch() sendet Header auf
  state-ändernden Requests automatisch

Schritt 29 — Globaler Rate-Limiter:
- server/index.js: apiLimiter (300 req/min/IP) auf allen /api/-Routen;
  ergänzt den bestehenden loginLimiter (5 req/min)

Schritt 27 — Zentralisierte Eingabe-Validierung:
- server/middleware/validate.js: str(), oneOf(), date(), time(), num(), color(),
  collectErrors() mit einheitlichen Längengrenzen (MAX_TITLE=200, MAX_TEXT=5000)
- server/routes/tasks.js: validateTaskInput() nutzt nun validate.js

Schritt 31 — Frontend Error Boundary:
- public/router.js: window.onerror + unhandledrejection-Handler zeigen Toast

Schritt 33 — README.md:
- Setup-Anleitung (Docker + Node.js), Nginx-Config, User-Verwaltung,
  Umgebungsvariablen-Referenz, Backup, Sicherheitsübersicht

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

server/middleware/csrf.js

@@ -0,0 +1,71 @@
+/**
+ * Modul: CSRF-Schutz (Double Submit Cookie Pattern)
+ * Zweck: Schützt state-ändernde API-Endpunkte vor Cross-Site Request Forgery
+ * Abhängigkeiten: node:crypto
+ *
+ * Funktionsweise:
+ *   1. Beim ersten authentifizierten Request wird ein 32-Byte-Hex-Token in der Session gespeichert.
+ *   2. Das Token wird als nicht-httpOnly-Cookie gesetzt (lesbar durch JavaScript).
+ *   3. Das Frontend liest das Cookie und sendet es als X-CSRF-Token-Header.
+ *   4. Der Server vergleicht Header und Session-Token per timingSafeEqual.
+ *   5. GET/HEAD/OPTIONS sind ausgenommen (safe methods).
+ */
+
+'use strict';
+
+const crypto = require('node:crypto');
+
+const TOKEN_LENGTH = 32; // Bytes → 64 Hex-Zeichen
+
+/**
+ * Generiert einen kryptographisch sicheren CSRF-Token.
+ * @returns {string} 64-stelliger Hex-String
+ */
+function generateToken() {
+  return crypto.randomBytes(TOKEN_LENGTH).toString('hex');
+}
+
+/**
+ * CSRF-Middleware für authentifizierte API-Routen.
+ * Muss NACH requireAuth eingebunden werden.
+ */
+function csrfMiddleware(req, res, next) {
+  // Token generieren falls noch nicht vorhanden (erste Request nach Login)
+  if (!req.session.csrfToken) {
+    req.session.csrfToken = generateToken();
+  }
+
+  // Cookie bei jedem Request erneuern (SameSite=Strict, nicht httpOnly → JS-lesbar)
+  res.cookie('csrf-token', req.session.csrfToken, {
+    httpOnly: false,
+    sameSite: 'strict',
+    secure: process.env.NODE_ENV === 'production',
+    maxAge: 1000 * 60 * 60 * 24 * 7, // 7 Tage (gleich wie Session)
+  });
+
+  // Safe Methods benötigen keine Validierung
+  if (['GET', 'HEAD', 'OPTIONS'].includes(req.method)) {
+    return next();
+  }
+
+  // CSRF-Token aus Header prüfen
+  const headerToken   = req.headers['x-csrf-token'] ?? '';
+  const sessionToken  = req.session.csrfToken;
+  const expectedLen   = TOKEN_LENGTH * 2; // 64 Hex-Zeichen
+
+  const tokenValid =
+    headerToken.length === expectedLen &&
+    sessionToken.length === expectedLen &&
+    crypto.timingSafeEqual(
+      Buffer.from(headerToken,  'hex'),
+      Buffer.from(sessionToken, 'hex')
+    );
+
+  if (!tokenValid) {
+    return res.status(403).json({ error: 'Ungültiges CSRF-Token.', code: 403 });
+  }
+
+  next();
+}
+
+module.exports = { csrfMiddleware, generateToken };