security: Sicherheitsaudit 07.10.2026 (S-01–S-06) behoben, Passkeys und Zweitfaktor-Pflicht für Admins

Audit: dev/sicherheit/SICHERHEITSAUDIT-2026-10-07.md, Plan und Entscheidungen:
dev/sicherheit/ENTWICKLUNGSPLAN-SICHERHEIT-2026-10-07.md.

- S-01 Legacy-Rechnungen fremder Kunden nur mit billing:manage (auch Kundenroute).
- S-02 Kontaktzuordnung auf der Firmenanzeige verlangt companies:write, $id gesperrt.
- S-03 CompanyMembershipObserver: automatische Firmenrechte werden bei jeder
  Adress-/Zuordnungsänderung sofort neu bewertet; memberships:resync-auto.
- S-04 Passwortwechsel beendet alle anderen Sessions (PasswordChanger), Reset
  alle Sessions und offene Login-Links; Fortify PUT /user/password abgeschaltet.
  API-Tokens bleiben bestehen.
- S-05 Google: email_verified Pflicht, feste Bindung über die Provider-ID;
  Erstverknüpfung bestehender Konten außerhalb gmail/hd nur per Bestätigungslink
  in derselben Browser-Session.
- S-06 Frischer Identitätsnachweis (Passwort, App-Code, E-Mail-Code oder
  Passkey) vor E-Mail-Wechsel, erster 2FA-Einrichtung und Token-Erzeugung;
  Hinweis-Mails an die (bisherige) Kontoadresse.
- Entscheidung 5: Passkeys (Fortify, @laravel/passkeys) für alle; Super-Admins
  und Admins bestätigen die Session für den Admin-Bereich per Passkey oder
  App-Code (EnsureStrongAdminAuthentication, Notfallschalter
  AUTH_REQUIRE_STRONG_ADMIN); Reset des zweiten Faktors durch Super-Admins.

Neue Migration: create_passkeys_table. Suite 2.403 grün (1 übersprungen),
Larastan ohne Meldung.

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

app/Http/Controllers/Auth/ConfirmEmailChangeController.php

@@ -2,9 +2,11 @@
 
 namespace App\Http\Controllers\Auth;
 
+use App\Enums\SecurityChange;
 use App\Http\Controllers\Controller;
 use App\Models\User;
 use App\Services\Auth\ContactAccessService;
+use App\Services\Auth\SecurityNotifier;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
 
@@ -15,7 +17,7 @@ class ConfirmEmailChangeController extends Controller
      * signierten Link aus der Mail an die NEUE Adresse geklickt hat.
      * Bis dahin bleibt die alte Adresse aktiv (kein Aussperren bei Tippfehlern).
      */
-    public function __invoke(Request $request, User $user, string $hash, ContactAccessService $contactAccess): RedirectResponse
+    public function __invoke(Request $request, User $user, string $hash, ContactAccessService $contactAccess, SecurityNotifier $notifier): RedirectResponse
     {
         abort_unless($request->user()->is($user), 403);
 
@@ -34,6 +36,8 @@ class ConfirmEmailChangeController extends Controller
                 ->with('security-error', __('Die neue E-Mail-Adresse wird inzwischen von einem anderen Konto verwendet. Die Änderung wurde verworfen.'));
         }
 
+        $previousEmail = (string) $user->email;
+
         $user->forceFill([
             'email' => $user->pending_email,
             'email_verified_at' => now(),
@@ -45,6 +49,11 @@ class ConfirmEmailChangeController extends Controller
         // vergeben – nicht erst beim nächsten Login.
         $contactAccess->syncMembershipsForEmail($user);
 
+        // Die bisherige Adresse erfährt von der Änderung (Sicherheitsaudit
+        // 07.10.2026, S-06) — sonst bliebe eine Übernahme per fremder Session
+        // für den Inhaber unsichtbar.
+        $notifier->notify($user, SecurityChange::EmailChanged, recipient: $previousEmail, newEmail: (string) $user->email);
+
         return redirect()->route('me.security')
             ->with('security-status', __('Ihre E-Mail-Adresse wurde erfolgreich geändert.'));
     }

app/Http/Controllers/Auth/GoogleController.php

@@ -3,17 +3,24 @@
 namespace App\Http\Controllers\Auth;
 
 use App\Http\Controllers\Controller;
+use App\Models\User;
 use App\Services\Auth\LoginCompletion;
+use App\Services\Auth\SocialAccountLinker;
 use App\Services\Auth\SocialAuthService;
+use App\Services\Auth\SocialLoginResult;
 use App\Support\LoginRedirect;
 use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Log;
+use Laravel\Socialite\AbstractUser;
 use Laravel\Socialite\Facades\Socialite;
 
 /**
  * Google-Login (WS-6). Erst-Login legt – de-dupliziert über die E-Mail – einen
- * aktiven, verifizierten customer-Account an; bestehende Accounts werden nur
- * verknüpft. Deaktivierte Accounts werden nicht reaktiviert.
+ * aktiven, verifizierten customer-Account an; bestehende Accounts werden
+ * verknüpft, bei Adressen außerhalb von Googles Zuständigkeit erst nach
+ * Bestätigung per E-Mail (Sicherheitsaudit 07.10.2026, S-05). Deaktivierte
+ * Accounts werden nicht reaktiviert.
  */
 class GoogleController extends Controller
 {
@@ -22,29 +29,72 @@ class GoogleController extends Controller
         return Socialite::driver('google')->redirect();
     }
 
-    public function callback(Request $request, SocialAuthService $social, LoginCompletion $completion): RedirectResponse
+    public function callback(Request $request, SocialAuthService $social, SocialAccountLinker $linker, LoginCompletion $completion): RedirectResponse
     {
         try {
             $googleUser = Socialite::driver('google')->user();
         } catch (\Throwable) {
-            return redirect()->route('login')->withErrors([
-                'email' => __('Die Anmeldung mit Google ist fehlgeschlagen. Bitte versuchen Sie es erneut.'),
-            ]);
+            return $this->failed(__('Die Anmeldung mit Google ist fehlgeschlagen. Bitte versuchen Sie es erneut.'));
         }
 
-        $user = $social->resolveUser(
+        $raw = $googleUser instanceof AbstractUser ? $googleUser->getRaw() : [];
+        $providerId = (string) $googleUser->getId();
+
+        $result = $social->resolve(
             'google',
-            (string) $googleUser->getId(),
+            $providerId,
             $googleUser->getEmail(),
             $googleUser->getName(),
+            emailVerified: filter_var($raw['email_verified'] ?? false, FILTER_VALIDATE_BOOLEAN),
+            hostedDomain: isset($raw['hd']) ? (string) $raw['hd'] : null,
         );
 
-        if (! $user || ! $user->is_active) {
-            return redirect()->route('login')->withErrors([
-                'email' => __('Ihr Konto ist nicht aktiv. Bitte wenden Sie sich an den Support.'),
-            ]);
+        if ($result->outcome === SocialLoginResult::UNVERIFIED_EMAIL) {
+            return $this->failed(__('Google hat keine bestätigte E-Mail-Adresse übermittelt. Bitte melden Sie sich per E-Mail-Link an.'));
         }
 
+        if ($result->outcome === SocialLoginResult::PROVIDER_MISMATCH) {
+            Log::warning('google-login.provider-mismatch', ['user_id' => $result->user?->getKey()]);
+
+            return $this->failed(__('Ihr Konto ist bereits mit einem anderen Google-Konto verknüpft. Bitte melden Sie sich per E-Mail-Link an.'));
+        }
+
+        $user = $result->user;
+
+        if (! $user || ! $user->is_active) {
+            return $this->failed(__('Ihr Konto ist nicht aktiv. Bitte wenden Sie sich an den Support.'));
+        }
+
+        if ($result->outcome === SocialLoginResult::CONFIRM_LINK) {
+            if (! $linker->requestConfirmation($user, 'google', $providerId)) {
+                return $this->failed(__('Zu viele Anfragen. Bitte warten Sie einige Minuten und versuchen Sie es erneut.'));
+            }
+
+            return redirect()->route('login')->with('status', __('Für Ihr bestehendes Konto ist eine einmalige Bestätigung nötig: Wir haben Ihnen einen Link an Ihre E-Mail-Adresse geschickt. Bitte öffnen Sie ihn in diesem Browser.'));
+        }
+
+        return $this->completeLogin($request, $user, $completion);
+    }
+
+    /**
+     * Bestätigungslink aus der Mail (SocialAccountLinker): verknüpft und
+     * meldet an — nur in der Browser-Session, die den Google-Login begonnen hat.
+     */
+    public function confirmLink(Request $request, User $user, SocialAccountLinker $linker, LoginCompletion $completion): RedirectResponse
+    {
+        if (! $linker->confirm($user, (string) $request->query('provider_id', ''))) {
+            return $this->failed(__('Der Bestätigungslink ist ungültig oder abgelaufen. Bitte öffnen Sie ihn im selben Browser, in dem Sie die Anmeldung mit Google gestartet haben, oder starten Sie die Anmeldung erneut.'));
+        }
+
+        if (! $user->is_active) {
+            return $this->failed(__('Ihr Konto ist nicht aktiv. Bitte wenden Sie sich an den Support.'));
+        }
+
+        return $this->completeLogin($request, $user, $completion);
+    }
+
+    private function completeLogin(Request $request, User $user, LoginCompletion $completion): RedirectResponse
+    {
         // 2FA aktiv: wie Passwort- und Magic-Link-Login nicht direkt einloggen,
         // sondern in Fortifys Challenge übergeben (Audit F02). Google belegt
         // den Besitz des Postfachs, nicht den zweiten Faktor.
@@ -65,4 +115,9 @@ class GoogleController extends Controller
             LoginRedirect::homeFor($user),
         ));
     }
+
+    private function failed(string $message): RedirectResponse
+    {
+        return redirect()->route('login')->withErrors(['email' => $message]);
+    }
 }

app/Http/Middleware/BlockUnusedFortifyRoutes.php

@@ -33,6 +33,9 @@ class BlockUnusedFortifyRoutes
         'two-factor.secret-key',
         'two-factor.recovery-codes',
         'two-factor.regenerate-recovery-codes',
+        // Passkeys löscht die Sicherheitsseite mit Identitätsnachweis
+        // (Entscheidung 5, 07.10.2026).
+        'passkey.destroy',
     ];
 
     public function handle(Request $request, Closure $next): Response

app/Http/Middleware/EnsurePasskeyManagementIsConfirmed.php

@@ -0,0 +1,49 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Actions\Admin\UserImpersonation;
+use App\Models\User;
+use App\Services\Auth\SecurityConfirmation;
+use Closure;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Passkey hinzufügen nur mit frischem Identitätsnachweis (Entscheidung 5,
+ * Sicherheitsaudit 07.10.2026, S-06): Ein Passkey ist dauerhafter Zugang —
+ * eine fremde Session allein darf keinen hinterlegen. Den Nachweis erbringt
+ * die Sicherheitsseite (ConfirmsIdentity), bevor sie die Registrierung im
+ * Browser startet. Während einer Impersonation nie.
+ *
+ * Hängt über `fortify.middleware` an allen Fortify-Routen und greift nur bei
+ * den Registrierungsrouten. Gelöscht wird über die Sicherheitsseite; die
+ * Fortify-Löschroute sperrt BlockUnusedFortifyRoutes.
+ */
+class EnsurePasskeyManagementIsConfirmed
+{
+    /**
+     * @var list<string>
+     */
+    public const GUARDED_ROUTES = [
+        'passkey.registration-options',
+        'passkey.store',
+    ];
+
+    public function __construct(private readonly SecurityConfirmation $confirmation) {}
+
+    public function handle(Request $request, Closure $next): Response
+    {
+        if (! in_array($request->route()?->getName(), self::GUARDED_ROUTES, true)) {
+            return $next($request);
+        }
+
+        $user = $request->user();
+
+        if (! $user instanceof User || app(UserImpersonation::class)->isActive() || ! $this->confirmation->isFresh($user)) {
+            abort(403, __('Bitte bestätigen Sie zuerst Ihre Identität.'));
+        }
+
+        return $next($request);
+    }
+}

app/Http/Middleware/EnsureStrongAdminAuthentication.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Http\Middleware;
+
+use App\Models\User;
+use App\Services\Auth\StrongAuthentication;
+use Closure;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Admin-Bereich nur mit starker Anmeldung (Entscheidung 5, 07.10.2026):
+ * Super-Admins und Admins bestätigen ihre Session einmalig per Passkey oder
+ * Authenticator-Code. Seitenaufrufe führen zur Bestätigungsseite und danach
+ * zurück; Livewire- und JSON-Folgeanfragen werden abgewiesen. Editoren und
+ * Kunden sind nicht betroffen. Läuft auch als persistente Livewire-Middleware.
+ */
+class EnsureStrongAdminAuthentication
+{
+    public function __construct(private readonly StrongAuthentication $strong) {}
+
+    public function handle(Request $request, Closure $next): Response
+    {
+        $user = $request->user();
+
+        if (! $user instanceof User || ! $this->strong->isRequiredFor($user) || $this->strong->isSatisfiedBy($user)) {
+            return $next($request);
+        }
+
+        if (! $request->isMethod('GET') || $request->expectsJson()) {
+            abort(403, __('Bitte bestätigen Sie Ihre Anmeldung mit Passkey oder Authenticator-Code.'));
+        }
+
+        $request->session()->put(StrongAuthentication::INTENDED_KEY, $request->fullUrl());
+
+        return redirect()->route('strong-auth.confirm');
+    }
+}

app/Http/Responses/PasskeyLoginResponse.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Http\Responses;
+
+use App\Models\User;
+use App\Services\Auth\LoginCompletion;
+use App\Support\LoginRedirect;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\RedirectResponse;
+use Laravel\Passkeys\Contracts\PasskeyLoginResponse as PasskeyLoginResponseContract;
+
+/**
+ * Abschluss eines Passkey-Logins (Entscheidung 5, 07.10.2026): wie
+ * RoleAwareLoginResponse den Login protokollieren und nur auf erlaubte Ziele
+ * weiterleiten. Aktiv- und Verifizierungsstatus prüft bereits
+ * Passkeys::authorizeLoginUsing() vor der Anmeldung (FortifyServiceProvider).
+ * Der Browser-Client erwartet JSON mit `redirect`.
+ */
+class PasskeyLoginResponse implements PasskeyLoginResponseContract
+{
+    public function toResponse($request): JsonResponse|RedirectResponse
+    {
+        /** @var User $user */
+        $user = $request->user();
+
+        app(LoginCompletion::class)->recordLogin($user, $request);
+
+        $target = LoginRedirect::safeTarget(
+            $user,
+            $request->session()->pull('url.intended'),
+            LoginRedirect::homeFor($user),
+        );
+
+        return $request->wantsJson()
+            ? new JsonResponse(['redirect' => $target])
+            : redirect($target);
+    }
+}