mitmario.dev

SQL-Injection

PHP Sandbox 4 Min Lesezeit 4 BeispieleLektion 1 von 7

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

Die Anmeldung von 2009
<?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.

Auch mit password_verify bleibt sie offen
<?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

Was eine Fehlermeldung ausplaudert
<?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

Der eine Fall ohne Platzhalter
<?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, 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.