security: Andere Geräte abmelden, IP-weites Login-Limit, dauerhafte Sperrmarke, Passwortregeln, CSP im Melde-Modus

Restliche Phase 4 aus dem Sicherheitsaudit 07.10.2026:

- Sicherheitsseite: „Andere Geräte abmelden“ rotiert remember_token und
  beendet alle anderen Sessions, die aktuelle bleibt (nicht während einer
  Impersonation).
- LoginIpThrottle: 20 Fehlversuche je IP in 15 Minuten über alle Konten.
  Gezählt über das Failed-Event, damit Livewire-Login und Fortifys
  POST /login denselben Zähler teilen; Erfolg setzt ihn nicht zurück.
- Sperrmarke für Sessions in users.sessions_revoked_at_ms statt nur im
  Cache — übersteht cache:clear. Die alte Cache-Marke zählt übergangsweise
  mit und kann im nächsten Release entfallen.
- Neue und geänderte Passwörter: mindestens 12 Zeichen, in Produktion
  zusätzlich uncompromised() (HIBP, k-Anonymität). Bestehende bleiben gültig.
- Content-Security-Policy-Report-Only in Produktion; Meldungen über
  /csp-report nach storage/logs/csp-*.log, je Meldung höchstens einmal pro
  Stunde, ohne Query und tokenartige Pfadsegmente.

Migration: users.sessions_revoked_at_ms (users hat FULLTEXT, 25 MB, Sekunden).

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

app/Services/Auth/LoginIpThrottle.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Services\Auth;
+
+use Illuminate\Support\Facades\RateLimiter;
+
+/**
+ * Obergrenze für fehlgeschlagene Anmeldungen je IP-Adresse über alle Konten
+ * hinweg (Sicherheitsaudit 07.10.2026, Phase 4). Das Limit je Adresse und IP
+ * (5 pro Minute) bremst kein Durchprobieren vieler fremder Adressen von einer
+ * Quelle — davon kamen laut Monitoring rund 250 Versuche am Tag. Gezählt
+ * wird über das `Failed`-Event, damit Livewire-Anmeldung und Fortifys
+ * `POST /login` denselben Zähler teilen. Erfolgreiche Anmeldungen setzen ihn
+ * bewusst nicht zurück — sonst reichte ein eigenes Konto zum Entsperren.
+ * Wirkt erst, seit gefälschte X-Forwarded-For-Header ignoriert werden
+ * (config/trustedproxy.php).
+ */
+class LoginIpThrottle
+{
+    public const MAX_FAILURES = 20;
+
+    public const DECAY_SECONDS = 900;
+
+    public function recordFailure(?string $ip): void
+    {
+        RateLimiter::hit($this->key($ip), self::DECAY_SECONDS);
+    }
+
+    public function isBlocked(?string $ip): bool
+    {
+        return RateLimiter::tooManyAttempts($this->key($ip), self::MAX_FAILURES);
+    }
+
+    public function availableIn(?string $ip): int
+    {
+        return RateLimiter::availableIn($this->key($ip));
+    }
+
+    private function key(?string $ip): string
+    {
+        return 'login-failures-ip|'.($ip ?? 'unknown');
+    }
+}

app/Services/Auth/SessionRevocation.php

@@ -6,6 +6,7 @@ use App\Models\User;
 use Illuminate\Auth\Events\Login;
 use Illuminate\Contracts\Session\Session;
 use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Str;
 
 /**
  * Beendet alle offenen Browser-Sessions eines Kontos (Umsetzungsaudit
@@ -16,10 +17,12 @@ use Illuminate\Support\Facades\Cache;
  * ein Zeitstempel je Konto: Jede Anmeldung schreibt ihren Zeitpunkt in die
  * Session (`Login`-Event), `revokeAllFor()` merkt sich „ungültig vor jetzt",
  * und die Middleware EnsureSessionIsNotRevoked meldet jede ältere Session
- * beim nächsten Request ab. Die Marke lebt so lange wie eine Session
- * (`session.lifetime`) — danach ist jede ältere Session ohnehin abgelaufen.
- * Remember-Cookies deckt das Rotieren von `remember_token` ab, API-Tokens
- * löscht der Aufrufer.
+ * beim nächsten Request ab. Remember-Cookies deckt das Rotieren von
+ * `remember_token` ab, API-Tokens löscht der Aufrufer.
+ *
+ * Die Marke steht seit v1.6.0 in `users.sessions_revoked_at_ms` und übersteht
+ * so ein Leeren des Caches (Sicherheitsaudit 07.10.2026, Phase 4). Die
+ * Middleware liest sie am ohnehin geladenen User — kein zusätzlicher Zugriff.
  */
 class SessionRevocation
 {
@@ -35,11 +38,10 @@ class SessionRevocation
     {
         $revokedAt = now()->getTimestampMs();
 
-        Cache::put(
-            $this->cacheKey((int) $user->getKey()),
-            $revokedAt,
-            now()->addMinutes(max(1, (int) config('session.lifetime', 120)) + 5),
-        );
+        // Ohne Model-Events und ohne updated_at: Die Marke ist keine
+        // inhaltliche Änderung am Konto und soll keine Observer auslösen.
+        $user->newQuery()->whereKey($user->getKey())->update(['sessions_revoked_at_ms' => $revokedAt]);
+        $user->forceFill(['sessions_revoked_at_ms' => $revokedAt])->syncOriginalAttribute('sessions_revoked_at_ms');
 
         return $revokedAt;
     }
@@ -57,6 +59,18 @@ class SessionRevocation
         $current->migrate(true);
     }
 
+    /**
+     * „Andere Geräte abmelden“ auf der Sicherheitsseite: Remember-Cookies
+     * anderer Geräte werden ungültig (neuer `remember_token`), alle anderen
+     * Sessions enden beim nächsten Request, die aktuelle bleibt angemeldet.
+     */
+    public function logoutOtherDevices(User $user, Session $current): void
+    {
+        $user->forceFill(['remember_token' => Str::random(60)])->save();
+
+        $this->revokeOthersFor($user, $current);
+    }
+
     /**
      * Listener für `Login`: Zeitpunkt der Anmeldung in der Session.
      * Die Methode heißt bewusst nicht `handle*` (Event-Discovery).
@@ -74,19 +88,24 @@ class SessionRevocation
      * Session stammt aus der Zeit vor der letzten Sperre dieses Kontos.
      * Ohne Anmeldezeitpunkt (Session von vor dem Deploy) gilt sie als alt.
      */
-    public function isRevoked(int $userId, Session $session): bool
+    public function isRevoked(User $user, Session $session): bool
     {
-        $revokedAt = Cache::get($this->cacheKey($userId));
+        $revokedAt = max((int) $user->sessions_revoked_at_ms, $this->legacyCachedMark((int) $user->getKey()));
 
-        if ($revokedAt === null) {
+        if ($revokedAt === 0) {
             return false;
         }
 
-        return (int) $session->get(self::SESSION_KEY, 0) < (int) $revokedAt;
+        return (int) $session->get(self::SESSION_KEY, 0) < $revokedAt;
     }
 
-    private function cacheKey(int $userId): string
+    /**
+     * Übergang: Bis v1.5.0 lag die Marke nur im Cache, mit Ablauf nach
+     * `session.lifetime` + 5 Minuten. Sperren aus dieser Zeit sollen über den
+     * Deploy hinweg gelten. Kann im Release nach v1.6.0 entfallen.
+     */
+    private function legacyCachedMark(int $userId): int
     {
-        return 'auth.sessions-revoked-at.'.$userId;
+        return (int) Cache::get('auth.sessions-revoked-at.'.$userId, 0);
     }
 }