mitmario.dev

Prepared Statements

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

Ein Autor heißt O’Brien, und die Suche nach seinen Büchern stürzt ab, weil der Apostroph im Namen mitten in eine Anweisung gerät. Durch dieselbe Lücke kann ein Fremder die Anweisung umschreiben. Davor schützen die Fragezeichen, die in Lektion 12.3 schon in den Anweisungen standen.

Der bequeme Weg und was er anrichtet

Zusammengebaut, und schon kaputt
import { DatabaseSync } from "node:sqlite";
import { AUFBAU } from "./bestand.js";

const db = new DatabaseSync(":memory:");
db.exec(AUFBAU);

// Der Wert wird in den Text der Anweisung hineingeschrieben. Bequem, und
// eben das ist das Problem.
function suche(autor) {
  const sql = `SELECT count(*) AS n FROM buecher WHERE autor = '${autor}'`;
  console.log(`  SQL: ${sql}`);
  try {
    console.log(`  Treffer: ${db.prepare(sql).get().n}`);
  } catch (fehler) {
    console.log(`  Fehler: ${fehler.message}`);
  }
}

console.log("Suche nach Adler:");
suche("Adler");
console.log("Suche nach O'Brien:");
suche("O'Brien");
console.log("Suche nach ' OR '1'='1 :");
suche("' OR '1'='1");

Derselbe Code läuft dreimal, und jede Suche geht anders aus. Zu jedem Lauf steht die Anweisung mit in der Ausgabe, die dabei entstanden ist.

  • Bei „Adler“ geht es gut. Der Wert landet zwischen den Anführungszeichen, und die Anweisung sagt, was sie sagen soll. Vier Treffer.
  • Bei „O’Brien“ bricht es ab, mit near "Brien": syntax error. Der Apostroph im Namen beendet den Text in Anführungszeichen mitten im Wort, und was danach kommt, hält SQLite für einen Teil der Anweisung. Ein Angreifer ist dafür nicht nötig, ein Autor mit einem irischen Nachnamen genügt.
  • Beim dritten Wert wird aus der Suche etwas anderes. Aus WHERE autor = '' plus OR '1'='1' wird eine Bedingung, die für jede Zeile stimmt, und die Suche zählt den ganzen Bestand. Mit SELECT * statt count(*) käme so jede Zeile der Tabelle heraus.

Der Wert wird so Teil der Anweisung. Wer den Text einer Anweisung aus fremden Daten zusammensetzt, überlässt dem Absender die Anweisung.

Der Platzhalter und was der Treiber damit tut

Dasselbe mit Platzhaltern
import { DatabaseSync } from "node:sqlite";
import { AUFBAU } from "./bestand.js";

const db = new DatabaseSync(":memory:");
db.exec(AUFBAU);

// Die Anweisung steht fest, der Wert kommt getrennt dazu.
const nachAutor = db.prepare("SELECT count(*) AS n FROM buecher WHERE autor = ?");

for (const gesucht of ["Adler", "O'Brien", "' OR '1'='1"]) {
  console.log(`${nachAutor.get(gesucht).n} Treffer für ${gesucht}`);
}

// Bei mehreren Werten sind Namen lesbarer als eine Reihe Fragezeichen.
const benannt = db.prepare("SELECT count(*) AS n FROM buecher WHERE autor = $autor AND titel LIKE $muster");
console.log(`${benannt.get({ autor: "Adler", muster: "%Nacht%" }).n} Treffer für Adler mit Nacht im Titel`);

Derselbe Angriff, dieselben Daten, und alles verhält sich, wie man es erwarten würde. O’Brien wird gefunden, der Einschleusversuch findet niemanden, weil es keinen Autor mit diesem seltsamen Namen gibt.

Gefiltert oder ausgeputzt wird dabei nichts. Anweisung und Werte gehen getrennt zur Datenbank. Dazwischen sitzt der Treiber, also das Stück Software, über das ein Programm mit der Datenbank spricht, hier node:sqlite. Er schickt erst SELECT count(*) AS n FROM buecher WHERE autor = ? und lässt SQLite daraus einen fertigen Plan bauen. Eine Anweisung, deren Plan so feststeht, heißt vorbereitete Anweisung (englisch prepared statement). Der Wert kommt erst danach dazu. Zu dem Zeitpunkt wird nichts mehr zerlegt, und deshalb kann er keine Anweisung mehr werden.

Man könnte stattdessen die Eingabe prüfen und hoffen, dass die Prüfung gut genug ist. Das wird ein Wettlauf mit den Einfällen von Fremden. Mit dem Platzhalter stellt sich die Frage gar nicht erst.

Benannte Parameter

Bei zwei Werten sind Fragezeichen in Ordnung. Bei sechs zählt man, und beim Umsortieren zählt man falsch. Dann nimmt man Namen, also $autor und $muster in der Anweisung und ein Objekt mit denselben Namen bei get(). Auf die Reihenfolge kommt es dann nicht mehr an.

Bei LIKE gehören die Prozentzeichen in den Wert und nicht in die Anweisung. In LIKE '%?%' steht ein Fragezeichen zwischen zwei Prozentzeichen. Das ist ganz normaler Text und kein Platzhalter mehr. LIKE unterscheidet übrigens nicht zwischen Groß und Klein, allerdings nur bei A bis Z. „Über“ findet „über“ nicht.

Vorbereitet ist auch schneller

Eine vorbereitete Anweisung wird einmal zerlegt und geprüft, und danach lässt sie sich beliebig oft mit anderen Werten ausführen, ohne dass SQLite noch einmal von vorn anfangen muss. Das ist der Handgriff mit prepare() vor der Schleife und run() darin. Sicherheit und Geschwindigkeit zeigen hier in dieselbe Richtung. Das kommt selten genug vor.

Wie schlimm es wirklich wird, und wie schlimm nicht

Die berühmteste Fassung des Angriffs hängt eine zweite Anweisung an, '; DROP TABLE buecher; --. Ob die läuft, hängt an der Methode.

Wie schlimm es wirklich wird
import { DatabaseSync } from "node:sqlite";
import { AUFBAU } from "./bestand.js";

const db = new DatabaseSync(":memory:");
db.exec(AUFBAU);

const zaehle = () => {
  try {
    return `${db.prepare("SELECT count(*) AS n FROM buecher").get().n} Zeilen`;
  } catch (fehler) {
    return `keine Tabelle mehr (${fehler.message})`;
  }
};

console.log("vorher:", zaehle());

const gemein = "'; DROP TABLE buecher; --";

// prepare fuehrt nur die erste Anweisung aus. Das Angehaengte laeuft ins Leere.
db.prepare(`SELECT count(*) AS n FROM buecher WHERE autor = '${gemein}'`).all();
console.log("nach prepare:", zaehle());

// exec fuehrt alles aus, was im Text steht.
db.exec(`DELETE FROM buecher WHERE autor = '${gemein}'`);
console.log("nach exec:", zaehle());

Über prepare() läuft es ins Leere. db.prepare() nimmt genau eine Anweisung, und alles Angehängte wird nicht ausgeführt. Die Tabelle steht danach noch.

Über db.exec() fliegt die Tabelle raus. exec() führt aus, was im Text steht, und wenn dort drei Anweisungen stehen, führt es drei aus.

Das heißt aber nicht, dass prepare() allein schützt. Im ersten Beispiel hat die Verkettung auch mit prepare() den ganzen Bestand gezählt, und mit SELECT * wäre er ausgeliefert worden. exec() gehört nie in die Nähe fremder Werte. Es ist für feste Anweisungen da, die man selbst geschrieben hat, wie CREATE TABLE, BEGIN oder COMMIT. Alles, wo ein Wert von außen vorkommt, läuft über prepare() mit Platzhaltern.

Die eine Stelle, an der Platzhalter nicht helfen

Platzhalter stehen für Werte. Ein Tabellenname ist kein Wert, ein Spaltenname auch nicht. Willst du die Sortierspalte von außen bestimmen lassen, kommst du mit ORDER BY ? nicht weit. Einen Fehler gibt es dafür nicht einmal. SQLite setzt den Wert ein wie jeden anderen, und ein Wert, der in jeder Zeile gleich ist, sortiert nichts.

Für Spaltennamen gibt es deshalb eine feste Liste, gegen die der Wunsch geprüft wird. In die Anweisung kommt der Name aus dieser Liste und nie der Text vom Aufrufer.

Noch steckt in der Aufgabe der gesuchte Wert mitten im Text von drei Abfragen.

Zum Mitnehmen

Ein Wert von außen kommt über einen Platzhalter in die Anweisung und nie in ihren Text, sonst wird er selbst zu SQL. exec bleibt festen Anweisungen vorbehalten, und ein Spaltenname kommt aus einer eigenen Liste.

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 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe, dein Code läuft auf einem Server

    Öffnet sich mit dem Basis Konto.