8. Authentifizierung und Autorisierung
Bei jeder Anfrage stellen sich zwei getrennte 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 Ärzte und Klienten.
Der Identitätsnachweis muss bei jeder Anfrage mitgeliefert werden. [Symfony] speichert den angemeldeten Benutzer typischerweise in seiner Session (siehe den Abschnitt über Gültigkeitsbereiche), 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], [Laravel]) 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 ist das Prinzip hinter dem signierten Cookie in Beispiel 23). 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 ä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.
[Symfony] verfügt über eine umfassende Sicherheitskomponente, die durch SecurityBundle integriert wird und deren Elemente wir unverändert verwenden werden:
- Die URLs der Anwendung werden auf Firewalls (firewalls) verteilt, jede mit ihrer eigenen Methode zur Authentifizierung der Benutzer;
- Die Authentifizierung übernehmen Authenticators (authenticators): Objekte, die bei jeder Anfrage die Identität des Benutzers bestimmen. [Symfony] bietet mehrere davon (Anmeldeformular, Session, API-Token usw.); wir schreiben unseren eigenen, der das JWT-Token liest. Der Rest der Anwendung sieht nur das Ergebnis: den authentifizierten Benutzer, bereitgestellt durch [#[CurrentUser]], [$this->getUser()] und in den Views durch [app.user];
- Benutzer werden von einem User-Provider bereitgestellt, und ihre Passwörter werden von der Komponente PasswordHasher gehasht (Algorithmus [bcrypt]);
- Die Autorisierung ist rollenbasiert: Der Seiten-Schutz wird durch Access-Control-Regeln beschrieben ([access_control]) oder durch das Attribut [#[IsGranted]] der Aktionen; Views prüfen ein Recht mit [is_granted];
- Anmeldeversuche werden von der Komponente RateLimiter begrenzt (Beispiel 27).
All das wird durch Kernel-Ereignis-Listener erreicht (vorheriges Kapitel): Die Firewall reagiert auf [kernel.request] (Priorität 8), [#[IsGranted]] wird bei [kernel.controller_arguments] gelesen, und Zugriffsverweigerungen sind Exceptions, die bei [kernel.exception] behandelt werden.
Die Erzeugung und Überprüfung der Token übernimmt die Bibliothek [firebase/php-jwt], die am häufigsten verwendete in [PHP], installiert durch die Datei [composer.json] der Beispiele. (Es gibt ein weit verbreitetes Bundle für Token – JWT und [LexikJWTAuthenticationBundle] –, das für APIs entwickelt wurde; für eine Webanwendung genügen wenige Zeilen, und sie veranschaulichen den Mechanismus besser.)
8.1. Beispiel 25: Anmeldung, Token, geschützte Seite
8.1.1. Konfiguration: .env, bundles.php und framework.yaml
Das Token wird mit einem geheimen Schlüssel signiert, der nicht fest im Code stehen darf. Es ist an der Zeit, die Konfiguration wirklich vom Code zu trennen. Die für eine Installation spezifischen Einstellungen stehen in der Datei [.env] (Beispiel 01), die nun drei neue Zeilen enthält (einen Kommentar, gefolgt von zwei Variablen):
Der Standard verlangt, dass der verwendete Algorithmus (HMAC-SHA256) einen Schlüssel von mindestens 256 Bit bzw. 32 Byte hat; die Bibliothek weist jeden kürzeren Schlüssel zurück. Der Code selbst liest die Datei [.env] nicht direkt: Die Komponente [Dotenv] (Beispiel 01) hat sie in Umgebungsvariablen umgewandelt, die der Container den Services bereitstellt, die sie anfordern (das sehen wir beim Service [AuthService]). Eine echte Umgebungsvariable hat Vorrang vor der Datei [.env]: Unter [Linux] oder [macOS] würde die Anwendung wie folgt mit einem anderen Schlüssel gestartet:
und unter [Windows] (PowerShell):
(Die Option [-d variables_order=EGPCS] weist [PHP] an, das Array [$_ENV] mit Umgebungsvariablen zu füllen, was seine Standardkonfiguration nicht immer tut.) In der Produktion werden Secrets häufig dem [Symfony]-Tresor (Secrets Vault, Befehl [bin/console secrets:set]) anvertraut, der sie verschlüsselt im Projekt speichert.
SecurityBundle wird der Liste der Bundles hinzugefügt:
Die Session wird hier ausschließlich für das Anti-CSRF-Token des Anmeldeformulars verwendet (Beispiel 21):
8.1.2. Sicherheitskonfiguration: config/packages/security.yaml
- Zeilen 4–6: der Passwort-Hash-Algorithmus für Benutzer der Klasse [User]: [bcrypt]. (Der Wert [auto] würde den besten verfügbaren Algorithmus auswählen und Hashes anderer Algorithmen überprüfen können);
- Zeilen 9–11: der User Provider – der Service, der einen Benutzer anhand seiner ID findet (hier unsere Klasse [UsersService]). [Symfony] bietet mehrere: [memory] (eine in dieser Datei geschriebene Liste), [entity] (eine Datenbanktabelle; siehe Fallstudie) ...;
- Zeilen 14–27: die Firewalls. Jede gilt für die URLs, die ihrem Muster entsprechen ([pattern]), wobei der erste passende Eintrag gewählt wird. Die erste, [resources], deckt die Dateien von [Bootstrap] (Beispiel 15) ohne Sicherheit ab ([security: false]): Man muss keinen Benutzer suchen, um ein Stylesheet auszuliefern. Die zweite, [main], hat keinen besonderen Grund: Sie deckt alle anderen URLs ab;
- Zeile 23: Die Firewall ist zustandslos (stateless): Der authentifizierte Benutzer wird nicht in der Session gespeichert; er wird bei jeder Anfrage anhand seines Tokens identifiziert;
- Zeilen 26–27: der Authenticator der Firewall, unsere Klasse [TokenAuthenticator];
- Zeilen 31–32: Zugriffskontrolle: eine Liste von Regeln, die der Reihe nach geprüft werden und von denen die erste, die zur URL passt, angewendet wird. Die URLs, die mit [/profile] beginnen, erfordern einen authentifizierten Benutzer ([IS_AUTHENTICATED]); die übrigen sind öffentlich.
In einem Standardprojekt wird diese Datei von [Symfony Flex] geschrieben, sobald das Bundle ([composer require security]) installiert wird, und der Befehl [bin/console make:user] von [MakerBundle] erzeugt die Benutzerklasse und ihren Provider.
8.1.3. Benutzer: src/Security/User.php und UsersService.php
- Zeile 11: ein Benutzer. [Symfony] erwartet, dass authentifizierte Benutzer die Schnittstelle [UserInterface] implementieren: Deren Methoden liefern die ID und die Rollen des Benutzers. Die Schnittstelle [PasswordAuthenticatedUserInterface] ergänzt das gehashte Passwort. In einer typischen Anwendung implementiert die [Doctrine]-Entität der Benutzertabelle (nächstes Kapitel) diese Methoden;
- Zeilen 13–23: der Login, der Name, die Rolle, der Passwort-Hash und der Inhalt des Tokens, mit dem der Benutzer authentifiziert wurde (leer bei einem Benutzer, der aus der Benutzerliste geladen wurde). Ein Server speichert ein Passwort niemals, auch nicht in verschlüsselter Form: Würde die Datenbank gestohlen, wären auch die Passwörter gestohlen (und viele Menschen verwenden überall dasselbe Passwort). Er speichert das Ergebnis einer Hashfunktion, einer Einwegfunktion: Man kann den Hash eines Passworts berechnen, aber aus dem Hash lässt sich kein Passwort wiederherstellen. Um ein eingegebenes Passwort zu prüfen, berechnet man seinen Hash und vergleicht ihn mit dem gespeicherten;
- Zeilen 32–35: Rollen, wie von [Symfony] definiert: Zeichenketten, die mit [ROLE_] beginnen. Die Rolle [USER] aus der Fallstudie wird zu [ROLE_USER].
- Zeilen 17–20: zwei fest codierte Testbenutzer (Beispiel 28 und die Fallstudie speichern sie in einer 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 besondere Eigenschaften. Er ist absichtlich langsam, mit einstellbarem Grad der Langsamkeit (der Kostenfaktor, hier auf 10 gesetzt: 2^10 Rechenzyklen, daraus ergibt sich der Hash [$10$]): wenige 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 somit unterschiedliche Hashes. Die Hashes wurden einmalig mit der Funktion [password_hash] von [PHP] (Zeile 16) oder mit dem Befehl [bin/console security:hash-password] von [Symfony] berechnet: Sie bei jeder Anfrage neu 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 22–29: 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;
- Zeilen 32–47: die drei Methoden der Schnittstelle [UserProviderInterface], die die Klasse zu einem User Provider machen: [loadUserByIdentifier] liefert den zu einem Bezeichner gehörenden Benutzer oder wirft die Exception [UserNotFoundException]; [refreshUser] lädt den in der Session gespeicherten Benutzer neu (bei einer Stateless-Firewall überflüssig); [supportsClass] gibt die Klasse der bereitgestellten Benutzer an. Der Operator [??] gefolgt von [throw] löst die Exception aus, wenn der Ausdruck auf der linken Seite zu [null] ausgewertet wird.
8.1.4. Der Authentifizierungsservice: src/Security/AuthService.php
- Zeilen 17–26: Der Service erhält den User Provider, den Service zum Hashen von Passwörtern ([UserPasswordHasherInterface], der den in [security.yaml] gewählten Algorithmus anwendet) sowie zwei Konfigurationswerte. Das Attribut [#[Autowire(env: 'NAME')]] liefert den Wert einer Umgebungsvariablen; ein Präfix konvertiert ihn: [int:] in eine Ganzzahl (es gibt weitere: [bool:], [json:], [base64:] ...). Die Gültigkeitsdauer ist eine öffentliche schreibgeschützte Eigenschaft: Der Controller wird sie verwenden;
- Zeilen 31–41: Überprüfung von Benutzername und Passwort. [isPasswordValid] hasht das eingegebene Passwort mit dem Salt des gespeicherten Hashs und vergleicht die beiden Hashes. Ein unbekannter Benutzername und ein falsches Passwort führen zum selben Ergebnis, [null];
- Zeilen 44–56: Erzeugung des Tokens. Das Token enthält ein Array von Aussagen (Claims) über den Benutzer. Einige haben standardisierte Namen: [sub] (subject), die ID des Benutzers; [iat] (issued at), das Erstellungsdatum; [exp] (expiration), das Ablaufdatum. Die Datumsangaben sind in Sekunden seit dem 1. Januar 1970 ausgedrückt (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 60–69: Überprüfung des Tokens. [JWT::decode] prüft die Signatur und das Ablaufdatum und liefert dann die Aussagen zurück (ein Objekt, das mit [(array)] in ein Array umgewandelt wird). Jede Auffälligkeit (gefälschtes, abgelaufenes oder fehlerhaft aufgebautes 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 Objekt [Key] verknüpft 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.5. Der Authenticator: src/Security/TokenAuthenticator.php
Für jede Anfrage, die die Firewall durchläuft, ruft [Symfony] die Methoden des Authenticators in dieser Reihenfolge auf:
- Zeilen 28–31: [supports]: Ist der Authenticator an dieser Anfrage beteiligt? Ja, wenn sie das Token-Cookie enthält. Andernfalls geschieht nichts: Der Besucher bleibt anonym;
- Zeilen 35–44: [authenticate] erstellt einen Passport: die Identität des Benutzers (ein Badge, [UserBadge]) und die zu überprüfenden Nachweise. Ein klassisches Anmeldeformular würde das eingegebene Passwort in den Passport aufnehmen, das [Symfony] selbst überprüfen würde. Hier ist der Nachweis das Token, das bereits von [AuthService] überprüft wurde: Der Passport validiert sich selbst ([SelfValidatingPassport]). Das Badge enthält den Login und eine Funktion, die den Benutzer identifiziert: hier den im Token beschriebenen Benutzer, ohne die Benutzerliste zu befragen (ohne diese Funktion würde [Symfony] den Benutzer beim Provider anfordern). Ein ungültiges Token löst eine Authentifizierungs-Exception aus;
- Zeilen 47–50: [onAuthenticationSuccess]: Die Authentifizierung war erfolgreich. Die Rückgabe von [null] lässt die Anfrage mit einem authentifizierten Benutzer zur Action durch. (Ein Anmeldeformular würde hier auf die Startseite umleiten);
- Zeilen 53–58: [onAuthenticationFailure]: Die Authentifizierung ist fehlgeschlagen (Token abgelaufen oder gefälscht). Die Antwort leitet auf die Anmeldeseite um und nutzt die Gelegenheit, das Cookie zu löschen: [clearCookie] fügt der Antwort ein leeres, bereits abgelaufenes Cookie hinzu;
- Zeilen 62–65: [start] ist die Methode der Schnittstelle [AuthenticationEntryPointInterface]: der Einstiegspunkt der Firewall, d. h. die Antwort, die an einen anonymen Besucher gesendet wird, der eine geschützte Seite anfordert. Hier ist das eine Umleitung auf die Anmeldeseite.
Der Authenticator verweigert keinen Zugriff: Er stellt fest, wer der Benutzer ist, oder dass der Benutzer anonym ist. Das ist die Authentifizierung. Verweigerungen sind Sache der Zugriffskontrolle.
8.1.6. Die Controller
- Zeilen 36–38: Das Anmeldeformular ist wie alle Formulare gegen gefälschte Anfragen geschützt (Beispiel 21);
- Zeilen 40–45: der Anmeldevorgang. Schlägt er 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 49–54: 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 vor Skriptinjektion (XSS) schützt; es ist [SameSite=Lax]: Der Browser sendet es nicht bei einer POST-Anfrage mit, die von einer anderen Website stammt, was die Anwendung vor CSRF-Angriffen schützt; sein Ablaufdatum ([withExpires], hier eine Anzahl von Sekunden seit 1970) entspricht dem des Tokens. In der Produktion würden wir bei HTTPS [withSecure(true)] ergänzen: Das Cookie würde dann niemals über eine unverschlüsselte Verbindung gesendet;
- Zeilen 59–68: Das Abmelden löscht das Cookie ([clearCookie]). Dies ist eine POST-Action, die durch ein Anti-CSRF-Token geschützt ist: Ein einfacher Link auf [/logout], der auf einer anderen Website oder in einem Bild platziert ist, kann den Benutzer nicht ohne sein Wissen abmelden. Beachten Sie eine Einschränkung von Tokens: Das Token selbst bleibt bis zu seinem Ablauf gültig. Wer eine Kopie davon angefertigt hat, könnte es weiterhin verwenden. Deshalb ist ihre Lebensdauer begrenzt.
[Symfony] kann auch selbst die formularbasierte Anmeldung (den Authenticator [form_login]) und die Abmeldung (die Firewall-Option [logout] ) übernehmen; diese speichern den Benutzer jedoch in der Session, wohingegen wir ein Token wollen.
- Zeile 18: Das Attribut [#[CurrentUser]] liefert den authentifizierten Benutzer, den der Authenticator ermittelt hat. Die Action ist durch die Regel [access_control] aus [security.yaml] geschützt: Es ist garantiert, dass sie einen Benutzer erhält. Wir würden ihn auch über [$this->getUser()] erhalten.
8.1.7. Die Views
- Zeile 6: das Anti-CSRF-Token des Formulars (Beispiel 21);
- Zeile 9: Der eingegebene Login wird nach einem Fehlschlag erneut angezeigt ([??]: eine leere Zeichenkette, wenn die Variable [login] nicht existiert).
- Zeilen 8–10: der Inhalt des Tokens, zu Anschauungszwecken angezeigt. Eine Schleife mit [for] in [Twig] kann die Schlüssel und Werte eines assoziativen Arrays durchlaufen ([for key, value in ...]);
- Zeilen 13–16: die Abmeldung über ein Formular, das auf eine einzige Schaltfläche reduziert ist.
Der authentifizierte Benutzer steht in allen Views außerdem unter dem Namen [app.user] zur Verfügung.
8.1.8. Ausführung
Fordern wir die geschützte Seite [/profile] an, ohne angemeldet zu sein:
Ein falsches Passwort:

Erfolgreiche Anmeldung. Mit [curl] müssen Sie zuerst das Formular anfordern, um das Anti-CSRF-Token und das Session-Cookie zu erhalten (Beispiel 21), und dann das Formular absenden, wobei Sie das empfangene Cookie beibehalten:
Das Token besteht aus drei durch Punkte getrennten, jeweils Base64-codierten Teilen: dem Header, dem Inhalt und der Signatur. Die ersten beiden Teile lassen sich ohne Schlüssel decodieren:
(Das [é] wird in seiner JSON-Escape-Form geschrieben, [\u00e9].) Die Ablaufzeit liegt eine Stunde (3.600 Sekunden) nach der Erstellung. Im Browser zeigt die Profilseite denselben Inhalt an:

Ein böswilliger Benutzer verä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 veränderten Inhalts neu, die nun nicht mehr übereinstimmt:
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 ist es wichtig, 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 der Rolle ADMIN vorbehalten ist. Es werden nur neue oder geänderte Dateien angezeigt.
8.2.1. Die Konfiguration: config/packages/security.yaml
- Zeilen 12–13: die Rollenhierarchie: Die Rolle [ROLE_ADMIN] schließt die Rolle [ROLE_USER] ein. Ein Administrator hat somit alle Rechte eines Benutzers, ohne dass ihm beide Rollen zugewiesen werden müssen;
- Zeile 25: Der Handler für verweigerten Zugriff der Firewall ([access_denied_handler]): die Klasse, die die Antwort erzeugt, die an einen authentifizierten Benutzer gesendet wird, der eine Seite anfordert, die er nicht ansehen darf;
- Zeilen 27–31: Die Seite [/admin] könnte hier mit einer zusätzlichen Regel geschützt werden; stattdessen schützen wir sie in ihrem Controller, um einen alternativen Ansatz zu zeigen.
Der Unterschied zwischen den beiden Verweigerungsantworten ist wichtig: Ein anonymer Besucher, der eine geschützte Seite anfordert, wird zum Einstiegspunkt der Firewall umgeleitet (der Anmeldeseite, Beispiel 25); ein authentifizierter Benutzer ohne die verlangte Rolle erhält einen 403-Fehler (Forbidden): Eine Anmeldung wäre sinnlos, da er bereits authentifiziert ist.
8.2.2. Zugriff verweigert: src/Security/AccessDenied.php
- Zeile 13: Die Klasse implementiert die Schnittstelle [AccessDeniedHandlerInterface], deren einzige Methode [handle] die Verweigerungsantwort liefert;
- Zeile 21: die 403-Fehlerseite, erzeugt von [Twig] (wie beim [ErrorPage]-Listener in Beispiel 24), mit dem Code 403 ([Response::HTTP_FORBIDDEN], eine Konstante der Klasse [Response]).
Ohne diesen Handler würde die Verweigerung eine Exception [AccessDeniedHttpException] auslösen, und der Benutzer sähe die 403-Fehlerseite von [Symfony] (im Debug-Modus detailliert). Die Seite [templates/errors/403.html.twig] ist eine Standard-Fehlerseite mit einem Link zurück zum Profil.
8.2.3. Der Controller: src/Controller/AdminController.php
- Zeile 17: Das Attribut [#[IsGranted]] erlaubt die Ausführung der Action nur einem Benutzer, der die erforderliche Berechtigung besitzt, hier die Rolle [ROLE_ADMIN]. Ein anonymer Besucher wird zum Einstiegspunkt umgeleitet; einem authentifizierten Benutzer ohne diese Rolle wird der Zugriff verweigert. Auf die Klasse angewendet, würde das Attribut alle ihre Actions schützen.
Der Controller führt selbst keine Prüfungen durch. Im Code würde man eine Berechtigung mit [$this->isGranted('ROLE_ADMIN')] (liefert einen booleschen Wert) oder [$this->denyAccessUnlessGranted('ROLE_ADMIN')] (löst eine Verweigerungs-Exception aus) prüfen. Für Regeln, die feiner sind als eine Rolle („ein Benutzer darf nur seine eigenen Termine bearbeiten“), erlaubt [Symfony] die Definition von „Votern“ (Voter): Klassen, die eine Berechtigung festlegen und die von [#[IsGranted]] und [is_granted] wie Rollen abgefragt werden.
8.2.4. Die Profil-View
- Zeilen 7–11: Die Funktion [is_granted] von [Twig] prüft die Berechtigung eines Benutzers. So wird vermieden, dass ein Link angezeigt wird, der zu einem Fehler führen würde; dies ist jedoch nur eine Komfortfunktion: Der eigentliche Schutz kommt von der Action selbst.
8.2.5. Ausführung
Marie mit der Rolle USER folgt dem Link zur Administrationsseite:

Der Administrator hingegen hat Zugriff darauf:

Mit [curl]: ein Benutzer mit der Rolle USER (angemeldet wie in Beispiel 25, mit in der Datei [token.txt] gespeicherten Cookies), gefolgt von einem anonymen Besucher:
Das einzelne Schützen von Routen hat einen Nachteil: Wird eine übersehen, ist die Seite für alle zugänglich. Die Fallstudie kehrt diese Logik um: Alle URL-Seiten sind standardmäßig durch eine allgemeine [access_control]-Regel geschützt, und nur wenige URL-Seiten (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 einen Menschen leicht, für ein Programm aber schwer lesbar ist;
- eine Begrenzung der Versuche: Nach drei fehlgeschlagenen Versuchen wird die IP-Adresse des Clients eine Minute lang gesperrt.
Beispiel 27 baut auf Beispiel 25 auf und fügt diese beiden Sicherheitsmaßnahmen hinzu.
8.3.1. Das CAPTCHA-Bild: src/Security/CaptchaDrawing.php
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 | |
Das Bild liegt im Format SVG (Scalable Vector Graphics) vor: eine Vektorzeichnung, die in XML – also als Text – beschrieben ist, vom Server ohne Grafikbibliothek erzeugt wird und die der Browser direkt in der Seite darstellt. Diese Klasse ist reines [PHP] ohne Framework-Besonderheiten: Sie ist identisch mit der [Laravel]-Version dieses Kurses.
- 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 Raster von 4 × 6. 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 Sicherheitszwecke. [random_int] ist ein kryptografischer Generator; er ist nicht vorhersagbar;
- Zeilen 67–70: eine zufällige Gleitkommazahl, erzeugt aus einer zufälligen Ganzzahl ([PHP_INT_MAX] ist die größte Ganzzahl 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>] der SVG ([M]: Verschiebung, [L]: Linie). Drei Kurven ([C]: Bézierkurve) durchqueren das Bild, um Texterkennungsprogramme 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.
Die Klasse [Captcha] kombiniert die ID eines CAPTCHAs mit seinem Bild:
8.3.2. Der CAPTCHA-Service: src/Security/CaptchaService.php
- Zeilen 18–29: ein neues CAPTCHA: ein zufälliger Text, ein zufälliger, nicht erratbarer Bezeichner und das Bild. Zu jedem Bezeichner speichert der Server die erwartete Antwort zehn Minuten lang im Cache (Beispiel 20): Die Methode [expiresAfter] des Cache-Elements legt dessen Lebensdauer in Sekunden fest. Nach Ablauf dieser Zeit verwirft der Cache es automatisch. Die Seite erhält nur den Bezeichner und das Bild: Die Antwort verlässt den Server nie;
- Zeilen 32–46: die Validierung. Der Bezeichner stammt vom Client: Wir prüfen zuerst, ob er aus Hexadezimalziffern besteht ([ctype_xdigit]), da bestimmte Zeichen ([{}()/\@:]) in Cache-Schlüsseln verboten sind und eine Exception auslösen würden. Das Element wird gelesen und dann aus dem Cache entfernt ([deleteItem]): Das CAPTCHA wird in jedem Fall verbraucht, ob erfolgreich oder nicht. Ohne dies könnte ein Programm alle möglichen Antworten für dasselbe Bild ausprobieren. Der Vergleich ignoriert die Groß- und Kleinschreibung ([strcasecmp] liefert 0 für zwei gleiche Zeichenketten, unabhängig von Groß- und Kleinbuchstaben) und Leerzeichen um die Eingabe ([trim]).
8.3.3. Begrenzung der Versuche: config/packages/framework.yaml
- Zeile 11: Locks (Beispiel 20): Der Limiter verwendet sie, damit zwei gleichzeitige Anfragen seine Zählung nicht verfälschen;
- Zeilen 14–18: ein Rate Limiter mit dem Namen [login]. Ein Rate Limiter verteilt „Tokens“ (ohne Bezug zum JWT-Token): Jede beschränkte Aktion verbraucht eines, und sind keine mehr übrig, wird die Aktion verweigert. Die Policy [fixed_window] (festes Fenster) gewährt 3 Tokens pro Zeitraum von 60 Sekunden, gezählt ab dem ersten verbrauchten Token. Es gibt weitere Policies: [sliding_window] (ein gleitendes Fenster, gleichmäßiger), [token_bucket] (ein Eimer, der sich mit einer bestimmten Rate füllt). Die Zähler werden im Anwendungs-Cache gespeichert.
Für jeden deklarierten Limiter erstellt [Symfony] einen Limiter-Factory-Service ([RateLimiterFactoryInterface]), den man per Injektion unter einem Parameternamen erhält, der sich aus dem Namen des Limiters gefolgt von [Limiter] zusammensetzt: [$loginLimiter].
8.3.4. Der Controller: src/Controller/AuthController.php
- Zeilen 21–26: Der Controller erhält die Factory für den Limiter [login];
- Zeile 49: der Limiter dieses Clients, [create(key)], liefert einen Limiter, der unter diesem Schlüssel einen eigenen Zähler hat – hier die IP-Adresse des Clients ([getClientIp()]);
- Zeilen 53–57: Eine gesperrte Adresse wird gar nicht erst angehört. [consume(0)] fragt den Limiter ab, ohne etwas zu verbrauchen; das zurückgegebene Objekt [RateLimit] liefert die Anzahl der verbleibenden Tokens ([getRemainingTokens()]) und den Zeitpunkt, ab dem die Aktion wieder erlaubt ist ([getRetryAfter()]), woraus sich die Anzahl der Sekunden ableiten lässt, die zu warten sind;
- Zeilen 60–68: 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 Fehlschlag – sei es beim CAPTCHA oder beim Passwort – verbraucht ein Token ([consume()], das standardmäßig eines verbraucht). Nach dem dritten Fehlschlag ist kein Token mehr übrig: Die Adresse ist bis zum Ende des 60-Sekunden-Fensters gesperrt, gezählt ab dem ersten Fehlschlag;
- Zeile 70: Eine erfolgreiche Anmeldung setzt die fehlgeschlagenen Versuche zurück ([reset()]);
- Zeilen 91–95: Bei jeder Anzeige des Formulars wird ein neues CAPTCHA erzeugt, auch nach einem fehlgeschlagenen Versuch.
Das SecurityBundle bietet außerdem eine eingebaute Begrenzung der Anmeldeversuche (die Firewall-Option [login_throttling] ), die für seine eigenen Login-Authenticators ([form_login] ...) gilt, nicht für unsere Action. Um die Anzahl der Anfragen für eine Route zu begrenzen, würden wir einen Limiter auf dieselbe Weise verwenden, entweder innerhalb der Action oder in einem Listener für [kernel.request]. Wir haben uns entschieden, nur die fehlgeschlagenen Versuche zu zählen, um einen Benutzer, der sich normal anmeldet, nicht zu behindern.
8.3.5. Die View: templates/auth/login.html.twig
- Zeile 18: Die SVG-Grafik wird unverändert, ohne Escaping, in die Seite eingefügt (Filter [raw], Beispiel 14). Das ist zulässig: Dieses HTML wurde vom Server erzeugt und enthält keine Benutzereingaben;
- Zeile 20: die CAPTCHA-ID in einem versteckten Feld;
- Zeile 21: Der Browser schlägt für dieses Feld keine früheren Eingaben vor.
8.3.6. Ausführung

Ein fehlerhaft abgeschriebener Code:

Nach drei fehlgeschlagenen Versuchen wird die Adresse gesperrt:

Mit [curl] vier Versuche mit einer erfundenen CAPTCHA-ID (nachdem man wie in Beispiel 25 das Session-Cookie und das Anti-CSRF-Token besorgt hat):
Selbst mit dem richtigen Passwort wird der vierte Versuch abgelehnt, ohne bearbeitet zu werden.