Unsachgemäße Einschränkung des Kommunikationskanals auf beabsichtigte Endpunkte

Beschreibung

Unsachgemäße Einschränkung des Kommunikationskanals auf beabsichtigte Endpunkte tritt auf, wenn ein Produkt einen Kommunikationskanal für privilegierte oder geschützte Operationen erstellt, aber nicht ordnungsgemäß sicherstellt, dass es mit dem richtigen Endpunkt kommuniziert. Wenn Software Verbindungen zu Servern, Peers oder anderen Endpunkten herstellt, muss sie die Identität der entfernten Partei überprüfen, bevor sensible Daten ausgetauscht oder privilegierte Operationen durchgeführt werden. Das Versäumnis, Endpunkte ordnungsgemäß zu validieren, ermöglicht es Angreifern, legitime Server oder Clients zu imitieren, Kommunikationen abzufangen, Anmeldedaten zu stehlen oder bösartige Daten einzuschleusen.

Risiko

Diese Schwachstelle ermöglicht Man-in-the-Middle-Angriffe, bei denen Angreifer Kommunikationen zwischen legitimen Parteien abfangen und möglicherweise modifizieren. Angreifer können vertrauenswürdige Server imitieren, um Anmeldedaten zu stehlen oder bösartige Inhalte bereitzustellen. In Cross-Domain-Szenarien können bösartige Websites unautorisierte Anfragen an sensible Dienste stellen. Auf mobilen Plattformen können Anwendungen Intents oder Nachrichten von nicht vertrauenswürdigen Quellen akzeptieren. Zertifikatsvalidierungsfehler ermöglichen es Angreifern mit Netzwerkzugang, gefälschte Zertifikate zu präsentieren. Das Risiko ist schwerwiegend, weil Benutzer und Systeme glauben, mit legitimen Endpunkten zu kommunizieren, während sie tatsächlich mit Angreifern interagieren.

Lösung

Implementieren Sie robuste Endpunktverifizierung für alle Kommunikationen. Überprüfen Sie TLS-Zertifikate einschließlich Hostname-Validierung - deaktivieren Sie niemals Zertifikatsprüfungen, auch nicht vorübergehend. Verwenden Sie Certificate Pinning für hochsichere Anwendungen. Validieren Sie die Quelle von Nachrichten, Intents oder Anfragen vor der Verarbeitung. Implementieren Sie strikte Cross-Domain-Richtlinien (CORS, Content-Security-Policy). Für IP-basierte Einschränkungen kombinieren Sie mit Authentifizierung, anstatt sich allein auf IP zu verlassen. Verwenden Sie gegenseitiges TLS, bei dem beide Parteien authentifizieren. Validieren Sie Weiterleitungsziele, bevor Sie ihnen folgen. Implementieren Sie geeignete DNS-Sicherheitsmaßnahmen. Für mobile Apps validieren Sie Intent-Ursprünge und verwenden Sie explizite Intents, wo möglich.

Häufige Auswirkungen

Auswirkung	Details
Integrität, Vertraulichkeit	Bereich: Integrität, Vertraulichkeit Privilegien erlangen oder Identität annehmen - Angreifer können Endpunkte imitieren, um Privilegien und Zugang zu erhalten, die für legitime Parteien bestimmt sind.
Vertraulichkeit	Bereich: Vertraulichkeit Anwendungsdaten lesen - Man-in-the-Middle-Angriffe ermöglichen es Angreifern, sensible Kommunikationen abzufangen und zu lesen.
Integrität	Bereich: Integrität Anwendungsdaten modifizieren - Angreifer können Daten während der Übertragung einschleusen oder modifizieren, wenn die Endpunktverifizierung fehlt.

Beispielcode

Anfälliger Code

// Anfällig: SSL-Zertifikatsvalidierung deaktivieren
public class VulnerableHttpClient {

    public void makeRequest(String url) throws Exception {
        // Anfällig: Allen Zertifikaten vertrauen
        TrustManager[] trustAllCerts = new TrustManager[] {
            new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() { return null; }
                public void checkClientTrusted(X509Certificate[] certs, String authType) {}
                public void checkServerTrusted(X509Certificate[] certs, String authType) {}
            }
        };

        SSLContext sc = SSLContext.getInstance("TLS");
        sc.init(null, trustAllCerts, new SecureRandom());

        HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());

        // Anfällig: Hostname-Verifizierung deaktivieren
        HttpsURLConnection.setDefaultHostnameVerifier((hostname, session) -> true);

        // Jetzt Verbindung zu jedem Server, auch Angreifer mit ungültigen Zertifikaten
        URL requestUrl = new URL(url);
        HttpsURLConnection conn = (HttpsURLConnection) requestUrl.openConnection();
    }
}

# Anfällig: SSL-Verifizierung in Python deaktivieren
import requests

def vulnerable_api_call(url, data):
    # Anfällig: SSL-Verifizierung deaktiviert
    response = requests.post(url, json=data, verify=False)
    return response.json()

# Anfällig: Weiterleitungsziel nicht prüfen
def vulnerable_follow_redirect(initial_url):
    response = requests.get(initial_url, allow_redirects=True)
    # Könnte zu bösartiger Seite weitergeleitet werden
    return response.text

// Anfällig: CORS erlaubt alle Origins
const express = require('express');
const app = express();

// Anfällig: Akzeptiert Anfragen von jedem Origin
app.use((req, res, next) => {
    res.header('Access-Control-Allow-Origin', '*');
    res.header('Access-Control-Allow-Credentials', 'true');
    next();
});

// Sensibler API-Endpunkt jetzt von bösartigen Seiten zugänglich
app.get('/api/user/data', (req, res) => {
    res.json(getUserData(req.session.userId));
});

// Anfällig: Nur IP-basierte Authentifizierung
func vulnerableHandler(w http.ResponseWriter, r *http.Request) {
    // Anfällig: IP-Adressen können gespooft werden
    clientIP := r.RemoteAddr

    if isAllowedIP(clientIP) {
        // Privilegierte Operation ausführen
        performAdminAction()
        w.Write([]byte("Aktion abgeschlossen"))
    } else {
        http.Error(w, "Verboten", 403)
    }
}

Korrigierter Code

// Korrigiert: Ordnungsgemäße SSL-Zertifikatsvalidierung
public class FixedHttpClient {

    public void makeRequest(String url) throws Exception {
        // Korrigiert: Standard-TrustManager verwenden, der Zertifikate ordnungsgemäß validiert
        URL requestUrl = new URL(url);
        HttpsURLConnection conn = (HttpsURLConnection) requestUrl.openConnection();

        // Standard-SSLSocketFactory validiert Zertifikate ordnungsgemäß

        // Für zusätzliche Sicherheit Certificate Pinning implementieren
        conn.setSSLSocketFactory(getPinnedSSLSocketFactory());

        // Verbindung wird nur fortgesetzt, wenn Zertifikat gültig ist
    }

    private SSLSocketFactory getPinnedSSLSocketFactory() throws Exception {
        // Gepinntes Zertifikat laden
        CertificateFactory cf = CertificateFactory.getInstance("X.509");
        InputStream caInput = getClass().getResourceAsStream("/trusted_cert.pem");
        Certificate ca = cf.generateCertificate(caInput);

        // KeyStore mit vertrauenswürdigem Zertifikat erstellen
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, null);
        keyStore.setCertificateEntry("ca", ca);

        // TrustManager erstellen, der unserem Zertifikat vertraut
        TrustManagerFactory tmf = TrustManagerFactory.getInstance(
            TrustManagerFactory.getDefaultAlgorithm());
        tmf.init(keyStore);

        SSLContext context = SSLContext.getInstance("TLS");
        context.init(null, tmf.getTrustManagers(), null);

        return context.getSocketFactory();
    }
}

# Korrigiert: Ordnungsgemäße SSL-Verifizierung in Python
import requests
from urllib.parse import urlparse

def fixed_api_call(url, data):
    # Korrigiert: SSL-Verifizierung aktiviert (Standard)
    response = requests.post(url, json=data, verify=True)
    # Oder CA-Bundle angeben: verify='/path/to/ca-bundle.crt'
    return response.json()

# Korrigiert: Weiterleitungsziele validieren
ALLOWED_REDIRECT_DOMAINS = {'trusted.com', 'api.trusted.com'}

def fixed_follow_redirect(initial_url):
    response = requests.get(initial_url, allow_redirects=False)

    while response.is_redirect:
        redirect_url = response.headers.get('Location')

        # Korrigiert: Weiterleitungsziel validieren
        parsed = urlparse(redirect_url)
        if parsed.netloc not in ALLOWED_REDIRECT_DOMAINS:
            raise SecurityError(f"Weiterleitung zu nicht vertrauenswürdiger Domain: {parsed.netloc}")

        response = requests.get(redirect_url, allow_redirects=False)

    return response.text

// Korrigiert: Restriktive CORS-Konfiguration
const express = require('express');
const cors = require('cors');
const app = express();

// Korrigiert: Spezifische Origins auf Whitelist
const allowedOrigins = [
    'https://www.trusted-site.com',
    'https://app.trusted-site.com'
];

const corsOptions = {
    origin: function (origin, callback) {
        // Anfragen ohne Origin erlauben (mobile Apps, curl, etc.)
        // Oder strengere Richtlinie implementieren
        if (!origin || allowedOrigins.includes(origin)) {
            callback(null, true);
        } else {
            callback(new Error('Nicht von CORS erlaubt'));
        }
    },
    credentials: true,
    methods: ['GET', 'POST'],
    allowedHeaders: ['Content-Type', 'Authorization']
};

app.use(cors(corsOptions));

app.get('/api/user/data', (req, res) => {
    // Korrigiert: Origin ist validiert
    res.json(getUserData(req.session.userId));
});

// Korrigiert: Ordnungsgemäße Authentifizierung über IP hinaus
func fixedHandler(w http.ResponseWriter, r *http.Request) {
    // Korrigiert: Authentifizierungs-Token erforderlich
    authHeader := r.Header.Get("Authorization")
    if !validateAuthToken(authHeader) {
        http.Error(w, "Nicht autorisiert", 401)
        return
    }

    // Korrigiert: IP als zusätzliche Verteidigungsschicht, nicht alleinige Auth
    clientIP := getClientIP(r)
    if !isAllowedIP(clientIP) {
        log.Printf("Warnung: Anfrage von unerwarteter IP: %s", clientIP)
        // Loggen, aber nicht unbedingt blockieren, wenn Auth gültig ist
    }

    performAdminAction()
    w.Write([]byte("Aktion abgeschlossen"))
}

func getClientIP(r *http.Request) string {
    // Korrigiert: X-Forwarded-For nicht blind vertrauen
    // Nur vertrauen, wenn hinter bekanntem Proxy
    if behindTrustedProxy() {
        forwarded := r.Header.Get("X-Forwarded-For")
        if forwarded != "" {
            // Erste IP nehmen (Client)
            parts := strings.Split(forwarded, ",")
            return strings.TrimSpace(parts[0])
        }
    }

    // Direkte Verbindungs-IP verwenden
    ip, _, _ := net.SplitHostPort(r.RemoteAddr)
    return ip
}

---

CVE-Beispiele

• CVE-2022-30319: IP-Allowlist durch gefälschte Quelladressen umgangen.
• CVE-2012-5810: Mobile-Banking-Anwendung fehlende Hostname-Verifizierung in SSL.
• CVE-2014-1266: Apples "goto fail"-Bug führte dazu, dass Zertifikatsvalidierung immer erfolgreich war.

---

Verwandte CWEs

• CWE-284: Improper Access Control (Eltern)
• CWE-291: Reliance on IP Address for Authentication (Kind)
• CWE-297: Improper Validation of Certificate with Host Mismatch (Kind)
• CWE-300: Channel Accessible by Non-Endpoint (Kind)
• CWE-940: Improper Verification of Source of a Communication Channel (Kind)

---

Referenzen

1. MITRE Corporation. "CWE-923: Improper Restriction of Communication Channel to Intended Endpoints." https://cwe.mitre.org/data/definitions/923.html
2. OWASP. "Transport Layer Protection Cheat Sheet." https://cheatsheetseries.owasp.org/cheatsheets/Transport_Layer_Protection_Cheat_Sheet.html
3. OWASP. "Cross-Origin Resource Sharing (CORS)." https://owasp.org/www-community/attacks/CORS_OriginHeaderScrutiny