Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Uruchamiasz mały serwer WWW, zalewasz go ruchem z dwóch kontenerów „botów” w izolowanej sieci i obserwujesz, jak zwykły użytkownik utyka. Znajdujesz atakujących w dzienniku dostępu. Potem włączasz ograniczanie liczby żądań, powtarzasz zalew i widzisz, że nadmiarowe żądania są odrzucane ze statusem HTTP 429, a zwykły użytkownik jest obsługiwany z pełną szybkością.
## Cele
- Zmierzyć normalne opóźnienie serwera WWW (poziom bazowy) oraz jego opóźnienie podczas zalewu.
- Wykryć zalew, zliczając żądania według adresu klienta i kodu statusu w dzienniku dostępu.
- Włączyć w nginx ograniczanie liczby żądań (`limit_req`) i połączeń (`limit_conn`) i przeładować konfigurację bez przerwy w działaniu.
- Pokazać, że limit odrzuca zalew (status 429), ale nadal obsługuje zwykłego klienta (status 200).
- Odczytać ustawienie SYN cookies hosta i kontenera oraz wyjaśnić, co ono robi.
## Wymagania wstępne
- Komputer z Linuksem z **Podmanem w wersji 4 lub nowszej** uruchomionym **bez uprawnień roota** (jako zwykły użytkownik; nigdy nie potrzebujesz `sudo`) i z backendem sieciowym netavark. Przetestowano z Podmanem 5.8.7 w Fedorze z jądrem 7.2. Sprawdź poleceniem `podman info --format '{{.Host.NetworkBackend}}'`: powinno wypisać `netavark`.
- Dostęp do internetu jednorazowo, aby pobrać obrazy nginx i Alpine Linux (łącznie kilkadziesiąt MB) oraz dwa małe pakiety (około 8 MB). Potem nic w laboratorium nie wymaga internetu.
- Około 400 MB wolnego miejsca na dysku i co najmniej 2 rdzenie procesora.
- [Lekcja](lesson.pl.md) z tego modułu. Techniki Podmana są te z [laboratorium o bezpieczeństwie sieci](../06-network-security/lab.pl.md): sieci `--internal`, przypięte obrazy, kontenery bez uprawnień roota.
> [!WARNING]
> **Upoważnienie i etyka.** Zalewanie ruchem systemu, którego nie posiadasz lub do którego testowania nie masz wyraźnego pisemnego upoważnienia, jest w większości krajów nielegalne i szkodzi innym ludziom, nawet jeśli nazwiesz to testem. W tym laboratorium „atak” odbywa się wyłącznie między czterema kontenerami utworzonymi w tym laboratorium, w sieci utworzonej z `--internal` (nic nie opuszcza Twojego komputera). Obciążenie jest umiarkowane i ograniczone czasem (15 sekund) oraz liczbą wątków roboczych. Nigdy nie kieruj narzędzi z tego laboratorium na nic innego, nawet na własny serwer u dostawcy hostingu, bez wcześniejszego przeczytania zasad dostawcy dotyczących testów obciążeniowych.
## Architektura
<figure class="diagram" style="--dg-w: 1180px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1180 560" width="1180" height="560" role="img" aria-labelledby="ddos-lab-architecture-pl-title ddos-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="ddos-lab-architecture-pl-title">Architektura laboratorium: jeden serwer WWW, dwa boty i jeden zwykły użytkownik w odizolowanej sieci</title>
<desc id="ddos-lab-architecture-pl-desc">Jedna wewnętrzna sieć Podman, lab-ddos-net, 10.60.0.0/24. Kontener serwera WWW lab-ddos-web ma adres 10.60.0.10, tcp 80, uruchamia nginx 1.31.6-alpine z limitem CPU 0,5 i limitem pamięci 128 MB oraz serwuje /report.html, stronę, którą nginx kompresuje gzipem na poziomie 9 przy każdym żądaniu. Jego limits.conf początkowo jest pusty, a później zostaje wypełniony: limit_req 5 żądań na sekundę z burst 10, limit_conn 10 na adres i status 429 po przekroczeniu limitu. Dwa kontenery botów, lab-ddos-bot1 pod adresem 10.60.0.20 i lab-ddos-bot2 pod adresem 10.60.0.21, uruchamiają każdy hey przez 15 sekund z 25 równoległymi workerami i wysyłają zalew żądań do serwera WWW grubymi czerwonymi liniami. Kontener zwykłego użytkownika, lab-ddos-user pod adresem 10.60.0.30, wysyła jedno zwykłe żądanie za pomocą curl cienką zieloną linią. Po lewej karta folderu ~/ddos-lab na Twoim hoście wymienia nginx.conf, conf/limits.conf i www/report.html, zamontowane tylko do odczytu w kontenerze WWW. Notatka mówi, że sieć jest wewnętrzna: nic nie opuszcza Twojego komputera.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1179" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="300" y="20" width="860" height="470" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(316 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g>
<text x="342" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-ddos-net · 10.60.0.0/24 · --internal</text></g>
<rect class="dg-card" x="20" y="130" width="240" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(36 146) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g></g>
<g class="dg-l3"><text x="78" y="167" font-size="14" class="dg-ink" fill="#b45309" font-weight="700">~/ddos-lab na Twoim hoście</text></g>
<text x="38" y="198" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nginx.conf</text>
<text x="38" y="218" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">conf/limits.conf</text>
<text x="38" y="238" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">www/report.html</text>
<g class="dg-l3"><path class="dg-stroke" d="M260 205H460" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M471 199l8 6-8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="20" y="308" font-size="11.5" class="dg-muted" fill="#5c5c68" font-weight="500">zamontowane tylko do odczytu w kontenerze WWW</text>
<rect class="dg-card" x="480" y="80" width="320" height="280" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(496 96) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l4"><text x="538" y="117" font-size="15" class="dg-ink" fill="#c2410c" font-weight="700">lab-ddos-web</text></g>
<text x="498" y="148" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.10/24 · tcp 80</text>
<text x="498" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nginx 1.31.6-alpine</text>
<text x="498" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 · --memory 128m</text>
<text x="498" y="208" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">/report.html: gzip poziom 9 przy każdym żądaniu</text>
<text x="498" y="250" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">limits.conf: najpierw wyłączony, potem włączony</text>
<rect class="dg-tint" x="494" y="262" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="278.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">limit_req 5r/s, burst 10</text>
<rect class="dg-tint" x="494" y="292" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="308.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">limit_conn 10 na adres</text>
<rect class="dg-tint" x="494" y="322" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="338.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">status 429 po przekroczeniu</text>
<rect class="dg-card" x="900" y="60" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(916 76) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g></g>
<g class="dg-warn"><text x="958" y="97" font-size="13.5" class="dg-ink" fill="#b91c1c" font-weight="700">lab-ddos-bot1</text></g>
<text x="918" y="128" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.20/24</text>
<text x="918" y="148" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">hey -z 15s -c 25 -q 20</text>
<rect class="dg-card" x="900" y="170" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(916 186) scale(1.2500)" fill="none" stroke="#b91c1c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g></g>
<g class="dg-warn"><text x="958" y="207" font-size="13.5" class="dg-ink" fill="#b91c1c" font-weight="700">lab-ddos-bot2</text></g>
<text x="918" y="238" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.21/24</text>
<text x="918" y="258" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">hey -z 15s -c 25 -q 20</text>
<g class="dg-warn"><path class="dg-stroke" d="M900 107H850V135H810" stroke="#b91c1c" stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M900 217H850V165H810" stroke="#b91c1c" stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M811 129l-8 6 8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M811 159l-8 6 8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="824.2" y="138" width="51.6" height="24" rx="12" fill="#ffffff"/><text x="850" y="154.5" font-size="12" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">zalew</text></g>
<rect class="dg-card" x="900" y="330" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(916 346) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 16V7a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v9m16 0H4m16 0 1.28 2.55a1 1 0 0 1-.9 1.45H3.62a1 1 0 0 1-.9-1.45L4 16"/></g></g>
<g class="dg-l2"><text x="958" y="367" font-size="13.5" class="dg-ink" fill="#15803d" font-weight="700">lab-ddos-user</text></g>
<text x="918" y="398" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.30/24</text>
<text x="918" y="418" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">curl: jedno zwykłe żądanie</text>
<g class="dg-l2"><path class="dg-stroke" d="M900 377H850V300H810" stroke="#15803d" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><path class="dg-stroke" d="M811 294l-8 6 8 6" stroke="#15803d" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="810.76" y="328" width="78.48" height="24" rx="12" fill="#ffffff"/><text x="850" y="344.5" font-size="12" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle">1 żądanie</text></g>
<g class="dg-l1"><rect class="dg-tint" x="394.5" y="516" width="391" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="533.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Sieć wewnętrzna: nic nie opuszcza Twojego komputera</text></g>
</svg></figure>
*Rysunek 1. Dwa boty i jeden zwykły użytkownik dzielą jeden mały serwer WWW. Na początku nic nie ogranicza botów; później robi to `limits.conf`.*
| Kontener | Adres | Rola |
|---|---|---|
| `lab-ddos-web` | `10.60.0.10`, TCP 80 | nginx, ograniczony do pół procesora i 128 MB, serwujący `/report.html` |
| `lab-ddos-bot1` | `10.60.0.20` | „Bot”: zalewa serwer WWW za pomocą `hey` |
| `lab-ddos-bot2` | `10.60.0.21` | Drugi bot (żeby atak pochodził z więcej niż jednego adresu) |
| `lab-ddos-user` | `10.60.0.30` | Zwykły użytkownik: kilka żądań `curl` |
**Dlaczego ta strona jest „kosztowna”.** nginx serwuje mały plik statyczny prawie za darmo i żadne małe laboratorium nie mogłoby go zalać. Dlatego `/report.html` to duży plik tekstowy (około 900 KB), który nginx musi **kompresować gzipem przy każdym żądaniu**, co zużywa prawdziwy czas procesora. Kontener WWW może używać tylko pół procesora, a nginx uruchamia jeden proces roboczy. Daje to serwerowi przepustowość rzędu 20 żądań na sekundę, którą łatwo przekroczyć w laboratorium, i reprezentuje każdą stronę kosztowną w wytworzeniu (wyszukiwanie, raport, zapytanie do bazy danych).
> [!NOTE]
> Jeden adres zalewający serwer to ściśle rzecz biorąc atak DoS. Laboratorium używa dwóch kontenerów botów, by pokazać, że limity stosuje się na adres, i by skłonić Cię do zastanowienia, co się dzieje przy tysiącach. Wnioski są takie same.
## Kroki
### Krok 1 — Sprawdź narzędzia i utwórz folder roboczy (3 min)
Upewnij się, że Podman działa bez uprawnień roota i używa netavark oraz że nic nie zostało po wcześniejszej próbie.
```bash
podman --version
podman info --format '{{.Host.NetworkBackend}} rootless={{.Host.Security.Rootless}}'
podman ps -a --filter name=lab-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
mkdir -p ~/ddos-lab && cd ~/ddos-lab
```
Oczekiwany wynik (Twoja wersja może się różnić):
```text
podman version 5.8.7
netavark rootless=true
```
Dwa polecenia `ls` nic nie wypisują. Jeśli wypiszą nazwy `lab-ddos-`, najpierw wykonaj [Sprzątanie](#sprzątanie). Wszystkie następne polecenia zakładają, że jesteś w `~/ddos-lab`. Jeśli otworzysz nowy terminal, wykonaj ponownie `cd ~/ddos-lab`.
### Krok 2 — Zbuduj obraz z narzędziami (4 min)
Boty i użytkownik potrzebują dwóch narzędzi: `curl` (jedno żądanie, z pomiarem czasu) i `hey` (generator obciążenia HTTP: wiele żądań naraz, z podsumowaniem). Alpine Linux ma oba w pakietach. Tag jest przypięty do Alpine 3.20.10.
```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache hey curl
EOT
podman build -t lab-ddos-tools:1 . 2>&1 | tail -4
podman run --rm lab-ddos-tools:1 sh -c 'cat /etc/alpine-release; apk list -I 2>/dev/null | grep -E "^(hey|curl)-"'
```
Oczekiwany wynik (identyfikator obrazu i wersje pakietów mogą się nieznacznie różnić):
```text
COMMIT lab-ddos-tools:1
--> 5b5d9cc480f1
Successfully tagged localhost/lab-ddos-tools:1
5b5d9cc480f1dd3f292ce2e615536cf0b39fcbd2c72460b0be3b8fc2e8c51b88
3.20.10
curl-8.14.1-r2 x86_64 {curl} (curl) [installed]
hey-0.1.4-r26 x86_64 {hey} (Apache-2.0) [installed]
```
Budowanie jednorazowo korzysta z Twojej zwykłej sieci, aby pobrać pakiety. Kontenery laboratorium nie będą miały żadnej sieci zewnętrznej.
### Krok 3 — Napisz pliki serwera WWW (5 min)
nginx potrzebuje trzech plików, trzymanych na Twoim hoście i zamontowanych w kontenerze. Oto, do czego służy każdy z nich:
- `www/report.html` to kosztowna strona: 150 000 wierszy z liczbami.
- `nginx.conf` to cała konfiguracja serwera. Włącza gzip na poziomie 9 (kosztowna część), wysyła dziennik dostępu na standardowe wyjście, tak że można go czytać przez `podman logs`, i **definiuje** dwa liczniki na adres klienta (`limit_req_zone`, `limit_conn_zone`). Zdefiniowanie ich jeszcze niczego nie ogranicza.
- `conf/limits.conf` jest dołączany przez blok serwera. Na razie jest pusty. W kroku 8 wpisujesz w nim limity.
```bash
mkdir -p conf www
seq 1 150000 > www/report.html
echo '# no limits yet' > conf/limits.conf
cat > nginx.conf <<'EOT'
worker_processes 1;
error_log /dev/stderr notice;
pid /tmp/nginx.pid;
events {
worker_connections 1024;
}
http {
include /etc/nginx/mime.types;
access_log /dev/stdout;
# An "expensive" page: nginx compresses it on every request, which costs CPU.
gzip on;
gzip_comp_level 9;
# Two counters, one per client address. They do nothing until limits.conf uses them.
limit_req_zone $binary_remote_addr zone=perip:1m rate=5r/s;
limit_conn_zone $binary_remote_addr zone=connperip:1m;
server {
listen 80;
root /usr/share/nginx/html;
location /report.html {
alias /srv/www/report.html;
}
include /etc/nginx/lab/limits.conf;
}
}
EOT
wc -lc www/report.html
```
Oczekiwany wynik:
```text
150000 938895 www/report.html
```
Plik ma 150 000 wierszy i 938 895 bajtów (około 0,9 MB). `rate=5r/s` to limit, który włączysz później: pięć żądań na sekundę na adres klienta.
### Krok 4 — Utwórz izolowaną sieć i cztery kontenery (5 min)
Jedna sieć Podmana to całe laboratorium. `--internal` oznacza, że Podman nie dodaje trasy do świata zewnętrznego ani NAT do Twojego hosta, więc nic nie może opuścić Twojego komputera. `10.60.0.0/24` to zakres prywatny ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).
Kontener WWW dostaje `--cpus 0.5` i `--memory 128m`: może użyć najwyżej pół procesora, więc łatwo go przeciążyć i nigdy nie zaszkodzi Twojemu komputerowi. `:ro,Z` montuje pliki tylko do odczytu (etykieta `Z` sprawia, że są czytelne w systemach z SELinux, takich jak Fedora, a gdzie indziej nic nie robi). Tag obrazu jest przypięty do dokładnej wersji. Pozostałe trzy kontenery po prostu wykonują `sleep infinity`; polecenia w nich uruchamiasz przez `podman exec`.
```bash
podman network create --internal --subnet 10.60.0.0/24 lab-ddos-net
podman network inspect lab-ddos-net --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
podman run -d --name lab-ddos-web --network lab-ddos-net:ip=10.60.0.10 --cpus 0.5 --memory 128m \
-v ~/ddos-lab/nginx.conf:/etc/nginx/nginx.conf:ro,Z \
-v ~/ddos-lab/conf:/etc/nginx/lab:ro,Z \
-v ~/ddos-lab/www:/srv/www:ro,Z \
docker.io/library/nginx:1.31.6-alpine
podman run -d --name lab-ddos-bot1 --network lab-ddos-net:ip=10.60.0.20 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-bot2 --network lab-ddos-net:ip=10.60.0.21 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-user --network lab-ddos-net:ip=10.60.0.30 lab-ddos-tools:1 sleep infinity
podman ps --filter name=lab-ddos --format 'table {{.Names}}\t{{.Status}}'
podman exec lab-ddos-web nginx -v
```
Oczekiwany wynik (cztery długie identyfikatory kontenerów są różne; przy pierwszym uruchomieniu pobierany jest obraz nginx):
```text
lab-ddos-net
lab-ddos-net subnet=10.60.0.0/24 internal=true
e296e3434133eb65348ff7d7faddaf2d1ef80540dde41d434314abaab37b7fb4
8dbf7b4179c98cbd8c67e41f33c93215f78b912f4e397d48016d7a14a584be7d
1c262b3347113f409267c40260d01089054015daad18efbe960669ee88773df1
24f0c870b1f753edee63a94317a8c675d407a974608211a5982aca0caed2af03
NAMES STATUS
lab-ddos-web Up Less than a second
lab-ddos-bot1 Up Less than a second
lab-ddos-bot2 Up Less than a second
lab-ddos-user Up Less than a second
nginx version: nginx/1.31.6
```
Teraz sprawdź izolację. Kontener użytkownika ma jedną trasę, tylko do sieci laboratorium, a połączenie z adresem zewnętrznym (`192.0.2.1` to adres dokumentacyjny, [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)) kończy się natychmiast niepowodzeniem, bo nie ma trasy:
```bash
podman exec lab-ddos-user ip route
podman exec lab-ddos-user curl -sS -m 3 -o /dev/null http://192.0.2.1/ ; echo "curl exit code: $?"
```
Oczekiwany wynik:
```text
10.60.0.0/24 dev eth0 scope link src 10.60.0.30
curl: (7) Failed to connect to 192.0.2.1 port 80 after 0 ms: Could not connect to server
curl exit code: 7
```
Kod wyjścia 7 oznacza „nie udało się połączyć”. Narzędzia ataku nie mogą dotrzeć do niczego poza serwerem WWW.
### Krok 5 — Poziom bazowy: jak szybki jest serwer, gdy nikt nie atakuje? (5 min)
Przed atakiem musisz wiedzieć, jak wygląda normalność. To Twój **poziom bazowy**. Najpierw jedno żądanie od zwykłego użytkownika, z pomiarem czasu (`--compressed` prosi o gzip, jak każda przeglądarka, więc serwer wykonuje kosztowną pracę). Potem 30 żądań, jedno po drugim (`-c 1` oznacza po jednym naraz), za pomocą `hey`.
```bash
podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
podman exec lab-ddos-user hey -n 30 -c 1 http://10.60.0.10/report.html 2>&1 | grep -E 'Total:|Average:|Slowest:|Requests/sec|^ \[[0-9]+\]'
```
Oczekiwany wynik (czasy się różnią; liczy się rząd wielkości):
```text
status=200 time=0.030266s
Total: 1.6079 secs
Slowest: 0.1015 secs
Average: 0.0536 secs
Requests/sec: 18.6580
[200] 30 responses
```
Jak to czytać: `status=200` to „OK”. Jedno żądanie trwa około 30 do 50 milisekund (ms) z powodu kompresji. Wszystkie 30 dostało `[200]`. Serwer obsługuje około **18 żądań na sekundę**, gdy jeden klient pyta po jednym naraz, i to jest jego przybliżona przepustowość. Zapisz poziom bazowy: **około 0,03 sekundy dla zwykłego użytkownika**.
### Krok 6 — Zalej serwer i zobacz, co widzi zwykły użytkownik (8 min)
Teraz „atak”. Każdy bot uruchamia `hey` przez 15 sekund (`-z 15s`) z 25 wątkami roboczymi (`-c 25`), a każdy wątek próbuje 20 żądań na sekundę (`-q 20`): około 500 żądań na sekundę na bota, 1000 łącznie, przeciw serwerowi, który potrafi obsłużyć około 18. Oba polecenia `hey` działają w tle (`&`). Trzy sekundy później zwykły użytkownik raz prosi o tę samą stronę. `wait` blokuje do końca pracy botów. Twoja powłoka może wypisać wiersze zadań, takie jak `[1] 12345`; są nieszkodliwe.
```bash
for b in bot1 bot2; do
podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood1-$b.txt 2>&1 &
done
sleep 3
podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^ \[[0-9]+\]' flood1-$b.txt; done
```
Oczekiwany wynik (trwa około 20 sekund; **liczby się różnią, obraz nie**):
```text
status=200 time=14.640884s
== bot1
Total: 17.6109 secs
Average: 16.4463 secs
Requests/sec: 1.4764
[200] 26 responses
== bot2
Total: 16.5475 secs
Average: 1.3776 secs
Requests/sec: 17.2232
[200] 285 responses
```
Przeczytaj to uważnie:
- Zwykły użytkownik poprosił o stronę raz i **czekał około 15 sekund** (w Twoim uruchomieniu: wiele sekund, a nie milisekundy) na odpowiedź, która wcześniej zajmowała 0,03 sekundy. Nikt się nie włamał i żadne dane nie zniknęły, a usługa jest faktycznie niedostępna. To jest odmowa usługi.
- Każdy bot próbował wykonać tysiące żądań, ale serwer zrealizował łącznie tylko około 300 w 15 sekund, czyli tyle, ile wynosi jego przepustowość. Reszta czekała w kolejce lub wygasła.
- Jeden bot dostał większość odpowiedzi (tutaj `bot2`: 285 wobec 26). Który, to się zmienia; nginx nie dzieli sprawiedliwie. To normalne.
### Krok 7 — Wykryj to: przeczytaj dziennik dostępu (5 min)
Dziennik dostępu to Twoje pierwsze narzędzie wykrywania. nginx zapisuje jeden wiersz na każde **zakończone** żądanie na standardowe wyjście, a `podman logs` je pokazuje. To polecenie zostawia wiersze prawdziwych żądań (`GET`) w pliku i je zlicza: pierwsza kolumna to adres klienta, dziewiąta to status HTTP.
```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' > access-all.txt
wc -l < access-all.txt
awk '{print $1, $9}' access-all.txt | sort | uniq -c | sort -rn
```
Oczekiwany wynik (liczby różnią się nieznacznie):
```text
343
285 10.60.0.21 200
32 10.60.0.30 200
26 10.60.0.20 200
```
Program `awk` wypisuje adres i status z każdego wiersza, `sort | uniq -c` zlicza takie same pary, a `sort -rn` układa największe na górze. Odczytanie tabeli:
- Dwa adresy `10.60.0.20` i `10.60.0.21` to **najaktywniejsi nadawcy** wśród klientów, którym się udało, a w rzeczywistości próbowali o wiele więcej. Zwykły użytkownik `10.60.0.30` pojawia się z 32 żądaniami poziomu bazowego i jednym żądaniem, które czekało.
- Zauważ ograniczenie tej metody: **dziennik wymienia tylko żądania, które serwer zrealizował**. Przeciążenie sprawiło, że serwer odpowiedział na mniej, a nie na więcej, więc dziennik zaniża skalę ataku. Prawdziwe wykrywanie wymaga też liczników na poziomie sieci (pakiety i połączenia na sekundę), obciążenia, opóźnienia i odsetka błędów z monitoringu. W dzienniku sygnałem jest to, że kilka adresów odpowiada za większość ruchu.
### Krok 8 — Włącz ograniczanie liczby żądań i przeładuj konfigurację (5 min)
Teraz obrona. Plik `conf/limits.conf` dostaje cztery wiersze:
- `limit_req zone=perip burst=10 nodelay;` stosuje licznik `perip`: każdy adres klienta może wykonać **5 żądań na sekundę** (zdefiniowane w `nginx.conf`) i może to przekroczyć o **serię (burst)** 10 dodatkowych żądań. `nodelay` obsługuje serię od razu, zamiast ją spowalniać. Żądania ponad to są odrzucane.
- `limit_req_status 429;` ustawia status odmowy HTTP `429 Too Many Requests` (domyślnie jest 503).
- `limit_conn connperip 10;` pozwala każdemu adresowi mieć najwyżej **10 połączeń z żądaniem w toku** jednocześnie. Pomaga, gdy każde żądanie obsługuje się długo (wolna baza danych, duży upload). nginx zaczyna liczyć żądanie dopiero po całkowitym nadejściu jego nagłówków.
- `limit_conn_status 429;` nadaje temu ten sam status.
```bash
cat > conf/limits.conf <<'EOT'
# At most 5 requests per second per client address, with a burst of 10 extra requests
limit_req zone=perip burst=10 nodelay;
limit_req_status 429;
# At most 10 simultaneous connections per client address
limit_conn connperip 10;
limit_conn_status 429;
EOT
podman exec lab-ddos-web nginx -t
podman exec lab-ddos-web nginx -s reload
```
Oczekiwany wynik (wiersz `notice` pokazuje czas Twojego przeładowania):
```text
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
2026/11/07 20:08:04 [notice] 28#28: signal process started
```
`nginx -t` najpierw testuje konfigurację (zawsze to rób), a `nginx -s reload` sprawia, że nginx uruchamia nowe procesy robocze z nowymi regułami i wygasza stare bez zrywania połączeń. Jeśli test się nie powiedzie, nic nie jest przeładowywane i zostają stare reguły.
### Krok 9 — Zalej ponownie, z włączonym limitem (8 min)
Ten sam atak, te same polecenia. Tym razem zwykły użytkownik prosi trzy razy, co sekundę, jak osoba odświeżająca stronę.
```bash
for b in bot1 bot2; do
podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood2-$b.txt 2>&1 &
done
sleep 3
for i in 1 2 3; do
podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
sleep 1
done
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^ \[[0-9]+\]' flood2-$b.txt; done
```
Oczekiwany wynik (liczby różnią się o kilka; obraz nie):
```text
status=200 time=0.030948s
status=200 time=0.029585s
status=200 time=0.029022s
== bot1
Total: 15.0048 secs
Average: 0.0193 secs
Requests/sec: 431.1286
[200] 81 responses
[429] 6388 responses
== bot2
Total: 15.0118 secs
Average: 0.0201 secs
Requests/sec: 442.9185
[200] 85 responses
[429] 6564 responses
```
Porównaj z krokiem 6:
| | Krok 6: bez limitu | Krok 9: z limitem |
|---|---|---|
| Czas oczekiwania zwykłego użytkownika | około 15 sekund | około 0,03 sekundy, jak w poziomie bazowym |
| Odpowiedzi otrzymane przez każdego bota | jeden bot kilkaset, drugi prawie żadnej | po około 85 |
| Odmowy (status 429) | brak | około 6400 na bota |
| Średni czas żądania bota | sekundy | około 0,02 sekundy |
Dwie rzeczy warto zauważyć. Po pierwsze, **zwykły użytkownik jest obsługiwany z normalną szybkością**: limit działa na adres, a adres użytkownika jest daleko poniżej niego. Po drugie, każdy bot dostał tylko około 85 odpowiedzi. To nie przypadek: `10 + 5 × 15 = 85`, czyli seria plus 5 żądań na sekundę przez 15 sekund. Cała reszta została odrzucona malutką odpowiedzią `429`, której wytworzenie kosztuje prawie nic, i dlatego serwer znów jest wolny.
### Krok 10 — Wykryj to i udowodnij w dzienniku (4 min)
Ta sama analiza dziennika co w kroku 7, teraz tylko dla wierszy zapisanych od migawki z kroku 7 (`tail -n +N` wypisuje od wiersza N). Potem obejrzyj jedno odrzucone żądanie i własny dziennik błędów nginx.
```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' | tail -n +$(( $(wc -l < access-all.txt) + 1 )) > access-flood2.txt
wc -l < access-flood2.txt
awk '{print $1, $9}' access-flood2.txt | sort | uniq -c | sort -rn
grep ' 429 ' access-flood2.txt | head -1
podman logs lab-ddos-web 2>&1 | grep 'limiting requests' | head -1
podman logs lab-ddos-web 2>&1 | grep -c 'limiting requests'
```
Oczekiwany wynik (liczby się różnią):
```text
13121
6564 10.60.0.21 429
6388 10.60.0.20 429
85 10.60.0.21 200
81 10.60.0.20 200
3 10.60.0.30 200
10.60.0.21 - - [07/Nov/2026:20:08:05 +0000] "GET /report.html HTTP/1.1" 429 169 "-" "hey/0.0.1"
2026/11/07 20:08:05 [error] 29#29: *54 limiting requests, excess: 10.815 by zone "perip", client: 10.60.0.21, server: , request: "GET /report.html HTTP/1.1", host: "10.60.0.10"
12952
```
Teraz dziennik opowiada historię wyraźnie: 13 121 żądań w 15 sekund, prawie wszystkie `429` z dwóch adresów, i zwykły użytkownik z trzema `200`. To sygnał, którego użyłby system wykrywania. Dwie dodatkowe obserwacje:
- Liczba wierszy `limiting requests` w dzienniku błędów (12 952) jest równa liczbie 429 w dzienniku dostępu (6388 + 6564 = 12 952): każda odmowa jest zapisana. W prawdziwym systemie ustawiasz alert na dużą liczbę 429 z tych samych adresów i możesz przekazać te adresy zaporze albo dostawcy.
- `limit_conn` nigdy się nie uruchomił. nginx obsługuje tutaj każde żądanie jednym szybkim ciągiem, więc adres nigdy nie ma więcej niż jednego żądania w toku, a odrzucone dostają odpowiedź natychmiast. `limit_conn` się opłaca, gdy żądania pozostają w toku długo, i nie jest obroną przed atakami powolnymi, które nigdy nie kończą nagłówków (zobacz wyzwanie).
### Krok 11 — Odczytaj ustawienie SYN cookies (4 min)
Dotychczasowe limity dotyczą zalewów HTTP (warstwa 7). Przeciw zalewowi SYN (warstwa 4, zobacz lekcję) jądro Linuksa ma własną obronę, SYN cookies. Tylko **odczytujesz** ustawienie, zarówno na swoim komputerze, jak i w kontenerze WWW, oraz liczniki jądra. Niczego nie musisz zmieniać, a zalew SYN wymaga surowych pakietów, których to laboratorium świadomie nie używa.
```bash
cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web awk '/^TcpExt:/ { if (!h) { split($0, n); h = 1 } else { split($0, v); for (i = 2; i <= NF; i++) if (n[i] ~ /^(SyncookiesSent|SyncookiesRecv|SyncookiesFailed|ListenOverflows|ListenDrops)$/) print n[i], v[i] } }' /proc/net/netstat
```
Oczekiwany wynik:
```text
1
1
SyncookiesSent 0
SyncookiesRecv 0
SyncookiesFailed 0
ListenOverflows 0
ListenDrops 0
```
Jak to czytać:
- Wartości `net.ipv4.tcp_syncookies` oznaczają: `0` cookies wyłączone, `1` cookies **tylko wtedy, gdy kolejka połowicznie otwartych połączeń się przepełni** (zwykła wartość domyślna), `2` cookies zawsze. W obu miejscach widzisz `1`: Twój system jest od razu po instalacji chroniony przed zalewami SYN. Kontener ma własną kopię ustawienia, w swojej przestrzeni nazw sieci, i zaczyna z tą samą wartością.
- Liczniki w ostatnim poleceniu to własny zapis jądra dla sieci kontenera: `SyncookiesSent` zlicza wysłane cookies, a `ListenOverflows` i `ListenDrops` zliczają próby połączeń utracone, bo kolejka była pełna. Wszystkie wynoszą `0`: zalew HTTP otwierał pełne połączenia, nie zapełniał kolejki połowicznie otwartych, więc SYN cookies nie musiały działać. Na tym polega sens klasyfikacji: właściwa obrona zależy od klasy ataku, a ustawienie SYN cookies nie uratowałoby serwera przed tym zalewem, za to uratował go limit żądań.
> [!NOTE]
> Twoje liczniki mogą nie być dokładnie zerowe, jeśli coś innego na Twoim komputerze korzystało z sieci kontenera. Znaczenie jest takie samo: rosną tylko wtedy, gdy kolejka połowicznie otwartych połączeń się przepełni.
## Weryfikacja
Sprawdź te wyniki; każdy musi być spełniony w Twoim uruchomieniu:
| Sprawdzenie | Oczekiwany wynik |
|---|---|
| Poziom bazowy (krok 5) | Zwykłe żądanie dostaje `200` w dziesiątkach milisekund |
| Zalew bez limitu (krok 6) | Zwykły użytkownik czekał kilka sekund, a nie milisekundy |
| Dziennik dostępu (krok 7) | Dwa adresy botów odpowiadają za większość wierszy |
| Zalew z limitem (krok 9) | Zwykły użytkownik dostał `200` w około 0,03 s; boty dostały głównie `429` i po około 85 `200` |
| Dziennik dostępu (krok 10) | Wiersze `429` tylko dla dwóch adresów botów; `200` dla `10.60.0.30` |
| SYN cookies (krok 11) | `net.ipv4.tcp_syncookies` wynosi `1` na hoście i w kontenerze |
Wykonaj ten ostatni test, aby jeszcze raz udowodnić, że zwykły użytkownik jest obsługiwany, gdy limity są włączone:
```bash
for i in 1 2 3; do podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w '%{http_code}\n' http://10.60.0.10/report.html; done
```
Oczekiwany wynik:
```text
200
200
200
```
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `Error: ... cpu ... controller` albo `--cpus` is not supported przy uruchamianiu `lab-ddos-web` | Kontroler CPU nie jest delegowany Twojemu użytkownikowi (starsze systemy lub cgroup v1) | Usuń `--cpus 0.5` i zrób stronę cięższą: `seq 1 600000 > www/report.html`. Efekt zalewu w kroku 6 może być mniejszy; użyj `-c 50` w poleceniu botów |
| `podman run` kończy się błędem `permission denied` przy zamontowanych plikach | Etykieta SELinux lub zła ścieżka | Sprawdź, czy jesteś w `~/ddos-lab` i czy pliki istnieją; zostaw flagi `:Z`; nie montuj plików spoza swojego katalogu domowego |
| Krok 6 nie pokazuje spowolnienia dla zwykłego użytkownika (około 0,03 s) | Serwer jest szybszy, niż oczekiwano, albo zalew się nie rozpoczął | Sprawdź, czy `flood1-bot1.txt` ma wiersze `[200]` i brak błędu; użyj większej strony (`seq 1 600000`) albo `-c 50` |
| `hey: not found` albo `curl: not found` | Polecenie uruchomiono na hoście lub w kontenerze nginx | Dodaj na początku `podman exec lab-ddos-user` (albo `-bot1`, `-bot2`), które mają obraz z narzędziami |
| Po przeładowaniu wszystkie odpowiedzi nadal mają `200` (krok 9) | `limits.conf` nie został zaktualizowany albo przeładowanie się nie powiodło | `podman exec lab-ddos-web cat /etc/nginx/lab/limits.conf` pokazuje plik widziany przez nginx; uruchom `nginx -t` i przeczytaj wiersz, na który się skarży |
| `nginx -t` mówi `unknown directive` albo `invalid parameter` | Literówka w `limits.conf` | Porównaj go z tekstem z kroku 8; nginx zachowuje stare reguły, dopóki test się nie powiedzie |
| Zwykły użytkownik też dostaje `429` | Użytkownik prosił więcej niż 5 razy na sekundę plus seria | Poczekaj kilka sekund i poproś ponownie, powoli. To właśnie działanie reguły: limit może uderzyć też w prawdziwych użytkowników, którzy są bardzo szybcy albo dzielą adres |
| `Error: ... name "lab-ddos-web" is already in use` | Istnieje kontener z wcześniejszej próby | Wykonaj [Sprzątanie](#sprzątanie), a potem zacznij od nowa |
| Liczby w Twoich tabelach różnią się od tej strony | Czas, szybkość procesora i planowanie różnią się na każdym komputerze | Porównuj *obraz*: sekundy wobec milisekund oraz tysiące `429` wobec około 85 `200` na bota |
## Wyzwanie (opcjonalne)
Bez instrukcji krok po kroku spróbuj jednego lub kilku z tych zadań, a potem przywróć pliki z kroku 8:
1. **Atak powolny.** Ataki w stylu Slowloris otwierają połączenie i wysyłają nagłówek żądania bardzo wolno, nigdy go nie kończąc. Z `lab-ddos-bot1` użyj `nc`, aby otworzyć połączenie z `10.60.0.10` na port 80 i wysłać tylko pierwszy wiersz żądania, a potem czekać. Które ustawienie nginx w końcu zamyka takie połączenie (poszukaj `client_header_timeout` w dokumentacji nginx)? Dlaczego `limit_conn` go nie widzi?
2. **Limit globalny.** Dodaj drugi licznik oparty na `$server_name` z tempem 30 żądań na sekundę i zastosuj go do `/report.html`. Co dzieje się teraz ze zwykłym użytkownikiem podczas zalewu? Czego to uczy o limitach na adres wobec botnetu z tysiącami adresów?
3. **Tańsze strony.** Buforuj skompresowaną stronę: poszukaj `gzip_static` albo `proxy_cache` w dokumentacji nginx i zmierz, jak zmienia się przepustowość serwera w poziomie bazowym. Której warstwie z rysunku obrony w lekcji to odpowiada?
## Sprzątanie
Usuń wszystkie zasoby utworzone przez laboratorium. `-t 0` pomija 10-sekundowe oczekiwanie na kontenery, które ignorują sygnał zatrzymania.
```bash
podman rm -f -t 0 lab-ddos-web lab-ddos-bot1 lab-ddos-bot2 lab-ddos-user
podman network rm lab-ddos-net
podman rmi lab-ddos-tools:1
cd ~ && rm -rf ~/ddos-lab
podman ps -a --filter name=lab-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
```
Dwa ostatnie polecenia nic nie wypisują, gdy wszystko zniknęło. Pobrane obrazy `docker.io/library/nginx:1.31.6-alpine` i `alpine:3.20.10` zostają w magazynie obrazów (są współdzielone z innymi pracami); usuń je poleceniem `podman rmi`, jeśli chcesz odzyskać miejsce.
## Co już umiesz
- Zalew nie musi być ogromny, żeby zaszkodzić: serwer o ograniczonej przepustowości zamienił niegroźnie wyglądający zestaw żądań w 15-sekundowe oczekiwanie zwykłego użytkownika.
- Poziom bazowy normalnego opóźnienia i ruchu od razu mówi, że coś jest nie tak, a dziennik dostępu, zliczany według adresu i statusu, pokazuje, kto za to odpowiada.
- Ograniczanie liczby żądań na adres (`limit_req`, status 429) tanio odrzuca nadmiar, utrzymuje serwer responsywnym i przepuszcza zwykłych użytkowników; odrzucone żądania kosztują prawie nic w obsłudze.
- Arytmetyka limitu jest przewidywalna: seria plus tempo razy czas, tu `10 + 5 × 15 = 85` odpowiedzi na bota. Przy tysiącach adresów suma jest duża, więc potrzebne są też warstwy wyżej w sieci.
- SYN cookies chronią przed inną klasą (wyczerpaniem stanu): na Linuksie ustawienie domyślnie wynosi `1`, a tu nie miało znaczenia, bo zalew był zalewem HTTP.