Skip to content

6. Gültigkeitsbereiche von Daten

Eine Webanwendung bedient viele Benutzer gleichzeitig, und jeder Benutzer sendet zahlreiche Anfragen. Daten können daher auf mehreren Ebenen gemeinsam genutzt werden, den sogenannten Gültigkeitsbereichen (Scopes):

  • Anwendungsbereich: Die Daten werden von allen Benutzern während der gesamten Lebensdauer der Anwendung gemeinsam genutzt (zum Beispiel die Liste der Ärzte);
  • Anfragebereich: Die Daten existieren nur für die Dauer einer Anfrage (das Modell eines Templates, der angemeldete Benutzer, wie er für diese Anfrage identifiziert wurde);
  • Sitzungsbereich: Die Daten gehören einem einzelnen Benutzer und müssen von einer Anfrage zur nächsten erhalten bleiben (die gewählte Sprache, ein Warenkorb);
  • Clientbereich: Daten, die im Browser selbst gespeichert werden, in einem Cookie.

In [Python] haben diese Gültigkeitsbereiche eine andere Natur als die, die Leser des Kurses zu [Symfony] kennen, weil die Anwendung von einer Anfrage zur nächsten im Speicher bleibt (Beispiel 01). In einer Modulvariablen gespeicherte Daten (Beispiele 06, 20 und 21) haben von Natur aus Anwendungsbereich: Das ist bequem und sehr schnell. Dieser Bereich hat jedoch zwei Einschränkungen. Erstens gilt er nur für die Dauer des Prozesses: Ein Neustart des Servers löscht ihn. Zweitens ist er prozessspezifisch: In der Produktion werden üblicherweise mehrere Anwendungsprozesse gestartet (zum Beispiel mehrere „Worker“ von [gunicorn]) oder sogar mehrere Server hinter einem Load Balancer, und jeder hätte seine eigene Kopie der Daten. Daten, die wirklich gemeinsam genutzt werden und dauerhaft erhalten bleiben müssen, werden daher in einer Datenbank oder in einem gemeinsamen Cache gespeichert ([Redis], [Memcached], die [Django] über seine Einstellung [CACHES] nutzen kann). Als Gegenleistung für Geschwindigkeit erfordert das Teilen strenge Disziplin: Ein Prozess bearbeitet mehrere Anfragen gleichzeitig in mehreren Threads, und gemeinsam genutzte Daten, die von einem Prozess verändert werden, sind für alle sichtbar; sie müssen durch eine Sperre geschützt werden (Beispiel 20), und Daten, die einem bestimmten Benutzer gehören, dürfen dort niemals abgelegt werden.

In [Django] hat jeder Gültigkeitsbereich seinen eigenen Container:

Bereich
Container
Lebensdauer
Anwendung
eine Modulvariable (ein einzelner Prozess), der [Django]-Cache (Einstellung [CACHES]) oder die Datenbank
die des Prozesses; die für den Cache gewählte Dauer; unbegrenzt bei der Datenbank
Anfrage
das Objekt [HttpRequest], dem eine Middleware Attribute hinzufügen kann (Beispiel 12); die lokalen Variablen der View
die Bearbeitung einer Anfrage
Sitzung
die Session ([request.session], Anwendung [django.contrib.sessions]), vom Server verwaltet und über ein Cookie wiedergefunden
standardmäßig zwei Wochen (Einstellung [SESSION_COOKIE_AGE])
Client
ein Cookie ([set_cookie], Beispiel 22), entweder im Klartext oder signiert ([set_signed_cookie])
die im Cookie angegebene Dauer

Die Session von [Django] ist standardmäßig eine serverseitige Session, wie die von [Java] ([JSESSIONID]) oder [PHP] ([PHPSESSID]): Ihre Daten liegen auf dem Server, und der Browser besitzt nur den Bezeichner – eine zufällige, nicht erratbare Zahl – im Cookie [sessionid]. Die Einstellung [SESSION_ENGINE] bestimmt, wo die Daten gespeichert werden: in der Datenbank (die Standardoption, in einer Tabelle namens [django_session]), im Cache, in Dateien (die in unserem Beispiel verwendete Option) oder, wie bei [Flask], vollständig in einem signierten Cookie auf dem Gerät des Clients.

6.1. Beispiel 23: Gültigkeitsbereiche

23-scopes/
├── config/
│   ├── settings.py
│   └── ...
├── scopes/
│   ├── __init__.py
│   ├── counters.py
│   ├── middleware.py
│   └── views.py
├── templates/
│   └── scopes/
│       └── scopes.html
├── var/
│   └── sessions/
└── manage.py

6.1.1. Die Konfiguration: config/settings.py

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

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-1zxb1%#mksmtg+m&rsp_e6&i7@6sbtm_i=lqjq_+rg#-=i5r-p"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "django.contrib.staticfiles",
    # die SESSIONS
    "django.contrib.sessions",
    "scopes",
]

MIDDLEWARE = [
    # die Sessions-Middleware: Sie findet zu Beginn der Anfrage die Session des Browsers (dank des
    # Cookies sessionid) und speichert sie am Ende der Anfrage
    "django.contrib.sessions.middleware.SessionMiddleware",
    # der Gültigkeitsbereich ANFRAGE: ein Objekt pro Anfrage (siehe scopes/middleware.py)
    "scopes.middleware.RequestInfoMiddleware",
]

# die Session-Daten werden auf dem Server in DATEIEN gespeichert (eine pro
# Session), im Ordner var/sessions des Beispiels, der bei Bedarf angelegt wird
SESSION_ENGINE = "django.contrib.sessions.backends.file"
SESSION_FILE_PATH = BASE_DIR / "var" / "sessions"
SESSION_FILE_PATH.mkdir(parents=True, exist_ok=True)

TEMPLATES = [
    {
        "BACKEND": "django.template.backends.django.DjangoTemplates",
        "DIRS": [BASE_DIR / "templates"],
        "OPTIONS": {
            "context_processors": [
                # die Variable der Anfrage und damit request.session und request.info
                "django.template.context_processors.request",
            ],
        },
    },
]

STATIC_URL = "static/"
STATICFILES_DIRS = [
    BASE_DIR.parent / "common" / "static",
]
  • Zeile 17: die Sitzungsverwaltung;
  • Zeilen 21–27: zwei Middleware-Komponenten. [SessionMiddleware] ruft zu Beginn der Anfrage anhand des Cookies [sessionid] die Session des Browsers ab und legt sie in [request.session] ab; am Ende der Anfrage speichert sie die Session, falls sie verändert wurde, und sendet das Cookie. Die Daten werden erst beim ersten Zugriff auf [request.session] tatsächlich gelesen: Eine View, die sie nicht verwendet, verursacht keine Kosten. Die zweite Middleware ist unsere eigene (siehe unten);
  • Zeilen 31–33: Die Sitzungsdaten werden in Dateien gespeichert – eine pro Session – und zwar im Beispiel im Ordner [var/sessions], den wir untersuchen können. Zeile 33 legt diesen Ordner an, falls er nicht existiert ([parents=True]: einschließlich der übergeordneten Ordner; [exist_ok=True]: kein Fehler, wenn er bereits existiert): Die Einstellungsdatei ist [Python] und kann daher Code ausführen. Die Standardoption, die Datenbank, würde eine Datenbank erfordern (nächstes Kapitel);
  • Zeile 42: der Kontextprozessor [request]: Die Templates verwenden [request.session] und [request.info].

6.1.2. Die Objekte: scopes/counters.py und scopes/middleware.py

# scopes/counters.py: Gültigkeitsbereich ANWENDUNG, Zähler, die von allen
# Anfragen aller Benutzer gemeinsam genutzt werden

import threading
from collections import Counter

# ein Counter: ein Dictionary {Schlüssel: Zahl}, dessen fehlende Schlüssel den Wert 0 haben. Er wird
# beim Laden des Moduls erzeugt und lebt so lange wie der Serverprozess
_counters = Counter()
_lock = threading.Lock()


# eins mehr unter dem Schlüssel [key]; += ist keine atomare Operation: Zwei
# gleichzeitige Anfragen könnten denselben Wert lesen. Der Lock verhindert das
def next_value(key: str) -> int:
    with _lock:
        _counters[key] += 1
        return _counters[key]
  • Zeile 5: die Klasse [Counter] aus dem Modul [collections]: ein Dictionary, dessen Werte Zahlen sind und dessen fehlende Schlüssel auf 0 gesetzt werden;
  • Zeilen 9–10: die Zähler und ihre Sperre, erstellt beim Laden des Moduls; sie existieren, solange der Serverprozess läuft. Das ist der Anwendungsbereich;
  • Zeilen 15–18: eins mehr unter einem Schlüssel. Die Operation [+=] ist nicht atomar: Sie liest den Wert, erhöht ihn und schreibt ihn dann, und zwei gleichzeitige Anfragen könnten denselben Wert lesen – ein Besuch ginge verloren. Die Sperre (Beispiel 20) verhindert dies.
# scopes/middleware.py: Gültigkeitsbereich ANFRAGE, die Informationen einer Anfrage

from dataclasses import dataclass

from django.utils import timezone

from . import counters


@dataclass(frozen=True)
class RequestInfo:
    number: int
    start: str


# die Middleware erzeugt pro Anfrage EIN Objekt RequestInfo und speichert es in der Anfrage:
# die View und das Template finden es über request.info. Es verschwindet mit ihr
class RequestInfoMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        request.info = RequestInfo(
            # eine Nummer pro erzeugtem OBJEKT, entnommen einem allen Anfragen gemeinsamen Zähler
            number=counters.next_value("instances"),
            # die Uhrzeit mit ihren Millisekunden
            start=timezone.localtime().strftime("%H:%M:%S.%f")[:-3])
        return self.get_response(request)
  • Zeilen 10–13: Informationen im Anfragebereich: eine Nummer und die Uhrzeit der Anfrage;
  • Zeilen 18–28: Die Middleware erstellt für jede Anfrage ein Objekt [RequestInfo] und legt es in der Anfrage ab (Beispiel 12). Die Nummer stammt aus einem Zähler, der von allen Anfragen gemeinsam genutzt wird (das vorherige Modul, unter einem anderen Schlüssel); jedes Objekt hat daher eine andere Nummer. Die Uhrzeit wird einschließlich Millisekunden geschrieben: [%f] steht für die Mikrosekunden (sechs Ziffern), von denen [[:-3]] die letzten drei entfernt (ein String-Slice: alle Zeichen außer den letzten drei). Das Objekt wird zusammen mit der Anfrage gelöscht.

[Django] hat keinen Service-Container und damit auch keinen „Service im Anfragebereich“: Die Anfrage selbst trägt die Objekte dieses Bereichs. Leser des Kurses zu [Symfony] werden sich erinnern, dass es genau umgekehrt war: In [PHP] hatte jeder Service den Anfragebereich, und für den Anwendungsbereich war ein Cache erforderlich.

6.1.3. Signierte Cookies

Ein Cookie ist ein Datum, das dem Client anvertraut wird, der es lesen und ändern kann. Damit ein Cookie vertrauenswürdig ist, muss es lediglich signiert sein: Sein Wert wird im Klartext übertragen, aber es folgt eine Signatur, die nur der Server berechnen kann, weil sie von einem geheimen Schlüssel abhängt. Ein vom Client geänderter Wert hat nicht mehr die richtige Signatur, und der Server weist ihn zurück. [Django] übernimmt das für uns: [response.set_signed_cookie(name, value)] setzt ein signiertes Cookie, und [request.get_signed_cookie(name, default=...)] liefert seinen Wert, wenn die Signatur korrekt ist; andernfalls liefert es den Standardwert. Die Signatur ist ein HMAC (Hash-based Message Authentication Code): ein Hash des Wertes (SHA-256), berechnet mit dem geheimen Schlüssel der Anwendung ([SECRET_KEY], Beispiel 01), und einem „Salt“, der für den Namen des Cookies spezifisch ist. [Django] fügt das Datum der Signatur hinzu, wodurch ein veraltetes Cookie abgelehnt werden kann ([get_signed_cookie(..., max_age=3600)]). Die Überprüfung vergleicht die Signaturen in einer Zeit, die nicht von der Anzahl übereinstimmender Zeichen abhängt: Ein gewöhnlicher Vergleich würde beim ersten abweichenden Zeichen abbrechen, und ein Angreifer könnte durch Messen der Antwortzeit die Signatur Zeichen für Zeichen erraten. Das Modul [django.core.signing] bietet dieselben Funktionen zum Signieren beliebiger Daten ([signing.dumps], [signing.loads]): Dieses Modul signiert die Flash-Meldungen in Beispiel 20.

Dies ist das Prinzip des JWT-Tokens, das das nächste Kapitel für die Authentifizierung verwenden wird.

6.1.4. Die View: scopes/views.py

# scopes/views.py: die vier Gültigkeitsbereiche der Daten

from django.shortcuts import render
from django.views.decorators.http import require_GET

from . import counters


@require_GET
def scopes(request):
    # ANWENDUNG: der gemeinsame Zähler
    total = counters.next_value("visits")
    # SESSION: Daten, die für DIESEN Browser spezifisch sind, vom SERVER gehalten (eine
    # Datei in var/sessions), gefunden dank des Session-Cookies; die Session
    # wird wie ein Dictionary verwendet
    request.session["visits"] = request.session.get("visits", 0) + 1
    # CLIENT: Daten, die der BROWSER in Cookies hält und mit jeder Anfrage an den
    # Server zurücksendet; eines im Klartext, das andere signiert
    my_visits = int(request.COOKIES.get("myVisits", 0)) + 1
    # get_signed_cookie: der Wert, wenn die Signatur stimmt; sonst default
    my_visits_signed = int(request.get_signed_cookie("myVisitsSigned", default=0)) + 1
    response = render(request, "scopes/scopes.html", {
        "total": total,
        "instance": request.info.number,
        "session_visits": request.session["visits"],
        "my_visits": my_visits,
        "my_visits_signed": my_visits_signed,
    })
    response.set_cookie("myVisits", str(my_visits))
    # set_signed_cookie: der Wert, gefolgt von einer mit SECRET_KEY berechneten Signatur
    response.set_signed_cookie("myVisitsSigned", str(my_visits_signed))
    return response
  • Zeile 12: der Anwendungsbereich;
  • Zeile 16: der Sitzungsbereich. [request.session] wird wie ein Dictionary verwendet: [get(key, default)] liest einen Wert, und die Zuweisung schreibt ihn. [Django] speichert die Session am Ende der Anfrage. Die Werte müssen in JSON umwandelbar sein (Strings, Zahlen, Listen, Dictionaries): So werden sie gespeichert;
  • Zeilen 19–21: der Clientbereich mit zwei Cookies. [request.COOKIES] ist das Dictionary der vom Browser gesendeten Cookies. Ihre Werte sind vom Browser gelieferte Strings und können daher fehlen oder ungültig sein: [int] wandelt sie um (ein Cookie [myVisits=abc] würde hier eine Ausnahme [ValueError] auslösen und zu einem 500-Fehler führen; eine reale Anwendung würde den Wert prüfen; siehe Beispiel 07). Der Wert des signierten Cookies wird nur akzeptiert, wenn seine Signatur korrekt ist;
  • Zeilen 22–28: der Kontext des Templates;
  • Zeilen 29–31: Um ein Cookie zu setzen, benötigt man das Antwortobjekt: [render] erstellt es (Beispiel 13), dann fügen [set_cookie] und [set_signed_cookie] die Cookies hinzu. Ohne Ablaufzeit ([max_age]) bleibt ein Cookie bis zum Schließen des Browsers bestehen (das ist ein „Sitzungs“-Cookie im Sinne der Browser).

6.1.5. Das Template: templates/scopes/scopes.html

<!doctype html>
{% load static %}
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>Scopes</title>
  <link rel="stylesheet" href="{% static 'bootstrap/css/bootstrap.min.css' %}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {# request.info: das von der Middleware in der Anfrage gespeicherte Objekt; es ist dasselbe wie das der View #}
    <ul>
      <li>application: {{ total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ instance }} (no. {{ request.info.number }} in the template),
        request received at {{ request.info.start }}</li>
      {# request.session: die Session, auch in den Templates zugänglich #}
      <li>session: {{ session_visits }} visit(s) from this browser ({{ request.session.visits }} in the template)</li>
      <li>client: {{ my_visits }} visit(s) from this browser (plain cookie),
        {{ my_visits_signed }} (signed cookie)</li>
    </ul>
  </div>
</body>
</html>
  • Zeile 16: [request.info], das Objekt, das die Middleware in der Anfrage abgelegt hat: Es ist dasselbe [RequestInfo]-Objekt wie in der View; das Template zeigt seine Nummer an, die mit der von der View erhaltenen übereinstimmen muss;
  • Zeile 19: Die Session ist auch in den Templates über [request.session] zugänglich.

6.1.6. Ausführung

Nach drei Besuchen in einem Browser:

Image

Die Nummer des Anfrageobjekts ist größer als die Anzahl der Besuche: Beim ersten Besuch hat der Browser auch das Symbol der Website angefordert ([/favicon.ico]), das nicht existiert. Diese Anfrage, die einen 404-Fehler ergab, durchlief die Middleware und hatte daher ihr eigenes Objekt [RequestInfo].

Verfolgen wir die Anfragen mit [curl], das als erster Browser fungiert und seine Cookies in der Datei [a.txt] speichert (der Server wurde gerade gestartet):

curl -i -c a.txt -b a.txt http://localhost:8000/
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Vary: Cookie
Set-Cookie: myVisits=1; Path=/
Set-Cookie: myVisitsSigned=1:1xAspT:iu2OlkhoUcBt0QBGkt_Gkjm2PoYfUeS6WSsO5KEHt0k; Path=/
Set-Cookie: sessionid=ij72qd9hyuhwoqlplawuxycwg6ggccsq; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 1 (no. 1 in the template),
        request received at 19:38:23.123</li>
      <li>session: 1 visit(s) from this browser (1 in the template)</li>
      <li>client: 1 visit(s) from this browser (plain cookie),
        1 (signed cookie)</li>
...

Die Antwort setzt drei Cookies. Das erste, [myVisits], enthält den Wert im Klartext. Das zweite, [myVisitsSigned], enthält denselben Wert, gefolgt von einem Doppelpunkt, dem Datum der Signatur (in Basis 62) und der Signatur selbst. Das dritte, [sessionid], ist die Session-ID, zwei Wochen gültig ([Max-Age=1209600] Sekunden), [HttpOnly], und [SameSite=Lax] (Beispiel 20). Die Sitzungsdaten werden in einer Datei auf dem Server gespeichert, [var/sessions/sessionidij72qd9hyuhwoqlplawuxycwg6ggccsq], deren Name vom Bezeichner abgeleitet ist:

eyJ2aXNpdHMiOjF9:1xAspT:mYytMt_81vJlDI_gaKudIqPgoxAvrGUZbnk578MZr3I

Hier erkennen wir das Format der signierten Daten von [Django]: die Daten, das Datum und die Signatur. Die Daten stammen aus JSON, Base64-kodiert: [eyJ2aXNpdHMiOjF9] wird dekodiert zu [{"visits":1}]. Der Server signiert sogar seine eigenen Sitzungsdateien: Eine von Dritten veränderte Datei würde abgelehnt. Ein zweiter Besuch mit denselben Cookies:

curl -i -c a.txt -b a.txt http://localhost:8000/
...
Set-Cookie: myVisits=2; Path=/
Set-Cookie: myVisitsSigned=2:1xAspT:E9lE-GK-yE7WfT5Ak58h2tufzXQ5vLWcWz5UBAS-dLA; Path=/
Set-Cookie: sessionid=ij72qd9hyuhwoqlplawuxycwg6ggccsq; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the template),
        request received at 19:38:23.150</li>
      <li>session: 2 visit(s) from this browser (2 in the template)</li>
      <li>client: 2 visit(s) from this browser (plain cookie),
        2 (signed cookie)</li>
...

Die Session ist dieselbe (gleiche ID); ihr Cookie wird zurückgesendet, weil die Session verändert wurde, was ihre Lebensdauer verlängert. Ein zweiter „Browser“ mit eigener, zunächst leerer Cookie-Datei:

curl -c b.txt -b b.txt http://localhost:8000/
1
2
3
4
5
6
      <li>application: 3 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 3 (no. 3 in the template),
        request received at 19:38:23.167</li>
      <li>session: 1 visit(s) from this browser (1 in the template)</li>
      <li>client: 1 visit(s) from this browser (plain cookie),
        1 (signed cookie)</li>

Der Anwendungszähler läuft weiter; Session und Cookies des zweiten Browsers beginnen wieder bei 1. Jede Anfrage hatte ihr eigenes Objekt [RequestInfo], und in jeder waren View und Template dieselben. Schließlich fälscht ein böswilliger Benutzer seine eigenen Cookies: 1.000 Besuche in [myVisits], 999 in [myVisitsSigned] (mit einer erfundenen Signatur) und eine selbst ausgedachte Session-ID:

curl -i -b "myVisits=1000;myVisitsSigned=999:abc;sessionid=abc" http://localhost:8000/
1
2
3
4
5
6
7
8
9
...
Set-Cookie: myVisits=1001; Path=/
Set-Cookie: myVisitsSigned=1:1xAspT:iu2OlkhoUcBt0QBGkt_Gkjm2PoYfUeS6WSsO5KEHt0k; Path=/
Set-Cookie: sessionid=l4316xnwacgz81f7yemjar89cfe05jm3; expires=Sun, 11 Oct 2026 17:38:23 GMT; HttpOnly; Max-Age=1209600; Path=/; SameSite=Lax
...
      <li>session: 1 visit(s) from this browser (1 in the template)</li>
      <li>client: 1001 visit(s) from this browser (plain cookie),
        1 (signed cookie)</li>
...

Das Klartext-Cookie wurde unverändert akzeptiert: 1.001 Besuche. Das Cookie [myVisitsSigned] hatte dagegen nicht die richtige Signatur: Es wurde ignoriert, als würde es fehlen. Die Signatur eines anderen Wertes zu kopieren (die von [1] zum Beispiel neben den Wert [999]) funktioniert nicht besser: Die Signatur hängt vom Wert ab. Die erfundene Session-ID verweist auf keine existierende Session: [Django] ignoriert sie und erstellt eine neue Session mit einer neuen ID, die es selbst wählt. Der Benutzer kann daher nicht die Session eines anderen Benutzers auswählen.

Merken wir uns die Regel: Vom Client stammende Daten sind nur dann vertrauenswürdig, wenn sie vom Server geschützt werden (signiert, wie hier oder wie beim Token im Kapitel über die Authentifizierung, oder verschlüsselt); Daten, die nichts zu verbergen haben und deren Wert der Server überprüft (die Sprache in Beispiel 22), können im Klartext bleiben. Eine Signatur garantiert, dass ein Wert nicht verändert wurde, verbirgt ihn aber nicht: Ein Geheimnis darf dem Client niemals anvertraut werden, auch nicht signiert.