Skip to content

6. Gültigkeitsbereiche von Daten

Eine Webanwendung bedient viele Benutzer gleichzeitig, und jeder Benutzer stellt zahlreiche Anfragen. Daten können daher auf mehreren Ebenen gemeinsam genutzt werden, bekannt als ihr Gültigkeitsbereich:

  • Anwendung (Gültigkeitsbereich): Die Daten werden von allen Benutzern während der gesamten Lebensdauer der Anwendung gemeinsam genutzt (zum Beispiel die Liste der Ärzte);
  • Anfrage (Gültigkeitsbereich): Die Daten existieren nur für die Dauer der Verarbeitung einer Anfrage (das Modell einer View, der für diese Anfrage identifizierte angemeldete Benutzer);
  • Session (Gültigkeitsbereich): Die Daten gehören einem bestimmten Benutzer und müssen von einer Anfrage zur nächsten erhalten bleiben (die gewählte Sprache, ein Warenkorb);
  • Client (Gültigkeitsbereich): Daten, die im Browser selbst in einem Cookie gespeichert werden.

In [PHP] verhalten sich diese Gültigkeitsbereiche besonders, weil die Anwendung bei jeder Anfrage neu aufgebaut wird (Beispiel 01): Nichts bleibt im Speicher von einer Anfrage zur nächsten erhalten. Alle Daten, die länger als eine einzelne Anfrage bestehen müssen, werden daher außerhalb von [PHP] gespeichert: im Cache, in einer Datenbank, in Dateien oder auf der Seite des Clients. Das ist die sogenannte „Shared-nothing“-Architektur: Jede Anfrage wird isoliert von einem Prozess verarbeitet, der nichts mit den Prozessen teilt, die andere Anfragen verarbeiten. Dieser Ansatz hat erhebliche Vorteile: Ein Fehler betrifft nur eine einzelne Anfrage, es gelangen keine Daten von einem Benutzer zu einem anderen, und mehrere identische Server können hinter einem Load Balancer betrieben werden, sofern sie denselben Cache und dieselbe Datenbank teilen.

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

Gültigkeitsbereich
Container
Lebensdauer
Anwendung
der Cache (Service [cache.app], Beispiel 20) oder die Datenbank
die gewählte Dauer oder unbegrenzt
Anfrage
die Services des Containers (ein Objekt pro Klasse während der Anfrage), die Anfrageattribute (Beispiel 12)
Verarbeitung einer Anfrage
Session
die Session ([$request->getSession()], Beispiel 20), vom Server verwaltet und über ein Cookie abgerufen
standardmäßig bis zum Schließen des Browsers und höchstens für die Dauer der [PHP]-Session (standardmäßig 24 Minuten Inaktivität)
Client
ein Cookie ([Cookie::create], Beispiel 22), im Klartext
Die Ablaufzeit des Cookies

Die [Symfony]-Session ist eine serverseitige Session, wie die von [Java] ([JSESSIONID]) oder die Standard-[PHP]-Session, von der sie tatsächlich den Mechanismus und das Cookie übernimmt ([PHPSESSID]): Ihre Daten werden auf dem Server gespeichert (eine Datei pro Session, mit der in unseren Beispielen verwendeten Konfiguration), und der Browser hält nur den Bezeichner – eine zufällige Zahl, die sich unmöglich erraten lässt. Das unterscheidet sich von [Flask], dessen gesamte Session in einem signierten Cookie auf der Client-Seite gespeichert wird.

6.1. Beispiel 23: Gültigkeitsbereiche

23-scopes/
├── config/
│   └── packages/
│       ├── framework.yaml
│       └── twig.yaml
├── src/
│   ├── Controller/
│   │   └── ScopesController.php
│   └── Service/
│       ├── CounterService.php
│       ├── SignedCookies.php
│       └── RequestInfo.php
├── templates/
│   └── scopes/
│       └── scopes.html.twig
└── ...

Die Datei [config/packages/framework.yaml] konfiguriert die Session und die Sperren, wie in Beispiel 20.

6.1.1. Die Objekte: src/Service/CounterService.php und RequestInfo.php

<?php
// src/Service/CounterService.php: Geltungsbereich ANWENDUNG, Zähler, die von
// allen Anfragen aller Benutzer gemeinsam genutzt und im Cache gespeichert werden (siehe Beispiel 20)

namespace App\Service;

use Psr\Cache\CacheItemPoolInterface;
use Symfony\Component\Lock\LockFactory;

class CounterService
{
    public function __construct(
        private CacheItemPoolInterface $cache,
        private LockFactory $locks,
    ) {
    }

    // eine Zahl mehr unter dem Schlüssel [$key]; der Cache „file“ erhöht eine
    // Zahl nicht atomar: Ein Lock schützt das Lesen und das Schreiben
    public function next(string $key): int
    {
        $lock = $this->locks->createLock("$key-lock");
        $lock->acquire(true);
        try {
            $item = $this->cache->getItem($key);
            $value = ($item->isHit() ? $item->get() : 0) + 1;
            $this->cache->save($item->set($value));
            return $value;
        } finally {
            $lock->release();
        }
    }

    public function increment(): int
    {
        return $this->next('visits');
    }
}
  • Zeilen 12–16: Der Service erhält den Anwendungs-Cache und die Lock-Factory (Beispiel 20);
  • Zeilen 20–32: ein Zähler im Anwendungsbereich: eine im Cache unter einem Schlüssel gespeicherte Zahl, die bei jedem Aufruf um 1 erhöht wird. Der „File“-Cache in unseren Beispielen unterstützt keine atomaren Inkrementoperationen: Der Wert muss gelesen, erhöht und dann geschrieben werden, und zwei gleichzeitige Anfragen könnten denselben Wert lesen – was zu einem verlorenen Zählschritt führt. Eine Sperre – eine pro Schlüssel – schützt daher sowohl Lese- als auch Schreibvorgänge; der Block [finally] gibt sie in jedem Fall frei, auch nach dem [return] in Zeile 28;
  • Zeilen 34–37: der Besuchszähler.
<?php
// src/Service/RequestInfo.php: Geltungsbereich ANFRAGE, die Informationen einer Anfrage

namespace App\Service;

use DateTimeImmutable;

class RequestInfo
{
    public readonly int $number;

    public readonly string $start;

    // Der Container erzeugt EIN Objekt dieser Klasse bei der ersten Anforderung und
    // gibt es dann während der Anfrage an alle zurück, die danach fragen
    public function __construct(CounterService $counter)
    {
        // eine Nummer pro erzeugtem OBJEKT, entnommen einem Zähler, der von allen Anfragen gemeinsam genutzt wird
        $this->number = $counter->next('instances');
        // die Uhrzeit mit ihren Millisekunden (v)
        $this->start = (new DateTimeImmutable())->format('H:i:s.v');
    }
}
  • Zeilen 10–12: Eigenschaften, die als [readonly] einzeln deklariert werden (statt der gesamten Klasse): Sie können nur einmal zugewiesen werden, und zwar vom Konstruktor;
  • Zeilen 16–22: Informationen im Anfragebereich: eine Nummer, abgeleitet von einem Zähler, den alle Anfragen gemeinsam nutzen (der vorherige Service unter einem anderen Schlüssel), und die Zeit der Anfrage einschließlich Millisekunden ([v]-Format). Der Konstruktor erhält den [CounterService] vom Container: Ein Service kann einen anderen Service anfordern, genau wie eine Aktion.

Es ist keine Konfiguration erforderlich: Standardmäßig ist ein Service im Container geteilt (shared). Der Container erstellt das Objekt bei der ersten Anforderung und liefert dann bei allen folgenden Anforderungen dasselbe zurück. Im Standardmodus von [PHP] wird der Container bei jeder Anfrage neu aufgebaut: Ein geteilter Service ist daher ein Objekt im Anfragebereich. (Mit der Option [shared: false] in der Datei [services.yaml] lässt sich auch bei jeder Injection ein neues Objekt anfordern.) Eine Nuance ergibt sich bei Anwendungsservern, die die Anwendung zur Leistungssteigerung von einer Anfrage zur nächsten im Speicher halten, etwa im Worker-Modus von [FrankenPHP]: In diesem Fall wird ein Service von allen Anfragen geteilt, die der Prozess bearbeitet. [Symfony] setzt dann zwischen den Anfragen die Services zurück, die das Interface [ResetInterface] implementieren; diese Services müssen selbst dafür sorgen, dass nichts von einer Anfrage zur nächsten erhalten bleibt.

6.1.2. Eine globale Variable für die Views: config/packages/twig.yaml

1
2
3
4
5
6
7
# config/packages/twig.yaml: die Konfiguration des TwigBundle
twig:
    default_path: '%kernel.project_dir%/templates'
    # eine GLOBALE Variable der Views, die ein SERVICE ist (das @ bezeichnet einen Service):
    # das RequestInfo-Objekt der aktuellen Anfrage
    globals:
        info: '@App\Service\RequestInfo'
  • Zeilen 6–7: Eine globale Variable in den Views (Beispiel 15) kann ein Service sein: der Name seiner Klasse, dem [@] vorangestellt ist. Alle Views haben so Zugriff auf die Variable [info], die das [RequestInfo]-Objekt der aktuellen Anfrage ist. [Twig] hat kein Äquivalent zur Direktive [@inject] von [Blade]: Eine View fordert nichts vom Container an; sie erhält, was ihr gegeben wird.

6.1.3. Signierte Cookies: src/Service/SignedCookies.php

Ein Cookie sind Daten, die dem Client anvertraut werden, der sie lesen und ändern kann. [Laravel] verschlüsselt seine Cookies; [Symfony] tut das nicht. Damit ein Cookie vertrauenswürdig ist, genügt es jedoch, dass es signiert ist: 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.

<?php
// src/Service/SignedCookies.php: SIGNIERTE Cookies. Der Wert wird im Klartext übertragen,
// gefolgt von einer Signatur, die nur der Server berechnen kann: Ein vom Client geänderter Wert
// hat nicht mehr die richtige Signatur und wird abgelehnt

namespace App\Service;

use Symfony\Component\DependencyInjection\Attribute\Autowire;

class SignedCookies
{
    // der Schlüssel der Signatur: das Secret der Anwendung (APP_SECRET, Datei .env)
    public function __construct(#[Autowire('%kernel.secret%')] private string $secret)
    {
    }

    // "5" -> "5.3f1c...": der Wert, ein Punkt, die Signatur (HMAC-SHA256 des Werts)
    public function sign(string $value): string
    {
        return $value.'.'.hash_hmac('sha256', $value, $this->secret);
    }

    // der Wert, wenn die Signatur stimmt, sonst null
    public function verify(?string $cookie): ?string
    {
        if ($cookie === null || ! str_contains($cookie, '.')) {
            return null;
        }
        // strrpos: die Position des LETZTEN Punkts
        $value = substr($cookie, 0, strrpos($cookie, '.'));
        // hash_equals vergleicht zwei Strings in konstanter Zeit, was einem Angreifer nicht verrät,
        // wie viele Zeichen stimmen
        return hash_equals($this->sign($value), $cookie) ? $value : null;
    }
}
  • Zeile 13: Der Signaturschlüssel ist das Geheimnis der Anwendung – die Variable [APP_SECRET] in der Datei [.env] (Beispiel 01) –, das der Container als Parameter [kernel.secret] kennt. Ein Parameter ist kein Objekt: Das Attribut [#[Autowire]] teilt dem Container den bereitzustellenden Wert mit, wobei [%name%] auf einen Parameter verweist;
  • Zeilen 18–21: Die Signatur ist ein HMAC (Hash-based Message Authentication Code): der SHA-256-Hash des Werts, berechnet mit dem geheimen Schlüssel und hexadezimal geschrieben. Das Cookie enthält den Wert, einen Punkt und dann die Signatur;
  • Zeilen 24–34: Die Überprüfung berechnet die Signatur des empfangenen Werts neu und vergleicht sie mit der im Cookie. [hash_equals] vergleicht zwei Zeichenketten in einer Zeit, die nicht von der Anzahl identischer Zeichen abhängt: Ein normaler 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 ist das Prinzip hinter dem JWT-Token, das das nächste Kapitel für die Authentifizierung verwenden wird.

6.1.4. Der Controller: src/Controller/ScopesController.php

<?php
// src/Controller/ScopesController.php: die vier Geltungsbereiche der Daten

namespace App\Controller;

use App\Service\CounterService;
use App\Service\SignedCookies;
use App\Service\RequestInfo;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Cookie;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;

class ScopesController extends AbstractController
{
    // Die Services werden vom Container bereitgestellt (siehe Beispiel 06)
    #[Route('/', name: 'scopes', methods: ['GET'])]
    public function display(Request $request, CounterService $counter, RequestInfo $info,
        SignedCookies $cookies): Response
    {
        // ANWENDUNG: der gemeinsame Zähler
        $total = $counter->increment();
        // SESSION: Daten, die spezifisch für DIESEN Browser sind, vom SERVER aufbewahrt
        // (eine Datei in var/sessions) und über das Session-Cookie wiedergefunden
        $session = $request->getSession();
        $session->set('visits', $session->get('visits', 0) + 1);
        // CLIENT: Daten, die der BROWSER in Cookies aufbewahrt und
        // bei jeder Anfrage an den Server zurückschickt; eines im Klartext, das andere signiert
        $myVisits = (int) $request->cookies->get('myVisits') + 1;
        $mySignedVisits = (int) $cookies->verify($request->cookies->get('mySignedVisits')) + 1;
        $response = $this->render('scopes/scopes.html.twig', [
            'total' => $total, 'instance' => $info->number,
            'sessionVisits' => $session->get('visits'), 'myVisits' => $myVisits,
            'mySignedVisits' => $mySignedVisits,
        ]);
        $response->headers->setCookie(Cookie::create('myVisits', (string) $myVisits));
        $response->headers->setCookie(Cookie::create('mySignedVisits', $cookies->sign((string) $mySignedVisits)));
        return $response;
    }
}
  • Zeilen 19–20: Die Aktion erhält die Anfrage und drei vom Container bereitgestellte Services;
  • Zeile 23: der Anwendungsbereich;
  • Zeilen 26–27: der Session-Bereich. [$request->getSession()] liefert die Session des Benutzers; [get(key, default)] liest einen Wert, und [set(key, value)] schreibt ihn. [Symfony] speichert die Session am Ende der Anfrage;
  • Zeilen 30–31: der Client-Bereich mit zwei Cookies. Ihre Werte sind vom Browser gelieferte Zeichenketten und können daher fehlen oder ungültig sein: Die Umwandlung [(int)] liefert 0 für [null] oder für Text, der keine Zahl ist. Der Wert des signierten Cookies wird nur akzeptiert, wenn seine Signatur korrekt ist;
  • Zeilen 32–39: Um ein Cookie zu setzen, benötigt man das Antwortobjekt: [render] erstellt es (Beispiel 13), danach fügt [setCookie] die Cookies hinzu. Ohne Ablaufdatum bleibt ein Cookie bis zum Schließen des Browsers bestehen (das ist ein „Session“-Cookie im Sinne der Browser).

6.1.5. Die View: templates/scopes/scopes.html.twig

<!doctype html>
<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="{{ path('bootstrap', {file: 'css/bootstrap.min.css'}) }}">
</head>
<body>
  <div class="container py-3">
    <h1 class="h3">The scopes of data</h1>
    {# info: die globale Variable aus config/packages/twig.yaml, ein Service; während
       DERSELBEN Anfrage ist es dasselbe Objekt wie das der Action #}
    <ul>
      <li>application: {{ total }} visit(s) to the site, all browsers combined</li>
      <li>request: object no. {{ instance }} (no. {{ info.number }} in the view),
        request received at {{ info.start }}</li>
      {# app.session: die Sitzung, auch in den Views zugänglich #}
      <li>session: {{ sessionVisits }} visit(s) from this browser ({{ app.session.get('visits') }} in the view)</li>
      <li>client: {{ myVisits }} visit(s) from this browser (clear-text cookie),
        {{ mySignedVisits }} (signed cookie)</li>
    </ul>
  </div>
</body>
</html>
  • Zeile 16: [info], die globale Variable: Während derselben Anfrage ist dies dasselbe [RequestInfo]-Objekt wie das der Aktion; die View zeigt seine Nummer an, die mit der von der Aktion erhaltenen übereinstimmen muss;
  • Zeile 19: Die Session ist in den Views auch über die Variable [app.session] zugänglich.

6.1.6. Ausführung

Nach einigen Besuchen in einem Browser:

Image

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

curl -i -c a.txt -b a.txt http://localhost:8000/
HTTP/1.1 200 OK
...
Set-Cookie: myVisits=1; path=/; httponly; samesite=lax
Set-Cookie: mySignedVisits=1.e50058404359cc9be2e65b8d9366aa98b7d7db4ca7ee576cfdffb6d1a1150d37; path=/; httponly; samesite=lax
Set-Cookie: PHPSESSID=32da14307b05da3847ea54b2ae3e6f77; path=/; httponly; samesite=lax
...
      <li>application: 1 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 1 (no. 1 in the view),
        request received at 09:48:29.888</li>
            <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser (clear-text cookie),
        1 (signed cookie)</li>
...

Die Antwort setzt drei Cookies. Das erste, [myVisits], enthält den Wert im Klartext. Das zweite, [mySignedVisits], enthält denselben Wert, gefolgt von einem Punkt und seiner Signatur. Das dritte, [PHPSESSID], ist die Session-ID. Die Session-Daten werden in einer Datei auf dem Server gespeichert, [var/sessions/dev/sess_32da14307b05da3847ea54b2ae3e6f77], deren Name mit der Session-ID übereinstimmt:

_sf2_attributes|a:1:{s:6:"visits";i:1;}_sf2_meta|a:3:{s:1:"u";i:1790502509;s:1:"c";i:1790502509;s:1:"l";i:0;}

Im Serialisierungsformat von [PHP] sehen wir ein Array mit einem einzigen Schlüssel, [visits], und einem ganzzahligen Wert 1 ([i:1]), gefolgt von Informationen von [Symfony] zur Session (Erstellungs- und letztes Verwendungsdatum). Ein zweiter Besuch mit denselben Cookies:

curl -i -c a.txt -b a.txt http://localhost:8000/
...
Set-Cookie: myVisits=2; path=/; httponly; samesite=lax
Set-Cookie: mySignedVisits=2.4c7239f31c7e195c32dc5dcf2c7734ea05e6cb316eeab9a53239ab047db525ff; path=/; httponly; samesite=lax
...
      <li>application: 2 visit(s) to the site, all browsers combined</li>
      <li>request: object no. 2 (no. 2 in the view),
        request received at 09:48:32.813</li>
            <li>session: 2 visit(s) from this browser (2 in the view)</li>
      <li>client: 2 visit(s) from this browser (clear-text cookie),
        2 (signed cookie)</li>
...

Die Session existiert bereits: Das Cookie [PHPSESSID] wird nicht erneut gesendet. 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 view),
        request received at 09:48:32.826</li>
            <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1 visit(s) from this browser (clear-text cookie),
        1 (signed cookie)</li>

Der Anwendungszähler hat weitergezählt; die Session und die Cookies des zweiten Browsers beginnen wieder bei 1. Jede Anfrage hatte ihr eigenes [RequestInfo]-Objekt, und in jeder sahen die Aktion und die View dasselbe. Schließlich fälscht ein böswilliger Benutzer seine eigenen Cookies: 1.000 Besuche in [myVisits], 999 in [mySignedVisits] (mit einer erfundenen Signatur) und eine selbst ausgedachte Session-ID:

curl -i -b "myVisits=1000;mySignedVisits=999.abc;PHPSESSID=abc" http://localhost:8000/
1
2
3
4
5
6
7
8
...
Set-Cookie: PHPSESSID=1885ac965cf2dc862c4aecb994300956; path=/; httponly; samesite=lax
...
      <li>application: 4 visit(s) to the site, all browsers combined</li>
      ...
            <li>session: 1 visit(s) from this browser (1 in the view)</li>
      <li>client: 1001 visit(s) from this browser (clear-text cookie),
        1 (signed cookie)</li>

Das Klartext-Cookie wurde unverändert akzeptiert: 1.001 Besuche. Das Cookie [mySignedVisits] hatte dagegen nicht die richtige Signatur: Es wurde ignoriert, als würde es fehlen. Die Signatur eines anderen Werts zu kopieren (etwa die von [1] neben den Wert [999]) funktioniert ebenso wenig: Die Signatur hängt vom Wert ab. Was die ausgedachte Session-ID betrifft: Sie entspricht keiner existierenden Session; [Symfony] weist sie zurück (das ist der „strikte“ Modus der [PHP]-Sessions) und erstellt eine neue Session mit einer neuen ID. Der Benutzer kann sich also nicht die Session eines anderen Benutzers aussuchen.

Merken wir uns die Regel: Daten vom Client 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 vom Server überprüft wird (die Sprache in Beispiel 22), können im Klartext bleiben. Eine Signatur garantiert, dass ein Wert nicht verändert wurde, aber sie verbirgt ihn nicht: Ein Geheimnis darf dem Client niemals anvertraut werden, auch nicht signiert.