PHP PDO: sichere Datenbankabfragen schreiben

PHP PDO ist der sicherste und flexibelste Weg, in modernen PHP-Anwendungen mit einer Datenbank zu kommunizieren. Richtig eingesetzt eliminiert es SQL-Injection nahezu vollständig, einen der häufigsten und gefährlichsten Angriffe auf Webanwendungen. In dieser Anleitung lernst du, wie du eine PDO-Verbindung öffnest, wie Prepared Statements wirklich funktionieren und welche praktischen Muster du täglich brauchst.

Warum ist SQL-Injection so gefährlich?

SQL-Injection entsteht, wenn von Nutzern gelieferte Daten direkt in eine SQL-Abfrage eingefügt werden. Statt eines normalen Werts sendet ein Angreifer Text, der die Bedeutung der Abfrage verändert. Hier das klassische, fehlerhafte Beispiel:

// MACH DAS NIEMALS
$email = $_POST['email'];
$sql = "SELECT * FROM users WHERE email = '$email'";
$result = $pdo->query($sql);

Tippt der Nutzer ' OR '1'='1 in das Feld email, ist die Bedingung immer wahr und sämtliche Nutzerdatensätze können nach außen gelangen. Schlimmer noch: Ein Angreifer könnte Tabellen löschen oder seine Rechte ausweiten. Die Lösung ist einfach: Vermische Daten niemals direkt mit dem SQL-Text.

Die PDO-Verbindung korrekt einrichten

Eine gute PDO-Verbindung enthält einige Einstellungen, die verhindern, dass Fehler stillschweigend verschluckt werden, und das Verhalten vorhersehbar machen. Umschließe die Verbindung immer mit einem try/catch-Block und lies die Zugangsdaten aus Umgebungsvariablen, statt sie fest einzucodieren.

$dsn = 'mysql:host=127.0.0.1;dbname=app;charset=utf8mb4';

$options = [
    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
    PDO::ATTR_EMULATE_PREPARES   => false,
];

try {
    $pdo = new PDO($dsn, $user, $pass, $options);
} catch (PDOException $e) {
    // Fehler protokollieren, dem Nutzer niemals die Rohmeldung zeigen
    error_log($e->getMessage());
    exit('Verbindung zur Datenbank nicht möglich.');
}

Drei Einstellungen sind entscheidend: ERRMODE_EXCEPTION wirft Fehler als Ausnahmen, statt still zu scheitern, FETCH_ASSOC liefert lesbare assoziative Arrays, und EMULATE_PREPARES = false bringt den Treiber dazu, echte Prepared Statements zu verwenden, was sowohl für die Sicherheit als auch für die Typkorrektheit besser ist.

Wie Prepared Statements funktionieren

Ein Prepared Statement trennt die Struktur einer Abfrage von ihren Daten. Zuerst bereitest du die Abfragevorlage mit Platzhaltern vor, dann sendest du die Werte separat. Dadurch werden die Daten, so gefährlich sie auch aussehen, niemals als SQL-Befehl interpretiert, sondern stets als Wert behandelt.

$stmt = $pdo->prepare('SELECT id, name FROM users WHERE email = ?');
$stmt->execute([$email]);
$user = $stmt->fetch();

Hier ist ? ein Platzhalter. Das Array, das du an execute() übergibst, wird sicher an die Platzhalter gebunden. Der Treiber behandelt den Wert strikt als Daten, und die Möglichkeit einer Injection verschwindet.

Benannte Parameter

Wenn eine Abfrage mehrere Parameter hat, machen benannte Platzhalter den Code weitaus lesbarer als positionsbezogene ?-Zeichen. Benannte Parameter beginnen mit einem Doppelpunkt:

$stmt = $pdo->prepare(
    'INSERT INTO posts (title, body, user_id) VALUES (:title, :body, :user_id)'
);

$stmt->execute([
    ':title'   => $title,
    ':body'    => $body,
    ':user_id' => $userId,
]);

Wenn du mehr Kontrolle willst, kannst du mit bindValue() den Typ jedes Parameters festlegen:

$stmt = $pdo->prepare('SELECT * FROM products WHERE stock >= :min');
$stmt->bindValue(':min', $min, PDO::PARAM_INT);
$stmt->execute();

Die Ergebnisse lesen

PDO bietet mehrere Möglichkeiten, Ergebnisse zu lesen. Verwende fetch() für eine einzelne Zeile und fetchAll() für alle Zeilen. Beim Verarbeiten vieler Zeilen ist der speicherschonende Weg, sie einzeln in einer Schleife abzurufen:

$stmt = $pdo->prepare('SELECT id, title FROM posts WHERE user_id = ?');
$stmt->execute([$userId]);

foreach ($stmt as $row) {
    echo htmlspecialchars($row['title']) . "\n";
}

Achtung: Verwende htmlspecialchars(), wenn du Daten ausgibst, die aus der Datenbank stammen. PDO schützt dich vor SQL-Injection, aber XSS (Cross-Site-Scripting) ist ein separates Thema, das auf der Ausgabeseite behandelt werden muss.

Häufige Fehler

• Einen Tabellen- oder Spaltennamen als Parameter behandeln. Platzhalter sind nur für Werte; ORDER BY ? funktioniert nicht. Validiere Spalten- und Tabellennamen gegen eine feste Whitelist.
• EMULATE_PREPARES eingeschaltet lassen. Aktiviert setzt PDO die Abfrage auf seiner eigenen Seite zusammen; das ist in den meisten Fällen sicher, aber echte Prepared Statements sind immer robuster.
• Fehler dem Nutzer anzeigen. Rohe Fehlermeldungen verraten die Struktur deiner Datenbank. Protokolliere sie und gib eine allgemeine Meldung zurück.
• Dieselbe Abfrage in einer Schleife erneut vorbereiten. Rufe prepare() einmal auf und in der Schleife nur execute().

Transaktionen

Wenn du mehrere voneinander abhängige Schreibvorgänge ausführst, verwende eine Transaktion, damit sie alle gelingen oder alle gemeinsam scheitern. Schlägt ein Schritt fehl, macht rollBack() alles rückgängig:

try {
    $pdo->beginTransaction();

    $pdo->prepare('UPDATE accounts SET balance = balance - ? WHERE id = ?')
        ->execute([$amount, $fromId]);

    $pdo->prepare('UPDATE accounts SET balance = balance + ? WHERE id = ?')
        ->execute([$amount, $toId]);

    $pdo->commit();
} catch (PDOException $e) {
    $pdo->rollBack();
    throw $e;
}

Häufige Fragen

Sollte ich PDO oder MySQLi verwenden?

Beide unterstützen Prepared Statements und sind sicher. Der Vorteil von PDO ist, dass es ein Dutzend verschiedener Datenbanktreiber über eine einzige Schnittstelle unterstützt und eine lesbarere API bietet, einschließlich benannter Parameter. Für die meisten neuen Projekte ist PDO die flexiblere Wahl.

Schaden Prepared Statements der Leistung?

Nein, meist im Gegenteil. Wenn dieselbe Abfrage wiederholt mit unterschiedlichen Werten läuft, kann die Datenbank ihren Abfrageplan wiederverwenden. Bei einmaligen Abfragen ist der Unterschied vernachlässigbar, und die gewonnene Sicherheit ist weit mehr wert als diese Kosten.

Reichen Prepared Statements allein aus?

Gegen SQL-Injection ja, richtig eingesetzt reichen sie aus. Doch Sicherheit ist ganzheitlich: Du brauchst außerdem XSS-Schutz bei der Ausgabe, Eingabevalidierung, Autorisierung und das Prinzip der geringsten Rechte.

Nimm Datenbanksicherheit ernst. Wenn ich ein bestehendes PHP-Projekt prüfen oder eine sichere Datenschicht für dich aufbauen soll, nimm Kontakt auf und lass uns gemeinsam ein solides Fundament legen.