DDoS-Angriffe (Distributed Denial of Service) können Ihren Server lahmlegen. Dieser Artikel erklärt verschiedene Angriffstypen und zeigt Schutzmaßnahmen.

DDoS-Angriffstypen

Volumetrische Angriffe

- UDP Flood
- ICMP Flood
- DNS Amplification
- NTP Amplification

Ziel: Bandbreite überlasten
Größe: Bis zu mehreren Terabit/s

Protokoll-Angriffe

- SYN Flood
- Ping of Death
- Smurf Attack
- Fragmented Packet Attack

Ziel: Serverressourcen erschöpfen

Application-Layer-Angriffe (Layer 7)

- HTTP Flood
- Slowloris
- RUDY (R-U-Dead-Yet)
- DNS Query Flood

Ziel: Anwendung überlasten
Schwer zu erkennen: Sieht wie normaler Traffic aus

Grundlegende Server-Härtung

Kernel-Parameter optimieren

# /etc/sysctl.conf

# SYN-Flood-Schutz
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_max_syn_backlog = 2048
net.ipv4.tcp_synack_retries = 2
net.ipv4.tcp_syn_retries = 5

# Verbindungslimits
net.ipv4.ip_local_port_range = 1024 65535
net.ipv4.tcp_fin_timeout = 15
net.ipv4.tcp_keepalive_time = 300

# ICMP-Schutz
net.ipv4.icmp_echo_ignore_broadcasts = 1
net.ipv4.icmp_ignore_bogus_error_responses = 1

# Spoofing-Schutz
net.ipv4.conf.all.rp_filter = 1
net.ipv4.conf.default.rp_filter = 1

# Source-Routing deaktivieren
net.ipv4.conf.all.accept_source_route = 0

# Redirect-Schutz
net.ipv4.conf.all.accept_redirects = 0
net.ipv4.conf.all.send_redirects = 0

# TCP-Timestamps
net.ipv4.tcp_timestamps = 1
sysctl -p

Verbindungslimits mit iptables

# Neue Verbindungen pro IP limitieren
iptables -A INPUT -p tcp --syn -m connlimit --connlimit-above 50 -j DROP

# Verbindungsrate limitieren
iptables -A INPUT -p tcp --dport 80 -m state --state NEW -m recent --set
iptables -A INPUT -p tcp --dport 80 -m state --state NEW -m recent --update --seconds 60 --hitcount 20 -j DROP

# SYN-Flood-Schutz
iptables -A INPUT -p tcp --syn -m limit --limit 1/s --limit-burst 3 -j ACCEPT
iptables -A INPUT -p tcp --syn -j DROP

# ICMP-Rate limitieren
iptables -A INPUT -p icmp --icmp-type echo-request -m limit --limit 1/s --limit-burst 4 -j ACCEPT
iptables -A INPUT -p icmp --icmp-type echo-request -j DROP

# Ungültige Pakete verwerfen
iptables -A INPUT -m state --state INVALID -j DROP

Regeln speichern

# Debian/Ubuntu
apt install iptables-persistent
netfilter-persistent save

# CentOS/RHEL
service iptables save

Nginx-Härtung

Rate-Limiting

# /etc/nginx/nginx.conf

http {
    # Rate-Limit-Zonen definieren
    limit_req_zone $binary_remote_addr zone=one:10m rate=10r/s;
    limit_req_zone $binary_remote_addr zone=api:10m rate=5r/s;
    limit_conn_zone $binary_remote_addr zone=addr:10m;

    server {
        # Allgemeines Rate-Limit
        limit_req zone=one burst=20 nodelay;

        # Verbindungslimit
        limit_conn addr 10;

        # API-Endpunkte strenger limitieren
        location /api/ {
            limit_req zone=api burst=10 nodelay;
        }
    }
}

Slowloris-Schutz

# /etc/nginx/nginx.conf

http {
    # Timeouts
    client_body_timeout 10s;
    client_header_timeout 10s;
    keepalive_timeout 5s 5s;
    send_timeout 10s;

    # Buffer-Größen
    client_body_buffer_size 128k;
    client_max_body_size 10m;
    client_header_buffer_size 1k;
    large_client_header_buffers 4 4k;
}

Bestimmte User-Agents blockieren

# Bekannte Angriffs-Tools blockieren
if ($http_user_agent ~* (wget|curl|libwww|python|perl|nikto|scan)) {
    return 403;
}

# Leere User-Agents
if ($http_user_agent = "") {
    return 403;
}

Geo-Blocking

# /etc/nginx/conf.d/geo-block.conf

geo $blocked_country {
    default 0;
    # Länder blockieren (Beispiel)
    # CN 1;
    # RU 1;
}

server {
    if ($blocked_country) {
        return 403;
    }
}

Apache-Härtung

mod_evasive

apt install libapache2-mod-evasive
# /etc/apache2/mods-available/evasive.conf

<IfModule mod_evasive20.c>
    DOSHashTableSize    3097
    DOSPageCount        5
    DOSSiteCount        50
    DOSPageInterval     1
    DOSSiteInterval     1
    DOSBlockingPeriod   10
    DOSEmailNotify      admin@example.com
    DOSLogDir           "/var/log/apache2/evasive"
</IfModule>
a2enmod evasive
mkdir -p /var/log/apache2/evasive
chown www-data:www-data /var/log/apache2/evasive
systemctl restart apache2

mod_security (WAF)

apt install libapache2-mod-security2
# Standardregeln aktivieren
cp /etc/modsecurity/modsecurity.conf-recommended /etc/modsecurity/modsecurity.conf
# /etc/modsecurity/modsecurity.conf
SecRuleEngine On

Fail2ban für DDoS

HTTP-DDoS-Filter

# /etc/fail2ban/filter.d/http-ddos.conf

[Definition]
failregex = ^<HOST> -.*"(GET|POST).*
ignoreregex =

Jail konfigurieren

# /etc/fail2ban/jail.local

[http-ddos]
enabled = true
filter = http-ddos
action = iptables-multiport[name=http-ddos, port="http,https"]
logpath = /var/log/nginx/access.log
findtime = 60
maxretry = 300
bantime = 600

Fail2ban neu starten

systemctl restart fail2ban

UFW (Uncomplicated Firewall)

Rate-Limiting aktivieren

# SSH Rate-Limit
ufw limit ssh

# Eigene Regel
ufw limit from any to any port 80

# Status
ufw status verbose

Cloudflare-Schutz

DNS konfigurieren

1. Domain zu Cloudflare hinzufügen 2. DNS-Einträge importieren 3. Proxy aktivieren (orangene Wolke)

Cloudflare-Einstellungen

Security Level: Medium oder High
Challenge Passage: 30 Minuten
Browser Integrity Check: Ein
Always Use HTTPS: Ein

Firewall-Regeln

# Nur bestimmte Länder erlauben
(ip.geoip.country ne "DE" and ip.geoip.country ne "AT" and ip.geoip.country ne "CH")
→ Block

# Bekannte Bots blockieren
(cf.client.bot) → Challenge

Under Attack Mode

Bei aktivem Angriff: 1. Security → Settings → Under Attack Mode: On 2. Zeigt CAPTCHA für alle Besucher

DDoS-Schutz-Dienste

Vergleich

| Dienst | Kostenlos | Schutz bis | |--------|-----------|------------| | Cloudflare Free | Ja | Unbegrenzt | | AWS Shield | Basic: Ja | Layer 3/4 | | Cloudflare Pro | Nein | Layer 7 | | Akamai | Nein | Enterprise |

Cloudflare Setup

# Nur Cloudflare-IPs erlauben
# Cloudflare IP-Ranges: https://www.cloudflare.com/ips/

# iptables
for ip in $(curl -s https://www.cloudflare.com/ips-v4); do
    iptables -A INPUT -p tcp --dport 80 -s $ip -j ACCEPT
done
iptables -A INPUT -p tcp --dport 80 -j DROP

Monitoring und Erkennung

Traffic überwachen

# Verbindungen pro IP
netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -20

# Aktuelle Verbindungen
ss -s

# HTTP-Requests pro IP
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn | head -20

Automatische Erkennung

#!/bin/bash
# /usr/local/bin/ddos-detect.sh

THRESHOLD=500
LOGFILE=/var/log/nginx/access.log

# IPs mit mehr als THRESHOLD Requests in letzten 5 Minuten
awk -v threshold=$THRESHOLD '
{
    ip_count[$1]++
}
END {
    for (ip in ip_count) {
        if (ip_count[ip] > threshold) {
            print ip, ip_count[ip]
        }
    }
}' <(tail -10000 $LOGFILE)

Alerts einrichten

#!/bin/bash
# Warnung bei hoher Verbindungszahl

CONNECTIONS=$(ss -s | grep "TCP:" | awk '{print $2}')
THRESHOLD=1000

if [ $CONNECTIONS -gt $THRESHOLD ]; then
    echo "High connection count: $CONNECTIONS" | mail -s "DDoS Alert" admin@example.com
fi

Notfall-Maßnahmen

Bei aktivem Angriff

# 1. Angreifer-IPs identifizieren
netstat -ntu | awk '{print $5}' | cut -d: -f1 | sort | uniq -c | sort -rn | head -50

# 2. Top-Angreifer blockieren
iptables -A INPUT -s ANGREIFER_IP -j DROP

# 3. Temporär alle neuen Verbindungen limitieren
iptables -A INPUT -p tcp --syn -m limit --limit 10/s -j ACCEPT
iptables -A INPUT -p tcp --syn -j DROP

# 4. Cloudflare "Under Attack" aktivieren

# 5. Provider kontaktieren (bei volumetrischen Angriffen)

IP-Bereich blockieren

# Ganzes Subnetz blockieren
iptables -A INPUT -s 192.168.0.0/16 -j DROP

# Mit ipset (effizienter für viele IPs)
ipset create blacklist hash:net
ipset add blacklist 192.168.1.0/24
iptables -A INPUT -m set --match-set blacklist src -j DROP

Checkliste

□ Kernel-Parameter optimiert
□ Firewall mit Rate-Limiting
□ Nginx/Apache gehärtet
□ Fail2ban konfiguriert
□ DDoS-Schutz-Dienst (Cloudflare)
□ Monitoring eingerichtet
□ Notfallplan vorhanden
□ Backup-Kommunikation (falls Server down)

Fazit

Effektiver DDoS-Schutz erfordert mehrere Schichten: Kernel-Härtung, Firewall-Regeln, Webserver-Konfiguration und externe Schutzdienste. Für kleine bis mittlere Angriffe reichen serverseitige Maßnahmen, bei größeren volumetrischen Angriffen ist ein CDN wie Cloudflare unverzichtbar. Überwachen Sie Ihren Traffic kontinuierlich und haben Sie einen Notfallplan bereit.