mitmario.dev

Sitzungen

Node.js Sandbox 3 Min Lesezeit 3 BeispieleLektion 4 von 6

Was im Cookie steht, kann der Besucher umschreiben. Der Anmeldezustand und alles, was Geld kostet, haben darin also nichts verloren. Trotzdem muss der Server bei jeder Anfrage wissen, wer gerade fragt.

Die Kennung statt der Daten

Die Lösung dreht den Gedanken um. Beim Browser bleibt nur ein Schlüssel, und die Daten bleiben beim Server. Der Schlüssel heißt Sitzungskennung (englisch session ID), und die Sache heißt Sitzung (session). Die Kennung funktioniert wie ein Ausweis, den der Browser bei jedem Besuch vorzeigt.

Die Sitzungskennung und die Daten dahinter
import express from "express";
import { randomBytes } from "node:crypto";

const app = express();

// Die Daten liegen hier, beim Server. Im Cookie steht nur der
// Schluessel zu diesem Eintrag.
const sitzungen = new Map();

app.use((req, res, next) => {
  const cookies = Object.fromEntries(
    (req.headers.cookie ?? "")
      .split(";")
      .map((teil) => teil.trim().split("="))
      .filter((paar) => paar.length === 2)
  );

  let sid = cookies.sid;
  if (!sid || !sitzungen.has(sid)) {
    sid = randomBytes(16).toString("hex");
    sitzungen.set(sid, { besuche: 0 });
    res.cookie("sid", sid, { httpOnly: true, sameSite: "lax" });
  }

  req.sitzung = sitzungen.get(sid);
  next();
});

app.get("/zaehler", (req, res) => {
  req.sitzung.besuche += 1;
  res.type("text/plain").send(`Besuch ${req.sitzung.besuche}, ${sitzungen.size} Sitzung(en) im Speicher`);
});

app.listen(3000);

Mit jedem Klick auf Seite neu laden geht der Zähler eins weiter. Dein Browser schickt dabei dieselbe Sitzungskennung mit, ohne dass du etwas dafür tust.

Die Middleware liest die Sitzungskennung aus dem Cookie und sieht nach, ob es dazu einen Eintrag gibt. Gibt es keinen, legt sie einen neuen an und gibt dem Browser die Kennung mit. Danach hängt an req.sitzung ein Objekt, das nur diesem Besucher gehört. Die Routen darunter merken von alledem nichts mehr.

In der Befehlsleiste schreibt curl -c cookies.txt die Kennung in eine Datei, und -b cookies.txt schickt sie zurück. Dann kommt „Besuch 2“, der Zähler liegt also wirklich auf dem Server. Mit sid=erfunden fängt er wieder bei eins an, und eine fremde Sitzung geht dabei nicht auf.

Wie eine Sitzungskennung aussehen muss

Eine schlechte Kennung sieht aus wie eine gute. Im Alltag funktioniert sie auch genauso gut.

Die geratene Sitzungskennung
import { randomBytes } from "node:crypto";

// So nicht: eine Kennung, die man hochzaehlen kann.
let naechste = 1;
const sitzungen = new Map();

function schlechteKennung() {
  const sid = `sitzung-${naechste}`;
  naechste += 1;
  return sid;
}

for (const name of ["Anna", "Bert"]) {
  const sid = schlechteKennung();
  sitzungen.set(sid, { korb: `Warenkorb von ${name}` });
  console.log(`${name} bekommt ${sid}`);
}

// Bert sieht seine eigene Kennung und probiert die Nummer davor.
const geraten = "sitzung-1";
console.log(`Bert probiert ${geraten} und sieht: ${sitzungen.get(geraten).korb}`);

console.log(`Länge fortlaufend: ${schlechteKennung().length}`);
console.log(`Länge aus Zufall:  ${randomBytes(16).toString("hex").length}`);

Wer Sitzungen durchnummeriert, verschenkt sie. Bert braucht keine Lücke und kein Werkzeug. Er zieht eins von seiner eigenen Nummer ab und sieht Annas Warenkorb.

Mit Math.random() wird es nicht besser. Das ist dafür gebaut, schnell gleichverteilte Zahlen zu liefern, und unvorhersagbar muss es dabei nicht sein. Aus ein paar beobachteten Werten lässt sich der Rest berechnen. Eine Sitzungskennung kommt deshalb aus randomBytes in node:crypto. 16 Bytes ergeben als Hex-Text 32 Zeichen, und die rät niemand.

Wo die Daten liegen

Eine Map ist ein Objekt für Paare aus Schlüssel und Wert. set(schluessel, wert) legt ab, get(schluessel) holt, delete(schluessel) nimmt heraus. Der Schlüssel darf jeder Text sein, auch einer, der wie ein eingebauter Name aussieht.

In den Beispielen liegen die Sitzungen in so einer Map, und für diesen Kurs reicht das, denn an ihr sieht man ohne Umweg, dass die Daten im Prozess liegen.

Für den Betrieb hat das zwei Haken. Ein Neustart deines Servers leert die Map und meldet damit alle ab. Und laufen zwei Prozesse nebeneinander, auf die die Anfragen verteilt werden, findet der eine die Sitzungen des anderen nicht. Deshalb liegen Sitzungen in echten Anwendungen in einer Datenbank oder in einem Zwischenspeicher wie Redis. Am Ablauf ändert das nichts. Nur die drei Zeilen um sitzungen.get und sitzungen.set sehen dann anders aus.

Ablaufen und aufräumen

Eine Map, in die nur eingetragen wird, wächst. Jeder Besucher, der einmal vorbeischaut und nie wiederkommt, hinterlässt einen Eintrag, und den nimmt nie jemand heraus.

Abgelaufen und aufgeräumt
const ABLAUF_MS = 30 * 60 * 1000;
const jetzt = Date.now();

const sitzungen = new Map([
  ["gerade eben", { besuche: 2, zuletzt: jetzt }],
  ["vor zehn Minuten", { besuche: 5, zuletzt: jetzt - 10 * 60 * 1000 }],
  ["vor zwei Stunden", { besuche: 9, zuletzt: jetzt - 120 * 60 * 1000 }],
]);

console.log(`vorher im Speicher: ${sitzungen.size}`);

// Aufraeumen: wer laenger als ABLAUF_MS nicht da war, fliegt raus.
for (const [sid, sitzung] of sitzungen) {
  if (jetzt - sitzung.zuletzt > ABLAUF_MS) {
    sitzungen.delete(sid);
    console.log(`${sid.padEnd(18)} abgelaufen, entfernt`);
  }
}

console.log(`nachher im Speicher: ${sitzungen.size}`);

Deshalb merkt sich jede Sitzung, wann sie zuletzt benutzt wurde. Wer zu lange weg war, bekommt eine neue. Das hält den Speicher klein. Außerdem wäre eine Sitzungskennung, die ewig gälte, auch ewig brauchbar, falls sie doch einmal jemand mitliest.

Die Alternative ohne Serverzustand

Es gibt einen zweiten Weg. Die Daten wandern doch zum Browser, aber der Server unterschreibt sie, und dann fällt jede Änderung auf. So funktionieren signierte Token.

Der Vorteil ist, dass der Server nichts behalten muss. Den Nachteil merkst du beim Abmelden, denn ein Token, das der Server nicht kennt, kann er auch nicht zurücknehmen. Es gilt bis zu seinem Ablaufdatum weiter, und wer es hat, ist bis dahin angemeldet. Wer das beheben will, führt eine Liste zurückgenommener Token, und dann ist der Serverzustand wieder da, nur umständlicher.

Für diesen Kurs bleibt es deshalb bei der Sitzung, und Abmelden heißt dort sitzungen.delete(sid).

Die Middleware aus dem ersten Beispiel entsteht in der Aufgabe noch einmal, mit Zähler und Ablauf, und diesmal von dir.

Zum Mitnehmen

Der Browser trägt nur eine lange, zufällige Sitzungskennung aus randomBytes, alles andere liegt beim Server. Wer zu lange nicht da war, bekommt eine neue Sitzung, und die alte fliegt raus.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

In diesem Kurs läuft dein Code auf einem Server. Dafür hat das Basis Konto 1 Stunde im Monat, mehr Zeit gibt es mit dem Premium Konto.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.