Skip to content

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

25-jwt/
├── accounts/
│   ├── __init__.py
│   └── views.py
├── config/
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── security/
│   ├── __init__.py
│   ├── auth.py
│   ├── decorators.py
│   ├── middleware.py
│   └── users.py
├── templates/
│   ├── auth/
│   │   └── login.html
│   ├── profile/
│   │   └── profile.html
│   └── layout.html
└── manage.py

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:

# config/settings.py: die Konfiguration von Beispiel 25

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-jr8u&rl2ff+bpg(h18&^u2dtu^qtulf9yoy!e&la+nt_z-vb*8"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    "security",
    "accounts",
]

MIDDLEWARE = [
    "django.middleware.csrf.CsrfViewMiddleware",
    # AUTHENTIFIZIERUNG: Bei jeder Anfrage wird der Benutzer anhand des
    # JWT-Tokens in seinem Cookie gefunden (siehe security/middleware.py)
    "security.middleware.Authentication",
]

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]

# unsere eigenen Einstellungen: der Schlüssel, der die JWT-Tokens signiert (mindestens 32 Zeichen), und
# ihre Lebensdauer. os.environ.get: die gleichnamige Umgebungsvariable, falls sie
# existiert (in Produktion), sonst der hier geschriebene Wert (in der Entwicklung)
JWT_SECRET = os.environ.get("JWT_SECRET", "a-secret-key-of-at-least-32-characters-for-example-25")
JWT_DURATION_MINUTES = int(os.environ.get("JWT_DURATION_MINUTES", "60"))
  • 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:

JWT_SECRET="another-key-of-at-least-thirty-two-characters" python manage.py runserver

und für [Windows] ([PowerShell]):

$env:JWT_SECRET="another-key-of-at-least-thirty-two-characters"
python manage.py runserver

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

# security/users.py: die Benutzer, im Speicher (Beispiel 28 und die
# Fallstudie legen sie in einer Datenbank ab)

from dataclasses import dataclass, field


@dataclass(frozen=True)
class User:
    login: str
    name: str
    # die Rolle: USER oder ADMIN
    role: str
    # der HASH des Passworts (leer für einen aus einem Token gelesenen Benutzer)
    password_hash: str = ""
    # der Inhalt des Tokens, das den Benutzer authentifiziert hat; field(default_factory=dict):
    # ein NEUES leeres Dictionary für jedes Objekt
    claims: dict = field(default_factory=dict)


# wir speichern NIEMALS ein Passwort, nur seinen Hash, ein für alle Mal
# von der Funktion make_password von Django berechnet (Algorithmus PBKDF2-SHA256, 1.500.000
# Iterationen, ein zufälliges Salt):
# python -c "from django.conf import settings; settings.configure();
#            from django.contrib.auth.hashers import make_password; print(make_password('marie'))"
USERS = {
    "marie": ("Marie Pélissier", "USER",
              "pbkdf2_sha256$1500000$pjnFn2tL1G4bu5rVFTv6sZ$Y6v+fj3dC+Y0LZYJGxeE1OOi9beaZVuMVm6R6tljEwI="),
    "admin": ("Administrator", "ADMIN",
              "pbkdf2_sha256$1500000$UTT2hXVaLIEAuGHPFxgnv9$D9+Owt9lDG14VrvArR3n0GGQXWjY9Sg8cgFwip4+yx4="),
}


def find(login: str) -> User | None:
    if login not in USERS:
        return None
    # das "Entpacken" eines Tupels: seine drei Elemente in drei Variablen
    name, role, password_hash = USERS[login]
    return User(login, name, role, password_hash)
  • 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

# security/auth.py: die Prüfung der Passwörter und der JWT-Tokens

import time

import jwt
from django.conf import settings
from django.contrib.auth.hashers import check_password

from . import users
from .users import User

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


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


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


# der durch ein Token beschriebene Benutzer, dessen Signatur und Ablaufdatum
# gültig sind; sonst None (gefälschtes, abgelaufenes oder unlesbares Token)
def verify(token: str) -> User | None:
    try:
        # decode prüft die Signatur UND das Ablaufdatum (Claim exp)
        claims = jwt.decode(token, settings.JWT_SECRET, algorithms=["HS256"])
    except jwt.InvalidTokenError:
        return None
    return User(claims["sub"], claims["name"], claims["role"], claims=claims)
  • 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

# security/middleware.py: AUTHENTIFIZIERUNG: Wer ist bei jeder Anfrage der Benutzer?

from django.shortcuts import redirect

from . import auth


class Authentication:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # standardmäßig ist der Besucher anonym
        request.user = None
        token = request.COOKIES.get(auth.COOKIE)
        if token is not None:
            user = auth.verify(token)
            if user is None:
                # ein ungültiges Token (abgelaufen, gefälscht): weiter nach /login, und wir
                # löschen das Cookie
                response = redirect("login")
                response.delete_cookie(auth.COOKIE)
                return response
            request.user = user
        return self.get_response(request)

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

# security/decorators.py: die Zugriffskontrolle der Views

from functools import wraps

from django.shortcuts import redirect


# @login_required: Die View wird nur für einen authentifizierten Benutzer ausgeführt; ein
# anonymer Besucher wird auf die Login-Seite weitergeleitet
def login_required(view):
    @wraps(view)
    def wrapper(request, *args, **kwargs):
        if request.user is None:
            return redirect("login")
        return view(request, *args, **kwargs)
    return wrapper

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

# accounts/views.py: Login, Logout und eine Seite, die authentifizierten
# Benutzern vorbehalten ist

from django.conf import settings
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_http_methods, require_POST

from security import auth
from security.decorators import login_required


@require_GET
def home(request):
    return redirect("profile")


# GET: das Formular; POST: das Login (das Anti-CSRF-Token wurde von
# CsrfViewMiddleware geprüft)
@require_http_methods(["GET", "POST"])
def login(request):
    if request.method == "GET":
        return render(request, "auth/login.html")
    login = request.POST.get("login", "")
    user = auth.validate(login, request.POST.get("password", ""))
    if user is None:
        # eine absichtlich vage Meldung: Wir sagen nicht, ob es das Login oder das Passwort ist
        return render(request, "auth/login.html",
                      {"login": login, "error": "Incorrect login or password."})
    # das Token in einem Cookie: Das JavaScript der Seite kann es nicht lesen
    # (httponly); es begleitet keine POST-Anfragen von anderen Sites
    # (samesite); es verschwindet zugleich mit dem Ablauf des Tokens (max_age)
    response = redirect("profile")
    response.set_cookie(auth.COOKIE, auth.create_token(user),
                        max_age=settings.JWT_DURATION_MINUTES * 60, httponly=True, samesite="Lax")
    return response


# Logout: nur per POST (ein einfacher Link auf einer anderen Site kann den Benutzer
# nicht ohne sein Wissen abmelden); wir löschen das Cookie
@require_POST
def logout(request):
    response = redirect("login")
    response.delete_cookie(auth.COOKIE)
    return response


# request.user: der authentifizierte Benutzer, von der Middleware gefunden
@require_GET
@login_required
def profile(request):
    return render(request, "profile/profile.html", {"user": request.user})
  • 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

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Login</h1>
  <form method="post" action="{% url 'login' %}">
    {% csrf_token %}
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ login }}" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <button class="btn btn-primary" type="submit">Log in</button>
  </form>
  {% 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 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).
{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Hello {{ user.name }}</h1>
  <p>Your role: <b>{% if user.role == "ADMIN" %}administrator{% else %}user{% endif %}</b>.</p>
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    {% for key, value in user.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="{% url 'logout' %}">
    {% csrf_token %}
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
{% endblock %}
  • 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:

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

Ein falsches Passwort:

Image

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:

curl -c token.txt -b token.txt http://localhost:8000/login
curl -i -c token.txt -b token.txt -d "csrfmiddlewaretoken=...&login=marie&password=marie" http://localhost:8000/login
1
2
3
4
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /profile
Set-Cookie: token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJtYXJpZSIsIm5hbWUiOiJNYXJpZSBQXHUwMGU5bGlzc2llciIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNzkwNTMwOTM5LCJleHAiOjE3OTA1MzQ1Mzl9.eJQdDTFEYVlAzHENW7esgY82dUbjsj5dN6jW-Dy6Lfo; expires=Sun, 27 Sep 2026 18:42:19 GMT; HttpOnly; Max-Age=3600; Path=/; SameSite=Lax

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:

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

(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:

Image

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:

curl -i -b "token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.<modified content>.eJQdDTFEYVlAzHENW7esgY82dUbjsj5dN6jW-Dy6Lfo" http://localhost:8000/profile
1
2
3
4
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
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 (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

# security/users.py: die Benutzer, im Speicher (Beispiel 28 und die
# Fallstudie legen sie in einer Datenbank ab)

from dataclasses import dataclass, field


@dataclass(frozen=True)
class User:
    login: str
    name: str
    # die Rolle: USER oder ADMIN
    role: str
    # der HASH des Passworts (leer für einen aus einem Token gelesenen Benutzer)
    password_hash: str = ""
    # der Inhalt des Tokens, das den Benutzer authentifiziert hat; field(default_factory=dict):
    # ein NEUES leeres Dictionary für jedes Objekt
    claims: dict = field(default_factory=dict)

    # die HIERARCHIE der Rollen: Ein Administrator hat auch die Rechte eines Benutzers
    def has_role(self, role: str) -> bool:
        return role in HIERARCHY.get(self.role, set())

    # für die Templates, die keine Methode mit Parameter aufrufen können
    @property
    def is_admin(self) -> bool:
        return self.has_role("ADMIN")


# jede Rolle und die Menge der Rollen, die sie hat ({...}: eine Menge)
HIERARCHY = {
    "ADMIN": {"ADMIN", "USER"},
    "USER": {"USER"},
}


# wir speichern NIEMALS ein Passwort, nur seinen Hash, ein für alle Mal
# von der Funktion make_password von Django berechnet (Algorithmus PBKDF2-SHA256, 1.500.000
# Iterationen, ein zufälliges Salt):
# python -c "from django.conf import settings; settings.configure();
#            from django.contrib.auth.hashers import make_password; print(make_password('marie'))"
USERS = {
    "marie": ("Marie Pélissier", "USER",
              "pbkdf2_sha256$1500000$pjnFn2tL1G4bu5rVFTv6sZ$Y6v+fj3dC+Y0LZYJGxeE1OOi9beaZVuMVm6R6tljEwI="),
    "admin": ("Administrator", "ADMIN",
              "pbkdf2_sha256$1500000$UTT2hXVaLIEAuGHPFxgnv9$D9+Owt9lDG14VrvArR3n0GGQXWjY9Sg8cgFwip4+yx4="),
}


def find(login: str) -> User | None:
    if login not in USERS:
        return None
    # das "Entpacken" eines Tupels: seine drei Elemente in drei Variablen
    name, role, password_hash = USERS[login]
    return User(login, name, role, password_hash)
  • 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

# security/decorators.py: die Zugriffskontrolle der Views

from functools import wraps

from django.core.exceptions import PermissionDenied
from django.shortcuts import redirect


# @login_required: Die View wird nur für einen authentifizierten Benutzer ausgeführt; ein
# anonymer Besucher wird auf die Login-Seite weitergeleitet
def login_required(view):
    @wraps(view)
    def wrapper(request, *args, **kwargs):
        if request.user is None:
            return redirect("login")
        return view(request, *args, **kwargs)
    return wrapper


# @role_required("ADMIN"): ein PARAMETRISIERTER Dekorator (siehe Beispiel 08). Die View wird
# nur ausgeführt, wenn der authentifizierte Benutzer die verlangte Rolle hat; andernfalls erzeugt die
# Exception PermissionDenied eine 403-Antwort (siehe security/errors.py)
def role_required(role):
    def decorator(view):
        @wraps(view)
        @login_required
        def wrapper(request, *args, **kwargs):
            if not request.user.has_role(role):
                raise PermissionDenied(f"role {role} required")
            return view(request, *args, **kwargs)
        return wrapper
    return decorator
  • 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

1
2
3
4
5
6
7
8
# security/errors.py: die Antwort für einen AUTHENTIFIZIERTEN Benutzer, der eine
# ihm verbotene Seite anfordert (siehe handler403 in config/urls.py)

from django.shortcuts import render


def access_denied(request, exception):
    return render(request, "errors/403.html", status=403)
# config/urls.py: die Haupt-Routing-Tabelle

from django.urls import path

from accounts import views
from security.errors import access_denied

urlpatterns = [
    path("", views.home),
    path("login", views.login, name="login"),
    path("logout", views.logout, name="logout"),
    path("profile", views.profile, name="profile"),
    path("admin", views.admin, name="admin"),
]

# die View der 403-Fehler (Exception PermissionDenied)
handler403 = access_denied

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

# accounts/views.py: Login, Logout und Seiten, die authentifizierten
# Benutzern vorbehalten ist

from django.conf import settings
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_http_methods, require_POST

from security import auth
from security.decorators import login_required, role_required


@require_GET
def home(request):
    return redirect("profile")


# GET: das Formular; POST: das Login (das Anti-CSRF-Token wurde von
# CsrfViewMiddleware geprüft)
@require_http_methods(["GET", "POST"])
def login(request):
    if request.method == "GET":
        return render(request, "auth/login.html")
    login = request.POST.get("login", "")
    user = auth.validate(login, request.POST.get("password", ""))
    if user is None:
        # eine absichtlich vage Meldung: Wir sagen nicht, ob es das Login oder das Passwort ist
        return render(request, "auth/login.html",
                      {"login": login, "error": "Incorrect login or password."})
    # das Token in einem Cookie: Das JavaScript der Seite kann es nicht lesen
    # (httponly); es begleitet keine POST-Anfragen von anderen Sites
    # (samesite); es verschwindet zugleich mit dem Ablauf des Tokens (max_age)
    response = redirect("profile")
    response.set_cookie(auth.COOKIE, auth.create_token(user),
                        max_age=settings.JWT_DURATION_MINUTES * 60, httponly=True, samesite="Lax")
    return response


# Logout: nur per POST (ein einfacher Link auf einer anderen Site kann den Benutzer
# nicht ohne sein Wissen abmelden); wir löschen das Cookie
@require_POST
def logout(request):
    response = redirect("login")
    response.delete_cookie(auth.COOKIE)
    return response


# request.user: der authentifizierte Benutzer, von der Middleware gefunden
@require_GET
@login_required
def profile(request):
    return render(request, "profile/profile.html", {"user": request.user})


# eine der Rolle ADMIN vorbehaltene Seite
@require_GET
@role_required("ADMIN")
def admin(request):
    return render(request, "admin/admin.html", {"name": request.user.name})
  • 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

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Hello {{ user.name }}</h1>
  <p>Your role: <b>{% if user.role == "ADMIN" %}administrator{% else %}user{% endif %}</b>.</p>
  {# is_admin: hat der Benutzer die Rolle ADMIN? #}
  {% if user.is_admin %}
    <p><a href="{% url 'admin' %}">The administration area</a></p>
  {% else %}
    <p><a href="{% url 'admin' %}">The administration area</a> (which is forbidden to you)</p>
  {% endif %}
  <p>The content of your token:</p>
  <table class="table table-sm w-auto">
    {% for key, value in user.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="{% url 'logout' %}">
    {% csrf_token %}
    <button class="btn btn-outline-secondary" type="submit">Log out</button>
  </form>
{% endblock %}
  • 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:

Image

Der Administrator hat dagegen Zugriff darauf:

Image

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:

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

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:

27-captcha/
├── accounts/
│   └── views.py
├── config/
│   └── settings.py
├── security/
│   ├── auth.py
│   ├── captcha_drawing.py
│   ├── captchas.py
│   ├── decorators.py
│   ├── limiter.py
│   ├── middleware.py
│   └── users.py
├── templates/
│   └── auth/
│       └── login.html
└── ...

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

# security/captcha_drawing.py: das Zeichnen eines Captchas, eines SVG-Bildes (XML-Text),
# von Hand gebaut

import math
import secrets

WIDTH = 150
HEIGHT = 50

# 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]],
}

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

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


def random_text(length: int) -> str:
    alphabet = list(FONT)
    return "".join(secrets.choice(alphabet) for _ in range(length))


# eine Gleitkommazahl, zufällig, zwischen minimum und maximum
def random(minimum: float, maximum: float) -> float:
    return _random.uniform(minimum, maximum)


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


def svg(text: str) -> str:
    w, h = WIDTH, HEIGHT
    parts = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="{h}" viewBox="0 0 {w} {h}">',
             '<rect width="100%" height="100%" fill="#f5f7fa"/>']
    # die Zeichen: jedes vergrößert, geneigt, verschoben, und jeder Punkt leicht
    # zufällig verschoben
    step = (w - 20) / len(text)
    for i, character in enumerate(text):
        scale = random(4.6, 5.6)    # Größe einer Gittereinheit 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 = h / 2 + random(-4, 4)
        for stroke in FONT[character]:
            d = []
            # range(0, n, 2): 0, 2, 4 ... ein Punkt = zwei Zahlen
            for k in range(0, len(stroke), 2):
                # Punkt des Rasters, zentriert auf (2, 3), 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 durchkreuzen
    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} '
                     f'{random(0, 50):.1f} {random(130, 150):.1f} {random(5, 45):.1f}" '
                     f'fill="none" stroke="{color()}" stroke-width="1.3"/>')
    parts.append("</svg>")
    return "".join(parts)

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

# security/captchas.py: die ausstehenden Captchas, vom Server im Cache gehalten

import secrets
from dataclasses import dataclass

from django.core.cache import cache

from . import captcha_drawing

# die Lebensdauer eines Captchas, in Sekunden
LIFETIME = 600


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


def generate() -> Captcha:
    text = captcha_drawing.random_text(5)
    # eine zufällige, nicht erratbare Kennung: 12 Bytes, von einem
    # kryptografischen Generator gezogen, hexadezimal geschrieben
    id = secrets.token_hex(12)
    # die erwartete Antwort im Cache, für 10 Minuten: Der Cache vergisst sie danach von
    # selbst
    cache.set(f"captcha.{id}", text, LIFETIME)
    return Captcha(id, captcha_drawing.svg(text))


# das Captcha wird in jedem Fall VERBRAUCHT: Ein Bild wird nur einmal verwendet
def verify(id: str, entered: str) -> bool:
    if not id or not entered:
        return False
    # get liefert den Wert oder None; delete entfernt die Antwort aus dem Cache, egal ob sie
    # richtig ist oder nicht
    expected = cache.get(f"captcha.{id}")
    cache.delete(f"captcha.{id}")
    if expected is None:
        return False    # unbekannte Kennung oder abgelaufenes CAPTCHA
    # casefold: der String in Kleinbuchstaben, für einen Vergleich, der die Groß- und Kleinschreibung ignoriert
    return expected.casefold() == entered.strip().casefold()
  • 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

# security/limiter.py: die Begrenzung der Login-Versuche pro IP-Adresse

import time

from django.conf import settings
from django.core.cache import cache


# die Fehlschläge eines Clients werden in einem festen Zeit-FENSTER gezählt: höchstens
# LOGIN_MAX_FAILURES Fehlschläge pro Fenster von LOGIN_WINDOW_SECONDS Sekunden
class Limiter:
    def __init__(self, ip: str):
        self.key = f"login.{ip}"

    # die zu wartenden Sekunden, wenn der Client gesperrt ist, sonst 0
    def wait(self) -> int:
        state = cache.get(self.key)
        if state is None or state["failures"] < settings.LOGIN_MAX_FAILURES:
            return 0
        return max(1, int(state["end"] - time.time()))

    # ein weiterer Fehlschlag
    def failure(self) -> None:
        state = cache.get(self.key)
        if state is None:
            # ein neues Fenster beginnt
            state = {"failures": 0, "end": time.time() + settings.LOGIN_WINDOW_SECONDS}
        state["failures"] += 1
        # der Schlüssel verschwindet am Ende des Fensters aus dem Cache (timeout, in Sekunden)
        cache.set(self.key, state, timeout=max(1, int(state["end"] - time.time())))

    # ein erfolgreiches Login löscht die Fehlschläge
    def clear(self) -> None:
        cache.delete(self.key)

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

# config/settings.py: die Konfiguration von Beispiel 27

import os
from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-y=#3-i_9nrm%&a&_%_v^ajq460=!u*ry3uit-nj9_thr&v3ev)"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    "security",
    "accounts",
]

MIDDLEWARE = [
    "django.middleware.csrf.CsrfViewMiddleware",
    # AUTHENTIFIZIERUNG: Bei jeder Anfrage wird der Benutzer anhand des
    # JWT-Tokens in seinem Cookie gefunden (siehe security/middleware.py)
    "security.middleware.Authentication",
]

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]

# unsere eigenen Einstellungen: der Schlüssel, der die JWT-Tokens signiert (mindestens 32 Zeichen), und
# ihre Lebensdauer. os.environ.get: die gleichnamige Umgebungsvariable, falls sie
# existiert (in Produktion), sonst der hier geschriebene Wert (in der Entwicklung)
JWT_SECRET = os.environ.get("JWT_SECRET", "a-secret-key-of-at-least-32-characters-for-example-27")
JWT_DURATION_MINUTES = int(os.environ.get("JWT_DURATION_MINUTES", "60"))

# der CACHE der Anwendung: hier der Speicher des Serverprozesses (es ist der
# Standard-Cache von Django). Die ausstehenden Captchas und die Fehlschlagzähler werden
# darin gespeichert
CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
    },
}

# die Begrenzung der Login-Versuche: 3 Fehlschläge pro Fenster von 60 Sekunden
LOGIN_MAX_FAILURES = 3
LOGIN_WINDOW_SECONDS = 60
  • 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

# accounts/views.py: Login (mit Captcha und Begrenzung der Versuche),
# Logout und eine Seite, die authentifizierten Benutzern vorbehalten ist

from django.conf import settings
from django.shortcuts import redirect, render
from django.views.decorators.http import require_GET, require_http_methods, require_POST

from security import auth, captchas
from security.decorators import login_required
from security.limiter import Limiter


@require_GET
def home(request):
    return redirect("profile")


# GET: das Formular; POST: das Login, mit Captcha und Begrenzung der Versuche
@require_http_methods(["GET", "POST"])
def login(request):
    if request.method == "GET":
        return login_page(request)
    login = request.POST.get("login", "")
    # der Limiter DIESES Clients: Seine Fehlschläge werden unter seiner IP-Adresse gezählt
    limiter = Limiter(request.META["REMOTE_ADDR"])
    # 1. eine gesperrte Adresse wird gar nicht erst angehört
    seconds = limiter.wait()
    if seconds > 0:
        return login_page(request, login, f"Too many attempts: try again in {seconds} s.")
    # 2. zuerst das Captcha (billig), danach das Passwort (PBKDF2, teuer)
    if not captchas.verify(request.POST.get("captcha_id", ""), request.POST.get("captcha", "")):
        limiter.failure()
        return login_page(request, login, "The code of the image is incorrect.")
    user = auth.validate(login, request.POST.get("password", ""))
    if user is None:
        limiter.failure()
        return login_page(request, login, "Incorrect login or password.")
    limiter.clear()
    response = redirect("profile")
    response.set_cookie(auth.COOKIE, auth.create_token(user),
                        max_age=settings.JWT_DURATION_MINUTES * 60, httponly=True, samesite="Lax")
    return response


# jede Anzeige des Formulars baut ein NEUES Captcha
def login_page(request, login="", error=None):
    return render(request, "auth/login.html",
                  {"login": login, "error": error, "captcha": captchas.generate()})


# Logout: nur per POST (ein einfacher Link auf einer anderen Site kann den Benutzer
# nicht ohne sein Wissen abmelden); wir löschen das Cookie
@require_POST
def logout(request):
    response = redirect("login")
    response.delete_cookie(auth.COOKIE)
    return response


# request.user: der authentifizierte Benutzer, von der Middleware gefunden
@require_GET
@login_required
def profile(request):
    return render(request, "profile/profile.html", {"user": request.user})
  • 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

{% extends "layout.html" %}

{% block content %}
  <h1 class="h3">Login</h1>
  <form method="post" action="{% url 'login' %}">
    {% csrf_token %}
    <div class="mb-2">
      <label class="form-label" for="login">Login</label>
      <input class="form-control" id="login" name="login" value="{{ login }}" required>
    </div>
    <div class="mb-2">
      <label class="form-label" for="password">Password</label>
      <input class="form-control" type="password" id="password" name="password" required>
    </div>
    <div class="mb-3">
      <label class="form-label" for="captcha">Copy the code of the image</label>
      {# das vom Server erzeugte SVG-Bild: ohne Maskierung eingefügt (Filter safe) #}
      <div class="mb-1">{{ captcha.svg|safe }}</div>
      {# die CAPTCHA-Kennung wandert in einem versteckten Feld; die Antwort selbst bleibt auf dem Server #}
      <input type="hidden" name="captcha_id" 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 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

Image

Ein falsch abgeschriebener Code:

Image

Nach drei fehlgeschlagenen Versuchen wird die Adresse blockiert:

Image

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

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

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