Sicherheit beim Programmieren mit PHP

Erste Schritte – Sicherheit beim Programmieren mit PHP: grundlegender Input-Schutz, Filterfunktionen

Sicherheitslücken entstehen oft durch unzureichend validierte Benutzereingaben.
Ob du ein Kontaktformular, eine Login-Seite oder eine API betreibst:
In PHP solltest du eingehende Daten prüfen, filtern und nur
in entschärfter Form weiterverarbeiten. In diesem Tutorial geht es um die
wichtigsten Prinzipien für einen grundsätzlichen Input-Schutz und um
eingebaute Filterfunktionen in PHP.

1. Warum Eingaben validieren und filtern?

  • Vermeidung von XSS-Angriffen (Cross-Site Scripting):
    Bösartiger Code in Formularfeldern könnte HTML/JavaScript einschleusen.
  • Abwehr von SQL-Injection: Nicht validierte Eingaben
    könnten Datenbank-Abfragen manipulieren.
  • Datensicherheit: Unsachgemäße oder fehlerhafte Eingaben können
    deinen Code zum Absturz bringen oder sensible Infos preisgeben.

Durch eine gründliche Validierung sicherst du deine Anwendung
und verhinderst, dass fehlerhafte oder gefährliche Daten in kritische Bereiche gelangen.

2. Grundlegendes Konzept: Validierung vs. Bereinigung

  • Validierung (Validation): Prüfe, ob Eingaben den erwarteten Kriterien entsprechen (z. B. E-Mail, Integer, bestimmtes Muster).
  • Bereinigung (Sanitization / Escaping): Entferne oder entschärfe potenziell gefährlichen Code (z. B. HTML-Tags) in einer Eingabe.

Beides ist nötig: Du entscheidest, ob du bestimmte Daten ganz verbietest (Validation Fail) oder sie entschärfst (Sanitization), bevor du sie speicherst/ausgibst.

3. filter_var und FILTER_* Konstanten

PHP bietet filter_var() und filter_input(),
mit denen du Eingaben validieren oder bereinigen kannst.
Einige gängige Filter: 

// E-Mail prüfen
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    // Ungültige E-Mail
}

// Integer prüfen
if (filter_var($wert, FILTER_VALIDATE_INT) === false) {
    // Kein int
}

// URL validieren
if (!filter_var($url, FILTER_VALIDATE_URL)) {
    // Keine gültige URL
}

Damit kannst du schnell feststellen, ob z. B. $email oder $url
dem erwarteten Format entsprechen. Bei einer Rückgabe false (oder null)
ist die Validierung fehlgeschlagen.

4. Sanitization (FILTER_SANITIZE_*)

Wenn du Eingaben „bereinigen“ willst, statt sie abzulehnen, kannst du
FILTER_SANITIZE_* nutzen. Beispielsweise: 

// HTML-Sonderzeichen entfernen / maskieren
$cleanInput = filter_var($eingabe, FILTER_SANITIZE_STRING);

// Filter gegen illegale Zeichen in einer E-Mail
$cleanMail = filter_var($mail, FILTER_SANITIZE_EMAIL);

// Filter gegen ungültige Zeichen in einer URL
$cleanUrl = filter_var($url, FILTER_SANITIZE_URL);
  • Bei FILTER_SANITIZE_STRING wurden in neueren PHP-Versionen Empfänge geändert.
    Schau in die PHP-Dokumentation, um zu sehen, wie du Sonderzeichen am besten entfernst oder encodierst.
  • Denke daran: Sanitization kann nicht jede mögliche Attacke abfangen,
    du solltest den Code an mehreren Stellen schützen (z. B. Prepared Statements für DB).

5. HTML-Ausgabe absichern: htmlspecialchars

Wenn du Benutzereingaben in HTML-Seiten zurückgibst,
solltest du sie via htmlspecialchars() entschärfen,
um XSS zu vermeiden. 

echo htmlspecialchars($userInput, ENT_QUOTES, 'UTF-8');
  • ENT_QUOTES wandelt auch ‚ und “ um.
  • ‚UTF-8‘ ist wichtig, wenn deine Seite UTF-8 nutzt.

Dadurch kann ein Angreifer keinen bösartigen JavaScript-Code einbetten,
der im Browser ausgeführt wird.

6. Umgang mit SQL-Queries

Die sicherste Methode, Benutzereingaben in Datenbankabfragen einzusetzen,
ist über Prepared Statements (z. B. PDO).
Dadurch werden die Werte getrennt von der SQL-Logik an die DB übergeben,
was SQL-Injection erschwert. 

$db = new PDO($dsn, $user, $pass);

// Prepared Statement
$stmt = $db->prepare("SELECT * FROM users WHERE email = :email");
$stmt->bindValue(':email', $cleanMail);
$stmt->execute();

$results = $stmt->fetchAll();

Hier musst du die E-Mail nicht manuell escapen,
weil PDO das sauber trennt,
wenn du bindValue oder execute-Arrays nutzt.

7. Beispiele in der Praxis

// Beispiel: Validierung + Speicherung
$email = $_POST['email'] ?? '';

if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    echo "Ungültige E-Mail!";
} else {
    // Email ist gültig => Weiter
    $safeEmail = filter_var($email, FILTER_SANITIZE_EMAIL);

    // Hier in DB speichern
    // ...
    echo "E-Mail gespeichert: " . htmlspecialchars($safeEmail);
}

Du validierst zuerst streng, ob es eine E-Mail ist.
Bei Erfolg wendest du eine Sanitization an (optional),
bevor du den Wert einsetzt.
Bei der Ausgabe verwendest du htmlspecialchars().

8. Fazit

Grundlegender Input-Schutz und Filterfunktionen
in PHP sind elementar, um deine Webanwendung
gegen typische Angriffe (XSS, SQL-Injection) und falsche Eingaben abzusichern.
Mit filter_var() (Validate, Sanitize) und htmlspecialchars()
bist du schon sehr gut gerüstet, um die meisten Szenarien abzufangen.
Zusätzlich solltest du niemals direkte User-Eingaben in SQL-Abfragen verwenden,
sondern Prepared Statements nutzen.
So sorgst du für sichere und stabile PHP-Anwendungen,
in denen bösartige Eingaben keine Chance haben.