So schützen Sie Ihren Server vor DDoS-Angriffen mit Proxy: Einrichtung in 15 Minuten

DDoS-Angriffe können den Betrieb eines jeden Webdienstes in wenigen Minuten lahmlegen. Angreifer senden Tausende von Anfragen von verschiedenen IP-Adressen, überlasten den Server und machen ihn für echte Benutzer unzugänglich. Proxy-Server sind eines der effektiven Schutzwerkzeuge, die es ermöglichen, schädlichen Traffic zu filtern, die Last zu verteilen und die echte IP-Adresse Ihres Servers zu verbergen.

In diesem Leitfaden werden wir untersuchen, wie man Proxys zum Schutz vor DDoS einrichtet, welche Proxy-Typen verwendet werden sollten und wie man ein mehrschichtiges Sicherheitssystem aufbaut. Das Material richtet sich an Systemadministratoren, Eigentümer von Webdiensten und DevOps-Spezialisten.

Wie DDoS-Angriffe funktionieren und warum Proxys helfen

DDoS (Distributed Denial of Service) ist ein verteilter Denial-of-Service-Angriff. Der Angreifer nutzt ein Botnetz aus Tausenden von infizierten Geräten, die gleichzeitig Anfragen an Ihren Server senden. Ziel ist es, die Ressourcen des Servers (CPU, Speicher, Bandbreite) zu erschöpfen und ihn für legitime Benutzer unzugänglich zu machen.

Die Haupttypen von DDoS-Angriffen sind:

• Volumetrische Angriffe — füllen die Bandbreite mit einer riesigen Menge an Traffic (DNS-Verstärkung, UDP-Flut)
• Protokollangriffe — nutzen Schwachstellen in Netzwerkprotokollen aus (SYN-Flut, Ping of Death)
• Anwendungsangriffe — imitieren legitime Anfragen an Webanwendungen (HTTP-Flut, Slowloris)

Proxy-Server helfen, sich auf verschiedene Weise vor DDoS zu schützen:

• Verbergen der echten IP-Adresse des Servers — Angreifer sehen nur die IP des Proxys, nicht die Ihres Hauptservers
• Filterung von schädlichem Traffic — Proxys analysieren Anfragen und blockieren verdächtige
• Lastverteilung — mehrere Proxy-Server verteilen den Traffic auf Backend-Server
• Rate Limiting — Begrenzung der Anzahl von Anfragen von einer IP-Adresse
• Caching von statischen Inhalten — reduziert die Last auf dem Hauptserver

Es ist wichtig zu verstehen, dass Proxys kein Allheilmittel gegen alle Arten von DDoS sind. Mächtige volumetrische Angriffe können die Bandbreite bis zum Proxy-Server überlasten. Daher sind Proxys in Kombination mit anderen Schutzmethoden effektiv: CDN, Cloud-anti-DDoS-Dienste (Cloudflare, AWS Shield), Firewalls.

Proxy-Typen zum Schutz vor DDoS: Reverse vs. Forward

Zum Schutz vor DDoS werden zwei Haupttypen von Proxy-Servern verwendet:

Reverse Proxys

Ein Reverse Proxy befindet sich vor Ihrem Webserver und nimmt alle eingehenden Anfragen von Clients entgegen. Die Clients interagieren nur mit dem Proxy, ohne die echte IP-Adresse Ihres Servers zu kennen. Dies ist das Hauptwerkzeug zum Schutz vor DDoS.

Beliebte Lösungen für Reverse Proxys:

• Nginx — schneller und leichter Webserver mit Reverse-Proxy-Funktionen
• HAProxy — spezialisierter Lastverteiler mit leistungsstarken Filtermöglichkeiten
• Apache mod_proxy — Modul für Apache, weniger leistungsfähig als Nginx
• Varnish — HTTP-Beschleuniger mit Fokus auf Caching

Forward Proxys

Forward Proxys werden auf der Client-Seite für ausgehende Anfragen verwendet. Im Kontext des Schutzes vor DDoS werden sie seltener eingesetzt, können aber nützlich sein für:

• Verbergen der IP-Adressen Ihrer Server beim Zugriff auf externe APIs
• Verteilen des ausgehenden Traffics über viele IP-Adressen
• Umgehen von Sperren beim Sammeln von Informationen über potenzielle Angriffe

Für diese Aufgaben eignen sich Residential Proxys — sie haben echte IP-Adressen von Haushaltsnutzern und sehen aus wie normaler Traffic, was ihre Entdeckung und Blockierung erschwert.

Einrichtung eines Reverse Proxys auf Nginx zum Schutz des Servers

Nginx ist eines der beliebtesten Werkzeuge zur Erstellung eines Reverse Proxys. Es verarbeitet eingehende Anfragen schnell, unterstützt Rate Limiting und kann verdächtigen Traffic filtern.

Grundlegende Einrichtung eines Reverse Proxys

Installieren Sie Nginx auf einem separaten Server, der den gesamten eingehenden Traffic entgegennimmt. Der echte Webserver sollte hinter dem Proxy verborgen sein und Anfragen nur von diesem annehmen.

# /etc/nginx/nginx.conf

http {
    # Begrenzung der Anzahl von Verbindungen von einer IP
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;
    limit_conn conn_limit 10;

    # Begrenzung der Anzahl von Anfragen (Rate Limiting)
    limit_req_zone $binary_remote_addr zone=req_limit:10m rate=10r/s;
    limit_req zone=req_limit burst=20 nodelay;

    # Timeouts zum Schutz vor Slowloris
    client_body_timeout 10s;
    client_header_timeout 10s;
    keepalive_timeout 5s 5s;
    send_timeout 10s;

    upstream backend {
        # IP Ihres echten Webservers
        server 192.168.1.100:80;
        # Es können mehrere Server zur Lastverteilung hinzugefügt werden
        # server 192.168.1.101:80;
    }

    server {
        listen 80;
        server_name example.com;

        location / {
            # Weiterleitung der Anfragen an das Backend
            proxy_pass http://backend;
            
            # Weiterleitung der ursprünglichen IP des Clients
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header Host $host;
            
            # Timeouts für den Proxy
            proxy_connect_timeout 5s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
        }
    }
}

Blockierung verdächtiger User-Agents

Viele DDoS-Angriffe verwenden Bots mit charakteristischen User-Agents. Fügen Sie Regeln zur Blockierung hinzu:

# Blockierung bekannter Bots
map $http_user_agent $bad_bot {
    default 0;
    ~*bot 1;
    ~*crawler 1;
    ~*spider 1;
    ~*scraper 1;
    "" 1; # Leerer User-Agent
}

server {
    listen 80;
    server_name example.com;

    if ($bad_bot) {
        return 403;
    }

    location / {
        proxy_pass http://backend;
    }
}

Geo-Blockierung unerwünschter Länder

Wenn Ihr Dienst nur für bestimmte Länder verfügbar ist, können Sie den Traffic aus anderen Regionen mit dem GeoIP-Modul blockieren:

# Installation des GeoIP-Moduls
# apt-get install nginx-module-geoip

load_module modules/ngx_http_geoip_module.so;

http {
    geoip_country /usr/share/GeoIP/GeoIP.dat;

    # Erlauben Sie nur Traffic aus Russland und der Ukraine
    map $geoip_country_code $allowed_country {
        default no;
        RU yes;
        UA yes;
    }

    server {
        listen 80;
        server_name example.com;

        if ($allowed_country = no) {
            return 403;
        }

        location / {
            proxy_pass http://backend;
        }
    }
}

HAProxy zur Lastverteilung und Traffic-Filterung

HAProxy ist ein leistungsstarker Lastverteiler mit erweiterten Möglichkeiten zur Traffic-Filterung. Es unterstützt komplexe ACLs (Access Control Lists) zur Blockierung von Angriffen auf Anwendungsebene.

Grundkonfiguration von HAProxy

# /etc/haproxy/haproxy.cfg

global
    maxconn 50000
    # Logging
    log /dev/log local0
    log /dev/log local1 notice

defaults
    mode http
    log global
    option httplog
    option dontlognull
    
    # Timeouts
    timeout connect 5s
    timeout client 30s
    timeout server 30s
    
    # Begrenzung der Anfragröße (Schutz vor POST-Flut)
    maxconn 3000

frontend http_front
    bind *:80
    
    # Rate Limiting: maximal 100 Anfragen in 10 Sekunden von einer IP
    stick-table type ip size 100k expire 30s store http_req_rate(10s)
    http-request track-sc0 src
    http-request deny if { sc_http_req_rate(0) gt 100 }
    
    # Blockierung von Anfragen ohne Host-Header
    acl has_host hdr(host) -m found
    http-request deny if !has_host
    
    # Blockierung verdächtiger User-Agents
    acl bad_bot hdr_sub(User-Agent) -i bot crawler spider scraper
    http-request deny if bad_bot
    
    # Weiterleitung an das Backend
    default_backend web_servers

backend web_servers
    balance roundrobin
    option httpchk GET /health
    
    # Liste der Backend-Server
    server web1 192.168.1.100:80 check
    server web2 192.168.1.101:80 check
    server web3 192.168.1.102:80 check

Schutz vor HTTP-Flut mit ACL

HTTP-Flut ist ein Angriff, bei dem der Angreifer viele legitime HTTP-Anfragen sendet. HAProxy ermöglicht es, komplexe Regeln zu erstellen, um diese zu erkennen:

frontend http_front
    bind *:80
    
    # Verfolgung der Anzahl von Anfragen von einer IP
    stick-table type ip size 100k expire 30s store http_req_rate(10s),conn_cur
    http-request track-sc0 src
    
    # Blockierung bei Überschreitung der Limits
    acl too_many_requests sc_http_req_rate(0) gt 50
    acl too_many_connections sc_conn_cur(0) gt 10
    
    http-request deny deny_status 429 if too_many_requests
    http-request deny deny_status 429 if too_many_connections
    
    # Blockierung von Anfragen an nicht existierende Pfade (Scanning)
    acl valid_path path_beg /api /static /login /
    http-request deny if !valid_path
    
    default_backend web_servers

Whitelist vertrauenswürdiger IP-Adressen

Erstellen Sie eine Whitelist für vertrauenswürdige IPs (z.B. Ihre Büroadressen oder Partner), die nicht dem Rate Limiting unterliegen:

frontend http_front
    bind *:80
    
    # Whitelist vertrauenswürdiger IPs
    acl whitelist src 203.0.113.0/24 198.51.100.50
    
    # Rate Limiting nur für nicht-whitelist IPs
    stick-table type ip size 100k expire 30s store http_req_rate(10s)
    http-request track-sc0 src if !whitelist
    http-request deny if { sc_http_req_rate(0) gt 100 } !whitelist
    
    default_backend web_servers

Verwendung von Residential Proxys zur Verbergung der Infrastruktur

Neben Reverse Proxys vor Ihrem Server können Sie Residential Proxys zur zusätzlichen Sicherung der Infrastruktur verwenden. Dies ist besonders relevant, wenn Sie:

• Die IP-Adressen Ihrer Überwachungsserver verbergen — wenn Sie DDoS-Angriffe überwachen oder Informationen über Bedrohungen sammeln, helfen Residential Proxys, Ihre Aktivitäten zu verbergen
• Auf externe APIs zugreifen, ohne die Infrastruktur offenzulegen — Ihre Server können Anfragen über Residential Proxys stellen, was deren Entdeckung erschwert
• Den Schutz vor DDoS testen — Angriffe von verschiedenen IP-Adressen simulieren, um die Wirksamkeit Ihrer Filter zu überprüfen

Residential Proxys haben IP-Adressen echter Haushaltsnutzer, was sie von normalem Traffic nicht unterscheidbar macht. Dies erschwert ihre Blockierung und ermöglicht das Umgehen von Geo-Beschränkungen.

Beispiel: Bedrohungsüberwachung über Residential Proxys

Angenommen, Sie möchten die Aktivität von Botnetzen überwachen, die Ihren Dienst angreifen könnten. Mit Residential Proxys können Sie Informationen sammeln, ohne die IP-Adressen Ihrer Server offenzulegen:

import requests

# Einrichtung des Residential Proxys
proxies = {
    'http': 'http://username:password@residential-proxy.com:8080',
    'https': 'http://username:password@residential-proxy.com:8080'
}

# Sammeln von Informationen über potenzielle Bedrohungen
threat_sources = [
    'http://suspicious-site1.com',
    'http://suspicious-site2.com'
]

for source in threat_sources:
    try:
        response = requests.get(source, proxies=proxies, timeout=5)
        # Analyse der Antwort zur Erkennung von Angriffsmustern
        print(f"Status: {response.status_code}, IP: {response.headers.get('X-Your-IP')}")
    except Exception as e:
        print(f"Fehler beim Zugriff auf {source}: {e}")

Filterregeln: Wie man einen Angriff von legitimen Traffic unterscheidet

Die größte Herausforderung beim Schutz vor DDoS auf Anwendungsebene (L7) besteht darin, schädlichen Traffic von legitimen zu unterscheiden. Moderne Angriffe imitieren das Verhalten echter Benutzer, was ihre Erkennung erschwert.

Anzeichen eines DDoS-Angriffs

• Plötzlicher Anstieg der Anfragen — 2-10 mal mehr als gewöhnlich in kurzer Zeit
• Anfragen mit identischem User-Agent — Bots verwenden oft denselben User-Agent
• Fehlender Referer — direkte Anfragen ohne Übergang von anderen Seiten
• Einheitliche Anfragen — Anfragen an dieselbe URL mit minimalen Variationen
• Fehlendes JavaScript — Bots führen keinen JS-Code auf der Seite aus
• Niedrige Verweildauer auf der Seite — Bots schließen die Verbindung sofort nach Erhalt der Antwort
• Verdächtige IP-Bereiche — massenhafte Anfragen aus einem Subnetz

Mehrschichtige Filterung

Effektiver Schutz nutzt mehrere Filterungsebenen:

Beispiel: JavaScript Challenge in Nginx

Ein einfacher Weg, Bots herauszufiltern, besteht darin, die Ausführung von JavaScript zur Setzung von Cookies zu verlangen:

server {
    listen 80;
    server_name example.com;

    # Überprüfung auf Vorhandensein von Cookies
    set $has_cookie 0;
    if ($http_cookie ~* "verified=true") {
        set $has_cookie 1;
    }

    # Wenn kein Cookie vorhanden ist, zeigen wir die JS-Challenge an
    location / {
        if ($has_cookie = 0) {
            return 200 '
                <html>
                <head><title>Verifizierung</title></head>
                <body>
                <script>
                    document.cookie = "verified=true; path=/";
                    window.location.reload();
                </script>
                <noscript>Bitte aktivieren Sie JavaScript</noscript>
                </body>
                </html>
            ';
        }

        proxy_pass http://backend;
    }
}

Überwachung und Reaktion auf DDoS in Echtzeit

Effektiver Schutz vor DDoS erfordert eine ständige Überwachung des Traffics und eine schnelle Reaktion auf Anomalien. Richten Sie ein Überwachungssystem ein, das wichtige Metriken verfolgt:

• Anzahl der Anfragen pro Sekunde — ein plötzlicher Anstieg kann auf einen Angriff hinweisen
• Anzahl der eindeutigen IP-Adressen — DDoS kommt oft von vielen IPs
• Fehlerquote 4xx/5xx — ein Anstieg der Fehler kann ein Zeichen für Überlastung sein
• Antwortzeit des Servers — eine Erhöhung der Latenz deutet auf Probleme hin
• Ressourcennutzung — CPU, Speicher, Netzwerktraffic

Überwachungstools

Einrichtung von Alarmen in Prometheus

Erstellen Sie Regeln für automatische Benachrichtigungen bei der Entdeckung von Anomalien:

# prometheus_alerts.yml

groups:
  - name: ddos_detection
    interval: 10s
    rules:
      # Alarm bei plötzlichem Anstieg der Anfragen
      - alert: HighRequestRate
        expr: rate(nginx_http_requests_total[1m]) > 1000
        for: 1m
        labels:
          severity: warning
        annotations:
          summary: "Hohe Anfragequote erkannt"
          description: "Anfragequote beträgt {{ $value }} req/s"

      # Alarm bei Anstieg der 5xx-Fehler
      - alert: HighErrorRate
        expr: rate(nginx_http_requests_total{status=~"5.."}[5m]) > 10
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Hohe 5xx Fehlerquote"
          description: "5xx Fehler: {{ $value }} req/s"

      # Alarm bei hoher CPU-Nutzung
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Hohe CPU-Nutzung"
          description: "CPU-Nutzung beträgt {{ $value }}%"

Automatische Reaktion mit Fail2ban

Fail2ban analysiert Logs und blockiert automatisch IP-Adressen, die die Anfragegrenzen überschreiten:

# /etc/fail2ban/jail.local

[nginx-req-limit]
enabled = true
filter = nginx-req-limit
logpath = /var/log/nginx/access.log
maxretry = 100
findtime = 60
bantime = 3600
action = iptables-multiport[name=ReqLimit, port="http,https", protocol=tcp]

# /etc/fail2ban/filter.d/nginx-req-limit.conf
[Definition]
failregex = ^<HOST> -.*"(GET|POST).*HTTP.*"
ignoreregex =

Mehrschichtiger Schutz: Kombination von Proxys mit anderen Methoden

Proxy-Server sind ein wichtiger Bestandteil des Schutzes vor DDoS, aber sie sind am effektivsten in Kombination mit anderen Methoden. Lassen Sie uns die Architektur eines mehrschichtigen Schutzes betrachten:

Ebene 1: Netzwerkschutz (L3/L4)

• Cloud-anti-DDoS-Dienste — Cloudflare, AWS Shield, Google Cloud Armor filtern den Traffic, bevor er Ihre Server erreicht
• Hardware-Firewalls — spezialisierte Hardware zur Filterung von Netzwerktraffic
• BGP Blackholing — Umleitung von schädlichem Traffic in ein "schwarzes Loch" auf Anbieterebene

Ebene 2: CDN und Caching

• CDN (Content Delivery Network) — verteilt statische Inhalte auf viele Server und reduziert die Last auf dem Origin
• Caching auf Proxys — Varnish, Nginx cachen beliebte Seiten und liefern sie ohne Zugriff auf das Backend aus
• Optimierung von Inhalten — Minifizierung von CSS/JS, Komprimierung von Bildern reduzieren das Traffic-Volumen

Ebene 3: Proxys und Lastverteilung (L7)

• Reverse Proxys — Nginx, HAProxy filtern Anfragen auf Anwendungsebene
• Lastverteilung — Verteilung der Last auf mehrere Backend-Server
• Rate Limiting — Begrenzung der Anzahl von Anfragen von einer IP
• WAF (Web Application Firewall) — ModSecurity, AWS WAF blockieren Angriffe auf Webanwendungen

Ebene 4: Backend-Optimierung

• Datenbankoptimierung — Indizes, Caching von Anfragen, Read Replicas
• Asynchrone Verarbeitung — schwere Aufgaben werden im Hintergrund über Warteschlangen (RabbitMQ, Redis) ausgeführt
• Horizontale Skalierung — Hinzufügen neuer Server bei steigender Last

Beispielarchitektur

Client
  ↓
Cloudflare (anti-DDoS L3/L4, CDN)
  ↓
Nginx Reverse Proxy (Rate Limiting, Filterung)
  ↓
HAProxy (Lastverteilung)
  ↓
Backend-Server (Webanwendung)
  ↓
Datenbank (mit Replikation)

Diese Architektur bietet Schutz auf allen Ebenen: Netzwerk-, Transport- und Anwendungsebene. Selbst wenn ein Angriff eine Ebene durchdringt, wird die nächste ihn stoppen.

Verwendung von Datacenter Proxys für eine zusätzliche Schicht

In einigen Fällen kann es sinnvoll sein, Datacenter Proxys als Zwischenschicht zwischen CDN und Ihren Servern hinzuzufügen. Sie bieten eine hohe Verarbeitungsrate und können zusätzliche Traffic-Filterung durchführen. Datacenter Proxys sind günstiger als Residential und mobile Proxys, was sie zu einer wirtschaftlichen Lösung für die Verarbeitung großer Traffic-Mengen macht.

Fazit

Der Schutz vor DDoS-Angriffen mit Proxy-Servern ist eine effektive Methode, die es ermöglicht, schädlichen Traffic zu filtern, die echten IP-Adressen der Server zu verbergen und die Last zu verteilen. Reverse Proxys auf Basis von Nginx oder HAProxy bieten eine flexible Konfiguration von Filterregeln, Rate Limiting und Blockierung verdächtiger Anfragen.

Die wichtigsten Punkte, die wir behandelt haben:

• Reverse Proxys (Nginx, HAProxy) — das Hauptwerkzeug zum Schutz auf Anwendungsebene (L7)
• Rate Limiting und Filterung nach User-Agent, IP-Reputation helfen, die meisten Angriffe abzuwehren
• Residential Proxys sind nützlich zum Verbergen der Überwachungsinfrastruktur und zum Sammeln von Informationen über Bedrohungen
• Mehrschichtiger Schutz (CDN + Proxys + WAF + Backend-Optimierung) gewährleistet maximale Widerstandsfähigkeit
• Überwachung und automatische Reaktion sind entscheidend für die schnelle Erkennung und Blockierung von Angriffen

Denken Sie daran, dass DDoS-Angriffe ständig weiterentwickelt werden, sodass das Schutzsystem regelmäßige Aktualisierungen und Tests erfordert. Führen Sie Lasttests durch, analysieren Sie Logs, aktualisieren Sie Filterregeln und bleiben Sie über neue Angriffsmethoden informiert.

Wenn Sie planen, ein mehrschichtiges Schutzsystem mit Proxys aufzubauen, empfehlen wir, Residential Proxys zum Verbergen kritischer Infrastruktur und Datacenter Proxys für die Hochgeschwindigkeitsverarbeitung großer Traffic-Mengen in Betracht zu ziehen. Die Kombination verschiedener Proxy-Typen sorgt für ein optimales Gleichgewicht zwischen Sicherheit, Leistung und Kosten.