Abschnitt 15 · Lektion 7
Synthese: die abgesicherte API
Auf dem eigenen Rechner fragt die Bücher-API niemand mit böser Absicht. Steht sie im Netz, kommen Anfragen von Leuten, die ausprobieren, was sie verrät, wie viel sie annimmt und was sie mit fremdem Text macht.
Die Liste zum Abhaken
Acht Punkte, jeder mit dem, wogegen er hilft:
| Punkt | Wogegen | Kam vor in |
|---|---|---|
| Eingaben prüfen | erfundene Rollen, Unsinn in Zahlenfeldern | 15.1 |
| Parameter statt Verkettung | SQL-Injection | 15.2 |
| Ausgabe maskieren | XSS | 15.3 |
| Secrets aus der Umgebung | Zugangsdaten im Repository | 15.4 |
| Anfragen begrenzen | Durchprobieren, teure Routen als Waffe | 15.5 |
| Größe des Rumpfs begrenzen | ein Aufruf, der den Speicher füllt | neu |
| Fehlermeldungen ohne Interna | die halbe Architektur in einer 500 | neu |
| Sicherheitskopfzeilen | die zweite Verteidigungslinie | neu |
Die ersten fünf hast du in diesem Abschnitt gebaut. Die letzten drei kommen hier dazu.
Maskieren heißt nicht überall dasselbe
„Ausgabe maskieren“ klingt nach einem Schalter, den man einmal umlegt.
// Ein Titel, den jemand angelegt hat. Gespeichert wird er unverändert.
const buch = { id: 11, titel: '<script>alert("hallo")</script>', jahr: 2026 };
function maskiere(text) {
return String(text)
.replaceAll("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'");
}
console.log("Als JSON, richtig:");
console.log(` ${JSON.stringify(buch)}`);
console.log("");
console.log("Als JSON, falsch maskiert:");
console.log(` ${JSON.stringify({ ...buch, titel: maskiere(buch.titel) })}`);
console.log("");
console.log("Als HTML, richtig:");
console.log(` <li>${maskiere(buch.titel)}</li>`);
console.log("");
console.log("Als HTML, falsch:");
console.log(` <li>${buch.titel}</li>`);
console.log("");
console.log("Der Wert ist derselbe. Was richtig ist, entscheidet die Ausgabe."); Dasselbe Buch kommt als JSON und als HTML je einmal richtig und einmal falsch heraus. In HTML muss
der Titel maskiert werden, sonst wird aus ihm ein Element. In JSON darf er es nicht. Dort ist <
ein ganz gewöhnliches Zeichen, und JSON.stringify kümmert sich um das, was in JSON wirklich
gefährlich ist, nämlich Anführungszeichen und Zeilenumbrüche. Wer eine JSON-Antwort HTML-maskiert,
liefert einem Programm einen Text aus, den nie jemand eingegeben hat, und irgendwann steht
&lt; in einer Datenbank.
Die API hat beide Ausgaben und damit zwei Antworten auf die Frage, ob maskiert wird. Für die HTML-Übersicht ja, für JSON nein.
Dass der unmaskierte Titel im JSON harmlos bleibt, sichert eine der Kopfzeilen weiter unten ab.
X-Content-Type-Options: nosniff sagt dem Browser, dass er den Content-Type ernst nehmen soll,
statt am Rumpf zu raten. Ein Browser, der rät, kann eine Antwort mit <script> darin für HTML
halten und ausführen.
Sicherheitskopfzeilen
import express from "express";
// Express' eingebauter Fehler-Logger legte sonst einen Stacktrace mit
// absoluten Pfaden auf stderr. Derselbe Griff wie in 10.5.
process.env.NODE_ENV = "test";
const app = express();
app.get("/ohne", (req, res) => res.json({ ok: true }));
app.get("/mit", (req, res) => {
res.set("X-Content-Type-Options", "nosniff");
res.set("Content-Security-Policy", "default-src 'none'");
res.set("Referrer-Policy", "no-referrer");
res.set("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
res.json({ ok: true });
});
app.get("/kaputt", () => {
throw new Error("etwas ist schiefgegangen");
});
app.listen(3000); In der Befehlsleiste steht je ein curl -si für /ohne, /mit und /kaputt, und das -i holt
die Kopfzeilen der Antwort mit ins Terminal.
Bei einer normalen Antwort wie unter /ohne setzt Express keine der vier Kopfzeilen. Bei einem
unbehandelten Fehler unter /kaputt stehen dagegen zwei da, Content-Security-Policy und
X-Content-Type-Options, weil die eingebaute Fehlerseite von Express sich selbst absichert.
Probierst du deine Kopfzeilen an einer Fehlerantwort aus, siehst du also die von Express.
Die vier in je einem Satz:
Content-Security-Policysagt, aus welchen Quellen der Browser überhaupt etwas laden und ausführen darf. Für eine API istdefault-src 'none'richtig, denn sie soll gar nichts laden. Gegen XSS ist das die zweite Verteidigungslinie, nach dem Maskieren.X-Content-Type-Options: nosniffverbietet dem Browser, den Inhaltstyp zu erraten.Referrer-Policy: no-referrerschickt beim Weiterklicken gar keine Herkunft mehr mit. Pfad und Query lassen heutige Browser an fremden Servern ohnehin weg, mitno-referrerfehlt auch noch die Domain.Strict-Transport-Securitysagt dem Browser, dass er diese Domain künftig nur noch über HTTPS ansprechen soll. Sie wirkt erst ab dem zweiten Besuch und nur über HTTPS, und sie ist die einzige der vier, die man versehentlich zu lange setzen kann.
In echten Projekten nimmt man dafür Helmet, ein Paket, das diese vier und acht weitere Kopfzeilen mit vernünftigen Vorgaben setzt. Im Kurs stehen sie trotzdem von Hand da. Es sind nur ein paar Zeilen, und man sieht daran, was das Paket eigentlich tut.
X-Powered-By: Express verrät dagegen, womit du arbeitest, und app.disable("x-powered-by") nimmt
diese Kopfzeile heraus. Schützen tut das nichts, du verrätst nur weniger.
Was eine Fehlerantwort verraten darf
import express from "express";
// Wie in 10.5: sonst legt Express' Logger absolute Pfade auf stderr.
process.env.NODE_ENV = "test";
const MELDUNG = "Verbindung zu postgres://kunde:s3cr3t@192.0.2.10/produktiv fehlgeschlagen";
function baue(variante) {
const app = express();
app.get("/kaputt", () => {
throw new Error(MELDUNG);
});
if (variante === "eigener Fehler-Handler, geschwätzig") {
app.use((fehler, req, res, next) => {
res.status(500).json({ fehler: fehler.message });
});
}
if (variante === "eigener Fehler-Handler, dicht") {
app.use((fehler, req, res, next) => {
console.error(`[intern] ${fehler.message}`);
res.status(500).json({ fehler: { code: "serverfehler", meldung: "Da ist etwas schiefgegangen." } });
});
}
return app;
}
// Die drei Varianten nebeneinander statt nacheinander: jede haengt
// unter ihrem eigenen Pfad, und du vergleichst die Antworten selbst.
const app = express();
app.use("/ohne", baue("kein eigener Fehler-Handler"));
app.use("/geschwaetzig", baue("eigener Fehler-Handler, geschwätzig"));
app.use("/dicht", baue("eigener Fehler-Handler, dicht"));
app.listen(3000); Dieselbe kaputte Route steht dreimal da, jede Fassung unter ihrem eigenen Pfad. Im Reiter Browser
steht die erste, /ohne/kaputt, und die beiden anderen holst du je mit einem curl. Gesucht wird
in jeder Antwort nach dem Wort s3cr3t und nach dem Dateinamen.
Ohne eigenen Fehler-Handler liefert Express eine Seite mit dem vollständigen Stacktrace. Darin
stehen Dateinamen, Zeilennummern, die Verzeichnisstruktur des Servers und nebenbei das
Datenbankpasswort, das in der Fehlermeldung stand. Gut ein Kilobyte Einblick für jemanden, der nur
eine Adresse aufgerufen hat. So antwortet Express, solange NODE_ENV nicht auf production steht,
und auf einem Server, auf dem das jemand vergessen hat, ebenso.
Die zweite Fassung sieht aufgeräumt aus und schreibt fehler.message in die Antwort. Der Stacktrace
ist weg, das Passwort steht immer noch drin. Geschrieben hat die Meldung ja jemand, der den Fehler
später finden wollte.
Die dritte ist die kürzeste. Nach außen gehen ein Statuscode, ein Code für Programme und ein Satz, nach innen auf stderr die ganze Meldung. Der Fehler-Handler der Bücher-API hat das schon so getrennt.
Auch die Größe des Rumpfs gehört an den Rand der Anwendung. express.json() nimmt ohne Angabe bis
zu 100 Kilobyte entgegen, und für eine API, die Titel und Jahreszahlen verwaltet, ist das drei
Größenordnungen zu viel. express.json({ limit: "1kb" }) antwortet stattdessen mit 413, bevor der
Rumpf vollständig gelesen ist.
Acht Stellen statt einer
Keiner der acht Punkte ist für sich genommen schwierig. Schwierig ist, dass sie an acht verschiedenen Stellen stehen. Die Prüfung gehört in die Route, das Maskieren in die Ausgabe, die Kopfzeilen ganz nach oben, die Fehlerbehandlung ganz nach unten, und das Secret gar nicht in den Code.
Der Tageskurs Web Security Mastery geht dieselben Themen über dreißig Tage durch statt über sieben Lektionen.
In der Aufgabe kommen die drei neuen Punkte in die server.js der Bücher-API, dazu eine maskierte
Übersicht unter /.
Zum Mitnehmen
Acht Punkte machen die Bücher-API öffentlich erreichbar, und sie stehen an acht verschiedenen Stellen. Neu sind ein Limit für den Rumpf, Fehlerantworten ohne Interna und vier Sicherheitskopfzeilen.
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 3 Beispielen zum Ausprobieren
Steht hier, ohne Konto lesbar.
-
Aufgabe, dein Code läuft auf einem Server
Öffnet sich mit dem Basis Konto.