Skip to content

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 weitere Anfrage muss belegen, dass sie 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 Klienten.

Da der Server zustandslos ist (siehe das Kapitel über Gültigkeitsbereiche), muss der Identitätsnachweis jeder Anfrage beiliegen. Dazu dient ein Token namens JWT (*JSON Web Token*): 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 prüft die Signatur. Der Benutzer kann sein Token lesen, aber nicht ändern: Jede Änderung macht die Signatur ungültig. Das ist dasselbe Prinzip wie bei der [Flask]-Session (Beispiel 20), jedoch mit einem standardisierten Format (RFC 7519), das alle Programmiersprachen verstehen, und mit einem im Token eingebetteten Ablaufdatum.

[Flask] hat keinen integrierten Sicherheitsmechanismus, anders als [Spring] ([Spring Security]) oder [ASP.NET Core]. Es gibt Erweiterungen ([Flask-Login], [Flask-JWT-Extended] ...), aber der Mechanismus ist einfach genug, um mit den Werkzeugen der vorherigen Kapitel von Hand geschrieben zu werden, was den Vorteil hat, dass er transparent bleibt:

  • Die Authentifizierung übernimmt eine [before_request]-Funktion (vorheriges Kapitel), die das Token aus dem Cookie holt, prüft und den authentifizierten Benutzer in [g], dem Anfrageobjekt, ablegt;
  • die Autorisierung übernehmen Dekoratoren, die auf die Aktionen angewendet werden ([@login_required], [@role_required("ADMIN")]) und wie der Dekorator [@with_language] in Beispiel 12 aufgebaut sind.

Es werden zwei Bibliotheken verwendet, die von der Datei [requirements.txt] der Beispiele installiert werden: [PyJWT], das Token erzeugt und prüft, und [bcrypt], das Passwörter hasht.

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

25-jwt/
├── app.py
├── auth/
│   ├── security.py
│   ├── service.py
│   └── users.py
├── config.py
├── controllers/
│   ├── auth.py
│   └── profile.py
└── templates/
    ├── auth/
    │   └── login.html
    ├── layout.html
    └── profile/
        └── profile.html

8.1.1. Konfiguration: config.py und app.py

Das Token wird mit einem geheimen Schlüssel signiert, der nicht fest im Code stehen darf. Es ist an der Zeit, die Konfiguration vom Code zu trennen:

1
2
3
4
5
6
# config.py: die Konfiguration der Anwendung, gelesen von app.config.from_pyfile.
# Nur die Variablen in GROSSBUCHSTABEN werden übernommen.

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

Eine [Flask]-Konfigurationsdatei ist einfach ein [Python]-Modul: Ihre Variablen in Großbuchstaben werden zu Schlüsseln von [app.config]. [JWT_SECRET] ist der Schlüssel zum Signieren der Token; der Standard verlangt für den verwendeten Algorithmus (HMAC-SHA256) einen Schlüssel von mindestens 256 Bit, also 32 Byte. [JWT_DURATION_MINUTES] ist die Lebensdauer eines Tokens.

# app.py: die Anwendung von Beispiel 25
from pathlib import Path

from flask import Blueprint, Flask

from auth import security
from auth.service import AuthService
from auth.users import UsersService
from controllers.auth import auth
from controllers.profile import profile

BOOTSTRAP = Path(__file__).resolve().parent.parent / "common" / "bootstrap"


def create_app():
    app = Flask(__name__)
    app.jinja_env.trim_blocks = True
    app.jinja_env.lstrip_blocks = True
    # die Konfiguration: die Datei config.py, dann die Umgebungsvariablen,
    # die mit FLASK_ beginnen (FLASK_JWT_SECRET ersetzt JWT_SECRET)
    app.config.from_pyfile("config.py")
    app.config.from_prefixed_env()
    # die Authentifizierungs-Services
    users = UsersService()
    app.extensions["auth"] = AuthService(users, app.config["JWT_SECRET"],
                                         app.config["JWT_DURATION_MINUTES"])
    app.register_blueprint(Blueprint("bootstrap", __name__, static_folder=BOOTSTRAP,
                                     static_url_path="/bootstrap"))
    app.register_blueprint(auth)
    app.register_blueprint(profile)
    # der Benutzer jeder Anfrage, aus dem Token des Cookies gelesen
    security.register(app)
    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Zeile 21: das Lesen der Konfigurationsdatei, angegeben durch einen Pfad relativ zum Ordner der Anwendung;
  • Zeile 22: das Lesen der Umgebungsvariablen , deren Namen mit [FLASK_] beginnen: [FLASK_JWT_SECRET] ersetzt den Schlüssel [JWT_SECRET] der Datei. Der Wert einer Variablen wird, wann immer möglich, als JSON interpretiert ([FLASK_JWT_DURATION_MINUTES=30] ergibt die ganze Zahl 30). In der Produktion stellt die Umgebung den geheimen Schlüssel bereit, und die Datei enthält nur einen Entwicklungswert;
  • Zeilen 24–26: die beiden Authentifizierungsservices, von denen der zweite den Schlüssel und die Lebensdauer des Tokens erhält;
  • Zeile 32: die Registrierung der [before_request]-Funktion, die das Token liest.

Unter [Linux] oder [macOS] würde die Anwendung wie folgt mit einem anderen Schlüssel gestartet:

FLASK_JWT_SECRET="another-key-of-at-least-thirty-two-characters" python app.py

und unter [Windows] (PowerShell):

$env:FLASK_JWT_SECRET="another-key-of-at-least-thirty-two-characters"
python app.py

8.1.2. Benutzer: auth/users.py

# auth/users.py: die Benutzer, im Speicher (Beispiel 28 und die Fallstudie
# legen sie in einer Datenbank ab)
from dataclasses import dataclass

import bcrypt


@dataclass(frozen=True)
class User:
    login: str
    name: str
    role: str
    password_hash: bytes


# der Hash eines Passworts: bcrypt, mit dem Kostenfaktor 10 (2^10 Runden);
# gensalt erzeugt einen zufälligen "Salt", der im Hash selbst gespeichert wird
def hash_password(password: str) -> bytes:
    return bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=10))


class UsersService:

    def __init__(self):
        # wir speichern NIEMALS ein Passwort, nur seinen Hash
        self._users = {u.login: u for u in (
            User("marie", "Marie Pélissier", "USER", hash_password("marie")),
            User("admin", "Administrator", "ADMIN", hash_password("admin")),
        )}

    def find(self, login: str) -> User | None:
        return self._users.get(login)
  • Zeilen 9–13: ein Benutzer: sein Login, Name, seine Rolle und der Hash seines Passworts. 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 Hashfunktion, einer Einwegfunktion: Man kann den Hash eines Passworts berechnen, aber aus dem Hash kein Passwort zurückgewinnen. Um ein eingegebenes Passwort zu prüfen, berechnet man seinen Hash und vergleicht ihn mit dem gespeicherten;
  • Zeilen 18–19: das Hashen mit dem Algorithmus [bcrypt], der für Passwörter entwickelt wurde. Er hat zwei Besonderheiten. Er ist absichtlich langsam, mit einstellbarer Langsamkeit (der Parameter [rounds] oder Kostenfaktor: 2^10 Berechnungsrunden): einige zehn Millisekunden, für einen Benutzer nicht wahrnehmbar, aber für einen Angreifer, der Milliarden von Passwörtern ausprobieren will, sehr kostspielig. Er verwendet ein Salt: [gensalt] erzeugt zufällig ein Salt, mischt es vor dem Hashen mit dem Passwort und speichert es im Hash selbst; so haben zwei Benutzer mit demselben Passwort unterschiedliche Hashes. [bcrypt] arbeitet mit Bytes: [encode()] wandelt die Zeichenkette in Bytes um ([UTF-8]). Er berücksichtigt nur die ersten 72 Bytes eines Passworts, und Version 5 der Bibliothek weist längere Passwörter zurück (die Fallstudie berücksichtigt das);
  • Zeilen 26–28: zwei Testbenutzer, im Arbeitsspeicher abgelegt und in einem Wörterbuch organisiert, das bei der Verarbeitung aufgebaut wird ([{key: value for ...}]). Beispiel 28 und die Fallstudie speichern sie in einer Datenbank.

8.1.3. Der Authentifizierungsservice: auth/service.py

# auth/service.py: die Prüfung der Passwörter und der JWT-Tokens
from datetime import datetime, timedelta, timezone

import bcrypt
import jwt
from flask import current_app

from auth.users import User, UsersService

# der Name des Cookies, das das Token trägt
COOKIE = "token"


class AuthService:

    def __init__(self, users: UsersService, secret: str, duration_minutes: int):
        self._users = users
        self._secret = secret
        self.duration = timedelta(minutes=duration_minutes)

    # der Benutzer oder None, wenn der Login unbekannt oder das Passwort falsch ist.
    # checkpw hasht das eingegebene Passwort mit dem Salt des gespeicherten Hashs
    # und vergleicht dann die beiden Ergebnisse
    def validate(self, login: str | None, password: str | None) -> User | None:
        if not login or password is None:
            return None
        user = self._users.find(login)
        if user is None or not bcrypt.checkpw(password.encode(),
                                              user.password_hash):
            return None
        return user

    # das JWT-Token des Benutzers, mit dem geheimen Schlüssel signiert (HMAC-SHA256)
    def create_token(self, user: User) -> str:
        now = datetime.now(timezone.utc)
        # der Inhalt des Tokens: die "Claims" (Aussagen über den Benutzer)
        claims = {
            "sub": user.login,
            "name": user.name,
            "role": user.role,
            "iat": now,
            "exp": now + self.duration,
        }
        return jwt.encode(claims, self._secret, algorithm="HS256")

    # die Claims eines Tokens, dessen Signatur und Ablaufdatum
    # gültig sind; sonst None (gefälschtes, abgelaufenes oder unlesbares Token)
    def check(self, token: str) -> dict | None:
        try:
            return jwt.decode(token, self._secret, algorithms=["HS256"])
        except jwt.InvalidTokenError:
            return None


def auth_service() -> AuthService:
    return current_app.extensions["auth"]
  • Zeilen 24–31: die Prüfung von Benutzername und Passwort. [bcrypt.checkpw] 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, [None];
  • Zeilen 34–44: das Erzeugen des Tokens. Sein Inhalt ist ein Wörterbuch von Claims über den Benutzer. Einige haben standardisierte Namen: [sub] (*subject*), die Kennung des Benutzers; [iat] (*issued at*), das Erstellungsdatum; [exp] (*expiration*), das Ablaufdatum. Die übrigen sind frei wählbar: 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). Datumsangaben müssen zeitzonenbehaftete Datumsangaben sein: [datetime.now(timezone.utc)];
  • Zeilen 48–30: die Prüfung des Tokens. [jwt.decode] prüft die Signatur und das Ablaufdatum und liefert dann die Claims. Jede Auffälligkeit (gefälschtes, abgelaufenes oder fehlerhaftes Token) löst eine Ausnahme aus der Familie [InvalidTokenError] aus. Der Parameter [algorithms] legt die akzeptierten Algorithmen fest: Ohne ihn könnte ein Angreifer ein Token erstellen, das einen anderen Algorithmus (oder gar keinen, [none]) angibt.

8.1.4. Sicherheit: auth/security.py

# auth/security.py: der Benutzer jeder Anfrage und der Schutz der Actions
from functools import wraps

from flask import g, redirect, request, url_for

from auth.service import COOKIE, auth_service


def register(app):

    # vor jeder Action: das Token des Cookies -> g.user (seine Claims) oder None
    @app.before_request
    def read_token():
        token = request.cookies.get(COOKIE)
        g.user = auth_service().check(token) if token else None


# ein Dekorator: die Action wird nur für einen authentifizierten Benutzer ausgeführt;
# andernfalls geht es zur Login-Seite
def login_required(action):
    @wraps(action)
    def protected_action(*args, **kwargs):
        if g.user is None:
            response = redirect(url_for("auth.form"))
            # ein vorhandenes, aber ungültiges Cookie (abgelaufenes, gefälschtes Token): wir löschen es
            if COOKIE in request.cookies:
                response.delete_cookie(COOKIE)
            return response
        return action(*args, **kwargs)

    return protected_action
  • Zeilen 13–15: Vor jeder Aktion wird das Token des Cookies geprüft; [g.user] enthält die Claims eines gültigen Tokens oder [None]. Diese Funktion weist nichts zurück: Sie stellt fest, wer der Benutzer ist. Das ist die Authentifizierung;
  • Zeilen 20–31: der Dekorator, der einen authentifizierten Benutzer verlangt. Bei einem anonymen Besucher liefert er nicht die Aktion zurück, sondern leitet auf die Anmeldeseite um. Hat der Browser ein Cookie gesendet, bedeutet das, dass das Token ungültig ist (abgelaufen oder gefälscht): Wir nutzen die Gelegenheit, es zu löschen ([delete_cookie] sendet ein leeres, bereits abgelaufenes Cookie).

8.1.5. Die Controller

# controllers/auth.py: Login und Logout
from flask import Blueprint, redirect, render_template, request, url_for

from auth.service import COOKIE, auth_service

auth = Blueprint("auth", __name__)


@auth.get("/")
def home():
    return redirect(url_for("profile.display"))


@auth.get("/login")
def form():
    return render_template("auth/login.html")


@auth.post("/login")
def login():
    login = request.form.get("login")
    user = auth_service().validate(login, request.form.get("password"))
    if user is None:
        # eine bewusst vage Meldung: wir sagen nicht, ob es der Login oder das Passwort ist
        return render_template("auth/login.html", login=login,
                               error="Incorrect login or password.")
    response = redirect(url_for("profile.display"))
    # 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 zusammen mit dem Ablauf des Tokens (max_age)
    response.set_cookie(COOKIE, auth_service().create_token(user), httponly=True,
                        samesite="Lax", max_age=auth_service().duration)
    return response


# Abmelden: nur per POST (ein einfacher Link, auf einer anderen Website platziert, könnte den Benutzer
# nicht ohne dessen Wissen abmelden); wir löschen das Cookie
@auth.post("/logout")
def logout():
    response = redirect(url_for("auth.form"))
    response.delete_cookie(COOKIE)
    return response
  • Zeilen 20–26: die Anmeldung. Schlägt sie 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 27–32: Bei Erfolg wird das Token in einem Cookie gespeichert, mit einer Umleitung auf die geschützte Seite (PRG-Muster). Das Cookie ist [httponly]: Das [JavaScript] der Seite kann es nicht lesen, was das Token vor Skript-Injektion (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 ([max_age], das ein [timedelta] akzeptiert) entspricht der des Tokens. In der Produktion würden wir bei HTTPS [secure=True] hinzufügen: Das Cookie würde dann nie über eine unverschlüsselte Verbindung gesendet;
  • Zeilen 38–41: Das Abmelden löscht das Cookie. Dies ist eine POST-Aktion: Ein einfacher Link auf [/logout], der auf einer anderen Website oder in einem Bild platziert wird, kann den Benutzer nicht ohne sein Wissen abmelden. Beachten Sie eine Einschränkung von Token: Das Token selbst bleibt gültig, bis es abläuft. Wer eine Kopie davon angefertigt hat, könnte es weiterhin verwenden. Deshalb ist ihre Lebensdauer begrenzt.
# controllers/profile.py: eine Seite, die authentifizierten Benutzern vorbehalten ist
from flask import Blueprint, g, render_template

from auth.security import login_required

profile = Blueprint("profile", __name__)


@profile.get("/profile")
@login_required
def display():
    # g.user: die Claims des Tokens, bereits geprüft (siehe auth/security.py)
    return render_template("profile/profile.html", name=g.user["name"],
                           admin=g.user["role"] == "ADMIN", claims=g.user)
  • Zeile 10: Die Seite ist geschützt;
  • Zeile 13: Die Aktion verwendet [g.user] und stellt sicher, dass es nicht [None] ist.

8.1.6. Die Views

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ login or '' }}" 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>
  {% 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>
{% endblock %}
  • Zeile 8: Das eingegebene Login wird nach einem Fehlschlag erneut angezeigt; der Ausdruck [login or ''] ergibt eine leere Zeichenkette, wenn [login] [None] ist (oder fehlt).
{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Hello {{ name }}</h1>
  <p>Your role: <b>{{ "administrator" if admin else "user" }}</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    {# eine Schleife über ein Dictionary: items() liefert die Paare (key, value) #}
    {% for key, value in claims.items() %}
    <tr><td><code>{{ key }}</code></td><td>{{ value }}</td></tr>
    {% endfor %}
  </table>
  {# Abmelden: ein POST-Formular, reduziert auf seinen Button #}
  <form method="post" action="/logout">
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
{% endblock %}
  • Zeilen 9–11: der Inhalt des Tokens, zur Veranschaulichung angezeigt;
  • Zeilen 14–16: die Abmeldung über ein Formular, das auf einen einzigen Button reduziert ist.

8.1.7. Ausführung

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

curl -i http://localhost:5000/profile
1
2
3
4
5
HTTP/1.1 302 FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 199
Location: /login
...

Ein falsches Passwort:

Image

Die Anmeldung war erfolgreich. Mit [curl] speichern wir das empfangene Cookie in einer Datei:

curl -i -c token.txt -d "login=marie&password=marie" http://localhost:5000/login
1
2
3
4
5
6
HTTP/1.1 302 FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 203
Location: /profile
Set-Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJtYXJpZSIsIm5hbWUiOiJNYXJpZSBQXHUwMGU5bGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwNDMwMDE4LCJleHAiOjE3OTA0MzM2MTh9.5jkKhOHitXj6dsXqgVx85QQIovkt2YB_oygSS-68jiE; Expires=Sat, 26 Sep 2026 14:40:18 GMT; Max-Age=3600; HttpOnly; Path=/; SameSite=Lax
...

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

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

Datumsangaben werden in Sekunden seit dem 1. Januar 1970 ausgedrückt; der Ablaufzeitpunkt liegt eine Stunde 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=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.<modified content>.5jkKhOHitXj6dsXqgVx85QQIovkt2YB_oygSS-68jiE" http://localhost:5000/profile
1
2
3
4
5
6
HTTP/1.1 302 FOUND
Content-Type: text/html; charset=utf-8
Content-Length: 199
Location: /login
Set-Cookie: token=; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Max-Age=0; Path=/
...

Das gefälschte Token wird abgelehnt und gelöscht. Um eine gültige Signatur zu erzeugen, müsste man den geheimen Schlüssel kennen – daher die Bedeutung, 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. Ein Dekorator mit Parameter: auth/security.py

# auth/security.py: der Benutzer jeder Anfrage und der Schutz der Actions
from functools import wraps

from flask import abort, g, redirect, request, url_for

from auth.service import COOKIE, auth_service


def register(app):

    # vor jeder Action: das Token des Cookies -> g.user (seine Claims) oder None
    @app.before_request
    def read_token():
        token = request.cookies.get(COOKIE)
        g.user = auth_service().check(token) if token else None


# ein Dekorator: die Action wird nur für einen authentifizierten Benutzer ausgeführt;
# andernfalls geht es zur Login-Seite
def login_required(action):
    @wraps(action)
    def protected_action(*args, **kwargs):
        if g.user is None:
            response = redirect(url_for("auth.form"))
            # ein vorhandenes, aber ungültiges Cookie (abgelaufenes, gefälschtes Token): wir löschen es
            if COOKIE in request.cookies:
                response.delete_cookie(COOKIE)
            return response
        return action(*args, **kwargs)

    return protected_action


# ein Dekorator MIT PARAMETER: @role_required("ADMIN"). role_required("ADMIN") gibt
# den eigentlichen Dekorator zurück, der die Action erhält. Er wird NACH (unter)
# @login_required verwendet: der Benutzer ist dann zwangsläufig authentifiziert
def role_required(role: str):
    def decorator(action):
        @wraps(action)
        def protected_action(*args, **kwargs):
            if g.user["role"] != role:
                abort(403)  # Zugriff verweigert
            return action(*args, **kwargs)

        return protected_action

    return decorator
  • Zeilen 37–47: [@role_required("ADMIN")] hat einen Parameter. Der Ausdruck nach [@] wird zuerst ausgewertet: [role_required("ADMIN")] liefert eine Funktion, [decorator], die der eigentliche Dekorator ist und auf die Aktion angewendet wird. Wir haben also drei verschachtelte Funktionen: [role_required] erhält die Rolle, [decorator] erhält die Aktion, und [protected_action] erhält die Parameter der Anfrage und erledigt die Arbeit. Jede hat Zugriff auf die Variablen der Funktionen, die sie enthalten ([role], [action]);
  • Zeile 42: Ein authentifizierter Benutzer, der nicht die verlangte Rolle hat, erhält einen 403-Fehler (*Forbidden*). Das unterscheidet sich deutlich vom anonymen Benutzer, der auf die Anmeldeseite umgeleitet wird: Eine Anmeldung wäre zwecklos, da der Benutzer bereits authentifiziert ist.

8.2.2. Der Controller: controllers/admin.py

# controllers/admin.py: eine Seite, die der Rolle ADMIN vorbehalten ist
from flask import Blueprint, g, render_template

from auth.security import login_required, role_required

admin = Blueprint("admin", __name__)


# die Dekoratoren werden von unten nach oben angewendet: role_required umhüllt die Action,
# dann umhüllt login_required das Ganze. Zur Laufzeit ist es daher
# login_required, das ZUERST prüft, ob der Benutzer authentifiziert ist
@admin.get("/admin")
@login_required
@role_required("ADMIN")
def display():
    return render_template("admin/admin.html", name=g.user["name"])
  • Zeilen 12–14: Dekoratoren werden von unten nach oben angewendet: [role_required] umhüllt die Aktion, danach umhüllt [login_required] das gesamte Gebilde. Zur Laufzeit ist die Reihenfolge umgekehrt: Die äußere Hülle, [login_required], wird zuerst ausgeführt. Wenn also [role_required] läuft, ist der Benutzer zwangsläufig authentifiziert, und [g.user] ist nicht [None].

8.2.3. Die Fehlerseite: app.py

# app.py: die Anwendung von Beispiel 26
from pathlib import Path

from flask import Blueprint, Flask, render_template

from auth import security
from auth.service import AuthService
from auth.users import UsersService
from controllers.admin import admin
from controllers.auth import auth
from controllers.profile import profile

BOOTSTRAP = Path(__file__).resolve().parent.parent / "common" / "bootstrap"


def create_app():
    app = Flask(__name__)
    app.jinja_env.trim_blocks = True
    app.jinja_env.lstrip_blocks = True
    # die Konfiguration: die Datei config.py, dann die Umgebungsvariablen,
    # die mit FLASK_ beginnen (FLASK_JWT_SECRET ersetzt JWT_SECRET)
    app.config.from_pyfile("config.py")
    app.config.from_prefixed_env()
    # die Authentifizierungs-Services
    users = UsersService()
    app.extensions["auth"] = AuthService(users, app.config["JWT_SECRET"],
                                         app.config["JWT_DURATION_MINUTES"])
    app.register_blueprint(Blueprint("bootstrap", __name__, static_folder=BOOTSTRAP,
                                     static_url_path="/bootstrap"))
    app.register_blueprint(auth)
    app.register_blueprint(profile)
    app.register_blueprint(admin)
    # der Benutzer jeder Anfrage, aus dem Token des Cookies gelesen
    security.register(app)

    # unzureichende Rolle: abort(403) (siehe auth/security.py) -> unsere Fehlerseite
    @app.errorhandler(403)
    def access_denied(e):
        return render_template("error.html", code=403), 403

    return app


if __name__ == "__main__":
    create_app().run(port=5000, debug=True)
  • Zeilen 37–39: Ein für einen bestimmten Code – den Fehler 403 – registrierter Fehlerbehandler zeigt unsere Seite an.
1
2
3
4
5
6
7
8
9
{% extends "layout.html" %}

{% block content %}
  <div class="alert alert-danger">
    <h1 class="h4">Error {{ code }}</h1>
    <p class="mb-0">{{ "Access denied: this page is reserved for administrators." if code == 403 else "An error occurred." }}</p>
  </div>
  <p><a href="/profile">Back to the profile</a></p>
{% endblock %}

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, gefolgt von einem anonymen Besucher:

curl -i -b token.txt http://localhost:5000/admin
curl -i http://localhost:5000/admin
HTTP/1.1 403 FORBIDDEN
Content-Type: text/html; charset=utf-8
Content-Length: 492
...
  <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
Content-Type: text/html; charset=utf-8
Content-Length: 199
Location: /login

Das Schützen der Aktionen einzeln hat einen Haken: Ein einziges Versehen öffnet eine Seite für alle. Die Fallstudie kehrt diese Logik um: Alle Aktionen sind standardmäßig geschützt, und ein Dekorator [@public] kennzeichnet die wenigen Ausnahmen (die Anmeldeseite, die Registrierung).

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 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 (ohne die Administrationsseite) und fügt diese beiden Sicherheitsmaßnahmen hinzu.

8.3.1. Das CAPTCHA-Bild: auth/captcha_drawing.py

# auth/captcha_drawing.py: die Zeichnung eines CAPTCHAs, ein SVG-Bild (XML-Text),
# von Hand erstellt
import math
import secrets

WIDTH = 150
HEIGHT = 50

# secrets: ein "kryptografischer" Zufallszahlengenerator, unvorhersehbar
# (anders als das Modul random, dessen Folge erraten werden könnte)
_random = secrets.SystemRandom()

# Die "Schrift": jedes Zeichen ist eine Liste von Strichen, jeder Strich eine
# Folge von Punkten (x, y) in einem Raster von 4 x 6 (y nach unten).
# Zeichen, die zu leicht miteinander verwechselt werden: ausgeschlossen (0 O, 1 I L).
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]],
}

ALPHABET = "".join(FONT)

# einige dunkle Farben, auf dem hellen Hintergrund gut lesbar
COLORS = ["#1f4e79", "#7b2d26", "#2e6b30", "#5b2c83", "#8a5a00", "#23395d", "#9c2a5b"]


def random_text(length: int) -> str:
    return "".join(_random.choice(ALPHABET) for _ in range(length))


def random(minimum: float, maximum: float) -> float:
    return _random.uniform(minimum, maximum)


def color() -> str:
    return _random.choice(COLORS)


def svg(text: str) -> str:
    parts = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{WIDTH}" height="{HEIGHT}" '
             f'viewBox="0 0 {WIDTH} {HEIGHT}">',
             '<rect width="100%" height="100%" fill="#f5f7fa"/>']

    # die Zeichen: jedes vergrößert, geneigt, verschoben, und jeder Punkt
    # zufällig leicht verschoben
    step = (WIDTH - 20) / len(text)
    for i, character in enumerate(text):
        scale = random(4.6, 5.6)  # Größe einer Rasterzelle in Pixeln
        angle = random(-0.35, 0.35)  # Drehung im Bogenmaß (etwa ±20°)
        cx = 10 + step * (i + 0.5) + random(-3, 3)  # Mittelpunkt des Zeichens
        cy = HEIGHT / 2 + random(-4, 4)
        d = []
        for stroke in FONT[character]:
            for k in range(0, len(stroke), 2):
                # Punkt des Rasters, auf (2, 3) zentriert, verzerrt, gedreht, platziert
                x = (stroke[k] - 2 + random(-0.2, 0.2)) * scale
                y = (stroke[k + 1] - 3 + random(-0.2, 0.2)) * scale
                px = cx + x * math.cos(angle) - y * math.sin(angle)
                py = cy + x * math.sin(angle) + y * math.cos(angle)
                d.append(f"{'M' if k == 0 else 'L'}{px:.1f} {py:.1f}")
        parts.append(f'<path d="{" ".join(d)}" fill="none" stroke="{color()}" '
                     f'stroke-width="{random(2.2, 3):.1f}" stroke-linecap="round" '
                     f'stroke-linejoin="round"/>')

    # 3 Störstriche: Kurven, die das Bild durchqueren
    for _ in range(3):
        parts.append(
            f'<path d="M{random(0, 20):.1f} {random(5, 45):.1f} '
            f'C{random(30, 60):.1f} {random(0, 50):.1f} {random(90, 120):.1f} {random(0, 50):.1f} '
            f'{random(130, 150):.1f} {random(5, 45):.1f}" fill="none" stroke="{color()}" '
            f'stroke-width="1.3"/>')
    parts.append("</svg>")
    return "".join(parts)

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

  • Zeile 11: Das Modul [random] von [Python] erzeugt vorhersagbare Zahlenfolgen (wer einige Werte kennt, kann die folgenden erraten): Es eignet sich für Simulationen, nicht für Sicherheitszwecke. Das Modul [secrets] bietet einen kryptografischen Generator, der nicht vorhersagbar ist;
  • Zeilen 16–48: 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;
  • Zeile 51: ["".join(FONT)] verbindet die Schlüssel des Wörterbuchs: die verfügbaren Zeichen;
  • Zeilen 57–58: zufälliger Text. [_] ist der übliche Name für eine nicht verwendete Variable;
  • Zeilen 69–103: die Zeichnung. Jedes Zeichen wird zufällig vergrößert, gedreht und verschoben, und jeder seiner Punkte wird leicht versetzt; jeder Strich wird zu einem [<path>]-Element des SVG ([M]: Verschiebung, [L]: Linie). Drei Kurven ([C]: Bézierkurve) durchziehen das Bild, um Erkennungsprogramme zu verwirren. Die Formate [:.1f] schreiben Zahlen mit einer Nachkommastelle.

8.3.2. Der CAPTCHA-Service: auth/captcha.py

# auth/captcha.py: die ausstehenden CAPTCHAs, vom Server im Speicher gehalten
import secrets
from dataclasses import dataclass
from datetime import datetime, timedelta
from threading import Lock

from flask import current_app

from auth import captcha_drawing

LIFETIME = timedelta(minutes=10)


# ein CAPTCHA: sein Bezeichner und sein Bild (SVG)
@dataclass(frozen=True)
class Captcha:
    id: str
    svg: str


class CaptchaService:

    def __init__(self):
        # Bezeichner -> (erwartete Antwort, Ablaufdatum)
        self._pending: dict[str, tuple[str, datetime]] = {}
        self._lock = Lock()

    def generate(self) -> Captcha:
        text = captcha_drawing.random_text(5)
        id = secrets.token_urlsafe(16)  # ein zufälliger Bezeichner, nicht zu erraten
        with self._lock:
            self._pending[id] = (text, datetime.now() + LIFETIME)
        return Captcha(id, captcha_drawing.svg(text))

    # das CAPTCHA wird in jedem Fall VERBRAUCHT: ein Bild wird nur einmal verwendet
    def check(self, id: str | None, answer: str | None) -> bool:
        with self._lock:
            expected = self._pending.pop(id, None) if id else None
        if expected is None or answer is None:
            return False
        text, expires = expected
        return expires > datetime.now() and text.lower() == answer.strip().lower()


def captcha_service() -> CaptchaService:
    return current_app.extensions["captchas"]
  • Zeilen 28–33: ein neues CAPTCHA: zufälliger Text, eine zufällige, nicht erratbare Kennung ([secrets.token_urlsafe]) und das Bild. Zu jeder Kennung speichert der Server die erwartete Antwort und ein Ablaufdatum. Die Seite erhält nur die Kennung und das Bild: Die Antwort verlässt den Server nie;
  • Zeilen 36–42: Überprüfung. [pop] entfernt den Eintrag aus dem Dictionary und gibt ihn zurück: Das CAPTCHA wird verbraucht – in jedem Fall, ob die Prüfung gelingt oder nicht. Ohne dies könnte ein Programm alle möglichen Antworten für dasselbe Bild durchprobieren. Der Vergleich ignoriert Groß- und Kleinschreibung sowie Leerzeichen um die Eingabe.

Dieser Service hält Daten im Arbeitsspeicher des Servers: Das weicht vom Prinzip des zustandslosen Servers ab (siehe das Kapitel über Gültigkeitsbereiche), was für kurzlebige Daten akzeptabel ist. Bei mehreren Servern müssten die Daten in einem gemeinsamen Speichersystem abgelegt werden (einer Datenbank, [Redis] ...). Beachten Sie außerdem, dass nie verwendete CAPTCHAs nicht gelöscht werden: Die Fallstudie bereinigt regelmäßig abgelaufene CAPTCHAs.

8.3.3. Begrenzung der Versuche: auth/limiter.py

# auth/limiter.py: zählt die fehlgeschlagenen Logins jeder IP-Adresse
import math
from datetime import datetime, timedelta
from threading import Lock

from flask import current_app

MAX_FAILURES = 3
BLOCK_DURATION = timedelta(minutes=1)


class Counter:
    def __init__(self):
        self.failures = 0
        self.blocked_until = datetime.min


class LimiterService:

    def __init__(self):
        self._counters: dict[str, Counter] = {}
        # mehrere gleichzeitige Anfragen, jeweils nur ein Zugriff
        self._lock = Lock()

    # die Anzahl der verbleibenden Sekunden der Sperre (0: nicht gesperrt)
    def blocked_seconds(self, ip: str) -> int:
        with self._lock:
            counter = self._counters.get(ip)
            if counter is None:
                return 0
            remaining = (counter.blocked_until - datetime.now()).total_seconds()
            return max(0, math.ceil(remaining))

    def failure(self, ip: str):
        with self._lock:
            counter = self._counters.setdefault(ip, Counter())
            counter.failures += 1
            if counter.failures >= MAX_FAILURES:
                counter.blocked_until = datetime.now() + BLOCK_DURATION
                counter.failures = 0  # nach der Sperre beginnen wir wieder bei null

    def success(self, ip: str):
        with self._lock:
            self._counters.pop(ip, None)


def limiter_service() -> LimiterService:
    return current_app.extensions["limiter"]
  • Zeilen 12–15: pro IP-Adresse eine Anzahl fehlgeschlagener Versuche und ein Datum, an dem die Sperre endet ([datetime.min], das früheste mögliche Datum, bedeutet „nicht gesperrt“);
  • Zeilen 26–32: die in der Sperre verbleibenden Sekunden, aufgerundet auf die nächste ganze Zahl ([math.ceil]);
  • Zeilen 34–40: ein weiterer Fehlversuch. [setdefault] setzt den Zähler der Adresse zurück und legt ihn an, falls er nicht existiert. Beim dritten Fehlversuch wird die Adresse für eine Minute gesperrt, und der Zähler wird auf null zurückgesetzt;
  • Zeilen 42–44: Eine erfolgreiche Anmeldung setzt den Zähler zurück.

8.3.4. Der Controller: controllers/auth.py

# controllers/auth.py: Login (mit CAPTCHA und Begrenzung der Versuche) und Logout
from flask import Blueprint, redirect, render_template, request, url_for

from auth.captcha import captcha_service
from auth.limiter import limiter_service
from auth.service import COOKIE, auth_service

auth = Blueprint("auth", __name__)


@auth.get("/")
def home():
    return redirect(url_for("profile.display"))


@auth.get("/login")
def form():
    return login_page()


@auth.post("/login")
def login():
    login = request.form.get("login")
    # die IP-Adresse des Clients
    ip = request.remote_addr

    # 1. eine gesperrte Adresse wird gar nicht erst angehört
    seconds = limiter_service().blocked_seconds(ip)
    if seconds > 0:
        return login_page(login, f"Too many attempts: try again in {seconds} s.")
    # 2. zuerst das CAPTCHA (günstig), danach das Passwort (bcrypt, teuer)
    if not captcha_service().check(request.form.get("captchaId"), request.form.get("captcha")):
        limiter_service().failure(ip)
        return login_page(login, "The image code is incorrect.")
    user = auth_service().validate(login, request.form.get("password"))
    if user is None:
        limiter_service().failure(ip)
        return login_page(login, "Incorrect login or password.")
    limiter_service().success(ip)
    response = redirect(url_for("profile.display"))
    response.set_cookie(COOKIE, auth_service().create_token(user), httponly=True,
                        samesite="Lax", max_age=auth_service().duration)
    return response


@auth.post("/logout")
def logout():
    response = redirect(url_for("auth.form"))
    response.delete_cookie(COOKIE)
    return response


# jede Anzeige des Formulars erstellt ein NEUES CAPTCHA
def login_page(login: str | None = None, error: str | None = None):
    return render_template("auth/login.html", login=login, error=error,
                           captcha=captcha_service().generate())
  • Zeile 25: die Adresse des Clients, IP;
  • Zeilen 28–30: Eine gesperrte Adresse wird gar nicht erst beachtet;
  • Zeilen 32–34: Das CAPTCHA wird vor dem Passwort geprüft: Die Prüfung kostet fast nichts, während [bcrypt] absichtlich langsam ist. Ein Programm, das ein falsches CAPTCHA eingibt, würde daher nicht [bcrypt] auslösen. Jeder Fehlversuch – ob beim CAPTCHA oder beim Passwort – wird gezählt;
  • Zeile 39: Eine erfolgreiche Anmeldung setzt die Fehlerzahl zurück;
  • Zeilen 54–56: Jedes Mal, wenn das Formular angezeigt wird, wird ein neues CAPTCHA erzeugt, auch nach einem Fehlversuch.

8.3.5. Die View: templates/auth/login.html

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Login</h1>
  <form method="post" action="/login">
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ login or '' }}" 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>
      {# das vom Server erzeugte SVG-Bild: ohne Maskierung eingefügt (safe) #}
      <div class="mb-1">{{ captcha.svg | safe }}</div>
      {# der CAPTCHA-Bezeichner wandert in einem versteckten Feld; die Antwort bleibt auf dem 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>
{% endblock %}
  • Zeile 17: Das SVG-Bild wird mit dem Filter [safe] unverändert in die Seite eingefügt (Beispiel 14). Das ist zulässig: Dieses HTML wurde vom Server erzeugt und enthält keine Benutzereingaben;
  • Zeile 19: Die CAPTCHA-ID in einem versteckten Feld;
  • Zeile 20: Der Browser schlägt für dieses Feld keine früheren Eingaben vor.

8.3.6. Ausführung

Image

Ein falsch abgeschriebener Code:

Image

Beim dritten fehlgeschlagenen Versuch wird die Adresse gesperrt:

Image

Mit [curl], vier Versuche mit einer erfundenen CAPTCHA-ID:

curl -d "login=marie&password=marie&captchaId=abc&captcha=XXXXX" http://localhost:5000/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 ohne Überprüfung abgelehnt.