Auswahl eines weniger sicheren Algorithmus während der Aushandlung (Algorithmus-Downgrade)

Beschreibung

Die Auswahl eines weniger sicheren Algorithmus während der Aushandlung, auch bekannt als Algorithmus-Downgrade, ist eine Schwachstelle, die auftritt, wenn ein Sicherheitsprotokoll oder Produkt aushandelt, welcher Algorithmus zwischen mehreren Parteien verwendet werden soll, aber nicht die stärkste verfügbare Option auswählt. Stattdessen erlaubt der Aushandlungsprozess die Auswahl eines schwächeren Algorithmus oder kann dazu gezwungen werden. Dies ermöglicht Angreifern, Sicherheitskontrollen zu umgehen, indem sie die Verwendung von Algorithmen mit bekannten Schwächen erzwingen, wie z.B. das Erzwingen der Verwendung schwächerer Chiffren für verschlüsselte Kommunikation oder sogar Klartext-Übertragung.

Risiko

Algorithmus-Downgrade-Angriffe untergraben die Sicherheit, indem sie die Verwendung schwächerer kryptografischer Optionen erzwingen. Wenn ein Angreifer die Kommunikation zur Verwendung von Klartext anstelle von Verschlüsselung zwingen kann, kann er den Datenverkehr passiv mitschneiden ohne den Aufwand der Kryptoanalyse. Das Erzwingen der Verwendung veralteter Algorithmen wie DES, RC4 oder MD5 macht Brute-Force- oder kryptoanalytische Angriffe durchführbar. TLS/SSL-Downgrade-Angriffe können die Verwendung anfälliger Protokollversionen mit bekannten Exploits erzwingen. Authentifizierungsmechanismen, die schwächere Methoden erlauben, können ausgenutzt werden, um starke Authentifizierung zu umgehen. Das Risiko ist besonders schwerwiegend bei Man-in-the-Middle-Positionen, wo Angreifer Aushandlungsnachrichten modifizieren können.

Lösung

Konfigurieren Sie Systeme so, dass sie nur starke Algorithmen akzeptieren und schwache ablehnen. Implementieren Sie Mindestanforderungen an die Algorithmenstärke. Verwenden Sie Protokollerweiterungen, die Downgrade-Angriffe verhindern (wie TLS_FALLBACK_SCSV für TLS). Vermeiden Sie die Unterstützung veralteter schwacher Algorithmen auch für Abwärtskompatibilität, sofern nicht unbedingt erforderlich. Prüfen und aktualisieren Sie regelmäßig die Mindestsicherheitsanforderungen, wenn Algorithmen veraltet werden. Überwachen Sie Downgrade-Versuche, da sie auf aktive Angriffe hinweisen können. Verwenden Sie authentifizierte Aushandlungsmechanismen, die Manipulationen an Algorithmusauswahlnachrichten erkennen.

Häufige Auswirkungen

Auswirkung	Details
Zugriffskontrolle	Bereich: Zugriffskontrolle Schutzmechanismus umgehen - Downgrade ermöglicht die Umgehung beabsichtigter Sicherheitsalgorithmen.
Vertraulichkeit	Bereich: Vertraulichkeit Anwendungsdaten lesen - Schwächere Algorithmen können gebrochen werden, um verschlüsselte Daten offenzulegen.
Integrität	Bereich: Integrität Anwendungsdaten modifizieren - Schwache Integritätsalgorithmen können unerkannte Modifikation ermöglichen.

Beispielcode + Lösungscode

Anfälliger Code

// Anfällig: Server akzeptiert jede SSL/TLS-Version einschließlich schwacher
import javax.net.ssl.*;

public class VulnerableSSLServer {

    public void vulnerableServerSocket() throws Exception {
        SSLServerSocketFactory factory =
            (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
        SSLServerSocket serverSocket =
            (SSLServerSocket) factory.createServerSocket(8443);

        // Anfällig: Akzeptiert SSLv3, TLS 1.0, 1.1 - alle haben bekannte Schwächen
        // Standard aktiviert alle Protokollversionen
        // Angreifer kann Downgrade zu SSLv3 erzwingen (POODLE-Angriff)

        SSLSocket clientSocket = (SSLSocket) serverSocket.accept();
        // Verbindung kann anfällige Protokollversion verwenden
    }
}

// Anfällig: Cipher-Suite enthält schwache Algorithmen
public class VulnerableCipherConfig {

    public void configureWeakCiphers(SSLSocket socket) {
        String[] weakCiphers = {
            "TLS_RSA_WITH_AES_256_CBC_SHA256",   // OK
            "TLS_RSA_WITH_AES_128_CBC_SHA",       // OK aber alt
            "SSL_RSA_WITH_3DES_EDE_CBC_SHA",      // Schwach: 3DES
            "SSL_RSA_WITH_RC4_128_SHA",           // Schwach: RC4
            "SSL_RSA_WITH_DES_CBC_SHA",           // Schwach: DES
            "SSL_RSA_EXPORT_WITH_RC4_40_MD5",     // Export-Qualität: Sehr schwach!
            "TLS_RSA_WITH_NULL_SHA"               // Keine Verschlüsselung!
        };

        // Anfällig: Erlaubt schwache und Null-Chiffren
        socket.setEnabledCipherSuites(weakCiphers);
    }
}

# Anfällig: Python SSL-Kontext erlaubt alte Protokolle
import ssl
import socket

def vulnerable_ssl_connection(host, port):
    # Anfällig: Verwendung von SSLv23 erlaubt Downgrade zu jeder Version
    context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)

    # Anfällig: Schwache Protokolle nicht deaktiviert
    # SSLv2, SSLv3, TLS 1.0, TLS 1.1 alle potenziell aktiviert

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    ssl_sock = context.wrap_socket(sock, server_hostname=host)
    ssl_sock.connect((host, port))

    return ssl_sock

# Anfällig: OpenSSL Cipher-String enthält schwache Optionen
def vulnerable_cipher_config():
    context = ssl.SSLContext(ssl.PROTOCOL_TLS)

    # Anfällig: Cipher-String enthält schwache Algorithmen
    context.set_ciphers('ALL:!aNULL')  # Enthält RC4, DES, Export-Chiffren

    return context

// Anfällig: OpenSSL-Konfiguration erlaubt Downgrade
#include <openssl/ssl.h>

SSL_CTX* vulnerable_ssl_context() {
    // Anfällig: Verwendet Methode, die Versionsaushandlung zu schwachen Versionen erlaubt
    SSL_CTX* ctx = SSL_CTX_new(SSLv23_method());

    // Anfällig: Keine Mindestversion gesetzt
    // Angreifer kann SSLv3 oder TLS 1.0 erzwingen

    // Anfällig: Schwache Cipher-Suites aktiviert
    SSL_CTX_set_cipher_list(ctx, "ALL:!aNULL:!eNULL");
    // Enthält RC4, DES, 3DES, Export-Chiffren

    return ctx;
}

// Anfällig: SSH erlaubt schwachen Schlüsselaustausch
/*
 * SSH-Konfiguration, die Downgrade erlaubt:
 * KexAlgorithms diffie-hellman-group1-sha1,diffie-hellman-group14-sha1,...
 * Ciphers 3des-cbc,aes128-cbc,...
 * MACs hmac-md5,hmac-sha1,...
 */

<!-- Anfällig: IIS-Konfiguration erlaubt schwache Protokolle -->
<system.webServer>
    <security>
        <access sslFlags="Ssl"/>
        <!-- Anfällig: Keine Mindest-TLS-Version erzwungen -->
        <!-- Server akzeptiert TLS 1.0, 1.1, die bekannte Schwachstellen haben -->
    </security>
</system.webServer>

<!-- Anfällig: Apache-Konfiguration -->
<!--
SSLProtocol all
# Anfällig: 'all' enthält SSLv3, TLS 1.0, TLS 1.1

SSLCipherSuite HIGH:MEDIUM:LOW
# Anfällig: Enthält MEDIUM und LOW Stärke-Chiffren
-->

Behobener Code

// Behoben: Server akzeptiert nur starke TLS-Versionen
import javax.net.ssl.*;

public class SecureSSLServer {

    public void secureServerSocket() throws Exception {
        SSLServerSocketFactory factory =
            (SSLServerSocketFactory) SSLServerSocketFactory.getDefault();
        SSLServerSocket serverSocket =
            (SSLServerSocket) factory.createServerSocket(8443);

        // Behoben: Nur TLS 1.2 und 1.3 aktivieren
        serverSocket.setEnabledProtocols(new String[]{"TLSv1.2", "TLSv1.3"});

        // Behoben: Nur starke Cipher-Suites
        serverSocket.setEnabledCipherSuites(getSecureCipherSuites());

        SSLSocket clientSocket = (SSLSocket) serverSocket.accept();
        // Verbindung wird nur starke Protokolle verwenden
    }

    private String[] getSecureCipherSuites() {
        return new String[]{
            // TLS 1.3 Cipher-Suites
            "TLS_AES_256_GCM_SHA384",
            "TLS_AES_128_GCM_SHA256",
            "TLS_CHACHA20_POLY1305_SHA256",
            // TLS 1.2 Cipher-Suites mit AEAD
            "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384",
            "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
            "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
            "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256"
            // Kein CBC-Modus, kein RSA-Schlüsselaustausch, keine schwachen Algorithmen
        };
    }
}

// Behoben: Java systemweite Konfiguration (Java 8+)
public class SecureJavaConfig {

    static {
        // Schwache Algorithmen global deaktivieren
        java.security.Security.setProperty("jdk.tls.disabledAlgorithms",
            "SSLv3, TLSv1, TLSv1.1, RC4, DES, MD5withRSA, " +
            "DH keySize < 2048, EC keySize < 224, 3DES_EDE_CBC, anon, NULL");
    }
}

# Behoben: Python SSL-Kontext mit starken Einstellungen
import ssl
import socket

def secure_ssl_connection(host, port):
    # Behoben: Standard-Kontext mit starken Einstellungen erstellen
    context = ssl.create_default_context()

    # Behoben: Mindest-TLS-Version setzen
    context.minimum_version = ssl.TLSVersion.TLSv1_2

    # Behoben: Nur starke Chiffren
    context.set_ciphers(
        'ECDHE+AESGCM:DHE+AESGCM:ECDHE+CHACHA20:DHE+CHACHA20:!aNULL:!MD5:!DSS'
    )

    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    ssl_sock = context.wrap_socket(sock, server_hostname=host)
    ssl_sock.connect((host, port))

    return ssl_sock

# Behoben: Strikter SSL-Kontext
def secure_strict_context():
    context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)

    # Behoben: TLS 1.2 Minimum
    context.minimum_version = ssl.TLSVersion.TLSv1_2

    # Behoben: Zertifikate verifizieren
    context.verify_mode = ssl.CERT_REQUIRED
    context.check_hostname = True

    # Behoben: Nur starke Chiffren
    context.set_ciphers('ECDHE+AESGCM:DHE+AESGCM')

    return context

// Behoben: OpenSSL-Konfiguration mit starken Einstellungen
#include <openssl/ssl.h>

SSL_CTX* secure_ssl_context() {
    // Behoben: TLS-Methode verwenden (nicht SSLv23)
    SSL_CTX* ctx = SSL_CTX_new(TLS_method());

    // Behoben: Mindestversion auf TLS 1.2 setzen
    SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);

    // Behoben: Nur starke Cipher-Suites
    SSL_CTX_set_cipher_list(ctx,
        "ECDHE+AESGCM:DHE+AESGCM:!aNULL:!MD5:!DSS:!RC4:!DES:!3DES:!EXPORT");

    // Behoben: Server-Cipher-Reihenfolge bevorzugen
    SSL_CTX_set_options(ctx, SSL_OP_CIPHER_SERVER_PREFERENCE);

    // Behoben: Kompression deaktivieren (CRIME-Angriff)
    SSL_CTX_set_options(ctx, SSL_OP_NO_COMPRESSION);

    return ctx;
}

# Behoben: Apache-Konfiguration mit starkem TLS
SSLEngine on
SSLProtocol -all +TLSv1.2 +TLSv1.3
SSLCipherSuite ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384
SSLHonorCipherOrder on
SSLCompression off
SSLSessionTickets off

# Behoben: Nginx-Konfiguration
# ssl_protocols TLSv1.2 TLSv1.3;
# ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
# ssl_prefer_server_ciphers on;

---

CVE-Beispiele

• CVE-2005-2969: SSL/TLS-Implementierung erlaubte Downgrade zu schwächeren Protokollversionen.
• CVE-2006-4302: Versions-Downgrade-Schwachstelle in Protokollaushandlung.
• CVE-2006-4407: Schwache Cipher-Auswahl während Aushandlung erlaubt.
• CVE-2001-1444: Telnet erlaubte Authentifizierungs- und Verschlüsselungs-Downgrade.
• CVE-2002-1646: SSH-Konfiguration könnte überschrieben werden, um schwächere Schemata zu verwenden.

---

Referenzen

1. MITRE Corporation. "CWE-757: Selection of Less-Secure Algorithm During Negotiation ('Algorithm Downgrade')." https://cwe.mitre.org/data/definitions/757.html
2. CAPEC-220: Client-Server Protocol Manipulation.
3. NIST Guidelines on TLS Implementations.