DDoS bescherming voor kleine servers

Je kleine VPS krijgt plotseling tienduizenden SYN-pakketten per seconde binnen, en je merkt het pas als je SSH-sessie bevriest.

Dit artikel laat zien hoe je met standaard Linux-tools een DDoS-aanval op een kleine server herkent, vastlegt en afzwakt — zonder dure appliance. Het is bedoeld voor beheerders van een VPS of dedicated server met beperkte bandbreedte die zelf de handen uit de mouwen willen steken.

Vereisten

• Ubuntu 22.04 LTS of 24.04 LTS (de commando's hieronder zijn getest op beide)
• Root-toegang of een gebruiker met `sudo`
• `tcpdump` 4.99 of nieuwer (`tcpdump --version`)
• `nftables` 1.0.2 of nieuwer voor rate limiting
• Een reverse proxy naar keuze: Nginx 1.18+ of Caddy 2.6+
• Toegang tot je DNS-provider als je een CDN wilt inzetten

Controleer eerst je Ubuntu-versie en de supportstatus:

```bash lsb_release -a ubuntu-distro-info --all ubuntu-distro-info --days ```

Die laatste regel vertelt je hoeveel dagen je huidige release nog security-updates krijgt. Draai je nog 20.04, dan is dat cijfer laag en is upgraden geen luxe meer.

Stappen

1. Meet het verkeer voordat je iets blokkeert

Je kunt niets zinnigs blokkeren als je niet weet wat er normaal binnenkomt. `tcpdump` is het goedkoopste observatiemiddel dat je hebt.

```bash sudo apt update && sudo apt install -y tcpdump sudo tcpdump -i eth0 -nn -c 200 'tcp[tcpflags] & tcp-syn != 0' ```

Wat je zoekt: honderden SYN-pakketten van verschillende bron-IP's naar dezelfde poort, zonder dat er ooit een ACK terugkomt. Dat patroon heet een SYN-flood.

Vervang `eth0` door je eigen interface. Op moderne Ubuntu-systemen met `systemd-networkd` heet die vaak `ens3` of `enp1s0`. Check met `ip -brief link`.

2. Leg een aanval vast op schijf

Live meekijken is leuk, maar bij een echte aanval wil je bewijs en patroonanalyse achteraf.

```bash sudo tcpdump -i eth0 -w /var/tmp/ddos-$(date +%s).pcap -c 10000 ```

Schrijf nooit naar `/tmp` als je schijf bijna vol zit — een aanval produceert gigabytes in minuten. `/var/tmp` heeft meestal meer ruimte, maar check het met `df -h` voordat je begint.

Het nadeel: `tcpdump` observeert alleen. Het blokkeert niets. Tijdens een echte aanval is de CPU die `tcpdump` gebruikt zelf een last.

3. Zet rate limiting op met nftables

Een firewall is de eerste actieve verdedigingslaag. Op Ubuntu 22.04 en 24.04 is dat `nftables`, niet meer `iptables`.

```bash sudo nft add table inet ddosguard sudo nft add chain inet ddosguard input '{ type filter hook input priority 0; policy accept; }' sudo nft add rule inet ddosguard input tcp flags syn limit rate 20/second burst 40 packets accept sudo nft add rule inet ddosguard input tcp flags syn drop ```

Dit accepteert 20 nieuwe verbindingen per seconde per bron, met een burst van 40. Alles daarboven wordt gedropt.

Wat het kost: legitieme pieken — een scraper, een RSS-lezer, een gedeeld NAT-IP — kunnen ook geraakt worden. Stel de limiet te strak in en je blokkeert echte gebruikers. Begin hoog en schroef terug op basis van wat je in stap 1 zag.

4. Zet een reverse proxy voor de applicatie

Je wilt niet dat je applicatieserver direct op poort 80 en 443 luistert. Nginx of Caddy ertussen geeft je filtering, TLS-terminatie en buffering.

```bash sudo apt install -y nginx sudo tee /etc/nginx/conf.d/ratelimit.conf > /dev/null <<'EOF' limit_req_zone $binary_remote_addr zone=perip:10m rate=10r/s; limit_conn_zone $binary_remote_addr zone=connperip:10m; EOF ```

Gebruik de zones in je serverblok:

```nginx server { listen 80; server_name example.com;

limit_req zone=perip burst=20 nodelay; limit_conn connperip 20;

location / { proxy_pass http://127.0.0.1:8080; proxy_set_header Host $host; proxy_set_header X-Real-IP $remote_addr; } } ```

Herlaad en test:

```bash sudo nginx -t && sudo systemctl reload nginx ```

Caddy doet rate limiting niet in de kern; daar heb je een plugin voor nodig. Nginx is hier de eenvoudigere keuze.

5. Zet een CDN voor je DNS

Dit is de effectiefste maatregel tegen volumetrische aanvallen, en tegelijk de minst populaire bij mensen die alles zelf willen draaien. Cloudflare, BunnyCDN en Fastly absorberen verkeer op hun eigen netwerk voordat het jouw uplink raakt.

Praktisch: zet je A-record om naar het CDN, zet de origin-server achter een firewall die alleen CDN-IP-ranges toestaat, en activeer "proxy" in het CDN-paneel.

Wat het kost: je verkeer loopt door een derde partij, je DNS hangt aan hun beschikbaarheid, en je moet vertrouwen op hun logging. Voor kleine servers is dat bijna altijd een betere ruil dan zelf een 10 Gbps-lijn huren. Zelf hosten klinkt nobel tot je uplink vol zit en je provider je tijdelijke null routeert.

6. Houd je besturingssysteem binnen de supportperiode

Een verouderde kernel of OpenSSL-versie is een makkelijker doelwit dan een goed geconfigureerde firewall.

```bash sudo apt update && sudo apt upgrade -y sudo apt install -y ubuntu-advantage-tools sudo pro status ```

Met Ubuntu Pro — gratis voor persoonlijk gebruik tot vijf machines — krijg je tien jaar security-updates op het main-archief en kernel live patching via `pro enable livepatch`. Livepatch betekent dat je kernel beveiligd wordt zonder reboot. Voor een server die niet mag omvallen is dat het verschil tussen een gepland onderhoudsvenster en een incident.

7. Controleer je TLS-certificaten

X.509-certificaten zijn geen DDoS-bescherming, maar een verlopen of verkeerd geconfigureerd certificaat maakt je server wel een aantrekkelijker doelwit voor misbruik — en browsers weigeren hem.

```bash openssl x509 -in /etc/letsencrypt/live/example.com/fullchain.pem -noout -text | grep -E 'Not Before|Not After|Subject:' ```

Let op de `Not After`-datum. Certbot 2.x vernieuwt automatisch via een systemd timer, maar alleen als die timer draait:

```bash systemctl list-timers | grep certbot ```

8. Monitor wat er gebeurt

Signalen van een aanval zie je het eerst in netwerk- en CPU-cijfers. Houd die continu in de gaten, niet alleen als het al misgaat.

```bash sudo apt install -y htop nload nload ```

`nload` toont inkomend en uitgaand verkeer per seconde, live. Een plotselinge piek in inkomend verkeer zonder dat je applicatie iets doet, is je eerste waarschuwing.

Voor langere trendanalyse kun je `vnstat` gebruiken:

```bash sudo apt install -y vnstat sudo systemctl enable --now vnstat vnstat -l -i eth0 ```

Verificatie

Check of je nftables-regels actief zijn:

```bash sudo nft list ruleset | grep -A2 ddosguard ```

Je moet de twee SYN-regels zien met de `limit rate` en `drop`-actie.

Test de rate limiting met een kleine SYN-scan naar je eigen server vanaf een andere machine:

```bash sudo hping3 -S --flood -p 80 ```

Draai dit maximaal tien seconden. Je `nft`-teller voor gedropte pakketten moet oplopen:

```bash sudo nft list chain inet ddosguard input -a ```

Zie je de teller niet bewegen, dan matcht je regel niet — meestal omdat de interface of hook-prioriteit niet klopt.

Veelgestelde problemen

`nft`-commando niet gevonden op Ubuntu 20.04. Op oudere systemen draait nog `iptables`. Installeer `nftables` handmatig (`sudo apt install nftables`) of migreer met `iptables-nft-restore`. Beide firewalls tegelijk draaien geeft onvoorspelbaar gedrag.

SSH valt weg tijdens een aanval. Je SYN-limiet raakt ook je eigen verbinding. Voeg een uitzondering toe voor je beheer-IP vóór de limit-regel:

```bash sudo nft insert rule inet ddosguard input ip saddr accept ```

Zet die regel er altijd eerst in, anders sluit je jezelf buiten.

CDN ziet je origin-IP nog steeds. Als je DNS-historie publiek is — via crt.sh, SecurityTrails of oude zone-transfers — kennen aanvallers je echte IP. Verhuis naar een nieuw IP, zet het oude uit, en sta op de origin-firewall alleen CDN-ranges toe.

Geen enkele opstelling houdt een aanval van 500 Gbps tegen op een VPS met 1 Gbps uplink. Wat je hier opbouwt, bepaalt hoe snel je herstelt — niet of je offline gaat.