mitmario.dev

XSS beim Rendern

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

Im Browser setzt textContent fremden Text als Text ein, ganz gleich, was darin steht. Baut ein Server HTML als Text zusammen, hat er nichts dergleichen. Steht in einem gespeicherten Kommentar <script>, landet es als Element in der Seite. Und das Skript läuft bei jedem, der sie aufruft.

Gespeichert ist nicht gefährlich, ausgeliefert schon

Der Kommentar, der kein Kommentar ist
// Ein gespeicherter Kommentar. Der Text ist genau der, den jemand ins
// Formular getippt hat, und gespeichert wurde er unverändert.
const kommentar = {
  autor: "Mallory",
  text: '<script>alert("übernommen")</script>',
};

function maskiere(text) {
  return String(text)
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;");
}

console.log("So liefert der Server die Zeile heute aus:");
console.log(`  <li><b>${kommentar.autor}</b>: ${kommentar.text}</li>`);
console.log("");
console.log("Und so, wenn er beim Ausgeben maskiert:");
console.log(`  <li><b>${maskiere(kommentar.autor)}</b>: ${maskiere(kommentar.text)}</li>`);
console.log("");
console.log("Im Browser steht in der zweiten Zeile sichtbar der Text");
console.log('<script>alert("übernommen")</script>, und in der ersten passiert er.');

Ein Kommentar liegt in der Datenbank, und darin steht ein script-Element. Dort richtet es keinen Schaden an, es ist Text wie „Schöner Artikel“. Gefährlich wird es in dem Moment, in dem der Server es in ein Dokument legt und ausliefert, denn ab da gehört es zur Seite.

In der ersten Zeile des Beispiels bleibt das Element ein Element. In der zweiten sind aus < und > die Umschreibungen &lt; und &gt; geworden, und der Browser zeigt sichtbaren Text an, statt etwas auszuführen. Maskieren (englisch escaping) heißt, jedes Zeichen, das in HTML etwas bedeutet, durch seine Umschreibung zu ersetzen.

Man unterscheidet zwei Formen, und beide entstehen an derselben Stelle:

  • Gespeichertes XSS ist der Fall aus dem Beispiel. Der Text liegt in der Datenbank und geht an jeden, der die Seite aufruft. Ein einziger Kommentar erwischt alle Leser.
  • Reflektiertes XSS kommt aus der Anfrage selbst zurück, etwa über einen Suchbegriff, den die Fehlerseite wiederholt. Es erwischt nur den, der auf den präparierten Link klickt, und braucht dafür keinen Schreibzugang.

Ein reflektiertes steckt schon in der Route /buecher/kategorie/:name aus Lektion 9.3, so wie die Musterlösung sie schreibt. Sie baut den Namen aus dem Pfad in ihre Überschrift ein, und /buecher/kategorie/%3Cimg%20src%3Dx%3E bekommt <h1>Kategorie <img src=x></h1> als text/html zurück.

Warum beim Ausgeben und nicht beim Speichern

Gespeichert wird roh. Maskiert wird beim Ausgeben, und zwar für die eine Stelle, an die der Text gerade geht. Es liegt nahe, den Text gleich beim Speichern zu maskieren und die Sache damit ein für alle Mal zu erledigen. Das scheitert daran, dass dieselben Daten an verschiedenen Stellen landen und jede ihre eigenen Regeln hat.

Derselbe Kommentar geht in die HTML-Seite, in die JSON-Antwort deiner API, in die Benachrichtigungsmail und irgendwann in einen CSV-Export. In JSON ist < harmlos und &lt; schlicht falsch, denn dort liest ein Programm mit und bekommt einen Text, den nie jemand geschrieben hat. Wer beim Speichern maskiert, hat entschieden, bevor er wusste, wohin die Daten gehen.

Wer nach „Tee & Kekse“ sucht, findet außerdem ein gespeichertes Tee &amp; Kekse nicht. Und weil für HTML beim Ausgeben trotzdem maskiert wird, wird aus dem gespeicherten &lt; in der Seite ein &amp;lt;.

Fünf Zeichen, und eins davon zuerst

Fünf Zeichen, und die Reihenfolge zählt
// Fünf Zeichen müssen weg, und eins davon ist besonders: das
// kaufmännische Und leitet jede Maskierung ein und muss deshalb zuerst
// dran sein.
function richtig(text) {
  return String(text)
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;");
}

function falsch(text) {
  return String(text)
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;")
    .replaceAll("&", "&amp;");
}

for (const eingabe of ["Tee & Kekse", "<b>fett</b>", 'sagt "hallo"', "Wolf's Blog"]) {
  console.log(`Eingabe   ${eingabe}`);
  console.log(`  richtig ${richtig(eingabe)}`);
  console.log(`  falsch  ${falsch(eingabe)}`);
}

Die fünf Zeichen sind &, <, >, " und '. Vier davon sind offensichtlich. Das kaufmännische Und ist die Falle, weil es jede Maskierung einleitet. Wer es zuletzt ersetzt, maskiert die eigene Arbeit noch einmal. Aus <b> wird dann &amp;lt;b&amp;gt;, und auf der Seite steht wörtlich &lt;b&gt;. Ein Sicherheitsproblem ist das nicht. Aber ein Fehler, den Nutzer melden.

Bei „Tee & Kekse“ kommt in beiden Reihenfolgen dasselbe heraus, weil von den fünf Zeichen nur das & darin steht. Bei den drei anderen Eingaben siehst du den Fehler.

Textinhalt, Attribut und Adresse

Drei Stellen, drei Regeln
function maskiere(text) {
  return String(text)
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;");
}

const boese = {
  text: '<img src=x onerror="alert(1)">',
  autor: 'Mallory" onmouseover="alert(1)',
  seite: "javascript:alert(1)",
};

console.log("1. Im Textinhalt");
console.log(`   roh        <p>${boese.text}</p>`);
console.log(`   maskiert   <p>${maskiere(boese.text)}</p>`);
console.log("");
console.log("2. In einem Attribut");
console.log(`   roh        <a title="${boese.autor}">Profil</a>`);
console.log(`   maskiert   <a title="${maskiere(boese.autor)}">Profil</a>`);
console.log("");
console.log("3. In einer Adresse");
console.log(`   roh        <a href="${boese.seite}">Webseite</a>`);
console.log(`   maskiert   <a href="${maskiere(boese.seite)}">Webseite</a>`);
console.log(`   zerlegt    Schema ${new URL(boese.seite).protocol}, zum Vergleich ${new URL("https://anna.example").protocol}`);

Im Textinhalt reicht Maskieren. Aus dem img-Element wird sichtbarer Text, und das onerror löst nie aus.

In einem gewöhnlichen Attribut wie title reicht Maskieren ebenfalls, solange der Wert in Anführungszeichen steht. Ohne das maskierte Anführungszeichen endet das title-Attribut mitten im Namen. Dahinter steht dann ein onmouseover, das der Browser als Ereignis versteht, und das ist ein vollständiges XSS ohne ein einziges script-Element. In einem Attribut wie onclick, dessen Wert selbst JavaScript ist, hilft HTML-Maskieren dagegen nicht. Fremder Text hat dort nichts zu suchen.

In einer Adresse hilft Maskieren gar nichts. In javascript:alert(1) kommt keins der fünf Zeichen vor, und die maskierte Fassung ist Zeichen für Zeichen dieselbe. Eine Adresse wird deshalb geprüft statt maskiert. new URL(...) zerlegt sie, und in der letzten Zeile steht, welches Schema dabei herauskommt. Danach lässt eine Allowlist nur die Schemata durch, die erlaubt sind, und aus allen anderen wird #.

Eine vierte Stelle ist der Inhalt eines script-Elements, und dort gelten noch einmal andere Regeln. Der Browser übersetzt in einem Skript keine Umschreibungen zurück. Maskieren nach HTML-Art macht die Daten dort unleserlich und schützt trotzdem nicht, weil ein Backslash im Wert das Anführungszeichen dahinter verschluckt.

Wer Daten an ein Skript übergeben muss, legt sie als JSON in ein <script type="application/json">, das der Browser nicht ausführt, und ersetzt darin jedes < durch \u003c. Sonst beendet ein </script> im Wert den Block, und was danach kommt, ist wieder HTML. Gelesen wird das Ganze mit JSON.parse. In echten Projekten übernimmt das alles eine Template-Engine, ein Paket, das HTML aus einer Vorlage und Daten baut und dabei selbst maskiert.

Die Zeile in einem echten Browser

Im letzten Beispiel läuft ein Server, der dieselbe Zeile als Seite ausliefert.

Dieselbe Zeile, einmal im echten Browser
import { createServer } from "node:http";

// Genau der Text, den Mallory ins Formular getippt hat. Statt eines
// alert steht hier etwas Sichtbares: Der Rahmen der Seite laeuft
// ohne allow-modals, ein alert bliebe wirkungslos. Der Schaden ist
// derselbe, nur sieht man ihn.
const kommentar = {
  autor: "Mallory",
  text:
    "<scr" + "ipt>" +
    'document.title = "\u00fcbernommen";' +
    'document.body.style.background = "#7f1d1d";' +
    'document.body.style.color = "white";' +
    'document.body.append("Dieser Satz kam aus einem Kommentarfeld.");' +
    "</scr" + "ipt>",
};

function maskiere(text) {
  return String(text)
    .replaceAll("&", "&amp;")
    .replaceAll("<", "&lt;")
    .replaceAll(">", "&gt;")
    .replaceAll('"', "&quot;")
    .replaceAll("'", "&#39;");
}

const seite = [
  "<!doctype html>",
  '<meta charset="utf-8">',
  "<title>Kommentare</title>",
  "<h1>Kommentare</h1>",
  "<h2>So liefert der Server sie heute aus</h2>",
  `<ul><li><b>${kommentar.autor}</b>: ${kommentar.text}</li></ul>`,
  "<h2>Und so, wenn er beim Ausgeben maskiert</h2>",
  `<ul><li><b>${maskiere(kommentar.autor)}</b>: ${maskiere(kommentar.text)}</li></ul>`,
].join("\n");

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

createServer((req, res) => {
  res.setHeader("Content-Type", "text/html; charset=utf-8");
  res.end(seite);
}).listen(PORT);

Auf der Seite steht zuerst die Fassung ohne Maskierung und darunter dieselbe Zeile maskiert. Läuft die Sandbox, siehst du im Reiter Browser die Wirkung. Der Hintergrund ist dunkelrot, die Seite heißt jetzt „übernommen“, und am Ende steht ein Satz, den der Server nie geschrieben hat. Alle drei kommen aus einem Kommentarfeld. In der zweiten Liste steht der Text <script>...</script> dagegen sichtbar da, und mehr passiert nicht.

Statt eines alert steht im Kommentar etwas Sichtbares, weil ein alert im Rahmen der Seite ohne allow-modals wirkungslos bliebe.

Was ein XSS anrichtet und was es begrenzt

Ein Skript, das in deiner Seite läuft, kann alles, was die Seite kann. Es liest den Inhalt, schickt Anfragen mit den Cookies des Lesers und tauscht das Anmeldeformular aus. An ein Cookie mit HttpOnly kommt es nicht heran, und hier zeigt sich, wozu diese Angabe aus Lektion 13.3 gut ist. Der Angreifer kann dann immer noch Anfragen im Namen des Lesers schicken. Die Sitzungskennung mitnehmen und später in Ruhe benutzen kann er aber nicht.

Eine weitere Sicherung ist die Kopfzeile Content-Security-Policy, die in der Synthese dieses Abschnitts dazukommt. Beide greifen erst, wenn das Maskieren schon versagt hat.

Die Aufgabe hat eine Kommentarseite, auf der ein einziger Kommentar Text, Titel und Adresse zugleich angreift.

Zum Mitnehmen

Ein Kommentar wird so gespeichert, wie er getippt wurde, und erst auf dem Weg in die Seite maskiert, nach den Regeln der Stelle, an der er landet. Eine Adresse wird stattdessen gegen eine Liste erlaubter Schemata geprüft.

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.