Session- und Sicherheitsfunktionen (CSRF, XSS-Schutz, SQL-Injection-Schutz)

Erste Schritte: Session- und Sicherheitsfunktionen (CSRF, XSS-Schutz, SQL-Injection-Schutz)

Die Sicherheit einer Webanwendung ist essenziell – sowohl für dich als Entwickler
als auch für die Nutzer. Das phpFK – PHP Framework stellt dir verschiedene
Sicherheitsfunktionen zur Verfügung, um gängige Schwachstellen wie CSRF-Angriffe,
Cross-Site Scripting (XSS) und SQL-Injection zu verhindern.
Zudem bietet es einfache Methoden, um Sessions zu verwalten und zu schützen.

Warum sind Sessions und Sicherheitsfunktionen so wichtig?

Session-Daten ermöglichen es, Benutzern zwischen Seitenaufrufen eine „Zugehörigkeit“
zuordnen zu können (z. B. ob jemand eingeloggt ist). Dabei ist jedoch Vorsicht geboten,
da Angreifer versuchen könnten, Session-Cookies zu klauen oder via manipulierte Formulare
unbeabsichtigte Aktionen auszulösen (CSRF). Auch bei Nutzereingaben (etwa in Formularen
oder URLs) muss man stets auf XSS und SQL-Injections achten, um das System nicht angreifbar zu machen.

Session-Verwaltung

Im phpFK – PHP Framework wird häufig eine Session-Klasse angeboten,
mit der du Sessions startest, liest und schreibst. Sie kann auch Sicherheitsfunktionen
bezüglich Session-Fixation implementieren (z. B. Regeneration der Session-ID).
Ein einfaches Beispiel: 

// core/Session.php (vereinfachtes Beispiel)

namespace Core;

class Session
{
    public static function start()
    {
        if (session_status() === PHP_SESSION_NONE) {
            session_start();
        }
    }

    public static function set($key, $value)
    {
        $_SESSION[$key] = $value;
    }

    public static function get($key)
    {
        return $_SESSION[$key] ?? null;
    }

    public static function destroy()
    {
        session_destroy();
        $_SESSION = [];
    }

    public static function regenerate()
    {
        session_regenerate_id(true);
    }
}

1. start() startet die Session nur, wenn noch keine läuft.
2. set() und get() fungieren als Hilfsmethoden,
um Daten in der Session zu speichern oder abzurufen.
3. destroy() beendet die Session, z. B. beim Logout.
4. regenerate() generiert eine neue Session-ID, um Session-Fixation-Angriffe zu verhindern
(z. B. nach erfolgreichem Login).

CSRF-Schutz

Ein Cross-Site Request Forgery (CSRF)-Angriff versucht,
einen Nutzer „heimlich“ Aktionen ausführen zu lassen, beispielsweise über ein externes Formular oder Bild.
Im phpFK – PHP Framework wird meist ein CSRF-Token in Formulare eingebettet,
das beim Absenden überprüft wird.

Token-Generierung

Häufig wird der Token in der Session gespeichert und als verstecktes Feld
im HTML-Formular angezeigt, z. B.: 

// core/Security.php (Auszug)

namespace Core;

class Security
{
    public static function generateCsrfToken()
    {
        if (!Session::get('csrf_token')) {
            $token = bin2hex(random_bytes(32));
            Session::set('csrf_token', $token);
        }
        return Session::get('csrf_token');
    }

    public static function checkCsrfToken($token)
    {
        return hash_equals(Session::get('csrf_token'), $token);
    }
}

1. generateCsrfToken() erstellt einmalig einen zufälligen String
und legt ihn in der Session ab.
2. checkCsrfToken($token) vergleicht den übergebenen Token mit dem Session-Token.

Einbau im Formular

In deinem HTML-Formular kannst du den Token so integrieren: 

<?php
  use Core\Security;
  $csrfToken = Security::generateCsrfToken();
?>

<form method="POST" action="/submit">
    <input type="hidden" name="csrf_token" value="<?= $csrfToken ?>" />
    <!-- weitere Felder -->
    <button type="submit">Absenden</button>
</form>

Prüfung bei der Verarbeitung

// app/controllers/FormController.php

use Core\Security;

public function submit()
{
    $token = $_POST['csrf_token'] ?? '';
    if (!Security::checkCsrfToken($token)) {
        die("Ungültiges CSRF-Token!");
    }

    // Ab hier sind wir sicher, dass die Anfrage legitim ist
    echo "Formular sicher empfangen!";
}

So stellst du sicher, dass kein Externer ein Formular an deinen Server sendet,
ohne das passende Token.

XSS-Schutz (Cross-Site Scripting)

Beim XSS werden schädliche Skripte (z. B. <script> Tags)
in deine Website eingeschleust, die im Browser des Opfers ausgeführt werden.
Um das zu verhindern, musst du alle Benutzereingaben und Ausgaben sorgfältig behandeln.

Sanitizing & Escaping

Im phpFK – PHP Framework kannst du eine Methode wie sanitize() oder
escape() verwenden. 

// core/Security.php (Auszug)

public static function sanitize($input)
{
    return htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
}

Im Controller (oder in der View) könntest du dann: 

$userInput = $_POST['comment'] ?? '';
$cleanInput = \Core\Security::sanitize($userInput);

echo "<p>Dein Kommentar: $cleanInput</p>";

So werden eventuell eingefügte Tags in HTML-Entities konvertiert
und können keinen Schaden anrichten.

SQL-Injection-Schutz

SQL-Injections entstehen, wenn Benutzereingaben unkontrolliert in SQL-Befehle
eingespeist werden. Im phpFK – PHP Framework verhinderst du dies durch
Prepared Statements in deinen Models.

Prepared Statements-Beispiel

public function getUserByEmail($email)
{
    $sql = "SELECT * FROM users WHERE email = :email";
    $stmt = $this->db->prepare($sql);
    $stmt->bindValue(':email', $email, \PDO::PARAM_STR);
    $stmt->execute();
    return $stmt->fetch(\PDO::FETCH_ASSOC);
}

Hier wird der Platzhalter :email gebunden,
bevor die Query ausgeführt wird. Dadurch kann nicht
einfach beliebiger SQL-Code eingeschleust werden.

Zusammenwirken der Sicherheitsfunktionen

In einer realen Anwendung greifen diese Maßnahmen ineinander:

  • CSRF-Schutz, um unautorisierte Formular-Submits zu verhindern.
  • XSS-Schutz, indem du potenziell gefährliche Ausgaben „escapest“.
  • SQL-Injection-Schutz durch Prepared Statements in deinem Model-Code.
  • Session-Verwaltung, damit deine Nutzer sicher eingeloggt bleiben und
    die Session-ID nicht kompromittiert wird.

Empfehlungen für deine App

  • HTTPS aktivieren:
    Deine Anwendung sollte SSL/TLS verwenden, damit keine Daten
    (inkl. Session-Cookie, CSRF-Token) im Klartext übertragen werden.
  • Header-Hygiene:
    Setze Sicherheits-Header (z. B. Content-Security-Policy, X-Frame-Options,
    X-Content-Type-Options), um zusätzlichen Schutz zu erreichen.
  • Regelmäßiges Logging:
    Nutze das integrierte Logging (siehe separates Tutorial zum Error-Handling & Logging),
    um Unregelmäßigkeiten schnell zu entdecken.
  • Sichere Passwörter:
    Speichere Benutzerpasswörter nie im Klartext. Nutze sichere Hashing-Algorithmen
    wie password_hash() und password_verify() (BCRYPT/ARGON2).

Fazit

Mit den Session- & Sicherheitsfunktionen des phpFK – PHP Frameworks
hast du ein solides Fundament, um deine Anwendung gegen gängige Angriffsszenarien zu wappnen.
Durch eine robuste CSRF-Token-Implementierung, Sanitizing-Funktionen für XSS-Schutz
und Prepared Statements gegen SQL-Injection minimierst du die größten Angriffsflächen.
Hinzu kommt die Session-Verwaltung, die dir sicheren und strukturierten Zugriff
auf Benutzerdaten ermöglicht. Implementiere diese Maßnahmen sorgfältig,
und du erreichst ein hohes Maß an Sicherheit für deine Anwendung und deine Nutzer.