Abschnitt 15 · Lektion 3
XSS beim Rendern
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
// 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("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'");
}
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 < und > 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 <
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 & Kekse nicht. Und weil
für HTML beim Ausgeben trotzdem maskiert wird, wird aus dem gespeicherten < in der Seite ein
&lt;.
Fünf Zeichen, und eins davon zuerst
// 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("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'");
}
function falsch(text) {
return String(text)
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'")
.replaceAll("&", "&");
}
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 &lt;b&gt;, und auf der Seite steht wörtlich
<b>. 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
function maskiere(text) {
return String(text)
.replaceAll("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'");
}
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.
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("&", "&")
.replaceAll("<", "<")
.replaceAll(">", ">")
.replaceAll('"', """)
.replaceAll("'", "'");
}
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, 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.