mitmario.dev

Synthese: die abgesicherte API

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

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:

PunktWogegenKam vor in
Eingaben prüfenerfundene Rollen, Unsinn in Zahlenfeldern15.1
Parameter statt VerkettungSQL-Injection15.2
Ausgabe maskierenXSS15.3
Secrets aus der UmgebungZugangsdaten im Repository15.4
Anfragen begrenzenDurchprobieren, teure Routen als Waffe15.5
Größe des Rumpfs begrenzenein Aufruf, der den Speicher fülltneu
Fehlermeldungen ohne Internadie halbe Architektur in einer 500neu
Sicherheitskopfzeilendie zweite Verteidigungslinieneu

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.

Dieselben Daten, zwei Ausgaben
// 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("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;");
}

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 &amp;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

Welche Kopfzeilen Express schon setzt
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-Policy sagt, aus welchen Quellen der Browser überhaupt etwas laden und ausführen darf. Für eine API ist default-src 'none' richtig, denn sie soll gar nichts laden. Gegen XSS ist das die zweite Verteidigungslinie, nach dem Maskieren.
  • X-Content-Type-Options: nosniff verbietet dem Browser, den Inhaltstyp zu erraten.
  • Referrer-Policy: no-referrer schickt beim Weiterklicken gar keine Herkunft mehr mit. Pfad und Query lassen heutige Browser an fremden Servern ohnehin weg, mit no-referrer fehlt auch noch die Domain.
  • Strict-Transport-Security sagt 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

Was eine Fehlerantwort verrät
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, 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.