Unsachgemäße Neutralisierung von Direktiven in statisch gespeichertem Code ('Static Code Injection')

Beschreibung

Static Code Injection tritt auf, wenn Software Eingaben von einer vorgelagerten Komponente erhält, diese an einem Ort speichert, der später als Code geparst und ausgeführt wird, und Code-Direktiven nicht oder nicht korrekt neutralisiert. Anders als Eval-Injection, die Code sofort ausführt, beinhaltet Static Code Injection das Schreiben von bösartigem Code in Dateien, Datenbanken oder andere persistente Speicher, die später ausgeführt werden, wenn der gespeicherte Inhalt geparst, eingebunden oder gerendert wird. Häufige Ziele umfassen Konfigurationsdateien, Template-Dateien, Log-Dateien die eingebunden werden könnten, serialisierte Datendateien und alle Dateien, die später vom Anwendungscode interpretiert werden.

Risiko

Static Code Injection erzeugt persistente Backdoors, die ausgeführt werden, wann immer die infizierte Datei verarbeitet wird. Angreifer können bösartigen Code in PHP-Dateien einschleusen, die bei jedem Seitenladen ausgeführt werden, bösartige Templates hinzufügen, die beim Rendern ausgeführt werden, Konfigurationsdateien vergiften, um Anwendungsverhalten zu ändern, oder Code in Log-Dateien einschleusen, die Administratoren möglicherweise ansehen oder verarbeiten. Die verzögerte Ausführung erschwert die Erkennung - die Injection kann zu einem Zeitpunkt erfolgen, während der bösartige Code später ausgeführt wird, potenziell unter verschiedenen Benutzerkontexten oder mit erhöhten Privilegien. Diese Schwachstelle ist besonders gefährlich in CMS-Systemen, Template-Engines und Anwendungen, die dynamisch Code-Dateien generieren oder modifizieren.

Lösung

Schreiben Sie niemals benutzerkontrollierte Eingaben in Dateien, die als Code interpretiert werden. Implementieren Sie strikte Ausgabecodierung entsprechend dem Dateiformat, bevor Sie externe Daten schreiben. Verwenden Sie Allowlist-Validierung, um sicherzustellen, dass Eingaben erwarteten, sicheren Mustern entsprechen. Trennen Sie Code von Daten, indem Sie Benutzerinhalte in Datenbanken speichern statt in Dateien, die ausgeführt werden könnten. Wenn Konfigurationsdateien modifiziert werden müssen, verwenden Sie strukturierte Datenformate (JSON, YAML) mit ordnungsgemäßer Serialisierung anstelle von ausführbarem Code. Setzen Sie restriktive Dateiberechtigungen, um unbefugte Modifikation zu verhindern. Implementieren Sie Dateiintegritätsüberwachung, um unbefugte Änderungen an Code-Dateien zu erkennen.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Eingeschleuster Code kann auf alle Daten zugreifen, die verfügbar sind, wenn die infizierte Datei ausgeführt wird, potenziell mit erhöhten Privilegien, wenn sie von Administratoren ausgeführt wird.
Integrität	Bereich: Integrität Persistente Code-Injection ermöglicht langfristige Manipulation des Anwendungsverhaltens, Datenmodifikation und fortlaufenden unbefugten Zugriff.
Verfügbarkeit	Bereich: Verfügbarkeit Bösartiger Code in kritischen Dateien kann Anwendungen zum Absturz bringen, Daten beschädigen oder Systeme unbrauchbar machen.
Zugriffskontrolle	Bereich: Persistente Kompromittierung Static Code Injection erstellt Backdoors, die Anwendungsneustarts überleben und möglicherweise durch Updates bestehen bleiben.

Beispielcode + Lösungscode

Anfälliger Code

<?php
// ANFÄLLIG: Benutzereingabe in eingebundene PHP-Datei schreiben

// Konfigurationsaktualisierungsfunktionalität
$setting_name = $_POST['setting'];
$setting_value = $_POST['value'];

// Angriff: value="; system($_GET['cmd']); $x="
// Ergibt: $settings['name'] = ""; system($_GET['cmd']); $x="";
$config = fopen('config.php', 'a');
fwrite($config, "\$settings['$setting_name'] = \"$setting_value\";\n");
fclose($config);

// Diese Konfigurationsdatei wird später eingebunden:
// include 'config.php';  // Führt eingeschleusten Code aus!

// ANFÄLLIG: Template-Datei-Injection
$template_name = $_GET['template'];
$template_content = $_POST['content'];
file_put_contents("templates/$template_name.tpl", $template_content);
// Bösartiges Template wird beim Rendern ausgeführt

Korrigierter Code

<?php
// SICHER: JSON für Konfigurationsspeicherung verwenden

function updateConfig($setting_name, $setting_value) {
    // Einstellungsname gegen Allowlist validieren
    $allowed_settings = ['theme', 'language', 'timezone'];
    if (!in_array($setting_name, $allowed_settings)) {
        throw new InvalidArgumentException("Unbekannte Einstellung");
    }

    // Bestehende Konfiguration aus JSON laden
    $config_file = 'config.json';
    $config = json_decode(file_get_contents($config_file), true) ?: [];

    // Wertformat basierend auf Einstellungstyp validieren
    switch ($setting_name) {
        case 'theme':
            if (!preg_match('/^[a-zA-Z0-9_-]+$/', $setting_value)) {
                throw new InvalidArgumentException("Ungültiger Theme-Name");
            }
            break;
        case 'language':
            if (!preg_match('/^[a-z]{2}(_[A-Z]{2})?$/', $setting_value)) {
                throw new InvalidArgumentException("Ungültiger Sprachcode");
            }
            break;
        // ... andere Validierungen
    }

    // Aktualisieren und als JSON speichern (keine Code-Ausführung möglich)
    $config[$setting_name] = $setting_value;
    file_put_contents(
        $config_file,
        json_encode($config, JSON_PRETTY_PRINT),
        LOCK_EX
    );
}

// SICHER: Template-Inhalt mit strikter Bereinigung
function saveTemplate($template_name, $content) {
    // Template-Name validieren
    if (!preg_match('/^[a-zA-Z0-9_-]+$/', $template_name)) {
        throw new InvalidArgumentException("Ungültiger Template-Name");
    }

    // PHP-Tags und gefährliche Inhalte entfernen
    $content = preg_replace('/<\?.*?\?>/s', '', $content);
    $content = strip_tags($content, '<p><br><div><span><a><img>');

    // In Datenbank speichern statt im Dateisystem
    $db->prepare("INSERT INTO templates (name, content) VALUES (?, ?)")
       ->execute([$template_name, $content]);
}

Ausgenutzt in der Praxis

WordPress-Plugin-Schwachstellen (WordPress, fortlaufend)

Mehrere WordPress-Plugins wurden durch Static Code Injection ausgenutzt, wobei Angreifer bösartigen PHP-Code in Theme- oder Plugin-Dateien schreiben und persistente Backdoors erstellen, die Plugin-Updates überleben.

https://blog.sucuri.net/tag/backdoor/

Web-Shell-Installationskampagnen (Verschiedene CMS, fortlaufend)

Angreifer nutzen Datei-Upload- und Code-Injection-Schwachstellen aus, um PHP-Web-Shells auf Server zu schreiben und so persistenten Remote-Zugriff auf kompromittierte Systeme zu erhalten.

https://www.cisa.gov/news-events/cybersecurity-advisories/aa21-200a

Tools zum Testen/Ausnutzen

Burp Suite — Web-Sicherheitstestplattform zur Identifizierung von Static-Code-Injection-Schwachstellen.
Web Shell Detection Tools — Tools zur Erkennung eingeschleuster Web-Shells in Dateisystemen.

CVE-Beispiele

CVE-2023-48795 — SSH-Protokoll-Konfigurations-Injection, die Verbindungssicherheit beeinträchtigt.
CVE-2022-26134 — Atlassian Confluence OGNL-Injection, die zum Schreiben von Code auf dem Server führt.

Referenzen

MITRE. "CWE-96: Improper Neutralization of Directives in Statically Saved Code." https://cwe.mitre.org/data/definitions/96.html
OWASP. "Code Injection." https://owasp.org/www-community/attacks/Code_Injection