Skip to content

8. Authentifizierung und Autorisierung

Bei jeder Anfrage stellen sich zwei verschiedene Fragen:

  • Wer ist der Benutzer? Das ist die Authentifizierung: Der Benutzer hat sich mit Benutzername und Passwort identifiziert, und jede folgende Anfrage muss belegen, dass sie von ihm stammt;
  • Hat er die Berechtigung, auf diese Seite zuzugreifen? Das ist die Autorisierung: In der Fallstudie verwaltet nur ein Benutzer mit der Rolle ADMIN die Ärzte und Klienten.

Der Identitätsnachweis muss jede Anfrage begleiten. [Laravel] speichert die ID des angemeldeten Benutzers typischerweise in dessen Session (siehe das Kapitel über Scopes), was die einfachste Lösung für eine Webanwendung ist. Die Fallstudie verwendet in allen ihren Versionen ([ASP.NET Core MVC], [Spring MVC], [NestJS], [Flask]) stattdessen ein Token (JWT (*JSON Web Token*)), das wir auch hier verwenden werden: Nach der Anmeldung erzeugt der Server ein Token, das die Identität des Benutzers enthält, und signiert es mit einem geheimen Schlüssel. Das Token wird in einem Cookie gespeichert; der Browser sendet es bei jeder Anfrage zurück; der Server überprüft die Signatur. Der Benutzer kann sein Token lesen, aber nicht verändern: Jede Änderung macht die Signatur ungültig. Das Format ist standardisiert (RFC 7519), wird von allen Programmiersprachen verstanden, und das Token enthält sein Ablaufdatum. Vor allem muss der Server nichts speichern: Jeder Server, der den Schlüssel kennt, kann das Token überprüfen.

[Laravel] verfügt über ein vollständiges Authentifizierungssystem, dessen Komponenten wir unverändert verwenden werden:

  • Die Authentifizierung übernimmt ein *Guard*: ein Objekt, das bei jeder Anfrage den authentifizierten Benutzer identifiziert. [Laravel] stellt einen Guard bereit, der die Session liest; wir schreiben unseren eigenen, der das Token liest, in wenigen Zeilen. Der Rest der Anwendung sieht nur den Guard: [auth()->user()], [#[CurrentUser]] und [@auth] in den Views;
  • Den Schutz der Seiten übernimmt die Route-Middleware (vorheriges Kapitel): [auth] verlangt einen authentifizierten Benutzer, [can:admin] verlangt eine Autorisierung;
  • Autorisierungen werden durch Gates beschrieben (z. B. in Beispiel 26);
  • Passwörter werden von der Fassade [Hash] gehasht (mit dem Algorithmus *bcrypt*), und die Begrenzung der Versuche übernimmt die Fassade [RateLimiter] (Beispiel 27).

Das Erzeugen und Überprüfen der Token übernimmt die Bibliothek [firebase/php-jwt], die am weitesten verbreitete in [PHP], die von der Datei [composer.json] der Beispiele installiert wird.

8.1. Beispiel 25: Anmeldung, Token, geschützte Seite

25-jwt/
├── app/
│   ├── Auth/
│   │   ├── AuthService.php
│   │   ├── User.php
│   │   └── UsersService.php
│   └── Http/
│       └── Controllers/
│           ├── AuthController.php
│           └── ProfileController.php
├── bootstrap/
│   └── app.php
├── config/
│   ├── auth.php
│   └── jwt.php
├── resources/
│   └── views/
│       ├── auth/
│       │   └── login.blade.php
│       ├── layout.blade.php
│       └── profile/
│           └── profile.blade.php
├── routes/
│   └── web.php
└── ...

8.1.1. Konfiguration: .env, config/jwt.php und config/auth.php

Das Token wird mit einem geheimen Schlüssel signiert, der nicht fest im Code stehen darf. Jetzt ist es an der Zeit, die Konfiguration wirklich vom Code zu trennen. Die Einstellungen, die für eine Installation spezifisch sind, stehen in der Datei [.env] (Beispiel 01), die nun zwei neue Zeilen enthält:

1
2
3
# der Schlüssel, der die JWT-Token signiert (mindestens 32 Zeichen), und ihre Lebensdauer
JWT_SECRET=a-secret-key-of-at-least-32-characters-for-example-25
JWT_DURATION_MINUTES=60

Der Standard verlangt für den verwendeten Algorithmus (HMAC-SHA256) einen Schlüssel von mindestens 256 Bit, also 32 Bytes; die Bibliothek lehnt einen kürzeren Schlüssel ab. Der Code liest jedoch nicht die Datei [.env], sondern die Konfiguration der Anwendung – eine Gruppe von [PHP]-Dateien im Ordner [config], von denen jede ein Array zurückgibt. Wir erstellen die Datei [config/jwt.php]:

<?php
// config/jwt.php: die Konfiguration der JWT-Token, gelesen mit config('jwt.secret')...
// env(NAME, default): die Variable NAME der Umgebung oder der Datei .env
return [
    // der Schlüssel, der die Token signiert (mindestens 32 Zeichen): niemals im Code
    'secret' => env('JWT_SECRET'),
    // die Lebensdauer eines Tokens in Minuten
    'duration' => (int) env('JWT_DURATION_MINUTES', 60),
    // der Name des Cookies, das das Token trägt
    'cookie' => 'token',
];
  • Zeile 6: Die Funktion [env] liest eine Variable aus der Prozess-Umgebung oder, falls dort nicht vorhanden, aus der Datei [.env]; ihr zweiter Parameter ist ein Standardwert. Eine Umgebungsvariable hat Vorrang vor der Datei: In der Produktion wird der geheime Schlüssel von der Umgebung bereitgestellt, und die Datei [.env] enthält keinen;
  • Zeile 8: Umgebungsvariablen sind Zeichenketten: [(int)] wandelt die Dauer in eine ganze Zahl um.

Der Code liest diese Werte mit der Funktion [config]: [config('jwt.secret')] verweist auf den Schlüssel [secret] in der Datei [jwt.php]. [env] wird nur in Konfigurationsdateien aufgerufen: In der Produktion fasst der Befehl [php artisan config:cache] die gesamte Konfiguration zur Beschleunigung in einer einzigen Datei zusammen, und [.env] wird nicht mehr gelesen. Die Datei [config/auth.php] konfiguriert die Authentifizierung:

<?php
// config/auth.php: die Authentifizierung. Diese Datei ERGÄNZT die Standard-
// konfiguration von Laravel (vendor/laravel/framework/config/auth.php)
return [
    // der standardmäßig verwendete "Guard": der, der das JWT-Token liest
    'defaults' => [
        'guard' => 'jwt',
    ],
    'guards' => [
        // ein Guard mit dem Treiber [jwt], definiert in bootstrap/app.php (Auth::viaRequest)
        'jwt' => [
            'driver' => 'jwt',
        ],
    ],
];

[Laravel] hat eine eigene Authentifizierungskonfiguration (die Datei [vendor/laravel/framework/config/auth.php]; siehe Beispiel 01); die Konfiguration der Anwendung ergänzt sie: Die Schlüssel, die sie liefert, ersetzen die des Frameworks, während die übrigen ihre Werte behalten. Wir deklarieren einen Guard mit dem Namen [jwt] mit dem Treiber [jwt] (Zeile 12) und legen ihn als Standard-Guard fest (Zeile 7). Der Treiber [jwt] existiert in [Laravel] nicht: Wir definieren ihn in [bootstrap/app.php].

Unter [Linux] oder [macOS] würden wir die Anwendung wie folgt mit einem anderen Schlüssel starten:

JWT_SECRET="another-key-of-at-least-thirty-two-characters" php artisan serve

und unter [Windows] (PowerShell):

$env:JWT_SECRET="another-key-of-at-least-thirty-two-characters"
php artisan serve

8.1.2. Benutzer: app/Auth/User.php und UsersService.php

<?php
// app/Auth/User.php: ein Benutzer. Authenticatable: das Interface, das
// Laravel von authentifizierten Benutzern erwartet

namespace App\Auth;

use Illuminate\Contracts\Auth\Authenticatable;

readonly class User implements Authenticatable
{
    public function __construct(
        public string $login,
        public string $name,
        public string $role,
        // der HASH des Passworts (leer bei einem aus einem Token gelesenen Benutzer)
        public string $passwordHash = '',
        // der Inhalt des Tokens, das den Benutzer authentifiziert hat
        public array $claims = [],
    ) {
    }

    // die Kennung des Benutzers: sein Login
    public function getAuthIdentifierName(): string
    {
        return 'login';
    }

    public function getAuthIdentifier(): string
    {
        return $this->login;
    }

    public function getAuthPasswordName(): string
    {
        return 'passwordHash';
    }

    public function getAuthPassword(): string
    {
        return $this->passwordHash;
    }

    // das "Remember-me"-Token der Sessions: hier nutzlos
    public function getRememberToken(): ?string
    {
        return null;
    }

    public function setRememberToken($value): void
    {
    }

    public function getRememberTokenName(): string
    {
        return '';
    }
}
  • Zeile 9: ein Benutzer. [Laravel] erwartet, dass authentifizierte Benutzer die Schnittstelle [Authenticatable] implementieren: Ihre Methoden liefern ihm die ID des Benutzers, sein gehashtes Passwort und das Token der Funktion „Angemeldet bleiben“, das hier nicht nötig ist. In einer typischen Anwendung implementiert das [Eloquent]-Modell der Benutzertabelle (nächstes Kapitel) sie;
  • Zeilen 12–18: der Login, der Name, die Rolle, der Passwort-Hash und der Inhalt des Tokens, das den Benutzer authentifiziert hat (leer bei einem Benutzer, der aus der Benutzerliste abgerufen wurde). Ein Server speichert niemals ein Passwort, nicht einmal verschlüsselt: Würde die Datenbank gestohlen, wären es auch die Passwörter (und viele Menschen verwenden überall dasselbe Passwort). Er speichert das Ergebnis einer Hash-Funktion, einer Einwegfunktion: Man kann den Hash eines Passworts berechnen, aber aus einem Hash kein Passwort zurückgewinnen. Um ein eingegebenes Passwort zu überprüfen, berechnet man seinen Hash und vergleicht ihn mit dem gespeicherten.
<?php
// app/Auth/UsersService.php: die Benutzer, im Speicher (Beispiel 28 und
// die Fallstudie legen sie in einer Datenbank ab)

namespace App\Auth;

class UsersService
{
    // wir speichern NIEMALS ein Passwort, nur seinen bcrypt-Hash, ein für alle Mal
    // berechnet mit: php -r "echo password_hash('marie', PASSWORD_BCRYPT);"
    private const USERS = [
        'marie' => ['Marie Pélissier', 'USER', '$2y$10$2DnOgGBiVcyc07su9rj2E.EvOoyPFzHN/h9PLKDuoW5P7UGtclW6W'],
        'admin' => ['Administrator', 'ADMIN', '$2y$10$m5o9euCi0EdgoZkLVw.UsO58RxJcqhMBfVrlLMCIOh2LyGSjuN29K'],
    ];

    public function find(string $login): ?User
    {
        if (! isset(self::USERS[$login])) {
            return null;
        }
        [$name, $role, $hash] = self::USERS[$login];
        return new User($login, $name, $role, $hash);
    }
}
  • Zeilen 11–14: Zwei Testbenutzer, fest im Programm hinterlegt (Beispiel 28 und die Fallstudie füllen damit eine Datenbank): für jeden Login der Name, die Rolle und der Passwort-Hash. Der Hash wird mit dem Algorithmus bcrypt erzeugt, der für Passwörter entwickelt wurde. Er hat zwei Besonderheiten. Er ist absichtlich langsam, mit einstellbarem Grad der Langsamkeit (dem Cost, hier auf 10 gesetzt: 2^10 Rechenzyklen, was den Hash [$10$] ergibt): einige Dutzend Millisekunden, für einen Benutzer nicht wahrnehmbar, die es für einen Angreifer aber sehr teuer machen, Milliarden von Passwörtern auszuprobieren. Er ist gesalzen: Ein zufällig erzeugtes Salt wird vor dem Hashen mit dem Passwort vermischt und im Hash selbst gespeichert (die 22 Zeichen nach [$10$]); zwei Benutzer mit demselben Passwort haben daher unterschiedliche Hashes. Die Hashes wurden ein für alle Mal von der Funktion [password_hash] von [PHP] berechnet (Zeile 10): Sie bei jeder Anfrage zu berechnen, wäre unnötige Zeitverschwendung, da die Anwendung bei jeder Anfrage neu aufgebaut wird. [bcrypt] berücksichtigt nur die ersten 72 Bytes eines Passworts: Die Fallstudie trägt dem Rechnung;
  • Zeilen 16–23: der Benutzer zu einem Login oder [null]. [isset] prüft, ob ein Schlüssel existiert; die Zuweisung [[$name, $role, $hash] = ...] zerlegt ein Array: Jede Variable erhält das entsprechende Element.

8.1.3. Der Authentifizierungsservice: app/Auth/AuthService.php

<?php
// app/Auth/AuthService.php: die Prüfung der Passwörter und der JWT-Token

namespace App\Auth;

use Firebase\JWT\JWT;
use Firebase\JWT\Key;
use Illuminate\Support\Facades\Hash;
use Throwable;

class AuthService
{
    public function __construct(private UsersService $users)
    {
    }

    // der Benutzer oder null, falls der Login unbekannt oder das Passwort falsch ist.
    // Hash::check hasht das eingegebene Passwort mit dem Salt des gespeicherten Hashs
    // und vergleicht dann die beiden Ergebnisse
    public function validate(?string $login, ?string $password): ?User
    {
        if (! $login || $password === null) {
            return null;
        }
        $user = $this->users->find($login);
        if ($user === null || ! Hash::check($password, $user->passwordHash)) {
            return null;
        }
        return $user;
    }

    // das JWT-Token des Benutzers, signiert mit dem geheimen Schlüssel (HMAC-SHA256)
    public function createToken(User $user): string
    {
        $now = time();
        // der Inhalt des Tokens: die "Claims" (Aussagen über den Benutzer)
        $claims = [
            'sub' => $user->login,
            'name' => $user->name,
            'role' => $user->role,
            'iat' => $now,
            'exp' => $now + config('jwt.duration') * 60,
        ];
        return JWT::encode($claims, config('jwt.secret'), 'HS256');
    }

    // der durch ein Token beschriebene Benutzer, dessen Signatur und Ablaufdatum
    // gültig sind; sonst null (gefälschtes, abgelaufenes oder unlesbares Token)
    public function check(string $token): ?User
    {
        try {
            // decode gibt ein Objekt zurück; (array) wandelt es in ein assoziatives Array um
            $claims = (array) JWT::decode($token, new Key(config('jwt.secret'), 'HS256'));
        } catch (Throwable) {
            return null;
        }
        return new User($claims['sub'], $claims['name'], $claims['role'], claims: $claims);
    }
}
  • Zeilen 20–30: die Überprüfung eines Benutzernamens und eines Passworts. [Hash::check] hasht das eingegebene Passwort mit dem Salt des gespeicherten Hashs und vergleicht die beiden Hashes. Ein unbekannter Benutzername und ein falsches Passwort liefern dasselbe Ergebnis, [null];
  • Zeilen 33–45: das Erzeugen des Tokens. Sein Inhalt ist ein Array von Claims über den Benutzer. Einige haben standardisierte Namen: [sub] (*subject*), die Kennung des Benutzers; [iat] (*issued at*), das Erstellungsdatum; [exp] (*expiration*), das Ablaufdatum. Daten werden in Sekunden seit dem 1. Januar 1970 angegeben (die Funktion [time()] von [PHP]). Die übrigen Felder sind optional: hier der Name und die Rolle. [JWT::encode] erzeugt das Token und signiert es mit dem Algorithmus [HS256] (HMAC-SHA256, eine Signatur mit einem gemeinsamen geheimen Schlüssel);
  • Zeilen 49–58: die Überprüfung des Tokens. [JWT::decode] überprüft die Signatur und das Ablaufdatum und gibt dann die Claims zurück (ein Objekt, das von [(array)] in ein Array umgewandelt wird). Jede Auffälligkeit (gefälschtes, abgelaufenes oder fehlerhaftes Token) löst eine Exception aus; [catch (Throwable)] fängt sie alle ab ([Throwable] ist die Schnittstelle für alle Exceptions und Fehler von [PHP]; der Variablenname ist optional, wenn er nicht verwendet wird). Das [Key]-Objekt verbindet den Schlüssel mit einem Algorithmus: Ein Token, das einen anderen Algorithmus angibt (oder gar keinen, [none]), würde abgelehnt. Das gültige Token wird zu einem [User] ohne Hash, zusammen mit seinen Claims (Parameter mit dem Namen [claims]).

8.1.4. Der Guard: bootstrap/app.php

<?php
// bootstrap/app.php: die Anwendung von Beispiel 25

use App\Auth\AuthService;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // die Route, die Bootstrap ausliefert (siehe Beispiel 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // das Token ist bereits signiert: das Cookie, das es trägt, ist nicht verschlüsselt
        $middleware->encryptCookies(except: ['token']);
        // ein anonymer Besucher, der eine geschützte Seite anfordert: ab zu /login
        $middleware->redirectGuestsTo('/login');
    })
    ->withExceptions()
    ->booted(function () {
        // der Guard-Treiber [jwt] (siehe config/auth.php): eine Funktion, die die
        // Anfrage erhält und den authentifizierten Benutzer zurückgibt, oder null für einen anonymen Besucher
        Auth::viaRequest('jwt', function (Request $request) {
            $token = $request->cookie(config('jwt.cookie'));
            if ($token === null) {
                return null;
            }
            $user = app(AuthService::class)->check($token);
            if ($user === null) {
                // ein vorhandenes, aber ungültiges Cookie (abgelaufenes oder gefälschtes Token): wir löschen es
                Cookie::queue(Cookie::forget(config('jwt.cookie')));
            }
            return $user;
        });
    })
    ->create();
  • Zeile 20: Das Token ist bereits signiert; das Cookie, das es trägt, wird nicht verschlüsselt (Beispiel 22), sodass es untersucht werden kann;
  • Zeile 22: Die Middleware [auth] leitet anonyme Besucher auf die Anmeldeseite um;
  • Zeilen 28–39: [Auth::viaRequest] definiert einen Guard-Treiber mit einer einfachen Funktion: Sie erhält die Anfrage und gibt den authentifizierten Benutzer zurück, oder [null] für einen anonymen Besucher. Sie wird nur aufgerufen, wenn die Anwendung den Benutzer benötigt, und sobald sie einen gefunden hat, [Laravel] behält ihn für die gesamte Anfrage (bei einem anonymen Besucher wird sie bei jeder Anfrage aufgerufen) (die Middleware [auth], [auth()->user()] ...). Sie lehnt nichts ab: Sie bestimmt, wer der Benutzer ist. Das ist die Authentifizierung. [app(AuthService::class)] fordert ein Objekt vom Container an (siehe Beispiel 06): Die Funktion [app] verschafft überall Zugriff auf den Container;
  • Zeilen 34–39: Hat der Browser ein Cookie gesendet, dessen Token aber ungültig ist (abgelaufen oder manipuliert), nutzen wir die Gelegenheit, es zu löschen. [Cookie::forget] erstellt ein leeres Cookie, das bereits abgelaufen ist; [Cookie::queue] stellt es in die Warteschlange: Die Middleware [AddQueuedCookiesToResponse] der Gruppe [web] fügt es der Antwort hinzu, welche Antwort es auch sein mag.

8.1.5. Die Controller

<?php
// app/Http/Controllers/AuthController.php: Login und Logout

namespace App\Http\Controllers;

use App\Auth\AuthService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class AuthController
{
    public function __construct(private AuthService $auth)
    {
    }

    public function home(): RedirectResponse
    {
        return redirect('/profile');
    }

    public function form(): View
    {
        return view('auth.login');
    }

    public function login(Request $request): View|RedirectResponse
    {
        $login = $request->input('login');
        $user = $this->auth->validate($login, $request->input('password'));
        if ($user === null) {
            // eine bewusst vage Meldung: wir sagen nicht, ob es der Login oder das Passwort ist
            return view('auth.login', ['login' => $login,
                'error' => 'Incorrect login or password.']);
        }
        // das Token in einem Cookie: das JavaScript der Seite kann es nicht lesen
        // (httpOnly); es wird nicht mit POST-Anfragen von anderen Websites gesendet
        // (sameSite); es verschwindet gleichzeitig mit dem Ablauf des Tokens (Dauer in Minuten)
        return redirect('/profile')->withCookie(cookie(config('jwt.cookie'),
            $this->auth->createToken($user), config('jwt.duration'),
            httpOnly: true, sameSite: 'lax'));
    }

    // Abmelden: nur per POST (ein einfacher Link auf einer anderen Website kann den
    // Benutzer nicht ohne sein Wissen abmelden); wir löschen das Cookie
    public function logout(): RedirectResponse
    {
        return redirect('/login')->withoutCookie(config('jwt.cookie'));
    }
}
  • Zeilen 30–34: die Anmeldung. Schlägt sie fehl, wird das Formular mit dem eingegebenen Benutzernamen und einer bewusst vagen Meldung erneut angezeigt: Die Meldung „unbekannter Benutzername“ würde einem Angreifer verraten, welche Benutzernamen existieren;
  • Zeilen 39–41: Bei Erfolg wird das Token in einem Cookie gespeichert, und der Benutzer wird auf die geschützte Seite umgeleitet (PRG-Schema). Das Cookie ist [httpOnly]: Das [JavaScript] der Seite kann es nicht lesen, was das Token gegen Skript-Injection (XSS) schützt; es ist [sameSite: 'lax']: Der Browser sendet es nicht bei einer POST-Anfrage, die von einer anderen Website stammt, was die Anwendung vor CSRF-Angriffen schützt (Beispiel 18); seine Lebensdauer (in Minuten) entspricht der des Tokens. In der Produktion würden wir für HTTPS [secure: true] hinzufügen: Das Cookie würde dann nie über eine unverschlüsselte Verbindung gesendet;
  • Zeilen 46–49: Die Abmeldung löscht das Cookie ([withoutCookie]). Das ist eine POST-Action: Ein einfacher Link auf [/logout], den man auf einer anderen Website oder in einem Bild platziert, kann den Benutzer nicht ohne sein Wissen abmelden. Beachten Sie eine Einschränkung von Token: Das Token selbst bleibt bis zu seinem Ablauf gültig. Wer eine Kopie davon angefertigt hat, könnte es weiterhin verwenden. Deshalb ist die Lebensdauer von Token begrenzt.
<?php
// app/Http/Controllers/ProfileController.php: eine für authentifizierte Benutzer reservierte Seite

namespace App\Http\Controllers;

use App\Auth\User;
use Illuminate\Container\Attributes\CurrentUser;
use Illuminate\View\View;

class ProfileController
{
    // #[CurrentUser]: der Container stellt den authentifizierten Benutzer der Anfrage bereit,
    // den vom Guard gefundenen (siehe bootstrap/app.php)
    public function display(#[CurrentUser] User $user): View
    {
        return view('profile.profile', ['user' => $user]);
    }
}
  • Zeile 14: Das Attribut [#[CurrentUser]] fordert den authentifizierten Benutzer vom Container an – den, den der Guard gefunden hat (zu Parameter-Attributen siehe Beispiel 12). Die Action ist durch die Middleware [auth] geschützt (siehe die Routing-Tabelle): Sie erhält garantiert einen Benutzer. Er ließe sich auch über [auth()->user()] oder [$request->user()] ermitteln.

Die Routing-Tabelle:

<?php
// routes/web.php: die Routen von Beispiel 25

use App\Http\Controllers\AuthController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', [AuthController::class, 'home']);
Route::get('login', [AuthController::class, 'form']);
Route::post('login', [AuthController::class, 'login']);
Route::post('logout', [AuthController::class, 'logout']);

// die Middleware [auth]: die Route ist nur für einen authentifizierten Benutzer zugänglich
Route::get('profile', [ProfileController::class, 'display'])->middleware('auth');
  • Zeile 14: Die Middleware [auth] schützt die Profilseite. Bei einem anonymen Besucher löst sie eine [AuthenticationException]-Exception aus, die [Laravel] in eine Umleitung auf die Anmeldeseite umwandelt ([redirectGuestsTo]). [auth] ist ein Alias – ein Kurzname, den [Laravel] mit der Middleware [Illuminate\Auth\Middleware\Authenticate] verknüpft. Eine Gruppe von Routen lässt sich auf einmal schützen: [Route::middleware('auth')->group(...)].

8.1.6. Die Views

@extends('layout')

@section('content')
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ $login ?? '' }}" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  @isset($error)
    <div class="alert alert-danger mt-3">{{ $error }}</div>
  @endisset
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
@endsection
  • Zeile 6: Das Anmeldeformular ist, wie alle Formulare, gegen gefälschte Anfragen geschützt (Beispiel 18);
  • Zeile 9: Der eingegebene Login wird nach einem fehlgeschlagenen Versuch erneut angezeigt.
@extends('layout')

@section('content')
  <h1 class="h3">Hello {{ $user->name }}</h1>
  <p>Your role: <b>{{ $user->role === 'ADMIN' ? 'administrator' : 'user' }}</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    @foreach ($user->claims as $key => $value)
      <tr><td><code>{{ $key }}</code></td><td>{{ $value }}</td></tr>
    @endforeach
  </table>
  {{-- logging out: a POST form reduced to its button --}}
  <form method="post" action="/logout">
    @csrf
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
@endsection
  • Zeilen 8–10: Der Inhalt des Tokens, zu Anschauungszwecken angezeigt;
  • Zeilen 13–16: die Abmeldung über ein Formular, das auf eine einzige Schaltfläche reduziert ist.

8.1.7. Ausführung

Fordern wir die geschützte Seite [/profile] an, ohne angemeldet zu sein:

curl -i http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/login
Content-Type: text/html; charset=utf-8
...

Ein falsches Passwort:

Image

Anmeldung erfolgreich. Mit [curl] müssen Sie zuerst das Formular anfordern, um das Anti-CSRF-Token und das Session-Cookie zu erhalten (Beispiel 18), und dann das Formular absenden, wobei Sie das erhaltene Cookie beibehalten:

curl -c token.txt -b token.txt http://localhost:8000/login
curl -i -c token.txt -b token.txt -d "_token=...&login=marie&password=marie" http://localhost:8000/login
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/profile
Set-Cookie: token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiJtYXJpZSIsIm5hbWUiOiJNYXJpZSBQXHUwMGU5bGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwNDM5NjgyLCJleHAiOjE3OTA0NDMyODJ9.cvP1bi4zFamN79t2nqG7WXYLIF3kewt6UTOVb3swNtw; expires=Sat, 26 Sep 2026 17:21:22 GMT; Max-Age=3600; path=/; httponly; samesite=lax
...

Das Token besteht aus drei durch Punkte getrennten Teilen, die jeweils Base64-codiert sind: dem Header, dem Inhalt und der Signatur. Die ersten beiden Teile lassen sich ohne Schlüssel decodieren:

{"typ":"JWT","alg":"HS256"}
{"sub":"marie","name":"Marie Pélissier","role":"USER","iat":1790439682,"exp":1790443282}

Die Ablaufzeit liegt eine Stunde (3.600 Sekunden) nach der Erstellung. Im Browser zeigt die Profilseite denselben Inhalt an:

Image

Ein böswilliger Benutzer ändert sein Token: Er ersetzt im Inhalt die Rolle [USER]*** durch [ADMIN]***, codiert diesen Teil erneut in Base64 und behält die ursprüngliche Signatur bei. Der Server berechnet die Signatur des geänderten Inhalts neu, die nun nicht mehr übereinstimmt:

curl -i -b "token=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.<modified content>.cvP1bi4zFamN79t2nqG7WXYLIF3kewt6UTOVb3swNtw" http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Location: http://localhost:8000/login
Set-Cookie: token=deleted; expires=Fri, 26 Sep 2025 16:21:27 GMT; Max-Age=0; path=/; httponly; samesite=lax
...

Das gefälschte Token wird abgelehnt und gelöscht (der Wert [deleted] und das abgelaufene Datum weisen den Browser an, das Cookie zu löschen). Um eine gültige Signatur zu erzeugen, müsste man den geheimen Schlüssel kennen – daher die Wichtigkeit, ihn geheim zu halten und einen langen, zufälligen Schlüssel zu wählen.

8.2. Beispiel 26: Rollen

Beispiel 26 fügt eine Administrationsseite hinzu, die auf die Rolle ADMIN beschränkt ist. Es werden nur neue oder geänderte Dateien angezeigt.

8.2.1. Eine Autorisierung: bootstrap/app.php

<?php
// bootstrap/app.php: die Anwendung von Beispiel 26

use App\Auth\AuthService;
use App\Auth\User;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Middleware;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cookie;
use Illuminate\Support\Facades\Gate;

(require __DIR__.'/../../vendor/autoload.php')->addPsr4('App\\', __DIR__.'/../app/');

return Application::configure(basePath: dirname(__DIR__))
    ->withRouting(
        web: __DIR__.'/../routes/web.php',
        // die Route, die Bootstrap ausliefert (siehe Beispiel 15)
        then: fn () => require __DIR__.'/../../common/bootstrap.php')
    ->withMiddleware(function (Middleware $middleware): void {
        // das Token ist bereits signiert: das Cookie, das es trägt, ist nicht verschlüsselt
        $middleware->encryptCookies(except: ['token']);
        // ein anonymer Besucher, der eine geschützte Seite anfordert: ab zu /login
        $middleware->redirectGuestsTo('/login');
    })
    ->withExceptions()
    ->booted(function () {
        // der Guard-Treiber [jwt] (siehe config/auth.php): eine Funktion, die die
        // Anfrage erhält und den authentifizierten Benutzer zurückgibt, oder null für einen anonymen Besucher
        Auth::viaRequest('jwt', function (Request $request) {
            $token = $request->cookie(config('jwt.cookie'));
            if ($token === null) {
                return null;
            }
            $user = app(AuthService::class)->check($token);
            if ($user === null) {
                // ein vorhandenes, aber ungültiges Cookie (abgelaufenes oder gefälschtes Token): wir löschen es
                Cookie::queue(Cookie::forget(config('jwt.cookie')));
            }
            return $user;
        });
        // eine benannte AUTORISIERUNG [admin]: die Funktion erhält den authentifizierten
        // Benutzer und sagt, ob er das angeforderte Recht hat
        Gate::define('admin', fn (User $user) => $user->role === 'ADMIN');
    })
    ->create();
  • Zeile 44: Die Fassade [Gate] (ein „Tor“) definiert eine Autorisierung mit dem Namen [admin]. Die Funktion erhält den authentifizierten Benutzer (und optional weitere Parameter, zum Beispiel das Objekt, auf das zugegriffen werden soll) und gibt [true] zurück, wenn der Benutzer die verlangte Berechtigung hat. Eine Berechtigung kann auf verschiedene Weise überprüft werden: [Gate::allows('admin')] oder [Gate::authorize('admin')] (das eine Exception, 403, auslöst) im Code, [@can('admin')] in den Views und die Middleware [can:admin] bei den Routen. Bei einer größeren Zahl von Regeln empfiehlt [Laravel] , sie nach Modellklassen in Policies (*policies*) zu gruppieren.

8.2.2. Die Routing-Tabelle und der Controller

<?php
// routes/web.php: die Routen von Beispiel 26

use App\Http\Controllers\AdminController;
use App\Http\Controllers\AuthController;
use App\Http\Controllers\ProfileController;
use Illuminate\Support\Facades\Route;

Route::get('/', [AuthController::class, 'home']);
Route::get('login', [AuthController::class, 'form']);
Route::post('login', [AuthController::class, 'login']);
Route::post('logout', [AuthController::class, 'logout']);

// die Middleware [auth]: die Route ist nur für einen authentifizierten Benutzer zugänglich
Route::get('profile', [ProfileController::class, 'display'])->middleware('auth');

// zwei Middlewares: [auth] (ein authentifizierter Benutzer), dann [can:admin] (wer
// die Autorisierung [admin] hat, siehe bootstrap/app.php)
Route::get('admin', [AdminController::class, 'display'])->middleware(['auth', 'can:admin']);
  • Zeile 19: zwei Middleware-Komponenten, die der Reihe nach ausgeführt werden: [auth] überprüft, ob ein Benutzer authentifiziert ist (andernfalls Umleitung auf die Anmeldeseite), danach [can:admin] , ob der Benutzer die Berechtigung [admin] hat (andernfalls ein 403-Fehler, *Forbidden*). Der Text nach [:] ist der Parameter der Middleware, den [Laravel] ihr nach [$next] übergibt. Der Unterschied zwischen den beiden Ablehnungsantworten ist bedeutsam: Für einen Benutzer, der authentifiziert ist, aber nicht die verlangte Rolle hat, wäre eine Anmeldung sinnlos, da er bereits authentifiziert ist.
<?php
// app/Http/Controllers/AdminController.php: eine für die Rolle ADMIN reservierte Seite

namespace App\Http\Controllers;

use App\Auth\User;
use Illuminate\Container\Attributes\CurrentUser;
use Illuminate\View\View;

class AdminController
{
    public function display(#[CurrentUser] User $user): View
    {
        return view('admin.admin', ['name' => $user->name]);
    }
}

Der Controller führt keine Prüfungen durch: Das ist Aufgabe der Middleware. [Laravel] erlaubt es auch, Middleware direkt an der Action selbst mithilfe von Attributen anzugeben: [#[Middleware('auth')]], [#[Authorize('admin')]].

8.2.3. Views

@extends('layout')
{{-- the page of the 403 error, which Laravel displays by itself: a view
     errors/<code>.blade.php replaces the standard error page of this code --}}

@section('content')
  <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
  <p><a href="/profile">Back to the profile</a></p>
@endsection

Die 403-Fehlerseite: [Laravel] sucht bei einem HTTP-Fehler nach einer View [errors/<code>.blade.php] und zeigt sie anstelle seiner Standardseite an (siehe vorheriges Kapitel). Es muss nichts deklariert werden. Die Profilseite enthält einen Link zur Administrationsseite:

@extends('layout')

@section('content')
  <h1 class="h3">Hello {{ $user->name }}</h1>
  <p>Your role: <b>{{ $user->role === 'ADMIN' ? 'administrator' : 'user' }}</b>.</p>
  {{-- @can: the block is displayed only if the user has the [admin] authorization --}}
  @can('admin')
    <p><a href="/admin">The administration area</a></p>
  @else
    <p><a href="/admin">The administration area</a> (which is forbidden to you)</p>
  @endcan
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    @foreach ($user->claims as $key => $value)
      <tr><td><code>{{ $key }}</code></td><td>{{ $value }}</td></tr>
    @endforeach
  </table>
  {{-- logging out: a POST form reduced to its button --}}
  <form method="post" action="/logout">
    @csrf
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
@endsection
  • Zeilen 7–11: Die Direktive [@can] zeigt ihren Block nur an, wenn der Benutzer die Berechtigung hat; [@else] behandelt den gegenteiligen Fall. Das verhindert, dass ein Link angezeigt wird, der zu einem Fehler führen würde; das ist jedoch nur eine Komfortmaßnahme: Der eigentliche Schutz kommt vom Routing.

8.2.4. Ausführung

Marie, mit der Rolle USER, folgt dem Link zur Administrationsseite:

Image

Der Administrator hingegen hat Zugriff darauf:

Image

Mit [curl]: ein Benutzer mit der Rolle USER (die Datei [token.txt], erhalten durch Anmeldung wie in Beispiel 25, aber bei Beispiel 26: Die beiden Beispiele signieren ihre Token mit unterschiedlichen Schlüsseln), gefolgt von einem anonymen Besucher:

curl -i -b token.txt http://localhost:8000/admin
curl -i http://localhost:8000/admin
HTTP/1.1 403 Forbidden
Content-Type: text/html; charset=utf-8
...
        <div class="alert alert-danger">
    <h1 class="h4">Error 403</h1>
    <p class="mb-0">Access denied: this page is reserved for administrators.</p>
  </div>
...
HTTP/1.1 302 Found
Location: http://localhost:8000/login
...

Routen einzeln zu schützen, hat einen Fehler: Wird eine übersehen, ist die Seite für jedermann zugänglich. Die Fallstudie kehrt diese Logik um: Alle Routen werden standardmäßig durch eine Gruppe geschützt, und nur wenige Routen (die Anmeldeseite, die Registrierungsseite) sind ausgenommen.

8.3. Beispiel 27: CAPTCHA und Begrenzung der Versuche

Ein Anmeldeformular ist ein Angriffsziel: Ein Programm kann Tausende von Passwörtern pro Minute ausprobieren (Brute-Force-Angriff). Zwei Schutzmaßnahmen ergänzen sich:

  • ein CAPTCHA (*Completely Automated Public Turing test to tell Computers and Humans Apart*): ein Bild mit einem verzerrten Code, der für Menschen leicht, für ein Programm aber schwer zu lesen ist;
  • eine Begrenzung der Versuche: Nach drei fehlgeschlagenen Versuchen wird die IP-Adresse des Clients für eine Minute gesperrt.

Beispiel 27 baut auf Beispiel 25 auf und fügt diese beiden Sicherheitsmaßnahmen hinzu.

8.3.1. Das CAPTCHA-Bild: app/Auth/CaptchaDrawing.php

<?php
// app/Auth/CaptchaDrawing.php: die Zeichnung eines CAPTCHAs, ein SVG-Bild (XML-Text)
// von Hand gebaut

namespace App\Auth;

class CaptchaDrawing
{
    public const WIDTH = 150;

    public const HEIGHT = 50;

    // Die "Schriftart": jedes Zeichen ist eine Liste von Strichen, jeder Strich eine
    // Folge von x,y-Punkten in einem 4 x 6 Raster (y nach unten).
    // Zeichen, die zu leicht miteinander zu verwechseln sind: ausgeschlossen (0 O, 1 I L).
    private const FONT = [
        'A' => [[0, 6, 2, 0, 4, 6], [0.8, 3.8, 3.2, 3.8]],
        'B' => [[0, 0, 0, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3], [0, 0, 3, 0, 4, 1, 4, 2, 3, 3]],
        'C' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5]],
        'D' => [[0, 0, 0, 6, 2.5, 6, 4, 4.5, 4, 1.5, 2.5, 0, 0, 0]],
        'E' => [[4, 0, 0, 0, 0, 6, 4, 6], [0, 3, 3, 3]],
        'F' => [[4, 0, 0, 0, 0, 6], [0, 3, 3, 3]],
        'G' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 3.5, 2.5, 3.5]],
        'H' => [[0, 0, 0, 6], [4, 0, 4, 6], [0, 3, 4, 3]],
        'J' => [[4, 0, 4, 5, 3, 6, 1, 6, 0, 5]],
        'K' => [[0, 0, 0, 6], [4, 0, 0, 3.5], [1.3, 2.6, 4, 6]],
        'M' => [[0, 6, 0, 0, 2, 3.5, 4, 0, 4, 6]],
        'N' => [[0, 6, 0, 0, 4, 6, 4, 0]],
        'P' => [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3]],
        'Q' => [[1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5, 0, 1, 1, 0], [2.5, 4.5, 4, 6.3]],
        'R' => [[0, 6, 0, 0, 3, 0, 4, 1, 4, 2, 3, 3, 0, 3], [2, 3, 4, 6]],
        'S' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 2, 1, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        'T' => [[0, 0, 4, 0], [2, 0, 2, 6]],
        'U' => [[0, 0, 0, 5, 1, 6, 3, 6, 4, 5, 4, 0]],
        'V' => [[0, 0, 2, 6, 4, 0]],
        'W' => [[0, 0, 1, 6, 2, 2.5, 3, 6, 4, 0]],
        'X' => [[0, 0, 4, 6], [4, 0, 0, 6]],
        'Y' => [[0, 0, 2, 3, 4, 0], [2, 3, 2, 6]],
        'Z' => [[0, 0, 4, 0, 0, 6, 4, 6]],
        '2' => [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 0, 6, 4, 6]],
        '3' => [[0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1.5, 3], [3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        '4' => [[3, 6, 3, 0, 0, 4, 4, 4]],
        '5' => [[4, 0, 0, 0, 0, 3, 3, 3, 4, 4, 4, 5, 3, 6, 1, 6, 0, 5]],
        '6' => [[4, 1, 3, 0, 1, 0, 0, 1, 0, 5, 1, 6, 3, 6, 4, 5, 4, 4, 3, 3, 0, 3]],
        '7' => [[0, 0, 4, 0, 1.5, 6]],
        '8' => [[1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 2, 3, 3, 1, 3, 0, 4, 0, 5, 1, 6, 3, 6, 4, 5,
            4, 4, 3, 3]],
        '9' => [[4, 3, 1, 3, 0, 2, 0, 1, 1, 0, 3, 0, 4, 1, 4, 5, 3, 6, 1, 6, 0, 5]],
    ];

    // ein paar dunkle Farben, gut lesbar auf dem hellen Hintergrund
    private const COLORS = ['#1f4e79', '#7b2d26', '#2e6b30', '#5b2c83', '#8a5a00', '#23395d', '#9c2a5b'];

    // ein zufälliger Text. random_int ist ein "kryptografischer" Generator,
    // unvorhersehbar (anders als rand oder mt_rand, deren Folge erraten werden könnte)
    public static function randomText(int $length): string
    {
        $alphabet = array_keys(self::FONT);
        $text = '';
        for ($i = 0; $i < $length; $i++) {
            $text .= $alphabet[random_int(0, count($alphabet) - 1)];
        }
        return $text;
    }

    // eine zufällige Gleitkommazahl zwischen $minimum und $maximum
    private static function random(float $minimum, float $maximum): float
    {
        return $minimum + ($maximum - $minimum) * random_int(0, PHP_INT_MAX) / PHP_INT_MAX;
    }

    private static function color(): string
    {
        return self::COLORS[random_int(0, count(self::COLORS) - 1)];
    }

    public static function svg(string $text): string
    {
        $l = self::WIDTH;
        $h = self::HEIGHT;
        $pieces = ["<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"$l\" height=\"$h\" viewBox=\"0 0 $l $h\">",
            '<rect width="100%" height="100%" fill="#f5f7fa"/>'];

        // die Zeichen: jedes vergrößert, gekippt, verschoben, und jeder Punkt
        // zufällig leicht bewegt
        $step = ($l - 20) / strlen($text);
        foreach (str_split($text) as $i => $character) {
            $scale = self::random(4.6, 5.6);    // Größe einer Rastereinheit in Pixeln
            $angle = self::random(-0.35, 0.35);   // Drehung im Bogenmaß (etwa ±20°)
            $cx = 10 + $step * ($i + 0.5) + self::random(-3, 3);    // Mittelpunkt des Zeichens
            $cy = $h / 2 + self::random(-4, 4);
            foreach (self::FONT[$character] as $stroke) {
                $d = [];
                for ($k = 0; $k < count($stroke); $k += 2) {
                    // Rasterpunkt, auf (2, 3) zentriert, verzerrt, gedreht, platziert
                    $x = ($stroke[$k] - 2 + self::random(-0.2, 0.2)) * $scale;
                    $y = ($stroke[$k + 1] - 3 + self::random(-0.2, 0.2)) * $scale;
                    $px = $cx + $x * cos($angle) - $y * sin($angle);
                    $py = $cy + $x * sin($angle) + $y * cos($angle);
                    $d[] = sprintf('%s%.1f %.1f', $k === 0 ? 'M' : 'L', $px, $py);
                }
                $pieces[] = sprintf('<path d="%s" fill="none" stroke="%s" stroke-width="%.1f" '
                    .'stroke-linecap="round" stroke-linejoin="round"/>',
                    implode(' ', $d), self::color(), self::random(2.2, 3));
            }
        }

        // 3 Störlinien: Kurven, die das Bild durchqueren
        for ($n = 0; $n < 3; $n++) {
            $pieces[] = sprintf('<path d="M%.1f %.1f C%.1f %.1f %.1f %.1f %.1f %.1f" fill="none" '
                .'stroke="%s" stroke-width="1.3"/>',
                self::random(0, 20), self::random(5, 45), self::random(30, 60), self::random(0, 50),
                self::random(90, 120), self::random(0, 50), self::random(130, 150), self::random(5, 45),
                self::color());
        }
        $pieces[] = '</svg>';
        return implode('', $pieces);
    }
}

Das Bild liegt im Format SVG (*Scalable Vector Graphics*) vor: eine Vektorgrafik, die in XML – also als Text – beschrieben ist, die der Server ohne Grafikbibliothek erzeugt und die der Browser direkt auf der Seite darstellt.

  • Zeilen 16–49: eine minimalistische „Schrift“: Jedes Zeichen ist eine Liste von Strichen, und jeder Strich ist eine Liste von Koordinaten [x, y] in einem 4 × 6-Raster. Leicht zu verwechselnde Zeichen ([0] und [O], [1], [I] und [L]) sind ausgeschlossen;
  • Zeilen 56–64: eine zufällige Zeichenkette, ausgewählt aus den Zeichen der Schrift ([array_keys], die Schlüssel der Tabelle). Die Funktionen [rand] und [mt_rand] von [PHP] erzeugen vorhersagbare Zahlenfolgen (wer einige Werte kennt, kann die nächsten erraten): Sie eignen sich für Simulationen, nicht für Sicherheit. [random_int] ist ein kryptografischer Generator; er ist unvorhersagbar;
  • Zeilen 67–70: eine zufällige Gleitkommazahl, erzeugt aus einer zufälligen ganzen Zahl ([PHP_INT_MAX] ist die größte ganze Zahl in [PHP]);
  • Zeilen 77–118: die Zeichnung. Jedes Zeichen wird zufällig skaliert, gedreht und verschoben, und jeder seiner Punkte wird leicht versetzt; jeder Strich wird zu einem Element [<path>] von SVG ([M]: Verschiebung, [L]: Linie). Drei Kurven ([C]: Bézierkurve) durchqueren das Bild, um Erkennungsprogramme zu stören. Die Funktion [sprintf] formatiert eine Zeichenkette: [%s] fügt eine Zeichenkette ein, und [%.1f] fügt eine Zahl mit einer Nachkommastelle ein. [str_split] zerlegt eine Zeichenkette in Zeichen.

8.3.2. Der CAPTCHA-Service: app/Auth/CaptchaService.php

<?php
// app/Auth/CaptchaService.php: die ausstehenden CAPTCHAs, vom Server
// im Cache aufbewahrt (siehe Beispiel 20)

namespace App\Auth;

use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Str;

class CaptchaService
{
    // die Lebensdauer eines CAPTCHAs in Sekunden
    private const LIFETIME = 600;

    public function generate(): Captcha
    {
        $text = CaptchaDrawing::randomText(5);
        // eine zufällige Kennung, nicht zu erraten
        $id = Str::random(24);
        // die erwartete Antwort im Cache, für 10 Minuten: der Cache vergisst sie danach
        // von selbst
        Cache::put("captcha:$id", $text, self::LIFETIME);
        return new Captcha($id, CaptchaDrawing::svg($text));
    }

    // das CAPTCHA wird in jedem Fall VERBRAUCHT: ein Bild wird nur einmal verwendet
    public function check(?string $id, ?string $answer): bool
    {
        // pull: liest den Wert UND entfernt ihn aus dem Cache (null, falls er nicht existiert oder abgelaufen ist)
        $expected = $id ? Cache::pull("captcha:$id") : null;
        if ($expected === null || $answer === null) {
            return false;
        }
        return strcasecmp($expected, trim($answer)) === 0;
    }
}
  • Zeilen 15–24: ein neues CAPTCHA: zufälliger Text, eine zufällige, nicht erratbare Kennung ([Str::random] verwendet ebenfalls einen kryptografischen Generator) und das Bild. Für jede Kennung speichert der Server die erwartete Antwort zehn Minuten lang im Cache (Beispiel 20): [Cache::put(key, value, seconds)]. Nach Ablauf dieser Zeit verwirft der Cache sie automatisch. Die Seite erhält nur die Kennung und das Bild: Die Antwort verlässt den Server nie. Die Klasse [Captcha] fasst Kennung und Bild zusammen;
  • Zeilen 27–35: die Überprüfung. [Cache::pull] liest den Wert und entfernt ihn aus dem Cache: Das CAPTCHA wird in jedem Fall verbraucht , ob erfolgreich oder nicht. Ohne das könnte ein Programm alle möglichen Antworten für dasselbe Bild ausprobieren. Der Vergleich ignoriert die Groß- und Kleinschreibung ([strcasecmp] gibt 0 für zwei gleiche Zeichenketten zurück, unabhängig von Groß- und Kleinbuchstaben) sowie Leerzeichen um die Eingabe ([trim]).

8.3.3. Der Controller: app/Http/Controllers/AuthController.php

<?php
// app/Http/Controllers/AuthController.php: Login (mit CAPTCHA und Begrenzung der Versuche) und Logout

namespace App\Http\Controllers;

use App\Auth\AuthService;
use App\Auth\CaptchaService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\RateLimiter;
use Illuminate\View\View;

class AuthController
{
    // höchstens 3 Fehlschläge, für 60 Sekunden
    private const MAX_FAILURES = 3;

    private const BLOCK_DURATION = 60;

    public function __construct(private AuthService $auth, private CaptchaService $captchas)
    {
    }

    public function home(): RedirectResponse
    {
        return redirect('/profile');
    }

    public function form(): View
    {
        return $this->loginPage();
    }

    public function login(Request $request): View|RedirectResponse
    {
        $login = $request->input('login');
        // der Schlüssel des Fehlschlagzählers: die IP-Adresse des Clients
        $key = 'login:'.$request->ip();

        // 1. einer gesperrten Adresse wird gar nicht erst zugehört
        if (RateLimiter::tooManyAttempts($key, self::MAX_FAILURES)) {
            $seconds = RateLimiter::availableIn($key);
            return $this->loginPage($login, "Too many attempts: try again in $seconds s.");
        }
        // 2. zuerst das CAPTCHA (billig), danach das Passwort (bcrypt, teuer)
        if (! $this->captchas->check($request->input('captchaId'), $request->input('captcha'))) {
            RateLimiter::hit($key, self::BLOCK_DURATION);
            return $this->loginPage($login, 'The image code is incorrect.');
        }
        $user = $this->auth->validate($login, $request->input('password'));
        if ($user === null) {
            RateLimiter::hit($key, self::BLOCK_DURATION);
            return $this->loginPage($login, 'Incorrect login or password.');
        }
        RateLimiter::clear($key);
        return redirect('/profile')->withCookie(cookie(config('jwt.cookie'),
            $this->auth->createToken($user), config('jwt.duration'),
            httpOnly: true, sameSite: 'lax'));
    }

    public function logout(): RedirectResponse
    {
        return redirect('/login')->withoutCookie(config('jwt.cookie'));
    }

    // jede Anzeige des Formulars baut ein NEUES CAPTCHA
    private function loginPage(?string $login = null, ?string $error = null): View
    {
        return view('auth.login', ['login' => $login, 'error' => $error,
            'captcha' => $this->captchas->generate()]);
    }
}
  • Zeile 38: Die Begrenzung übernimmt die Fassade [RateLimiter] von [Laravel], die „Versuche“ unter einem Schlüssel im Cache zählt. Der Schlüssel ist hier die IP-Adresse des Clients;
  • Zeilen 41–44: Auf eine gesperrte Adresse wird gar nicht erst gehört. [tooManyAttempts(key, 3)] ist wahr, wenn der Schlüssel 3 Versuche erreicht hat; [availableIn] gibt die Anzahl der Sekunden zurück, die bis zum Ende der Sperre verbleiben;
  • Zeilen 46–54: Das CAPTCHA wird vor dem Passwort überprüft; seine Überprüfung kostet fast nichts, während [bcrypt] absichtlich langsam ist. Ein Programm, das ein falsches CAPTCHA eingibt, würde daher [bcrypt] nicht auslösen. Jeder Fehlversuch – ob beim CAPTCHA oder beim Passwort – wird gezählt: [RateLimiter::hit(key, 60)] fügt einen Versuch hinzu und setzt die Lebensdauer des Zählers auf 60 Sekunden. Beim dritten Fehlversuch ist die Adresse daher bis zum Ende dieser 60 Sekunden gesperrt, gerechnet ab dem ersten Fehlversuch;
  • Zeile 55: Eine erfolgreiche Anmeldung löscht die fehlgeschlagenen Versuche;
  • Zeilen 67–71: Bei jeder Anzeige des Formulars wird ein neues CAPTCHA erzeugt, auch nach einem fehlgeschlagenen Versuch.

[Laravel] stellt außerdem eine Middleware-Komponente bereit, [throttle], die die Anzahl der Anfragen für eine Route begrenzt ([->middleware('throttle:5,1')]: 5 Anfragen pro Minute); wir haben uns entschieden, nur die fehlgeschlagenen Versuche zu zählen, um einen Benutzer, der sich normal anmeldet, nicht zu stören.

8.3.4. Die View: resources/views/auth/login.blade.php

@extends('layout')

@section('content')
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    @csrf
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ $login }}" required>
    </div>
    <div class="mb-2">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="captcha">Copy the code of the image</label>
      {{-- the SVG image, built by the server: inserted without escaping --}}
      <div class="mb-1">{!! $captcha->svg !!}</div>
      {{-- the captcha identifier travels in a hidden field; the answer stays on the server --}}
      <input type="hidden" name="captchaId" value="{{ $captcha->id }}">
      <input class="form-control" id="captcha" name="captcha" autocomplete="off" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  @if ($error)
    <div class="alert alert-danger mt-3">{{ $error }}</div>
  @endif
  <p class="text-muted small mt-3">Test accounts (password = login): marie (USER), admin (ADMIN).</p>
@endsection
  • Zeile 18: Das SVG-Bild wird unverändert, ohne Escaping, in die Seite eingefügt (Beispiel 14). Das ist legitim: Dieses HTML wurde vom Server erzeugt und enthält keine Benutzereingaben;
  • Zeile 20: Die CAPTCHA-Kennung in einem versteckten Feld;
  • Zeile 21: Der Browser schlägt für dieses Feld keine früheren Eingaben vor.

8.3.5. Ausführung

Image

Ein falsch abgeschriebener Code:

Image

Nach drei fehlgeschlagenen Versuchen wird die Adresse gesperrt:

Image

Mit [curl], vier Versuche mit einer erfundenen CAPTCHA-Kennung (nachdem, wie in Beispiel 25, das Session-Cookie und das Anti-CSRF-Token besorgt wurden):

curl -b cookies.txt -d "_token=...&login=marie&password=marie&captchaId=abc&captcha=XXXXX" http://localhost:8000/login
1
2
3
4
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">The image code is incorrect.</div>
      <div class="alert alert-danger mt-3">Too many attempts: try again in 60 s.</div>

Selbst mit dem richtigen Passwort wird der vierte Versuch abgelehnt, ohne bearbeitet zu werden.