Abschnitt 15 · Lektion 3
CSRF
Dein angemeldeter Besucher ruft eine fremde Seite auf, und bei dir steht danach eine Notiz, die er nie angelegt hat. Dein Code kann dabei fehlerfrei sein. Der Angriff heißt CSRF, ausgeschrieben Cross-Site Request Forgery, also eine Anfrage, die eine fremde Seite im Namen deines Besuchers fälscht. Eine geklebte Abfrage oder eine rohe Ausgabe braucht er nicht. Ausgenutzt wird der Browser des Besuchers.
Der Ablauf in fünf Sätzen
Dein Besucher ist bei dir angemeldet, sein Browser hat also das Cookie mit seiner Sitzungskennung. Er ruft eine ganz andere Seite auf, die ihm jemand geschickt hat. Diese Seite enthält ein verstecktes Formular, das auf deine Anwendung zeigt und sich beim Laden von selbst absendet. Der Browser schickt die Anfrage los und legt das Cookie automatisch dazu, denn die Anfrage geht ja an dich. Für deine Anwendung sieht das aus wie eine ganz normale, angemeldete Aktion, und sie führt sie aus.
<?php
declare(strict_types=1);
// Eine Notiz-App ohne Schutz. Sie glaubt jedem POST auf /speichern.
session_start();
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("CREATE TABLE IF NOT EXISTS notizen (id INTEGER PRIMARY KEY, titel TEXT NOT NULL)");
function e(?string $w): string { return htmlspecialchars($w ?? "", ENT_QUOTES, "UTF-8"); }
$pfad = parse_url($_SERVER["REQUEST_URI"], PHP_URL_PATH);
if ($pfad === "/speichern" && $_SERVER["REQUEST_METHOD"] === "POST") {
$t = trim($_POST["text"] ?? "");
if ($t !== "") {
$db->prepare("INSERT INTO notizen (titel) VALUES (:t)")->execute([":t" => $t]);
}
header("Location: /", true, 302);
exit;
}
$notizen = $db->query("SELECT titel FROM notizen ORDER BY id DESC")->fetchAll();
?>
<!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>Deine Notizen</title></head>
<body>
<h1>Deine Notizen</h1>
<form method="post" action="/speichern">
<input type="text" name="text" size="30"> <button type="submit">Anlegen</button>
</form>
<ul>
<?php foreach ($notizen as $n) { ?>
<li><?= e($n["titel"]) ?></li>
<?php } ?>
</ul>
</body>
</html> <!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>Gratis Katzenbilder</title></head>
<body>
<h1>Gratis Katzenbilder!</h1>
<p>Sieht harmlos aus. Im Hintergrund schickt diese Seite aber ein
Formular an deine Notiz-App, ohne dass du etwas anklickst.</p>
<form method="post" action="/speichern" id="angriff">
<input type="hidden" name="text" value="Von einer fremden Seite eingeschleust">
</form>
<script>document.getElementById("angriff").submit();</script>
</body>
</html> Neben der Notiz-App liegt angriff.html, die fremde Seite. Mit /angriff.html in der Adresszeile
öffnet sie sich, und viel zu lesen gibt es dort nicht. Ihr Skript schickt beim Laden ein Formular an
/speichern, die Weiterleitung führt zurück auf /, und dort steht eine Notiz, die niemand
angelegt hat. Im Reiter Netzwerk stehen die zwei Schritte, POST /speichern mit 302 und danach
GET / mit 200. Im Terminal tut curl -si -d 'text=Fremd' localhost:3000/speichern | head -1
dasselbe ohne Katzenbilder. Der Server sagt 302 Found und nimmt die Notiz.
Die fremde Seite liegt hier auf demselben Server wie die App, streng genommen ist das also gar kein
Cross-Site. Das Formular, das ohne Zutun absendet, ist trotzdem echt. Bei einem richtigen Angriff
läge angriff.html auf einer fremden Adresse, und ob der Browser dein Cookie dann dazulegt, hängt
am Cookie und am Browser. Chrome behandelt ein Cookie ohne SameSite-Angabe seit 2020 wie Lax und
lässt es weg, wenn eine fremde Seite ein Formular per POST abschickt. Nur Cookies, die höchstens
zwei Minuten alt sind, schickt Chrome bei so einem POST trotzdem mit. Chromium nennt diese Ausnahme
selbst vorübergehend.
Das Token als Antwort
Der Angreifer kann die Anfrage nachbauen, ohne deine Seite je gesehen zu haben, denn er kennt die Adresse und die Feldnamen. Einen Wert, der beim Aufbau des Formulars zufällig entsteht, kennt er dagegen nicht. Diese lange Zufallsfolge heißt Token. Sie liegt an zwei Orten, in der Sitzung des Besuchers und in einem versteckten Feld im Formular. Kommt der POST zurück, werden beide verglichen. Der ehrliche Absender hat das Token aus dem Formular und schickt es mit. Die fremde Seite kennt es nicht. Ihr Feld ist leer oder erfunden, und ihr POST prallt ab.
<?php
declare(strict_types=1);
// Dieselbe App, jetzt mit einem Token. Erzeugt in der Sitzung, ins
// Formular gelegt, beim Empfang verglichen.
session_start();
if (empty($_SESSION["token"])) {
$_SESSION["token"] = bin2hex(random_bytes(16));
}
$token = $_SESSION["token"];
$db = new PDO("sqlite:" . __DIR__ . "/daten.db", null, null, [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
]);
$db->exec("CREATE TABLE IF NOT EXISTS notizen (id INTEGER PRIMARY KEY, titel TEXT NOT NULL)");
function e(?string $w): string { return htmlspecialchars($w ?? "", ENT_QUOTES, "UTF-8"); }
$pfad = parse_url($_SERVER["REQUEST_URI"], PHP_URL_PATH);
if ($pfad === "/speichern" && $_SERVER["REQUEST_METHOD"] === "POST") {
if (!hash_equals($_SESSION["token"], $_POST["token"] ?? "")) {
http_response_code(403);
echo "Ungültiges Token.";
exit;
}
$t = trim($_POST["text"] ?? "");
if ($t !== "") {
$db->prepare("INSERT INTO notizen (titel) VALUES (:t)")->execute([":t" => $t]);
}
header("Location: /", true, 302);
exit;
}
$notizen = $db->query("SELECT titel FROM notizen ORDER BY id DESC")->fetchAll();
?>
<!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>Deine Notizen</title></head>
<body>
<h1>Deine Notizen</h1>
<form method="post" action="/speichern">
<input type="hidden" name="token" value="<?= e($token) ?>">
<input type="text" name="text" size="30"> <button type="submit">Anlegen</button>
</form>
<ul>
<?php foreach ($notizen as $n) { ?>
<li><?= e($n["titel"]) ?></li>
<?php } ?>
</ul>
</body>
</html> <!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>Gratis Katzenbilder</title></head>
<body>
<h1>Gratis Katzenbilder!</h1>
<p>Dieselbe fremde Seite wie vorhin. Diesmal kennt sie das Token
nicht, und ihr Formular prallt mit 403 ab.</p>
<form method="post" action="/speichern" id="angriff">
<input type="hidden" name="text" value="Von einer fremden Seite eingeschleust">
</form>
<script>document.getElementById("angriff").submit();</script>
</body>
</html> Dieselbe App mit Token, und dieselbe angriff.html. Diesmal endet ihr POST mit 403. Im Reiter
Browser steht Ungültiges Token., im Reiter Netzwerk der POST /speichern mit 403. Eine fremde
Notiz gibt es nicht. Das eigene Formular funktioniert weiter, denn es trägt das Token, das in der
Sitzung steht.
Im Reiter Netzwerk siehst du bei jedem POST auch, was im Anfrage-Rumpf mitging. Beim eigenen
Formular ist das ein token= mit der langen Zufallsfolge und dahinter das text=. Beim POST der
fremden Seite ist es nur das text=.
Im Terminal antwortet curl -si -d 'text=Fremd' localhost:3000/speichern | head -1 als fremde Seite
jetzt mit 403 Forbidden. Der zweite Befehl in der Befehlsleiste macht den ehrlichen Absender. Er
holt sich erst das Formular, merkt sich Token und Cookie und schickt dann damit ab. Seine
Antwort ist die 302. Das alles steht in einer Zeile, denn jeder Befehl im Terminal fängt mit einer
frischen Shell an. Eine Variable aus dem Befehl davor ist beim nächsten schon weg. T=$(…) legt
dabei die Ausgabe der Befehle in der Klammer in eine Variable T, und $T setzt sie im zweiten
Befehl wieder ein. Den Wert des Tokens schneiden grep -o und cut aus der Seite.
Verglichen wird mit hash_equals
<?php
declare(strict_types=1);
// Warum hash_equals und nicht ===, und die Falle mit dem leeren Token.
$echt = "6278c6f1387d8a3c55c8e851cade0e58";
echo "Richtiges Token stimmt überein:\n";
var_dump(hash_equals($echt, "6278c6f1387d8a3c55c8e851cade0e58"));
echo "\nFalsches Token nicht:\n";
var_dump(hash_equals($echt, "falsch"));
echo "\nDie Falle: zwei leere Texte gelten als gleich.\n";
var_dump(hash_equals("", ""));
echo "\nDeshalb reicht der Vergleich allein nicht. Liegt in der Sitzung\n";
echo "ein leeres Token und schickt der Angreifer auch keins, wäre das\n";
echo "hash_equals true. Man prüft also zuerst, ob überhaupt eins da ist:\n";
$sitzung = "";
$gesendet = "";
$ok = $sitzung !== "" && hash_equals($sitzung, $gesendet);
var_dump($ok); Für den Vergleich steht hash_equals($ausDerSitzung, $ausDemFormular) da und nicht ===. Ein
gewöhnlicher Zeichenvergleich hört beim ersten Unterschied auf, und an der gemessenen Zeit lässt
sich dann erraten, wie viele Zeichen am Anfang schon stimmen. hash_equals braucht immer gleich
lang, egal wo der Unterschied liegt.
Im dritten Beispiel steckt dazu eine Falle, denn hash_equals("", "") ist wahr. Liegt in der
Sitzung ein leeres Token, etwa weil der Code $_SESSION["token"] ?? "" schreibt, und schickt der
Angreifer auch keins, wäre der Vergleich zufrieden. Fehlt der Eintrag ganz, bricht hash_equals()
mit einem TypeError ab, denn null ist kein Text. Im Beispiel wird deshalb zuerst
$sitzung !== "" geprüft und erst danach verglichen. Mit einem leeren Token in der Sitzung kommt so
false heraus.
SameSite als zweite Linie
SameSite=Lax am Cookie mit der Sitzungskennung ist die zweite Linie. Das ist die Angabe aus
Lektion 12.2, für dieses Cookie in der php.ini als session.cookie_samesite = Lax. Der Browser
schickt das Cookie bei einem Formular, das eine fremde Seite per POST abschickt, gar nicht erst mit.
Ohne Cookie ist der Besucher für deine App nicht angemeldet.
SameSite ersetzt das Token aber nicht. Lax lässt das Cookie weiter mitgehen, wenn eine fremde
Seite den Besucher per Link oder mit einem Formular per GET zu dir schickt. Alle Subdomains
derselben Domain zählen dabei als eine Seite. Und nicht jeder Browser kennt die Angabe.
Im Browser dieses Kurses lässt sich SameSite=Lax nicht vorführen. Die Seite liegt dort in einem
Rahmen auf einer fremden Adresse. Deshalb wird jedes Cookie, das an diesen Browser geht, auf
SameSite=None umgeschrieben, sonst hielte hier keine Sitzung. Mit curl im Terminal siehst du
das Cookie so, wie dein Code es setzt.
In der Aufgabe schützt das Token zwei Aktionen derselben Notizanwendung, das Anlegen und das Löschen mit Rückfrage.
Zum Mitnehmen
Bei CSRF schickt eine fremde Seite ein Formular an deine Anwendung, und der Browser des Besuchers legt das Cookie mit seiner Sitzungskennung dazu. Aufhalten lässt sie sich mit einem Token in Sitzung und Formular, verglichen mit hash_equals. SameSite an diesem Cookie ist die zweite Linie.
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.