mitmario.dev

Geschützte Routen

Node.js Sandbox 4 Min Lesezeit 4 BeispieleLektion 4 von 7

Wo nur Angemeldete hineindürfen, gehört vor jede Route eine Prüfung. Die Prüfung selbst ist kurz. An der falschen Stelle lässt sie aber irgendwann eine Route offen, und keine Fehlermeldung sagt es dir.

Der Wächter gehört an den Router

Am nächsten liegt die erste Zeile jeder Route. Das hält, bis jemand eine Route dazuschreibt und die Zeile vergisst.

Die vergessene erste Zeile
import express from "express";

const angemeldet = (req) => req.headers.cookie === "sid=TESTID";

function nurAngemeldet(req, res, next) {
  if (!angemeldet(req)) return res.status(401).send("Nicht angemeldet");
  next();
}

const app = express();

// So nicht: die Pruefung als erste Zeile in jeder Route. Bei der
// dritten ist sie vergessen worden, und man sieht es der Datei nicht an.
const vonHand = express.Router();
vonHand.get("/profil", (req, res) => {
  if (!angemeldet(req)) return res.status(401).send("Nicht angemeldet");
  res.send("Profil");
});
vonHand.get("/rechnungen", (req, res) => {
  if (!angemeldet(req)) return res.status(401).send("Nicht angemeldet");
  res.send("Rechnungen");
});
vonHand.get("/notizen", (req, res) => {
  res.send("Notizen");
});
app.use("/vonhand", vonHand);

// So: einmal am Router, und alles darunter ist zu.
const amRouter = express.Router();
amRouter.get("/profil", (req, res) => res.send("Profil"));
amRouter.get("/rechnungen", (req, res) => res.send("Rechnungen"));
amRouter.get("/notizen", (req, res) => res.send("Notizen"));
app.use("/amrouter", nurAngemeldet, amRouter);

app.listen(3000);

Im Reiter Browser steht /vonhand/notizen, und die Seite ist offen. Über die Befehlsleiste fragst du dazu /vonhand/profil und /amrouter/notizen ab. Dieselbe Anwendung, dieselben drei Seiten, und nur eine Schreibweise hält.

Dabei geht nichts kaputt. Die vergessene Route funktioniert prächtig, sie ist nur offen. Kein Test schlägt fehl, im Protokoll steht kein Fehler, und bemerkt wird es erst, wenn jemand die Route findet.

Deshalb kommt die Prüfung eine Ebene höher, an den Router. app.use("/intern", nurAngemeldet, internRouter) schickt alles, was unter /intern liegt, durch diesen Wächter, auch das, was du nächsten Monat dazuschreibst. Ein Router aus Lektion 10.4 ist die Klammer, die man dafür braucht.

Damit ist erst einmal alles zu. Offen ist nur, was ausdrücklich außerhalb des Routers steht. Wer es andersherum baut, muss bei jeder neuen Route daran denken, dass sie geschützt gehört.

Und wie sich das für einen Browser anfühlt
import express from "express";

const PORT = Number(process.env.PORT ?? 3000);

const app = express();

function seite(titel, absatz) {
  return [
    "<!doctype html>",
    '<meta charset="utf-8">',
    `<title>${titel}</title>`,
    `<h1>${titel}</h1>`,
    `<p>${absatz}</p>`,
    '<p><a href="/">Startseite</a> · <a href="/intern">Interner Bereich</a></p>',
  ].join("\n");
}

function nurAngemeldet(req, res, next) {
  // Niemand ist angemeldet, es gibt in diesem Beispiel gar keinen Login.
  // Darum geht es hier auch nicht. Gezeigt werden die beiden Ausgaenge.
  if (req.accepts(["json", "html"]) === "html") return res.redirect(303, "/login");
  return res.status(401).json({ fehler: { code: "nicht_angemeldet", meldung: "Bitte melde dich an." } });
}

app.get("/", (req, res) => {
  res.send(seite("Offen für alle", "Von hier führt ein Link in den internen Bereich."));
});

app.get("/login", (req, res) => {
  res.send(seite("Bitte anmelden", "Hierher hat dich der Wächter geschickt, weil du HTML wolltest."));
});

app.get("/intern", nurAngemeldet, (req, res) => {
  res.send(seite("Intern", "Hierhin kommt in diesem Beispiel niemand."));
});

app.listen(PORT);

Ein Klick auf „Interner Bereich“ führt statt zu einer Fehlermeldung auf die Anmeldeseite, und in der Adresszeile siehst du, wohin es ging. Ein Programm bekommt auf dasselbe /intern ein nacktes 401, und beides ist richtig. Den Unterschied macht eine einzige Kopfzeile, die der Browser von sich aus mitschickt.

Im Terminal stehen beide Antworten nebeneinander. curl -si http://localhost:3000/intern antwortet mit HTTP/1.1 401 Unauthorized und einem JSON-Rumpf, denn curl fragt von sich aus mit */*. Derselbe Aufruf mit -H "Accept: text/html" antwortet dagegen mit HTTP/1.1 303 See Other und Location: /login.

An der Weiterleitung steht dann noch ein Vary: Accept. Das setzt res.redirect von selbst, weil es seinen kurzen Text je nach Accept als HTML oder als Text schickt. Ein Zwischenspeicher darf die Antwort damit nur für Anfragen mit derselben Accept-Zeile wiederverwenden. Am 401 fehlt die Zeile, obwohl auch er davon abhängt. Wer sie dort haben will, ruft res.vary("Accept") selbst auf.

401 heißt „wer bist du“, 403 heißt „das darfst du nicht“

Zwischen den beiden Codes liegt die Frage, ob der Server weiß, wer fragt.

Wer bist du und was darfst du
import express from "express";

// Drei Besucher: einer ohne Sitzungskennung, ein Kunde, eine Chefin.
const nutzer = new Map([
  ["sid=TESTID", { email: "anna@example.com", rolle: "kunde" }],
  ["sid=ADMINID", { email: "chefin@example.com", rolle: "admin" }],
]);

const app = express();

app.use((req, res, next) => {
  req.nutzer = nutzer.get(req.headers.cookie);
  next();
});

app.get("/intern/profil", (req, res) => {
  if (!req.nutzer) return res.status(401).send("Ich weiß nicht, wer du bist.");
  res.send(`Profil von ${req.nutzer.email}`);
});

app.get("/intern/admin", (req, res) => {
  if (!req.nutzer) return res.status(401).send("Ich weiß nicht, wer du bist.");
  if (req.nutzer.rolle !== "admin") return res.status(403).send("Ich weiß, wer du bist, und du darfst das nicht.");
  res.send("Adminbereich");
});

app.listen(3000);

Im Reiter Browser steht der Rumpf des 401, „Ich weiß nicht, wer du bist.“, denn dein Browser bringt keine Sitzungskennung mit. curl schickt eine mit, TESTID für einen Kunden und ADMINID für die Chefin.

Ein 401 sagt „ich weiß nicht, wer du bist, melde dich erst an“. Ein 403 sagt „ich weiß, wer du bist, und du darfst hier trotzdem nicht hin“. Bei einem 401 hilft Anmelden. Bei einem 403 hilft es nur, wenn sich jemand mit einem anderen Konto anmeldet, das die Rolle hat.

Streng genommen gehört der 401 zu einem anderen Anmeldeverfahren, dem von HTTP selbst. RFC 9110 verlangt an jedem 401 eine Kopfzeile WWW-Authenticate, die das Verfahren nennt, mit dem man sich anmeldet. Eine Anwendung mit Anmeldeformular und Cookie schickt sie nicht und benutzt den 401 trotzdem, weil es für „nicht angemeldet“ keinen besseren Code gibt.

In der Anwendung sind das zwei Wächter. Der erste beantwortet die Frage „angemeldet?“, hängt den gefundenen Nutzer an die Anfrage und gibt weiter. Der zweite sieht sich dessen Rolle an und kann sich dabei darauf verlassen, dass der erste schon gelaufen ist, denn sonst käme die Anfrage gar nicht erst bei ihm an.

Eine Seite leitet weiter, eine Schnittstelle antwortet

Ein 401 mit JSON ist für ein Programm richtig. Ein Mensch, der auf einen Link klickt, will aber lieber auf die Anmeldeseite, statt eine Fehlermeldung anzustarren. Beides erledigt derselbe Wächter, und was er tut, hängt an der Kopfzeile Accept der Anfrage.

Seite oder Schnittstelle
import express from "express";

const app = express();

app.get("/", (req, res) => {
  res.type("text/plain").send([
    `Accept-Kopfzeile:              ${req.headers.accept}`,
    `req.accepts(["json", "html"]): ${req.accepts(["json", "html"])}`,
    `req.accepts("html"):           ${req.accepts("html")}`,
  ].join("\n"));
});

app.listen(3000);

Die Falle steckt in dem, was curl ohne Angabe schickt, Accept: */*. Mit curl -s http://localhost:3000/ im Terminal antwortet der Server dann mit req.accepts("html"): html. req.accepts("html") fragt, ob HTML für den Aufrufer in Ordnung geht, und auf */* lautet die Antwort ja. Damit landete jedes Programm auf der Anmeldeseite, auch curl und auch dein eigenes Frontend.

Eigentlich will der Wächter wissen, was von beidem besser passt. Das fragt req.accepts(["json", "html"]) mit einer Liste. Bei */* gewinnt der erste Eintrag. Über die Reihenfolge entscheidest du also selbst, was im Zweifel herauskommt. Ein Browser mit seiner langen Liste bekommt html, alle anderen json.

Damit hat der Wächter drei Ausgänge. Er lässt durch, leitet weiter oder antwortet mit 401.

In der Aufgabe liegen beide Wächter schon fertig in schutz.js, offen ist nur, wo sie hängen.

Zum Mitnehmen

Ein Wächter vor dem ganzen Bereich ist sicherer als eine Prüfung in jeder Route, denn eine neue Route ist dann von selbst geschützt. Ein 401 heißt nicht angemeldet, ein 403 angemeldet, aber ohne die Rolle.

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 4 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.