Falsch angegebenes Ziel in einem Kommunikationskanal

Beschreibung

Falsch angegebenes Ziel in einem Kommunikationskanal tritt auf, wenn ein Produkt einen ausgehenden Kommunikationskanal erstellt, aber das beabsichtigte Ziel nicht korrekt angibt. Dies kann passieren, wenn Angreifer die Zielangabe kontrollieren oder beeinflussen können, oder wenn das Produkt falsch identifiziert, wohin Daten gesendet werden sollen. Diese Schwachstelle ist besonders verbreitet in Protokollen, die verbindungslose Kommunikation (wie UDP) verwenden, bei der das Ziel pro Paket angegeben wird, oder in Systemen, die Ziele dynamisch basierend auf potenziell gefälschten Eingabedaten bestimmen.

Risiko

Diese Schwachstelle kann zu verschiedenen Angriffen führen. Bei Netzwerk-Amplification-Angriffen werden Antworten an Opferadressen umgeleitet und überwältigen diese mit Datenverkehr (DDoS). Sensible Daten können an von Angreifern kontrollierte Ziele statt an legitime Server gesendet werden. DNS-Antworten können umgeleitet werden, um Cache-Poisoning zu ermöglichen. Offene Weiterleitungen können Benutzer auf bösartige Seiten senden. E-Mail- oder Nachrichtensysteme können missbraucht werden, um unbeabsichtigte Empfänger zu spammen. Die Schwere hängt von der Art der übertragenen Daten und dem Amplification-Faktor des Protokolls ab, wenn es in Reflection-Angriffen verwendet wird.

Lösung

Validieren Sie Zieladressen, bevor Sie Daten senden. Leiten Sie Antwortziele niemals ausschließlich aus nicht authentifizierten Anfragefeldern ab. Für UDP-basierte Protokolle implementieren Sie Verbindungsaufbau- oder Validierungs-Handshakes. Verwenden Sie Rate-Limiting für Antwortverkehr. Implementieren Sie BCP38/RFC2827 Ingress-Filterung, um Quelladress-Spoofing zu verhindern. Vermeiden Sie Protokolle, die für Amplification anfällig sind, wo möglich. Authentifizieren Sie Sender, bevor Sie antworten. Erwägen Sie die Verwendung von TCP, wo verbindungsorientierte Semantik eine inhärente Zielverifizierung bietet. Protokollieren und überwachen Sie ungewöhnliche Verkehrsmuster, die auf Missbrauch hindeuten könnten.

Häufige Auswirkungen

Auswirkung	Details
Vertraulichkeit	Bereich: Vertraulichkeit Anwendungsdaten lesen - Daten, die an falsche Ziele gesendet werden, können von Angreifern abgefangen werden.
Verfügbarkeit	Bereich: Verfügbarkeit DoS: Amplification - Antworten, die an Opferadressen umgeleitet werden, ermöglichen Denial-of-Service-Amplification-Angriffe.
Zugriffskontrolle	Bereich: Zugriffskontrolle Privilegien erlangen oder Identität annehmen - Angreifer können Daten oder Zugang zu Funktionalität erhalten, die für legitime Ziele bestimmt sind.

Beispielcode

Anfälliger Code

// Anfällig: DNS-Server antwortet auf gefälschte Quelle
#include <sys/socket.h>
#include <netinet/in.h>

void vulnerable_dns_server(int socket_fd) {
    char buffer[512];
    struct sockaddr_in client_addr;
    socklen_t addr_len = sizeof(client_addr);

    while (1) {
        // DNS-Abfrage empfangen
        ssize_t received = recvfrom(socket_fd, buffer, sizeof(buffer), 0,
                                    (struct sockaddr*)&client_addr, &addr_len);

        if (received > 0) {
            DNSQuery *query = parse_dns_query(buffer, received);
            DNSResponse *response = create_dns_response(query);

            // Anfällig: Antwort an Quelladresse senden
            // UDP-Quelle kann gefälscht werden!
            sendto(socket_fd, response->data, response->length, 0,
                   (struct sockaddr*)&client_addr, addr_len);

            // Wenn Quelle gefälscht ist, geht Antwort an Opfer
            // Amplification-Angriff: kleine Abfrage -> große Antwort
        }
    }
}

// Anfällig: NTP-Server anfällig für Amplification
void vulnerable_ntp_handler(int socket_fd, char *buffer, size_t len,
                            struct sockaddr_in *client) {

    NTPPacket *request = (NTPPacket *)buffer;

    // Anfällig: "monlist"-Befehl verarbeiten
    if (request->mode == NTP_MODE_PRIVATE && request->code == REQ_MON_GETLIST) {
        // Antwort kann 200x größer sein als Anfrage (Amplification)
        // An potenziell gefälschte Adresse senden
        MonitorList *list = get_monitor_list();

        for (int i = 0; i < list->count; i++) {
            sendto(socket_fd, &list->entries[i], sizeof(MonitorEntry), 0,
                   (struct sockaddr*)client, sizeof(*client));
        }
    }
}

# Anfällig: E-Mail-Dienst mit Open-Relay-Charakteristiken
import smtplib

def vulnerable_send_notification(user_email, message):
    # Anfällig: E-Mail-Adresse aus nicht validierter Benutzereingabe
    # Angreifer kann jede E-Mail-Adresse angeben
    sender = "[email protected]"
    recipient = user_email  # Benutzergesteuert!

    smtp = smtplib.SMTP('localhost')
    smtp.sendmail(sender, recipient, message)
    smtp.quit()

# Angriff: user_email = "[email protected]" + tausende Adressen
# Als Spam-Relay missbraucht

// Anfällig: Offene Weiterleitung
app.get('/redirect', (req, res) => {
    // Anfällig: Weiterleitungsziel aus Benutzereingabe
    const destination = req.query.url;

    // Angreifer: /redirect?url=https://malicious-site.com
    res.redirect(destination);
});

Korrigierter Code

// Korrigiert: DNS-Server mit Rate-Limiting und Validierung
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>

#define MAX_REQUESTS_PER_IP 10
#define RATE_LIMIT_WINDOW 1  // Sekunden

typedef struct {
    struct in_addr addr;
    int count;
    time_t window_start;
} RateLimitEntry;

RateLimitEntry rate_limits[10000];

void fixed_dns_server(int socket_fd) {
    char buffer[512];
    struct sockaddr_in client_addr;
    socklen_t addr_len = sizeof(client_addr);

    while (1) {
        ssize_t received = recvfrom(socket_fd, buffer, sizeof(buffer), 0,
                                    (struct sockaddr*)&client_addr, &addr_len);

        if (received > 0) {
            // Korrigiert: Rate-Limiting pro Quell-IP
            if (!check_rate_limit(&client_addr.sin_addr)) {
                continue;  // Anfrage von rate-limitierter IP verwerfen
            }

            // Korrigiert: Abfrage vor Antwort validieren
            DNSQuery *query = parse_dns_query(buffer, received);
            if (!is_valid_query(query)) {
                continue;
            }

            DNSResponse *response = create_dns_response(query);

            // Korrigiert: Response Rate Limiting (RRL)
            // Antwortgröße begrenzen, um Amplification zu reduzieren
            if (response->length > 512) {
                // TC-Flag setzen, TCP für große Antworten erforderlich
                response = create_truncated_response(query);
            }

            sendto(socket_fd, response->data, response->length, 0,
                   (struct sockaddr*)&client_addr, addr_len);
        }
    }
}

bool check_rate_limit(struct in_addr *addr) {
    time_t now = time(NULL);

    RateLimitEntry *entry = find_or_create_entry(addr);

    if (now - entry->window_start > RATE_LIMIT_WINDOW) {
        // Neues Fenster
        entry->count = 1;
        entry->window_start = now;
        return true;
    }

    entry->count++;
    return entry->count <= MAX_REQUESTS_PER_IP;
}

// Korrigiert: NTP-Server mit deaktiviertem monlist und Rate-Limiting
void fixed_ntp_handler(int socket_fd, char *buffer, size_t len,
                       struct sockaddr_in *client) {

    NTPPacket *request = (NTPPacket *)buffer;

    // Korrigiert: Gefährliche Befehle deaktivieren oder einschränken
    if (request->mode == NTP_MODE_PRIVATE) {
        // Nur von autorisierten Management-IPs erlauben
        if (!is_authorized_management_ip(&client->sin_addr)) {
            return;
        }

        // monlist vollständig deaktivieren oder Rate-Limiting implementieren
        if (request->code == REQ_MON_GETLIST) {
            // Deaktiviert, um Amplification zu verhindern
            send_error_response(socket_fd, client, NTP_ERR_DISABLED);
            return;
        }
    }

    // Normale NTP-Zeitsynchronisation - begrenzte Antwortgröße
    if (request->mode == NTP_MODE_CLIENT) {
        // Antworten rate-limitieren
        if (!check_ntp_rate_limit(&client->sin_addr)) {
            return;
        }

        NTPPacket response = create_time_response(request);
        sendto(socket_fd, &response, sizeof(response), 0,
               (struct sockaddr*)client, sizeof(*client));
    }
}

# Korrigiert: E-Mail-Dienst mit Zielvalidierung
import smtplib
import re

ALLOWED_DOMAINS = {'mycompany.com', 'partner-company.com'}
MAX_RECIPIENTS = 10

def fixed_send_notification(user_email, message):
    # Korrigiert: E-Mail-Adressformat validieren
    if not is_valid_email(user_email):
        raise ValueError("Ungültige E-Mail-Adresse")

    # Korrigiert: Erlaubte Domains prüfen (Open Relay verhindern)
    domain = user_email.split('@')[1].lower()
    if domain not in ALLOWED_DOMAINS:
        raise ValueError("E-Mail-Domain nicht erlaubt")

    sender = "[email protected]"

    smtp = smtplib.SMTP('localhost')
    smtp.sendmail(sender, user_email, message)
    smtp.quit()

def is_valid_email(email):
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

```javascript
// Korrigiert: Sichere Weiterleitung mit Allowlist
const ALLOWED_REDIRECT_PATHS = [
    '/dashboard',
    '/profile',
    '/settings',
    '/home'
];

const ALLOWED_EXTERNAL_DOMAINS = [
    'trusted-partner.com',
    'auth.mycompany.com'
];

app.get('/redirect', (req, res) => {
    const destination = req.query.url;

    // Korrigiert: Weiterleitungsziel validieren
    if (isAllowedRedirect(destination)) {
        res.redirect(destination);
    } else {
        res.status(400).send('Ungültiges Weiterleitungsziel');
    }
});

function isAllowedRedirect(url) {
    // Relative Pfade aus Allowlist erlauben
    if (ALLOWED_REDIRECT_PATHS.includes(url)) {
        return true;
    }

    // Externe URLs parsen
    try {
        const parsed = new URL(url);

        // Nur HTTPS erlauben
        if (parsed.protocol !== 'https:') {
            return false;
        }

        // Gegen erlaubte Domains prüfen
        return ALLOWED_EXTERNAL_DOMAINS.some(domain =>
            parsed.host === domain || parsed.host.endsWith('.' + domain)
        );
    } catch {
        // Relativer Pfad nicht in Allowlist
        return false;
    }
}

---

CVE-Beispiele

• CVE-2013-5211: NTP-monlist-Befehl ermöglichte massive Amplification-Angriffe mit gefälschten Quelladressen.
• CVE-1999-0513: Klassischer "Smurf"-Angriff mit ICMP und gefälschten Quelladressen.
• CVE-1999-1379: DNS-Abfrage-Spoofing verursacht Datenverkehrs-Amplification.

---

Verwandte CWEs

• CWE-923: Improper Restriction of Communication Channel to Intended Endpoints (Eltern)
• CWE-406: Insufficient Control of Network Message Volume (kann folgen)
• CWE-601: URL Redirection to Untrusted Site ('Open Redirect') (verwandt)

---

Referenzen

1. MITRE Corporation. "CWE-941: Incorrectly Specified Destination in a Communication Channel." https://cwe.mitre.org/data/definitions/941.html
2. US-CERT. "UDP-Based Amplification Attacks."
3. BCP 38/RFC 2827. "Network Ingress Filtering."