Wie greifst du sicher mit PDO auf eine Datenbank zu?

Question

Accepted Answer

**PDO** (PHP Data Objects) ist PHPs modernes, datenbankagnostisches Interface für den Zugriff auf Datenbanken. Das wichtigste Feature sind **Prepared Statements**, die **SQL-Injection** verhindern — die kritische Sicherheitspraxis für jeden Datenbankcode.

## Verbindung mit PDO

```php
<?php
$pdo = new PDO(
    "mysql:host=localhost;dbname=app;charset=utf8mb4",
    $username, $password,
    [
        PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,    // throw exceptions on errors
        PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, // fetch rows as associative arrays
    ]
);
```

PDO funktioniert datenbankübergreifend (MySQL, PostgreSQL, SQLite, etc.) mit derselben API. Das Setzen von `ERRMODE_EXCEPTION` macht Datenbankfehler zu abfangbaren Exceptions.

## Die kritische Praxis: Prepared Statements (SQL-Injection verhindern)

```php
// ❌ NEVER do this — concatenating user input → SQL INJECTION vulnerability
$result = $pdo->query("SELECT * FROM users WHERE id = " . $_GET['id']);
// input "1 OR 1=1" or "1; DROP TABLE users" → disaster

// ✅ ALWAYS use prepared statements with bound parameters
$stmt = $pdo->prepare("SELECT * FROM users WHERE id = ? AND active = ?");
$stmt->execute([$_GET['id'], true]);            // parameters bound SAFELY
$user = $stmt->fetch();

// named parameters work too
$stmt = $pdo->prepare("SELECT * FROM users WHERE email = :email");
$stmt->execute(["email" => $email]);
```

**Prepared Statements** senden SQL und Daten getrennt — die Datenbank behandelt Parameter als reine Daten, niemals als ausführbares SQL. Dies macht Injection **unmöglich**, egal was der Benutzer eingibt. Dies ist nicht verhandelbar für jede Query mit Benutzereingaben.

## Ergebnisse abrufen und andere Operationen

```php
$stmt->fetch();         // one row (associative array)
$stmt->fetchAll();      // all rows
$stmt->fetchColumn();   // a single value

// INSERT/UPDATE/DELETE — also use prepared statements
$stmt = $pdo->prepare("INSERT INTO users (name, email) VALUES (?, ?)");
$stmt->execute([$name, $email]);
$pdo->lastInsertId();   // the new row's ID
```

## Transaktionen

```php
$pdo->beginTransaction();
try {
    $pdo->prepare("UPDATE accounts SET balance = balance - ? WHERE id = ?")->execute([$amt, $from]);
    $pdo->prepare("UPDATE accounts SET balance = balance + ? WHERE id = ?")->execute([$amt, $to]);
    $pdo->commit();          // all-or-nothing
} catch (Throwable $e) {
    $pdo->rollBack();         // undo on failure
}
```

## Warum es wichtig ist

Sicherer Datenbankzugriff ist einer der sicherheitskritischsten Aspekte der PHP-Entwicklung, und **PDO mit Prepared Statements ist die essentielle Praxis**, die jeder PHP-Entwickler kennen muss.

SQL-Injection — verursacht durch das direkte Konkatenieren von nicht vertrauenswürdigen Benutzereingaben in SQL-Queries — ist eine der häufigsten und verheerendsten Web-Schwachstellen (die es Angreifern ermöglicht, Daten zu lesen, zu ändern oder zu zerstören), und sie ist vollständig vermeidbar. **Prepared Statements** mit gebundenen Parametern sind die Lösung: Indem die SQL-Struktur und die Daten getrennt gesendet werden, behandelt die Datenbank Benutzereingaben als reine Daten, die niemals als SQL ausgeführt werden können, was Injection unmöglich macht, unabhängig von der Eingabe.

Zu verstehen, dass du **immer** Prepared Statements für jede Query mit Benutzereingaben verwenden musst (niemals String-Konkatenation), ist nicht verhandelbar, sicherheitsessentielles Wissen.

Jenseits von Sicherheit machen PDOs datenbankagnostisches Interface, exception-basierte Fehlerbehandlung, flexible Ergebnis-Abrufe und Transaktionsunterstützung es zur robusten, modernen Methode für den Datenbankzugriff in PHP.

Da Datenbankzugriff fundamental für die meisten Anwendungen ist und SQL-Injection sowohl häufig als auch katastrophal ist, ist das Beherrschen von PDO und die absolute Disziplin bei Prepared Statements eine der wichtigsten Dinge, die ein PHP-Entwickler verstehen muss — es ist der Unterschied zwischen einer sicheren Anwendung und einer, die anfällig für einen ernstlichen, bekannten Angriff ist. (Frameworks wie Laravel verwenden PDO unter der Haube mit sicheren Query Buildern/ORMs, aber das zugrunde liegende Prinzip bleibt bestehen.)