Abschnitt 14 · Lektion 4
Geschützte Routen
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.
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.
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.
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.
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, kostenlosZu 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.