Unkontrolliertes Suchpfadelement

Beschreibung

Unkontrolliertes Suchpfadelement tritt auf, wenn ein Produkt einen festen oder kontrollierten Suchpfad zum Auffinden von Ressourcen verwendet, aber ein oder mehrere Elemente des Suchpfads unter der Kontrolle unbeabsichtigter Akteure stehen. Im Gegensatz zu CWE-426, wo der gesamte Suchpfad extern kontrolliert werden kann, beinhaltet CWE-427 speziell Fälle, in denen einzelne Elemente innerhalb des Suchpfads manipuliert werden können. Angreifer platzieren bösartige Ressourcen in beschreibbaren Verzeichnissen, die Teil des Suchpfads sind, wodurch die Anwendung angreifergesteuerten Code lädt. Dies wird häufig bei DLL-Hijacking, Python/Node.js-Paket-Dependency-Confusion und PATH-Variablen-Manipulation beobachtet.

Risiko

Schwachstellen durch unkontrollierte Suchpfade führen konsistent zu Privilegieneskalation und beliebiger Codeausführung. CVE-2025-7719 in GE Vernovas CIMPLICITY HMI/SCADA-Plattform ermöglicht niedrig-privilegierten Benutzern die Privilegieneskalation in industriellen Steuerungsumgebungen. CVE-2025-11772 im Synaptics Fingerprint Driver ermöglicht Codeausführung mit SYSTEM-Privilegien durch DLL-Planting in C:\ProgramData. Zahlreiche Produkte einschließlich Sony INZONE Hub, Panasonic AutoDownloader, FortiClient for Windows und Siemens Altair Grid Engine waren betroffen. Die "Dependency Confusion"-Angriffsvariante betrifft Software-Paketverwaltung und ermöglicht Angreifern, private Pakete durch bösartige öffentliche zu ersetzen.

Lösung

Entfernen Sie beschreibbare Verzeichnisse aus dem Suchpfad. Verwenden Sie absolute Pfade zum Laden von Ressourcen. Beschränken Sie Schreibrechte auf Verzeichnisse im Suchpfad. Unter Windows verwenden Sie SetDllDirectory("") und LOAD_LIBRARY_SEARCH_SYSTEM32-Flags. Für Paketmanager konfigurieren Sie private Registries und Namespace-Präfixe, um Dependency Confusion zu verhindern. Validieren Sie, dass geladene Ressourcen von vertrauenswürdigen Parteien signiert sind. Verwenden Sie Anwendungsmanifeste, um exakte Dependency-Standorte anzugeben. Auditieren Sie Anwendungen auf unsichere DLL-Lademuster.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Umfang: Codeausführung Angreifer führen beliebigen Code aus, wenn ihre bösartige Ressource aus einem kontrollierten Suchpfadelement geladen wird.
Integrität	Umfang: Privilegieneskalation Code läuft mit den Privilegien der anfälligen Anwendung, oft SYSTEM-Level unter Windows.
Verfügbarkeit	Umfang: Systemkompromittierung Vollständige Systemkompromittierung ermöglicht persistenten Zugriff und vollständige Kontrolle.

Beispielcode

Anfälliger Code

// ANFÄLLIG: Durchsucht aktuelles Verzeichnis nach DLLs
#include <windows.h>

int main() {
    // LoadLibrary ohne vollständigen Pfad durchsucht:
    // 1. Verzeichnis der ausführbaren Datei
    // 2. Aktuelles Verzeichnis (Angreifer kann kontrollieren!)
    // 3. Systemverzeichnisse
    HMODULE hMod = LoadLibrary("plugin.dll");

    // Angreifer platziert bösartige plugin.dll im aktuellen Verzeichnis
    // Anwendung lädt Angreifers DLL vor System-DLL
}

// ANFÄLLIG: Konfiguration zeigt auf beschreibbares Verzeichnis
// C:\ProgramData ist von Standardbenutzern beschreibbar!
const char* pluginPath = "C:\\ProgramData\\MyApp\\plugins\\";

# ANFÄLLIG: pip install durchsucht öffentliches PyPI vor privatem
# requirements.txt enthält internen Paketnamen
# internal-package==1.0.0

# Angreifer veröffentlicht "internal-package" auf öffentlichem PyPI
# mit höherer Versionsnummer, wird stattdessen installiert

# ANFÄLLIG: sys.path enthält beschreibbare Verzeichnisse
import sys
# Wenn Angreifer in ein beliebiges Verzeichnis in sys.path schreiben kann,
# kann er bösartige Module platzieren
print(sys.path)  # Könnte aktuelles Verzeichnis "." enthalten

// ANFÄLLIG: Node.js Modulauflösung
const helper = require('helper');
// Node durchsucht:
// 1. Kern-Module
// 2. node_modules im aktuellen und übergeordneten Verzeichnis
// 3. NODE_PATH-Verzeichnisse

// Wenn Angreifer in ein beliebiges durchsuchtes node_modules schreiben kann,
// kann er legitime Pakete ersetzen

// ANFÄLLIG: npm install mit Typosquatting
// package.json referenziert "lodash" aber Angreifer veröffentlicht "1odash"

Korrigierter Code

// SICHER: DLLs mit absoluten Pfaden und sicheren Flags laden
#include <windows.h>
#include <strsafe.h>

HMODULE load_dll_securely(const WCHAR* dllName) {
    // Aktuelles Verzeichnis aus Suchpfad entfernen
    SetDllDirectory(L"");

    // Für System-DLLs nur Systemverzeichnis durchsuchen
    return LoadLibraryExW(
        dllName,
        NULL,
        LOAD_LIBRARY_SEARCH_SYSTEM32
    );
}

HMODULE load_app_dll_securely(const WCHAR* dllName) {
    WCHAR fullPath[MAX_PATH];
    WCHAR appDir[MAX_PATH];

    // Anwendungsverzeichnis abrufen
    GetModuleFileNameW(NULL, appDir, MAX_PATH);
    PathRemoveFileSpecW(appDir);

    // Vollständigen Pfad zur DLL bauen
    StringCchPrintfW(fullPath, MAX_PATH, L"%s\\%s", appDir, dllName);

    // Pfad ist am erwarteten Ort verifizieren (kein Traversal)
    WCHAR canonicalPath[MAX_PATH];
    GetFullPathNameW(fullPath, MAX_PATH, canonicalPath, NULL);

    if (wcsncmp(canonicalPath, appDir, wcslen(appDir)) != 0) {
        SetLastError(ERROR_BAD_PATHNAME);
        return NULL;
    }

    // DLL-Signatur verifizieren (Windows Authenticode)
    if (!verify_dll_signature(canonicalPath)) {
        SetLastError(ERROR_INVALID_SIGNATURE);
        return NULL;
    }

    return LoadLibraryExW(
        canonicalPath,
        NULL,
        LOAD_WITH_ALTERED_SEARCH_PATH
    );
}

// SICHER: Nur in geschütztes Verzeichnis installieren
// C:\Program Files\ (erfordert Admin zum Schreiben)
const WCHAR* pluginPath = L"C:\\Program Files\\MyApp\\plugins\\";

# SICHER: pip konfigurieren, um private Registry mit Priorität zu verwenden
# pip.conf
# [global]
# index-url = https://private.example.com/simple/
# extra-index-url = https://pypi.org/simple/

# SICHER: Namespace-Präfixe für interne Pakete verwenden
# Statt: internal-package
# Verwenden: companyname-internal-package

# SICHER: Exakte Versionen mit Hashes pinnen
# requirements.txt
# internal-package==1.0.0 --hash=sha256:abc123...

# SICHER: Modulquelle vor Import verifizieren
import importlib.util
import os

def safe_import(module_name, expected_path):
    """Modul nur aus erwartetem Pfad importieren."""
    full_path = os.path.join(expected_path, f"{module_name}.py")

    # Pfad ist im erwarteten Verzeichnis verifizieren
    real_path = os.path.realpath(full_path)
    expected_real = os.path.realpath(expected_path)

    if not real_path.startswith(expected_real + os.sep):
        raise ImportError(f"Modul {module_name} nicht im erwarteten Pfad")

    if not os.path.exists(full_path):
        raise ImportError(f"Modul {module_name} nicht gefunden")

    spec = importlib.util.spec_from_file_location(module_name, full_path)
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module

// SICHER: Dependencies mit package-lock.json sperren
// Immer package-lock.json in Versionskontrolle committen
// npm ci statt npm install in CI/CD verwenden

// SICHER: npm konfigurieren, um private Registry zu verwenden
// .npmrc
// registry=https://private.example.com/
// @company:registry=https://private.example.com/

// SICHER: Scoped Packages für interne Module verwenden
// Statt: require('internal-helper')
// Verwenden: require('@company/internal-helper')

// SICHER: Paketintegrität verifizieren
const crypto = require('crypto');
const fs = require('fs');

function verifyPackageIntegrity(packagePath, expectedHash) {
    const fileBuffer = fs.readFileSync(packagePath);
    const hash = crypto.createHash('sha256').update(fileBuffer).digest('hex');

    if (hash !== expectedHash) {
        throw new Error(`Paket-Integritätsprüfung fehlgeschlagen für ${packagePath}`);
    }

    return true;
}

// SICHER: Absolute Pfade für require verwenden
const path = require('path');
const helper = require(path.join(__dirname, 'lib', 'helper'));

Ausgenutzt in der Praxis

GE Vernova CIMPLICITY (GE Vernova, 2025)

CVE-2025-7719 in GE Vernovas CIMPLICITY HMI/SCADA-Plattform ermöglicht niedrig-privilegierten lokalen Benutzern die Privilegieneskalation durch Ausnutzung unkontrollierter Suchpfadelemente, betrifft industrielle Steuerungssysteme mit CVSS 7.0.

https://www.cisa.gov/ics

Synaptics Fingerprint Driver (Synaptics, 2025)

CVE-2025-11772 im Synaptics Fingerprint Driver lädt DLLs aus C:\ProgramData\Synaptics ohne Validierung, wodurch lokale Angreifer SYSTEM-Level-Codeausführung während der Treiberinstallation erreichen können.

https://radar.offseq.com/

Dependency Confusion Angriffe (Mehrere, 2021-Heute)

Forscher demonstrierten Dependency-Confusion-Angriffe, die Microsoft, Apple, PayPal und andere große Unternehmen betrafen, indem sie bösartige Pakete mit internen Paketnamen auf öffentlichen Registries veröffentlichten und Code während der Paketinstallation ausführten.

https://medium.com/@alex.birsan/dependency-confusion-4a5d60fec610

Tools zum Testen/Ausnutzen

Dependency Confusion Checker — Dependency-Confusion-Risiken identifizieren.
Procmon — DLL-Ladeverhalten überwachen.
npm audit — anfällige Dependencies identifizieren.

CVE-Beispiele

CVE-2025-7719 — GE Vernova CIMPLICITY Privilegieneskalation.
CVE-2025-11772 — Synaptics Fingerprint Driver DLL-Planting.
CVE-2021-23566 — nanoid Paket Prototype Pollution.

Referenzen

MITRE. "CWE-427: Uncontrolled Search Path Element." https://cwe.mitre.org/data/definitions/427.html
OWASP. "Dependency Confusion." https://owasp.org/www-project-web-security-testing-guide/