8. Authentifizierung und Autorisierung
Bei jedem Request stellen sich zwei getrennte Fragen:
- Wer ist der Benutzer? Das ist die Authentifizierung: Der Benutzer hat sich mit Benutzername und Passwort identifiziert, und jeder weitere Request muss belegen, dass er von ihm stammt;
- Darf er auf diese Seite zugreifen? Das ist die Autorisierung: In der Fallstudie verwaltet nur ein Benutzer mit der Rolle ADMIN die Ärzte und Clients.
Der Identitätsnachweis muss jeden Request begleiten. [Django] besitzt eine vollständige Authentifizierungsanwendung, [django.contrib.auth]: ein Modell [User] (eine Datenbanktabelle), eine Middleware, die den angemeldeten Benutzer in [request.user] ablegt, Login- und Logout-Views, Berechtigungen, Gruppen und die Administrationsoberfläche, die sie verwaltet. Sie speichert den angemeldeten Benutzer in seiner Session (siehe das Kapitel über Gültigkeitsbereiche), was für eine Webanwendung die einfachste Lösung ist. Die Fallstudie dagegen verwendet in allen ihren Versionen ([ASP.NET Core MVC], [Spring MVC], [NestJS], [Flask], [Laravel], [Symfony]) ein JWT-Token (JSON Web Token), das wir auch hier einsetzen: Nach dem Login 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 des signierten Cookies in Beispiel 23). Das Token wird in einem Cookie gespeichert; der Browser sendet es bei jedem Request zurück; der Server prü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 prüfen.
Die Benutzer der Fallstudie stehen in einer eigenen Tabelle, [users], und nicht in [django.contrib.auth]; die Token selbst haben in [django.contrib.auth] keinen Platz. Wir setzen die Authentifizierung daher selbst um, mit Werkzeugen, die wir bereits kennen, was den Vorteil hat, dass alles transparent bleibt:
- Eine Middleware (Beispiel 03) bestimmt bei jedem Request anhand des Tokens in seinem Cookie, wer der Benutzer ist, und legt ihn im Request ab ([request.user], Beispiel 12). Der Rest der Anwendung sieht nur dieses Ergebnis;
- Dekoratoren (Beispiel 08) schützen die Views: [@login_required], [@role_required("ADMIN")];
- Passwörter werden mit den Hash-Funktionen von [Django] geprüft ([django.contrib.auth.hashers], die ohne den Rest der Anwendung [auth] verwendet werden können);
- Zugriffsverweigerungen sind [PermissionDenied]-Exceptions, die von einer View [handler403] in eine Fehlerseite umgewandelt werden (Beispiel 24);
- Login-Versuche werden mithilfe des Caches von [Django] begrenzt (Beispiel 27).
Die Erstellung und Prüfung der Token übernimmt die Bibliothek [PyJWT], die in [Python] am häufigsten verwendete, die durch die Beispieldatei [requirements.txt] installiert wird (sie wird unter dem Namen [jwt] importiert). (Es gibt JWT-Token-Bibliotheken für [Django], etwa [djangorestframework-simplejwt], die für APIs gedacht sind; für eine Webanwendung genügen wenige Zeilen, und sie veranschaulichen den Mechanismus besser.)
8.1. Beispiel 25: Login, Token, geschützte Seite
8.1.1. Konfiguration: config/settings.py
Das Token wird mit einem geheimen Schlüssel signiert, der im Code einer Produktivanwendung nicht fest eingetragen sein darf. Es ist an der Zeit, die Konfiguration wirklich vom Code zu trennen:
- Zeilen 21–26: zwei Middleware-Komponenten: der Anti-CSRF-Schutz (Beispiel 18), gefolgt von unserer Authentifizierungs-Middleware;
- Zeilen 43–44: zwei anwendungsspezifische Einstellungen (Beispiel 06): der Schlüssel, der die Token signiert, und ihre Lebensdauer in Minuten. [os.environ.get("NAME", default)] setzt den Wert der Umgebungsvariablen auf [NAME] , falls sie existiert; andernfalls wird der Standardwert verwendet. Während der Entwicklung genügt der in die Datei geschriebene Wert; in der Produktion wird der echte Schlüssel über eine Umgebungsvariable bereitgestellt, die Vorrang hat. Eine Umgebungsvariable ist immer ein String: [int] wandelt die Dauer in eine ganze Zahl um.
Der Standard verlangt für den verwendeten Algorithmus (HMAC-SHA256) einen Schlüssel von mindestens 256 Bit, also 32 Byte: [PyJWT] gibt bei einem kürzeren Schlüssel eine Warnung aus. Unter [Linux] oder [macOS] würde die Anwendung wie folgt mit einem anderen Schlüssel gestartet:
und für [Windows] ([PowerShell]):
Der geheime Schlüssel von [Django] selbst, [SECRET_KEY], erforderte dieselbe Behandlung; die Fallstudie liest alle ihre Geheimnisse aus einer Datei namens [.env] oder aus der Umgebung.
8.1.2. Benutzer: security/users.py
- Zeilen 7–17: ein Benutzer: das Login, der Name, die Rolle, der Passwort-Hash und der Inhalt des Tokens, das den Benutzer authentifiziert hat (leer bei einem Benutzer aus der Benutzerliste). Die letzten beiden Attribute haben einen Standardwert. Bei einem Dictionary darf dieser Wert nicht als [claims: dict = {}] geschrieben werden: Dieses Dictionary würde nur einmal erstellt und von allen Objekten geteilt. [field(default_factory=dict)] weist [@dataclass] an, für jedes neue Objekt [dict()] aufzurufen;
- Zeilen 20–24: Ein Server speichert niemals ein Passwort, auch nicht verschlüsselt: Würde die Datenbank gestohlen, wären auch die Passwörter gestohlen (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 dem Hash nicht auf das Passwort zurückschließen. Um ein eingegebenes Passwort zu prüfen, berechnet man seinen Hash und vergleicht ihn mit dem in der Datenbank gespeicherten;
- Zeilen 25–30: zwei Testbenutzer, fest im Programm eingetragen (Beispiel 28 und die Fallstudie befüllen damit eine Datenbank): für jedes Login der Name, die Rolle und der Passwort-Hash. Der Hash wurde ein für alle Mal mit der Funktion [make_password] von [Django] berechnet (der Befehl steht in einem Kommentar), und zwar mit dem Standardalgorithmus PBKDF2-SHA256. Der gespeicherte Hash besteht aus vier Teilen, getrennt durch [$]: den Algorithmus ([pbkdf2_sha256]), die Anzahl der Iterationen, das Salt und schließlich das Ergebnis. Ein guter Algorithmus zum Hashen von Passwörtern hat zwei Eigenschaften. Er ist absichtlich langsam, mit einstellbarem Grad der Langsamkeit: PBKDF2 wendet die Funktion SHA-256 1.500.000-mal an, was einige hundert Millisekunden dauert – für einen Benutzer nicht wahrnehmbar, für einen Angreifer, der Milliarden von Passwörtern ausprobieren will, aber sehr kostspielig; [Django] erhöht diese Zahl mit jeder Version, um mit der Rechenleistung Schritt zu halten (seine Anwendung [auth] aktualisiert dann bei Logins die gespeicherten Hashes); ältere Hashes bleiben prüfbar, da sie ihre Iterationszahl enthalten. Er ist gesalzen: Ein zufällig erzeugtes Salt wird vor dem Hashen mit dem Passwort vermischt und im Hash selbst gespeichert; zwei Benutzer mit demselben Passwort haben somit unterschiedliche Hashes. [Django] kann auch [Argon2] und [bcrypt] verwenden (Einstellung [PASSWORD_HASHERS]); die Fallstudie, deren Datenbank [bcrypt]-Hashes enthält, verwendet direkt die Bibliothek [bcrypt];
- Zeilen 33–38: der Benutzer eines Logins oder [None]. [not in] prüft das Fehlen eines Schlüssels; die Zuweisung [name, role, password_hash = ...] entpackt ein Tupel: Jede Variable erhält das entsprechende Element.
8.1.3. Der Authentifizierungsservice: security/auth.py
- Zeile 5: die Bibliothek [PyJWT];
- Zeile 7: die Funktion [check_password] von [Django];
- Zeile 13: der Name des Cookies, das das Token trägt;
- Zeilen 19–25: Prüfung von Benutzername und Passwort. [check_password] liest den Algorithmus, die Anzahl der Iterationen und das Salt aus dem gespeicherten Hash, hasht damit das eingegebene Passwort und vergleicht die beiden Ergebnisse (in konstanter Zeit, siehe Beispiel 23). Ein unbekannter Benutzername und ein falsches Passwort liefern dasselbe Ergebnis, [None];
- Zeilen 29–39: Erzeugung des Tokens. Sein Inhalt ist ein Dictionary mit Claims über den Benutzer. Einige haben standardisierte Namen: [sub] (subject), die Kennung des Benutzers; [iat] (issued at), das Erstellungsdatum; [exp] (expiration), das Ablaufdatum. Die Datumsangaben werden in Sekunden seit dem 1. Januar 1970 ausgedrückt ([time.time()] liefert diese Zahl samt Nachkommastellen, die [int] weglässt). 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 44–50: Prüfung des Tokens. [jwt.decode] prüft die Signatur und das Ablaufdatum und gibt dann die Claims zurück. Jede Auffälligkeit (gefälschtes, abgelaufenes oder fehlerhaftes Token) löst eine Exception der Klasse [jwt.InvalidTokenError] oder einer ihrer Unterklassen aus, die der Block [except] abfängt. Der Parameter [algorithms] gibt die Liste der akzeptierten Algorithmen an: Ein Token, das einen anderen Algorithmus (oder gar keinen, [none]) angibt, würde abgelehnt. Das gültige Token wird zu einem [User] ohne Hash, zusammen mit seinen Claims (Parameter namens [claims]).
8.1.4. Die Authentifizierungs-Middleware: security/middleware.py
Bei jedem Request, vor der View:
- Zeile 14: Standardmäßig ist der Besucher anonym: [request.user] ist gleich [None];
- Zeilen 15–17: Enthält der Request das Token-Cookie, wird das Token geprüft;
- Zeilen 18–23: ein ungültiges Token (abgelaufen oder gefälscht): Die Middleware antwortet selbst, ohne den Rest der Verarbeitungskette aufzurufen, indem sie auf die Login-Seite umleitet, und nutzt die Gelegenheit, das Cookie zu löschen: [delete_cookie] fügt der Antwort ein leeres, bereits abgelaufenes Cookie hinzu;
- Zeile 24: ein gültiges Token: Der Benutzer, den es identifiziert, wird im Request abgelegt. Der Benutzer wird nicht in der Benutzerliste nachgeschlagen: Das Token genügt, da es signiert ist.
Die Middleware verweigert keinen Zugriff: Sie ermittelt, wer der Benutzer ist, oder stellt fest, dass er anonym ist. Das ist die Authentifizierung. Verweigerungen werden von der Zugriffskontrolle behandelt.
8.1.5. Zugriffskontrolle: security/decorators.py
Der Dekorator [@login_required] umhüllt eine View (Beispiel 08): Ist der Benutzer anonym, antwortet er mit einer Umleitung auf die Login-Seite, ohne die View aufzurufen; andernfalls ruft er die View auf. [django.contrib.auth] stellt einen Dekorator mit demselben Namen und derselben Aufgabe bereit, [@login_required], der auf seinem eigenen [request.user] beruht.
8.1.6. Views: accounts/views.py
- Zeilen 19–22: Das im Template von Hand geschriebene Login-Formular wird, wie alle POST-Formulare, durch die Middleware [CsrfViewMiddleware] vor gefälschten Requests geschützt (Beispiel 18);
- Zeilen 23–28: der Login-Vorgang. Schlägt der Login fehl, wird das Formular mit dem eingegebenen Benutzernamen und einer bewusst vagen Meldung erneut angezeigt: Die Angabe „unbekannter Benutzername“ würde einem Angreifer verraten, welche Benutzernamen existieren;
- Zeilen 32–35: Bei Erfolg wird das Token in einem Cookie gespeichert und der Benutzer auf die geschützte Seite umgeleitet (PRG-Muster). Das Cookie ist [httponly]: Das [JavaScript] der Seite kann es nicht lesen, was das Token vor dem Einschleusen von Skripten (XSS) schützt; es ist [SameSite=Lax]: Der Browser sendet es nicht bei einem POST-Request, der von einer anderen Website stammt, was die Anwendung vor CSRF-Angriffen schützt; seine Lebensdauer ([max_age], in Sekunden) 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 40–44: Das Abmelden löscht das Cookie ([delete_cookie]). Das ist eine POST-View, die durch das 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 Token: Das Token selbst bleibt bis zu seinem Ablauf gültig. Wer eine Kopie davon angefertigt hat, könnte es weiterhin verwenden. Deshalb ist seine Lebensdauer begrenzt;
- Zeilen 48–51: die geschützte Seite. Der Dekorator [@login_required] stellt sicher, dass [request.user] nicht [None] ist.
8.1.7. Templates
- Zeile 6: das Anti-CSRF-Token des Formulars;
- Zeile 9: Das eingegebene Login wird nach einem Fehlschlag erneut angezeigt (eine fehlende Variable wird als leerer String ausgegeben).
- Zeilen 8–10: der Inhalt des Tokens, zur Veranschaulichung angezeigt. [items] durchläuft die (Schlüssel, Wert)-Paare des Dictionarys (Beispiel 18);
- Zeilen 13–16: das Abmelden über ein Formular, das aus einer einzigen Schaltfläche besteht.
8.1.8. Ausführung
Fordern wir die geschützte Seite [/profile] an, ohne angemeldet zu sein:
Ein falsches Passwort:

Erfolgreicher Login. Mit [curl]müssen Sie zunächst das Formular anfordern, um das Anti-CSRF-Token und sein Cookie zu erhalten (Beispiel 18), und dann das Formular absenden, wobei Sie das erhaltene Cookie beibehalten:
Das Token besteht aus drei Teilen, die durch Punkte getrennt und jeweils in Base64 kodiert sind: dem Header, dem Inhalt und der Signatur. Die ersten beiden Teile lassen sich ohne Schlüssel dekodieren:
(Das [é] ist in seiner maskierten JSON-Form geschrieben, [\u00e9].) Die Gültigkeitsdauer beträgt 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]***, kodiert 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 leere Wert 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 auf die Rolle ADMIN beschränkt ist. Es werden nur neue oder geänderte Dateien angezeigt.
8.2.1. Rollen: security/users.py
- Zeilen 20–21: Die Methode [has_role] bestimmt anhand der Rollenhierarchie, ob der Benutzer eine Rolle besitzt;
- Zeilen 24–26: eine Property (Beispiel 14) für Templates: DTL kann keine Methode mit Parameter aufrufen ([has_role("ADMIN")]), aber eine Property lesen ([user.is_admin]);
- Zeilen 30–33: die Rollenhierarchie: für jede Rolle die Menge ([set], in geschweiften Klammern) der Rollen, die sie umfasst. Die Rolle [ADMIN] schließt die Rolle [USER] ein: Ein Administrator hat somit alle Rechte eines Benutzers, ohne dass ihm beide Rollen zugewiesen werden müssen. Die Methode [has_role] kann [HIERARCHY] verwenden, obwohl diese weiter unten in der Datei definiert ist: Der Name wird erst beim Aufruf nachgeschlagen, wenn das gesamte Modul geladen ist.
8.2.2. Zugriffskontrolle: security/decorators.py
- Zeilen 23–32: ein parametrisierter Dekorator (Beispiel 08), [@role_required("ADMIN")]. Der Wrapper ist selbst von [@login_required] umhüllt: Ein anonymer Besucher wird zuerst auf die Login-Seite geschickt; ein authentifizierter Benutzer, der die verlangte Rolle nicht besitzt, löst die Exception [PermissionDenied] aus (Beispiel 24), was zu einem 403-Fehler (Forbidden) führt.
Der Unterschied zwischen den beiden Verweigerungsfällen ist bedeutsam: Ein anonymer Besucher, der eine geschützte Seite anfordert, wird auf die Login-Seite umgeleitet; ein authentifizierter Benutzer, der die verlangte Rolle nicht besitzt, erhält einen 403-Fehler – ein erneutes Anmelden wäre zwecklos, da er bereits authentifiziert ist.
8.2.3. Zugriffsverweigerung: security/errors.py und config/urls.py
Die View [access_denied] ist die 403-Fehler-View der Anwendung (Variable [handler403], Beispiel 24): [Django] ruft sie bei jeder [PermissionDenied]-Exception auf, sowohl im Debug- als auch im Produktionsmodus. Die Seite [templates/errors/403.html] ist eine Standard-Fehlerseite mit einem Link zurück zum Profil. Ohne diese View würde der Benutzer die schlichte 403-Seite von [Django] sehen („403 Forbidden“).
8.2.4. Views: accounts/views.py
- Zeilen 55–58: die Administrationsseite, geschützt durch den Dekorator [@role_required("ADMIN")]. Die View selbst führt keine Prüfungen durch.
Bei Regeln, die feiner sind als eine Rolle („ein Benutzer darf nur seine eigenen Termine bearbeiten“), führt die View die Prüfung selbst durch und löst bei Bedarf [PermissionDenied] aus. Die Fallstudie liefert Beispiele dafür.
8.2.5. Die Profil-View
- Zeilen 7–11: Die Property [is_admin] erlaubt es, die Seite an die Rolle anzupassen. So wird verhindert, dass ein Link angezeigt wird, der in einer realen Anwendung zu einem Fehler führen würde (hier bleibt der Link für Marie bestehen, um das Experiment durchzuführen); das ist jedoch nur eine Bequemlichkeit: Der eigentliche Schutz liegt in der View.
8.2.6. Ausführung
Marie mit der Rolle USER folgt dem Link zur Administrationsseite:

Der Administrator hat dagegen 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:
Views einzeln zu schützen hat einen Fehler: 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 Zugriffskontroll-Middleware geschützt, und nur einige wenige URL-Seiten (die Login-Seite, die Registrierungsseite) sind davon ausgenommen.
8.3. Beispiel 27: CAPTCHA und Begrenzung der Versuche
Ein Login-Formular ist ein Angriffsziel: Ein Programm kann Tausende von Passwörtern pro Minute ausprobieren (Brute-Force-Angriff). Zwei Schutzmaßnahmen ergänzen einander:
- 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 zu lesen ist;
- eine Begrenzung der Versuche: Nach drei fehlgeschlagenen Versuchen wird die IP-Adresse des Clients eine Minute lang blockiert.
Beispiel 27 baut auf Beispiel 25 auf und fügt diese beiden Sicherheitsmaßnahmen hinzu:
8.3.1. Das CAPTCHA-Bild: security/captcha_drawing.py
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 in der Seite darstellt. Dieses Modul ist reines [Python], ohne etwas Spezifisches für [Django]: Es ist die [Python]-Implementierung der Klassen aus den Versionen [Laravel] und [Symfony] dieses Kurses.
- Zeilen 13–46: eine minimalistische „Schrift“: Jedes Zeichen ist eine Liste von Strichen, und jeder Strich ist eine Liste von x- und y-Koordinaten in einem 4 × 6-Raster. Leicht zu verwechselnde Zeichen ([0] und [O], [1], [I] und [L]) sind ausgeschlossen;
- Zeilen 53–58: ein Zufallstext, gezogen aus den Zeichen der Schrift ([list(FONT)]: die Liste der Schlüssel des Dictionarys). Das Modul [random] von [Python] erzeugt vorhersagbare Zahlenfolgen (wer einige Werte kennt, kann die nächsten erraten): Es eignet sich für Simulationen, nicht für Sicherheit. Das Modul [secrets] ist ein kryptografischer, unvorhersagbarer Generator: [secrets.choice] zieht ein Element aus einer Liste, und [secrets.SystemRandom] stellt die Funktionen von [random] ([uniform]: eine Gleitkommazahl zwischen zwei Grenzen) auf Grundlage dieses Generators bereit. [for _ in range(length)] wiederholt [length]-mal; der Name [_] kennzeichnet eine Variable, die nicht verwendet wird;
- Zeilen 70–102: die Zeichnung. Jedes Zeichen wird zufällig vergrößert, gedreht und verschoben, und jeder seiner Punkte wird leicht versetzt; jeder Strich wird zu einem SVG-Element [<path>] ([M]: Verschiebung, [L]: Linie). Drei Kurven ([C]: Bézierkurve) durchqueren das Bild, um Erkennungsprogramme zu stören. In einem f-String schreibt [{px:.1f}] eine Zahl mit einer Nachkommastelle; ein bedingter Ausdruck kann eingefügt werden ([{'M' if k == 0 else 'L'}]). Das Modul [math] liefert [cos] und [sin]. Die Teile des SVG werden mit [join] zusammengesetzt.
8.3.2. Der CAPTCHA-Service: security/captchas.py
- Zeile 6: der Cache von [Django]: ein Speicher für Schlüssel-Wert-Paare, den alle Module gemeinsam nutzen. Wo diese Werte abgelegt werden, hängt von der Einstellung [CACHES] ab (siehe unten);
- Zeilen 21–29: ein neues CAPTCHA: eine zufällige Zeichenfolge, eine zufällige, nicht zu erratende Kennung ([secrets.token_hex(12)]: 12 Zufallsbytes, hexadezimal geschrieben, also 24 Zeichen) und das Bild. Für jede Kennung speichert der Server die erwartete Antwort zehn Minuten lang im Cache: Der dritte Parameter von [cache.set] ist die Lebensdauer in Sekunden. 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;
- Zeilen 33–43: die Prüfung. Die erwartete Antwort wird gelesen ([cache.get] liefert [None] für einen fehlenden Schlüssel) und anschließend aus dem Cache entfernt ([cache.delete]): 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 ([casefold] wandelt einen String in Kleinbuchstaben um und behandelt dabei alle Alphabete korrekt) sowie Leerzeichen um die Eingabe ([strip]).
8.3.3. Begrenzung der Versuche: security/limiter.py
Der Limiter zählt die fehlgeschlagenen Versuche eines Clients innerhalb eines festen Zeitfensters: höchstens drei fehlgeschlagene Versuche pro Fenster von 60 Sekunden, gerechnet ab dem ersten Fehlversuch. Jeder Client wird anhand seiner IP-Adresse identifiziert.
- Zeile 13: der Cache-Schlüssel, spezifisch für den Client: [login.127.0.0.1];
- Zeilen 16–20: die Anzahl der Sekunden, die gewartet werden muss, wenn der Client blockiert ist (die Zahl der Fehlschläge hat das Maximum erreicht), sonst 0. Der im Cache gespeicherte Zustand ist ein Dictionary: die Anzahl der Fehlschläge und der Endzeitpunkt des Fensters;
- Zeilen 23–30: ein weiterer Fehlschlag. Gibt es keinen Zustand im Cache, beginnt ein neues Fenster. Der Zustand wird mit einer Lebensdauer neu geschrieben, die am Ende des Fensters abläuft: Der Cache vergisst ihn dann automatisch, und der Client beginnt wieder bei null;
- Zeilen 33–34: Eine erfolgreiche Anmeldung setzt die Fehlschläge zurück.
Dieser zur Veranschaulichung geschriebene Limiter hat eine Schwäche: Zwei gleichzeitige Fehlschläge könnten denselben Zustand lesen und nur als einen zählen. Der Cache von [Django] bietet atomare Operationen ([cache.add], das nur schreibt, wenn der Schlüssel nicht existiert, und [cache.incr], das eine Zahl erhöht), die in der Version der Fallstudie verwendet werden. Es gibt auch fertige Bibliotheken ([django-ratelimit], [django-axes]).
8.3.4. Konfiguration: config/settings.py
- Zeilen 49–53: der Cache der Anwendung. [LocMemCache] speichert Werte im Speicher des Prozesses: Das ist der Standard-Cache von [Django], den wir ausdrücklich hinschreiben, damit er sichtbar ist. Er ist auf den Anwendungsbereich beschränkt (siehe das Kapitel über Gültigkeitsbereiche): Er gehört zum jeweiligen Prozess und geht beim Herunterfahren des Servers verloren. Die Fallstudie verwendet einen in Dateien gespeicherten Cache ([FileBasedCache]), der Neustarts übersteht; in der Produktion würden wir [Redis] ([django.core.cache.backends.redis.RedisCache]) bevorzugen, das von allen Prozessen gemeinsam genutzt wird;
- Zeilen 56–57: die Parameter des Limiters.
8.3.5. Die View: accounts/views.py
- Zeile 25: der Limiter dieses Clients, auf Grundlage seiner IP-Adresse ([REMOTE_ADDR], Beispiel 05);
- Zeilen 27–29: Eine blockierte Adresse wird gar nicht erst angehört;
- Zeilen 31–37: Das CAPTCHA wird vor dem Passwort geprüft; seine Prüfung kostet fast nichts, während der PBKDF2-Hash absichtlich langsam ist. Ein Programm, das das CAPTCHA falsch löst, würde den Server daher nicht belasten. Jeder Fehlschlag – ob beim CAPTCHA oder beim Passwort – wird gezählt. Beim dritten Fehlschlag wird die Adresse bis zum Ende des 60-Sekunden-Fensters blockiert, gerechnet ab dem ersten Fehlschlag;
- Zeile 38: Ein erfolgreicher Login setzt die Fehlschläge zurück;
- Zeilen 46–48: Bei jeder Anzeige des Formulars wird ein neues CAPTCHA erzeugt, auch nach einem Fehlschlag.
8.3.6. Das Template: templates/auth/login.html
- Zeile 18: Das SVG-Bild wird unverändert, ohne Escaping, in die Seite eingefügt (Filter [safe], 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 ([autocomplete="off"]).
8.3.7. Ausführung

Ein falsch abgeschriebener Code:

Nach drei fehlgeschlagenen Versuchen wird die Adresse blockiert:

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