mitmario.dev

Synthese: der geschützte Bereich

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

Ein Anmeldebereich, in dem jede Route für sich stimmt, kann trotzdem niemanden hineinlassen. Die Routen hängen an einer einzigen Sitzungskennung und an der Reihenfolge der Middlewares. Ein Stück an der falschen Stelle reicht.

Wo die Sitzungskennung entsteht und verschwindet

Die Seite hat drei Buttons für Registrieren, Anmelden und Abmelden und einen Link auf /intern.

Die ganze Reise, einmal selbst gelaufen
import express from "express";
import { DatabaseSync } from "node:sqlite";
import { randomBytes } from "node:crypto";

// Ein Konto ist hier nur eine Adresse, ein Passwort gibt es nicht.
const db = new DatabaseSync(":memory:");
db.exec("CREATE TABLE nutzer (id INTEGER PRIMARY KEY, email TEXT NOT NULL UNIQUE)");
const sitzungen = new Map();

const app = express();
app.use(express.urlencoded({ extended: true }));
app.use((req, res, next) => {
  const sid = (req.headers.cookie ?? "").split("=")[1];
  req.sitzung = sitzungen.get(sid);
  next();
});

app.get("/", (req, res) =>
  res.type("html").send(
    '<form method="post" action="/registrieren">' +
      '<p><input name="email" value="anna@example.com"></p>' +
      "<p><button>Registrieren</button></p>" +
      "</form>" +
      '<form method="post" action="/login">' +
      '<p><input name="email" value="anna@example.com"></p>' +
      "<p><button>Anmelden</button></p>" +
      "</form>" +
      '<p><a href="/intern">/intern</a></p>' +
      '<form method="post" action="/logout"><p><button>Abmelden</button></p></form>'
  )
);

app.post("/registrieren", (req, res) => {
  db.prepare("INSERT INTO nutzer (email) VALUES (?)").run(req.body.email.toLowerCase());
  res.status(201).send("angelegt");
});

app.post("/login", (req, res) => {
  const nutzer = db.prepare("SELECT id FROM nutzer WHERE email = ?").get(req.body.email);
  if (!nutzer) return res.status(401).send("Anmeldung fehlgeschlagen.");
  const id = randomBytes(16).toString("hex");
  sitzungen.set(id, { id, nutzerId: nutzer.id });
  res.cookie("sid", id, { httpOnly: true, sameSite: "lax" });
  res.redirect(303, "/intern");
});

app.get("/intern", (req, res) => {
  if (!req.sitzung?.nutzerId) return res.status(401).send("Nicht angemeldet");
  res.send(`Angemeldet als ${db.prepare("SELECT email FROM nutzer WHERE id = ?").get(req.sitzung.nutzerId).email}`);
});

app.post("/logout", (req, res) => {
  if (req.sitzung) sitzungen.delete(req.sitzung.id);
  res.clearCookie("sid", { httpOnly: true, sameSite: "lax" });
  res.redirect(303, "/");
});

app.listen(3000);

Am meisten siehst du in dieser Reihenfolge: erst /intern, dann Registrieren, wieder /intern, Anmelden, /intern, Abmelden und noch einmal /intern. Nur der Aufruf nach dem Anmelden lässt hinein.

Die Routen sind dafür gekürzt, ein Konto ist hier nur eine Adresse ohne Passwort. Wie das Passwort gehasht und beim Anmelden geprüft wird, steht in den Lektionen davor, und an der Reise der Sitzungskennung ändert es nichts. Außerdem fehlen eine Prüfung der Felder und die 409. Beim Anmelden wird eine mitgebrachte Sitzung nicht verworfen, und ein zweites Registrieren derselben Adresse endet mit einem 500. Auf dem Fehlerkanal steht dazu Error: UNIQUE constraint failed: nutzer.email.

Die Sitzungskennung entsteht beim Anmelden und verschwindet beim Abmelden. Dazwischen ändert sie sich nicht. Registrieren gibt keine aus, denn ein Konto anzulegen heißt nicht, angemeldet zu sein.

Im Reiter Netzwerk kannst du die Sitzungskennung dabei verfolgen. Die Antwort auf POST /login setzt sie mit Set-Cookie, die Anfragen danach tragen sie in der Kopfzeile Cookie, und die Antwort auf POST /logout löscht sie wieder.

An den Set-Cookie-Zeilen steht dort Secure; SameSite=None; Partitioned statt des SameSite=Lax aus dem Code. So schreibt der Server dieses Kurses jedes Cookie für den Reiter Browser um, denn sonst käme es im eingebetteten Fenster nicht an. curl im Terminal bekommt die Zeile so, wie der Code sie schreibt.

/intern antwortet am Anfang und am Ende mit demselben 401 und meint trotzdem zwei verschiedene Dinge. Beim ersten Mal war noch nie jemand angemeldet, beim letzten Mal hat sich jemand abgemeldet. Für den Server ist das dasselbe, und das ist richtig so. Er kennt nur gültige und ungültige Sitzungskennungen.

Die Reihenfolge der Middlewares

Die vier Routen sind schnell geschrieben. Schief geht in einer Synthese eher etwas anderes. Eine Middleware steht an der falschen Stelle, und dann funktioniert etwas nicht, das für sich genommen richtig aussieht.

Zwei Stücke an der falschen Stelle
import express from "express";

// Express' eingebauter Fehler-Logger schreibt sonst absolute Pfade auf
// stderr. Gelesen wird der Wert erst beim Erzeugen der Anwendung, die
// Zeile wirkt also auch hier oben schon. Derselbe Griff wie in 10.5.
process.env.NODE_ENV = "test";

// Dreimal dieselbe Anwendung, zweimal steht ein Stueck falsch.
function baue(variante) {
  const app = express();
  const sitzungen = new Map([["TESTID", { nutzerId: 1 }]]);

  const sitzungAnhaengen = (req, res, next) => {
    req.sitzung = sitzungen.get((req.headers.cookie ?? "").split("=")[1]);
    next();
  };

  if (variante !== "Parser fehlt") app.use(express.urlencoded({ extended: true }));
  if (variante !== "Sitzung zu spät") app.use(sitzungAnhaengen);

  app.post("/login", (req, res) => {
    res.type("text/plain").send(`angemeldet als ${req.body.email}`);
  });
  app.get("/intern", (req, res) => {
    if (!req.sitzung) return res.status(401).type("text/plain").send("Nicht angemeldet");
    res.type("text/plain").send("Intern");
  });

  // Zu spaet: die Routen darueber haben req.sitzung nie gesehen.
  if (variante === "Sitzung zu spät") app.use(sitzungAnhaengen);

  return app;
}

async function probiere(variante, port) {
  // Jede Variante bekommt einen eigenen Port. Mit einem gemeinsamen
  // griffe fetch beim naechsten Durchgang auf die Verbindung zum
  // vorigen, schon geschlossenen Server zurueck: close() wartet auf
  // offene Verbindungen, und eine offene ist genau das.
  const server = baue(variante).listen(port);
  await new Promise((fertig) => server.once("listening", fertig));

  console.log(variante);
  const anmelden = await fetch(`http://127.0.0.1:${port}/login`, {
    method: "POST",
    headers: { "Content-Type": "application/x-www-form-urlencoded" },
    body: "email=anna@example.com",
  });
  // Bei 500 antwortet Express mit einer Seite, die den Stacktrace zeigt.
  const text = anmelden.ok ? await anmelden.text() : "(Fehlerseite)";
  console.log(`  POST /login   ${anmelden.status}  ${text}`);

  const intern = await fetch(`http://127.0.0.1:${port}/intern`, { headers: { Cookie: "sid=TESTID" } });
  console.log(`  GET  /intern  ${intern.status}  ${await intern.text()}`);
  console.log("");

  server.close();
  await new Promise((fertig) => server.once("close", fertig));
}

let port = 3000;

for (const variante of ["Parser fehlt", "Sitzung zu spät", "alles an seinem Platz"]) {
  await probiere(variante, port++);
}

Fehlt express.urlencoded, ist req.body schlicht undefined, und der Zugriff darauf wirft TypeError: Cannot read properties of undefined (reading 'email'). Express antwortet dann mit 500, und im Beispiel steht dafür nur „(Fehlerseite)“.

Steht die Sitzungs-Middleware unter den Routen, läuft sie zwar, aber erst nach ihnen. Die Anfrage ist da längst beantwortet, und req.sitzung war die ganze Zeit undefined. Die Sitzungskennung stimmt, die Sitzung gibt es, und trotzdem kommt niemand hinein.

Vom Übungsbereich zur echten Anwendung

Was du in der Aufgabe baust, ist ein vollständiger Anmeldebereich. In eine echte Anwendung würdest du ihn so trotzdem nicht stellen. Es fehlen das vergessene Passwort, die Bestätigung der E-Mail-Adresse, ein zweiter Faktor und eine Grenze für die Zahl der Anmeldeversuche.

Die Grenze kommt in Lektion 15.5. Das vergessene Passwort und die Bestätigung der Adresse haben dasselbe Problem.

Der Link, den dieser Kurs nicht verschicken kann
import { randomBytes, createHash } from "node:crypto";

// Ein Ruecksetz-Token ist schnell gebaut. Er ist ein Passwortersatz auf
// Zeit und wird deshalb genauso behandelt: lang, zufaellig, nur gehasht
// gespeichert, mit Ablauf und nur einmal verwendbar.
const token = randomBytes(32).toString("hex");
const abgelegt = {
  nutzerId: 1,
  tokenHash: createHash("sha256").update(token).digest("hex"),
  gueltigBis: "in 30 Minuten",
  benutzt: false,
};

console.log(`Token für den Link:   ${token.length} Zeichen`);
console.log(`in der Tabelle:       tokenHash mit ${abgelegt.tokenHash.length} Zeichen`);
console.log(`gültig:               ${abgelegt.gueltigBis}`);
console.log(`schon benutzt:        ${abgelegt.benutzt}`);
console.log("");

// Und hier hoert dieser Kurs auf.
console.log("Der Link muss jetzt an die Adresse gehen, und ausschließlich dorthin.");
console.log("Das ist der Schritt, den eine Sandbox ohne Mailversand nicht tun kann.");

Beide brauchen einen zweiten Kanal, also einen Weg zum Nutzer, der nicht über denselben Browser läuft, meistens eine E-Mail. Der Code davor ist überschaubar, im Beispiel steht er fast vollständig. Der Token darin ist lang und zufällig, wird nur gehasht gespeichert, läuft ab und gilt nur einmal, wie ein Passwort auf Zeit. Nur verschicken kann diese Sandbox nichts, und an dieser Stelle hört der Kurs auf.

Der zweite Faktor mit einer App käme ohne Versand aus. Die App rechnet alle dreißig Sekunden eine Zahl aus einem Geheimnis, das sie einmal bekommen hat, und der Server rechnet dieselbe Zahl nach. Das wäre ein eigener Abschnitt.

Für eine echte Anwendung führt der Weg über einen Maildienst mit einer Schnittstelle. Die Regeln für den Link stehen im Forgot Password Cheat Sheet von OWASP.

Die Aufgabe verlangt die vier Routen des Bereichs, Sitzungen und Passwortfunktionen liegen schon bereit.

Zum Mitnehmen

Angemeldet ist, wer eine Sitzungskennung aus dem Login mitbringt, und mit dem Abmelden ist sie wertlos. Parser und Sitzungs-Middleware stehen über den Routen, sonst sehen die weder Rumpf noch Sitzung.

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.