---
title: "Laboratorium: ograniczanie liczby żądań do serwera WWW podczas symulowanego zalewu"
domain: cybersecurity
level: intermediate
duration: "50 min"
cost: "bezpłatnie"
environment: "kontenery (Podman bez uprawnień roota na lokalnym komputerze z Linuksem)"
lang: pl
source_hash: 8ef7469ed99c
---

# Laboratorium: ograniczanie liczby żądań do serwera WWW podczas symulowanego zalewu

## 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
![Jedna wewnętrzna sieć Podmana, lab-ddos-net, 10.60.0.0/24. Kontener serwera WWW lab-ddos-web ma adres 10.60.0.10 na 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 zaczyna jako pusty, a później jest wypełniany: limit_req 5 żądań na sekundę z serią 10, limit_conn 10 na adres i status 429 po przekroczeniu. Dwa kontenery botów, lab-ddos-bot1 pod adresem 10.60.0.20 i lab-ddos-bot2 pod adresem 10.60.0.21, uruchamiają hey przez 15 sekund z 25 równoległymi wątkami 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 folder ~/ddos-lab na Twoim hoście zawiera nginx.conf, conf/limits.conf i www/report.html, zamontowane tylko do odczytu w kontenerze WWW. Sieć jest wewnętrzna: nic nie opuszcza Twojego komputera.](../../../assets/diagrams/ddos-lab-architecture.pl.svg)

*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.
