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/Http/Controllers/CspReportController.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Nimmt CSP-Meldungen der Browser entgegen (ContentSecurityPolicy, Melde-
+ * Modus) und schreibt sie nach storage/logs/csp-*.log. Gleiche Meldungen
+ * landen höchstens einmal pro Stunde im Log. Adressen werden ohne Query und
+ * ohne tokenartige Pfadsegmente gespeichert — signierte Links und
+ * Anmeldelinks gehören nicht ins Log.
+ */
+class CspReportController extends Controller
+{
+    private const MAX_BYTES = 16384;
+
+    public function __invoke(Request $request): Response
+    {
+        $body = $request->getContent();
+
+        if (! config('security.csp.report_only') || $body === '' || strlen($body) > self::MAX_BYTES) {
+            return response()->noContent();
+        }
+
+        $report = json_decode($body, true)['csp-report'] ?? null;
+
+        if (! is_array($report)) {
+            return response()->noContent();
+        }
+
+        $entry = [
+            'directive' => mb_substr((string) ($report['effective-directive'] ?? $report['violated-directive'] ?? ''), 0, 60),
+            'blocked' => $this->scrub($report['blocked-uri'] ?? ''),
+            'document' => $this->scrub($report['document-uri'] ?? ''),
+            'source' => $this->scrub($report['source-file'] ?? ''),
+            'line' => (int) ($report['line-number'] ?? 0),
+            'sample' => mb_substr((string) ($report['script-sample'] ?? ''), 0, 40),
+        ];
+
+        if (Cache::add('csp-report.'.sha1(json_encode($entry)), true, now()->addHour())) {
+            Log::channel('csp')->warning('CSP-Verstoß (nur gemeldet)', $entry);
+        }
+
+        return response()->noContent();
+    }
+
+    private function scrub(mixed $value): string
+    {
+        $value = mb_substr(is_string($value) ? $value : '', 0, 500);
+        $parts = parse_url($value);
+
+        // Schlüsselwörter wie „inline“, „eval“, „data“ unverändert.
+        if (! is_array($parts) || empty($parts['host'])) {
+            return mb_substr(strtok($value, '?#') ?: '', 0, 60);
+        }
+
+        $path = preg_replace('#/[A-Za-z0-9_-]{32,}(?=/|$)#', '/[Filtered]', $parts['path'] ?? '');
+
+        return mb_substr(($parts['scheme'] ?? 'https').'://'.$parts['host'].$path, 0, 200);
+    }
+}

app/Http/Middleware/EnsureSessionIsNotRevoked.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Middleware;
 
+use App\Models\User;
 use App\Services\Auth\SessionRevocation;
 use Closure;
 use Illuminate\Auth\SessionGuard;
@@ -11,8 +12,8 @@ use Symfony\Component\HttpFoundation\Response;
 
 /**
  * Meldet eine Session ab, die vor der letzten Sperre ihres Kontos entstanden
- * ist (SessionRevocation, Audit K-04). Kostet je angemeldetem Request einen
- * Cache-Zugriff; Gäste lösen keinen aus.
+ * ist (SessionRevocation, Audit K-04). Die Marke steht am geladenen User;
+ * bis zum Release nach v1.6.0 kommt ein Cache-Zugriff dazu (Übergang).
  */
 class EnsureSessionIsNotRevoked
 {
@@ -33,7 +34,7 @@ class EnsureSessionIsNotRevoked
 
         $user = $guard->user();
 
-        if ($user === null || ! $this->revocation->isRevoked((int) $user->getAuthIdentifier(), $request->session())) {
+        if (! $user instanceof User || ! $this->revocation->isRevoked($user, $request->session())) {
             return $next($request);
         }
 

app/Http/Middleware/SecurityHeaders.php

@@ -2,6 +2,7 @@
 
 namespace App\Http\Middleware;
 
+use App\Support\ContentSecurityPolicy;
 use Closure;
 use Illuminate\Http\Request;
 use Symfony\Component\HttpFoundation\Response;
@@ -11,8 +12,7 @@ use Symfony\Component\HttpFoundation\Response;
  * Reverse-Proxy gesetzt, damit der Schutz auch bei Proxy-Wechsel bleibt.
  * Bereits vorhandene Header (z. B. vom Proxy) werden nicht überschrieben.
  * HSTS nur auf HTTPS-Antworten und laut config/security.php.
- * CSP fehlt absichtlich: Livewire/Alpine/Vite brauchen eine eigene
- * Inline-Script-Strategie — separat einführen, nicht nebenbei.
+ * CSP vorerst nur im Melde-Modus (ContentSecurityPolicy, config/security.php).
  */
 class SecurityHeaders
 {
@@ -31,6 +31,12 @@ class SecurityHeaders
             }
         }
 
+        if (config('security.csp.report_only')
+            && str_contains((string) $response->headers->get('Content-Type'), 'text/html')
+            && ! $response->headers->has('Content-Security-Policy-Report-Only')) {
+            $response->headers->set('Content-Security-Policy-Report-Only', ContentSecurityPolicy::header());
+        }
+
         if ($request->isSecure() && config('security.hsts.enabled') && ! $response->headers->has('Strict-Transport-Security')) {
             $response->headers->set('Strict-Transport-Security', 'max-age='.(int) config('security.hsts.max_age'));
         }

app/Listeners/CountFailedLoginsPerIp.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Listeners;
+
+use App\Services\Auth\LoginIpThrottle;
+use Illuminate\Auth\Events\Failed;
+
+/**
+ * Zählt jede fehlgeschlagene Web-Anmeldung für die IP-weite Obergrenze
+ * (LoginIpThrottle) — gleich, ob über die Livewire-Anmeldung oder Fortifys
+ * `POST /login`.
+ */
+class CountFailedLoginsPerIp
+{
+    public function __construct(private readonly LoginIpThrottle $throttle) {}
+
+    public function handle(Failed $event): void
+    {
+        if ($event->guard !== 'web' || ! app()->bound('request')) {
+            return;
+        }
+
+        $this->throttle->recordFailure(request()->ip());
+    }
+}

app/Models/User.php

@@ -87,6 +87,7 @@ class User extends Authenticatable implements MustVerifyEmail, PasskeyUser
             'deleted_at' => 'datetime',
             'password' => 'hashed',
             'press_release_quota_used_this_month' => 'integer',
+            'sessions_revoked_at_ms' => 'integer',
         ];
     }
 

app/Providers/AppServiceProvider.php

@@ -66,6 +66,7 @@ use Illuminate\Support\Facades\Gate;
 use Illuminate\Support\Facades\Queue;
 use Illuminate\Support\Facades\URL;
 use Illuminate\Support\ServiceProvider;
+use Illuminate\Validation\Rules\Password;
 use Laravel\Cashier\Cashier;
 use Laravel\Fortify\Events\TwoFactorAuthenticationFailed;
 use Livewire\Livewire;
@@ -108,6 +109,18 @@ class AppServiceProvider extends ServiceProvider
         // Ausgelieferte Version in `php artisan about` (Datei RELEASE bzw. APP_VERSION).
         AboutCommand::add('Pressekonto', fn (): array => ['Version' => config('app.version') ?? '—']);
 
+        // Passwortregeln für neue und geänderte Passwörter (Sicherheitsaudit
+        // 07.10.2026, Phase 4). Bestehende kürzere Passwörter bleiben gültig.
+        // Der Leak-Abgleich fragt Have I Been Pwned per k-Anonymität ab (nur
+        // die ersten 5 Zeichen des SHA-1-Hashes verlassen den Server) und
+        // lässt das Passwort durch, wenn der Dienst nicht antwortet — daher
+        // nur in Produktion, Tests und lokale Entwicklung bleiben offline.
+        Password::defaults(function (): Password {
+            $rule = Password::min(12);
+
+            return $this->app->isProduction() ? $rule->uncompromised() : $rule;
+        });
+
         // Die Generations-Nummer der Seiten-Caches wird prozessintern gemerkt.
         // Ein Queue-Worker lebt über beliebig viele Jobs hinweg und würde sonst
         // dauerhaft mit dem Stand seines ersten Zugriffs arbeiten — Keys einer

app/Providers/FortifyServiceProvider.php

@@ -9,6 +9,7 @@ use App\Http\Responses\FailedTwoFactorChallengeResponse;
 use App\Http\Responses\PasskeyLoginResponse;
 use App\Http\Responses\RoleAwareLoginResponse;
 use App\Models\User;
+use App\Services\Auth\LoginIpThrottle;
 use Illuminate\Cache\RateLimiting\Limit;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\RateLimiter;
@@ -53,6 +54,20 @@ class FortifyServiceProvider extends ServiceProvider
         // Keine View-Definitionen, die Auth-Seiten sind Livewire-Komponenten
 
         RateLimiter::for('login', function (Request $request) {
+            // IP-weite Obergrenze über alle Konten (LoginIpThrottle) — der
+            // Zähler ist derselbe wie in der Livewire-Anmeldung.
+            $ipThrottle = app(LoginIpThrottle::class);
+
+            if ($ipThrottle->isBlocked($request->ip())) {
+                $seconds = $ipThrottle->availableIn($request->ip());
+
+                return $request->expectsJson()
+                    ? response()->json(['message' => __('auth.throttle', ['seconds' => $seconds, 'minutes' => ceil($seconds / 60)])], 429, ['Retry-After' => $seconds])
+                    : back()->withInput($request->only(Fortify::username()))->withErrors([
+                        Fortify::username() => __('auth.throttle', ['seconds' => $seconds, 'minutes' => ceil($seconds / 60)]),
+                    ]);
+            }
+
             $throttleKey = Str::transliterate(Str::lower($request->input(Fortify::username())).'|'.$request->ip());
 
             return Limit::perMinute(5)->by($throttleKey);

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);
     }
 }

app/Support/ContentSecurityPolicy.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Support;
+
+/**
+ * Content Security Policy, vorerst nur im Melde-Modus
+ * (`Content-Security-Policy-Report-Only`, Sicherheitsaudit 07.10.2026,
+ * Phase 4). Browser blockieren nichts, sondern melden Verstöße an
+ * `/csp-report` (storage/logs/csp-*.log). Erst wenn die Meldungen zeigen,
+ * dass die Liste vollständig ist, wird sie scharf geschaltet.
+ *
+ * `'unsafe-inline'` und `'unsafe-eval'` sind für Livewire/Alpine und die
+ * Inline-Skripte der Layouts vorerst nötig; die Policy begrenzt daher vor
+ * allem, von wo Skripte geladen und wohin Daten geschickt werden dürfen,
+ * sowie Einbettung, Formularziele und `<base>`.
+ */
+class ContentSecurityPolicy
+{
+    public const REPORT_PATH = '/csp-report';
+
+    public static function header(): string
+    {
+        $own = array_merge(["'self'"], self::ownOrigins());
+        $umami = config('services.umami.enabled') ? self::originOf((string) config('services.umami.script_url')) : null;
+        $errors = self::originOf((string) config('monitoring.browser.dsn'));
+
+        $directives = [
+            'default-src' => ["'self'"],
+            'script-src' => [...$own, "'unsafe-inline'", "'unsafe-eval'", $umami],
+            'style-src' => [...$own, "'unsafe-inline'"],
+            'img-src' => [...$own, 'data:', 'blob:', 'https:'],
+            'font-src' => [...$own, 'data:'],
+            'connect-src' => [...$own, $umami, $errors],
+            'media-src' => [...$own],
+            'object-src' => ["'none'"],
+            'frame-src' => ["'self'"],
+            'frame-ancestors' => ["'self'"],
+            'base-uri' => ["'self'"],
+            'form-action' => [...$own, 'https://accounts.google.com', 'https://checkout.stripe.com', 'https://billing.stripe.com'],
+            'report-uri' => [self::REPORT_PATH],
+        ];
+
+        return collect($directives)
+            ->map(fn (array $sources, string $directive): string => trim($directive.' '.implode(' ', array_unique(array_filter($sources)))))
+            ->implode('; ');
+    }
+
+    /**
+     * Die drei Domains der Anwendung — Formulare und Assets können
+     * domainübergreifend auf die anderen zeigen.
+     *
+     * @return list<string>
+     */
+    private static function ownOrigins(): array
+    {
+        return collect([
+            config('domains.domain_portal'),
+            config('domains.domain_presseecho'),
+            config('domains.domain_businessportal'),
+        ])->filter()->map(fn (string $host): string => 'https://'.$host)->values()->all();
+    }
+
+    private static function originOf(string $url): ?string
+    {
+        $parts = parse_url($url);
+
+        if (! is_array($parts) || empty($parts['host'])) {
+            return null;
+        }
+
+        return ($parts['scheme'] ?? 'https').'://'.$parts['host'].(isset($parts['port']) ? ':'.$parts['port'] : '');
+    }
+}