Abschnitt 15 · Lektion 1
SQL-Injection
Eine Anmeldung, die den eingetippten Namen in ihre Abfrage klebt, lässt jemanden herein, der kein einziges Passwort kennt. Verhindern lässt sich das mit dem Platzhalter aus Lektion 14.4. Dort hat dieselbe Lücke an einer Suche schon alle Notizen auf einmal herausgegeben.
Die berühmteste Zeile der Websicherheit
<?php
declare(strict_types=1);
// Eine Anmeldung, wie sie in alten Anleitungen steht:
// Name und Passwort wandern direkt in den Abfragetext. Sie hat zwei
// Fehler auf einmal. Um den ersten geht es hier.
$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 nutzer (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
passwort TEXT NOT NULL
)");
$db->exec("INSERT OR IGNORE INTO nutzer (name, passwort) VALUES ('admin', 'der-chef-darf-alles')");
$db->exec("INSERT OR IGNORE INTO nutzer (name, passwort) VALUES ('mia', 'gurkenbeet-im-mai')");
function e(?string $wert): string
{
return htmlspecialchars($wert ?? "", ENT_QUOTES, "UTF-8");
}
$name = $_POST["name"] ?? "";
$passwort = $_POST["passwort"] ?? "";
$abfrage = null;
$meldung = null;
if ($_SERVER["REQUEST_METHOD"] === "POST") {
$abfrage = "SELECT id, name FROM nutzer WHERE name = '" . $name . "' AND passwort = '" . $passwort . "'";
$zeile = $db->query($abfrage)->fetch();
$meldung = $zeile === false ? "Anmeldung fehlgeschlagen" : "Angemeldet als " . $zeile["name"];
}
?>
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<title>Anmeldung</title>
<style>
body { font-family: system-ui, sans-serif; max-width: 40rem; margin: 2rem auto; }
pre { background: #f2f2f2; padding: 0.6rem; overflow-x: auto; }
.meldung { font-weight: bold; }
</style>
</head>
<body>
<h1>Anmeldung</h1>
<form method="post" action="/">
<p><label>Name: <input type="text" name="name" size="34" value="<?= e($name) ?>"></label></p>
<p><label>Passwort: <input type="text" name="passwort" size="34" value="<?= e($passwort) ?>"></label></p>
<button type="submit">Anmelden</button>
</form>
<?php if ($abfrage !== null) { ?>
<p>Daraus wird diese Abfrage:</p>
<pre><?= e($abfrage) ?></pre>
<p class="meldung"><?= e($meldung) ?></p>
<?php } ?>
</body>
</html> Im Reiter Browser steht eine Anmeldung, wie sie in alten Anleitungen stand. Name und Passwort werden
in den Abfragetext geklebt, und unter dem Formular siehst du, was daraus wird. Mit admin und
der-chef-darf-alles meldet die Seite Angemeldet als admin, so wie es sein soll.
Mit admin' OR '1'='1 im Namensfeld und irgendetwas im Passwortfeld meldet sie dasselbe. Der
Apostroph in der Eingabe beendet den Text in Apostrophen, in dem der Name stehen sollte, und alles
dahinter liest die Datenbank als SQL. Das ist SQL-Injection. Ein Wert wird zu einem Stück SQL.
AND bindet stärker als OR. Die Datenbank liest den Rest also als name = 'admin' oder
('1'='1' und das Passwort stimmt). Die linke Seite ist für die Zeile admin wahr, und das reicht.
Das '1'='1' braucht es dafür nicht einmal, admin' -- im Namensfeld tut dasselbe. Immer wahr
wird die Bedingung erst mit ' OR '1'='1 im Passwortfeld. Dann liefert sie jede Zeile, und die
erste ist admin.
Diese Anmeldung hat zwei Fehler
Der zweite Fehler hat mit SQL-Injection nichts zu tun. Die Anmeldung vergleicht das Passwort im Klartext, statt einen Hash zu prüfen, und die Anmeldung aus Lektion 12.5 macht das richtig. Die Lücke im SQL schließt ein Hash allerdings nicht.
<?php
declare(strict_types=1);
// Zwei Nutzer, die Passwoerter diesmal ordentlich gehasht: admin hat
// der-chef-darf-alles, mia hat gurkenbeet-im-mai. Die Hashs stehen fest im
// Quelltext, damit die Ausgabe bei jedem Lauf dieselbe ist. An
// dieser Datei aenderst du nichts.
$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("DROP TABLE IF EXISTS nutzer");
$db->exec("CREATE TABLE nutzer (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
hash TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO nutzer (name, hash) VALUES (?, ?)");
$einfuegen->execute(["admin", '$2y$12$yHj/TDQ9uKIREtGhEdTpGeJuWeCmVHo1pnLBGvW6iln3CURrsvyhm']);
$einfuegen->execute(["mia", '$2y$12$vuWc2OALu2CE9nxuCd6XmuvGDX9bYCdMSlioDc562fi89y527GHF6']); <?php
declare(strict_types=1);
// Dieselbe geklebte Abfrage, aber diesmal mit ordentlich gehashten
// Passwoertern. Der Klassiker prallt jetzt ab. Offen ist sie
// trotzdem, nur mit einem anderen Trick.
require __DIR__ . "/vorbereiten.php";
function anmelden(PDO $db, string $name, string $passwort): string
{
$abfrage = "SELECT id, name, hash FROM nutzer WHERE name = '" . $name . "'";
try {
$zeile = $db->query($abfrage)->fetch();
} catch (PDOException $fehler) {
return "Abfrage gescheitert: " . $fehler->getMessage();
}
if ($zeile !== false && password_verify($passwort, $zeile["hash"])) {
return "Angemeldet als " . $zeile["name"];
}
return "Anmeldung fehlgeschlagen";
}
// Der Hash von "knacken", von einem Angreifer auf dem eigenen
// Rechner erzeugt. Er kennt sein Passwort, nur nicht deins.
$fremderHash = '$2y$12$j04v.IOsk1BMeLqA2YRvGemDfEtHzt7znKE/Ci4iNfkdC5pZNhRvS';
echo "1. Richtiges Passwort\n";
echo " ", anmelden($db, "admin", "der-chef-darf-alles"), "\n\n";
echo "2. Der Klassiker aus dem letzten Beispiel\n";
echo " Eingabe im Namensfeld: admin' OR '1'='1\n";
echo " ", anmelden($db, "admin' OR '1'='1", "egal"), "\n\n";
echo "3. Eine Zeile, die es in der Tabelle gar nicht gibt\n";
echo " Eingabe: gibtesnicht' UNION SELECT 9, 'admin', '<hash von knacken>' -- \n";
echo " ", anmelden($db, "gibtesnicht' UNION SELECT 9, 'admin', '" . $fremderHash . "' -- ", "knacken"), "\n"; Im zweiten Beispiel sind die Passwörter gehasht, und password_verify() prüft sie. Der Klassiker
admin' OR '1'='1 prallt daran ab. Die Abfrage findet zwar wieder die Zeile admin, aber das
mitgegebene Passwort passt nicht zu ihrem Hash.
Geklebt ist die Abfrage trotzdem, und wer das weiß, hängt eine eigene Zeile an. Das UNION SELECT
im dritten Fall erfindet eine mit dem Namen admin. Ihr Hash stammt vom Rechner des Angreifers, zu
einem Passwort, das er kennt. Die echte Abfrage findet nichts, und die angehängte liefert die
erfundene Zeile. Also prüft password_verify sein Passwort gegen seinen eigenen Hash. Heraus kommt
Angemeldet als admin.
Im Reiter Debug steht beim dritten Fall abfrage mit dem zusammengeklebten Text samt UNION.
Danach steht zeile auf {id: 9, name: "admin", hash: "$2y$12$j04v…"}, einer Zeile, die es in der
Tabelle nie gab.
Ein LIMIT 1 am Ende der Abfrage hielte das nicht auf. Es begrenzt, wie viele Zeilen zurückkommen,
und nicht, welche. Außerdem macht das -- am Ende der Eingabe es ohnehin zu einem Kommentar.
Was ein Angreifer sonst noch erfährt
<?php
declare(strict_types=1);
// Zwei Nutzer mit gehashten Passwoertern. An dieser Datei aenderst
// du nichts.
$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("DROP TABLE IF EXISTS nutzer");
$db->exec("CREATE TABLE nutzer (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
hash TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO nutzer (name, hash) VALUES (?, ?)");
$einfuegen->execute(["admin", '$2y$12$yHj/TDQ9uKIREtGhEdTpGeJuWeCmVHo1pnLBGvW6iln3CURrsvyhm']);
$einfuegen->execute(["mia", '$2y$12$vuWc2OALu2CE9nxuCd6XmuvGDX9bYCdMSlioDc562fi89y527GHF6']); <?php
declare(strict_types=1);
// Eine Anmeldung, die ihre Fehlermeldung an den Besucher weiterreicht,
// so wie man es in Anleitungen oft sieht: catch, und dann getMessage()
// auf die Seite. Fuer einen Angreifer ist das ein Werkzeug.
require __DIR__ . "/vorbereiten.php";
function frage(PDO $db, string $eingabe): void
{
echo "Eingabe: ", $eingabe, "\n";
try {
$db->query("SELECT id, name, hash FROM nutzer WHERE name = '" . $eingabe . "'")->fetchAll();
echo " (kein Fehler)\n\n";
} catch (PDOException $fehler) {
echo " Fehler: ", $fehler->getMessage(), "\n\n";
}
}
// Jede Antwort sagt dem Angreifer etwas ueber die Tabelle, ohne dass
// er sie je zu sehen bekommt.
frage($db, "x' AND passwort = 1 -- ");
frage($db, "x' AND hash = 1 -- ");
frage($db, "x' UNION SELECT 1 -- "); Für ein UNION SELECT muss der Angreifer wissen, wie die Spalten heißen und wie viele es sind. Er
sieht die Tabelle nicht, aber er kann fragen, und die Datenbank antwortet, wenn der Code sie lässt.
Im dritten Beispiel tastet er sich vor. x' AND passwort = 1 liefert no such column: passwort,
also gibt es diese Spalte nicht. x' AND hash = 1 liefert keinen Fehler, also gibt es hash. Und
x' UNION SELECT 1 klagt, dass links und rechts nicht gleich viele Spalten stehen. Es sind also
mehr als eine.
Jede dieser Meldungen ist für sich harmlos. Zusammen verraten sie den Aufbau der Tabelle. Dafür
reicht schon, dass frage() im Beispiel die Meldung mit getMessage() ausgibt, statt dem Besucher
nur einen kurzen Satz zu zeigen und die Meldung ins Protokoll zu schreiben.
Der eine Fall, für den es keinen Platzhalter gibt
<?php
declare(strict_types=1);
// Zwei Nutzer mit gehashten Passwoertern. An dieser Datei aenderst
// du nichts.
$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("DROP TABLE IF EXISTS nutzer");
$db->exec("CREATE TABLE nutzer (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
hash TEXT NOT NULL
)");
$einfuegen = $db->prepare("INSERT INTO nutzer (name, hash) VALUES (?, ?)");
$einfuegen->execute(["admin", '$2y$12$yHj/TDQ9uKIREtGhEdTpGeJuWeCmVHo1pnLBGvW6iln3CURrsvyhm']);
$einfuegen->execute(["mia", '$2y$12$vuWc2OALu2CE9nxuCd6XmuvGDX9bYCdMSlioDc562fi89y527GHF6']); <?php
declare(strict_types=1);
// Ein Platzhalter steht fuer einen Wert. Fuer einen Spalten- oder
// Tabellennamen gibt es keinen, und diese Stelle braucht eine
// andere Loesung.
require __DIR__ . "/vorbereiten.php";
$db->exec("INSERT INTO nutzer (name, hash) VALUES ('ida', 'x'), ('ben', 'y')");
echo "Ein Platzhalter für die Spalte sortiert nicht nach der Spalte,\n";
echo "sondern nach dem Text, und der ist bei jeder Zeile gleich:\n";
// hash steht mit im SELECT, damit SQLite die Tabelle liest. Mit name
// allein liest es den Index der UNIQUE-Spalte, und die Namen kaemen
// zufaellig alphabetisch heraus.
$sortiert = $db->prepare("SELECT name, hash FROM nutzer ORDER BY ?");
$sortiert->execute(["name"]);
$namen = array_column($sortiert->fetchAll(), "name");
echo " ORDER BY ? mit dem Wert name -> ", implode(", ", $namen), "\n";
$richtig = $db->query("SELECT name, hash FROM nutzer ORDER BY name");
$namen = array_column($richtig->fetchAll(), "name");
echo " ORDER BY name ausgeschrieben -> ", implode(", ", $namen), "\n\n";
echo "Kommt die Sortierspalte von außen, ist die Antwort eine Allowlist.\n";
echo "Nur ein Name, der darin steht, wird eingesetzt:\n";
$erlaubt = ["name", "id"];
foreach (["name", "hash gestohlen"] as $wunsch) {
$spalte = in_array($wunsch, $erlaubt, true) ? $wunsch : "id";
echo " Wunsch \"$wunsch\" -> sortiert nach $spalte\n";
} Ein Platzhalter steht für einen Wert und nie für ein Stück Struktur wie einen Spaltennamen. Im
letzten Beispiel sortiert ORDER BY ? mit dem Wert name nach dem Text "name", und der ist bei
jeder Zeile gleich. Die vier Namen kommen ohne Fehlermeldung zurück, hier als
admin, mia, ida, ben. Diese Reihenfolge legt der Platzhalter nicht fest. Sie hängt daran, wie
SQLite die Zeilen liest.
Stünde nur name im SELECT, läse SQLite die Namen aus dem Index der UNIQUE-Spalte. Dann kämen
sie zufällig alphabetisch heraus, und der Fehler fiele gar nicht auf. Deshalb steht im Beispiel
hash mit dabei. Ausgeschrieben sortiert ORDER BY name die Namen zu admin, ben, ida, mia.
Soll ein Spalten- oder Tabellenname von außen kommen, etwa für eine wählbare Sortierung, braucht es
deshalb eine Allowlist, eine Liste des Erlaubten. Du schreibst die Namen selbst in ein Array und
setzt nur ein, was darin vorkommt. Alles andere fällt auf einen festen Standardwert zurück. Im
Beispiel wird aus dem Wunsch hash gestohlen so eine Sortierung nach id.
Das angehängte DROP TABLE
Bleibt noch die gestapelte Anweisung, ein '; DROP TABLE nutzer hinter der Eingabe. An einer
lesenden Abfrage mit query() läuft das angehängte DROP bei SQLite nicht. PDO führt dort nur die
erste Anweisung aus, und der Angreifer kommt zwar an die Daten, aber nicht an die Tabelle. An einer
schreibenden Anweisung mit exec() läuft es, und die Tabelle ist weg.
In der Aufgabe soll der UNION-Angriff an der gehashten Anmeldung aus dem zweiten Beispiel
abprallen.
Zum Mitnehmen
Wer in eine geklebte Abfrage tippen darf, baut sie um, mit OR an einem Passwortvergleich im SQL vorbei oder mit UNION SELECT zu einer Zeile, die es nicht gibt. Fehlermeldungen auf der Seite verraten dabei den Aufbau der Tabelle. Dagegen hilft der Platzhalter und, wo ein Spaltenname von außen kommt, eine Allowlist.
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.