Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Budujesz trzy strefy sieciowe („Internet”, DMZ i strefę wewnętrzną) połączone jednym kontenerem z zaporą. Skanujesz z zewnątrz, gdy wszystko jest otwarte, stosujesz politykę domyślnej odmowy nftables, która dopuszcza tylko dwa przepływy, skanujesz ponownie, czytasz liczniki i log odrzuceń zapory oraz dowodzisz testami, że każdy niechciany przepływ jest zablokowany.
## Cele
- Zbudować trzy odizolowane strefy i poprowadzić ruch między nimi przez jedną zaporę.
- Przeskanować sieć z zewnątrz za pomocą `nmap` i odczytać wyniki `open`, `closed` i `filtered`.
- Napisać stanowy zestaw reguł domyślnej odmowy, który dopuszcza tylko Internet do WWW (TCP 80) i WWW do bazy danych (TCP 5432).
- Odczytać liczniki reguł zapory i jej log odrzuceń, aby potwierdzić, że zablokowany ruch został zablokowany przez Twoje reguły.
- Zweryfikować politykę tabelą testów pozytywnych i negatywnych oraz pokazać, dlaczego kolejność reguł ma znaczenie.
## Wymagania wstępne
- Komputer z Linuksem z **Podmanem 4 lub nowszym** uruchomionym **bez uprawnień roota** (jako zwykły użytkownik; nigdy nie potrzebujesz `sudo`) i z backendem sieciowym netavark. Przetestowano z Podmanem 5.8.7 na Fedorze z jądrem 7.2. Sprawdź poleceniem `podman info --format '{{.Host.NetworkBackend}}'`: powinno wypisać `netavark`.
- Dostęp do Internetu jednorazowo, aby pobrać obraz Alpine Linux (około 8 MB) i kilka pakietów (łącznie około 40 MB). Potem nic w laboratorium nie wymaga Internetu.
- Około 400 MB wolnego miejsca na dysku.
- [Lekcja](lesson.pl.md) tego modułu oraz [Sieci 08 — Warstwa transportowa: TCP, UDP i porty](../../networking/08-tcp-udp/README.pl.md). Techniki kontenerowe są te same co w [laboratorium o sieciach w chmurze](../../cloud-computing/06-cloud-networking/lab.pl.md); tutaj skupiasz się na strefach, domyślnej odmowie, logowaniu i weryfikacji.
> [!WARNING]
> **Upoważnienie i etyka.** Skanowanie portów jest techniką ataku, gdy jest wymierzone w systemy, których nie kontrolujesz, i może być nielegalne. W tym laboratorium skanujesz wyłącznie trzy kontenery, które tworzysz samodzielnie, w sieciach utworzonych z `--internal` (nic nie opuszcza Twojego komputera). Nigdy nie kieruj `nmap` na system, który nie należy do Ciebie albo do którego testowania nie masz pisemnego, wyraźnego upoważnienia. Skanowanie własnego, odizolowanego laboratorium w celu sprawdzenia własnej zapory to defensywne użycie tego narzędzia.
## 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="netsec-lab-architecture-pl-title netsec-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="netsec-lab-architecture-pl-title">Architektura laboratorium: trzy strefy i jedna zapora z domyślną odmową</title>
<desc id="netsec-lab-architecture-pl-desc">Trzy wewnętrzne sieci Podmana spotykają się w jednym kontenerze zapory, lab-netsec-fw, z interfejsami net0 203.0.113.254, dmz0 10.40.2.254 i int0 10.40.3.254. Sieć internet 203.0.113.0/24 zawiera lab-netsec-client pod adresem 203.0.113.10, klienta zewnętrznego z nmap, nc i curl oraz trasą do 10.40.0.0/16 przez 203.0.113.254. Sieć dmz 10.40.2.0/24 zawiera lab-netsec-web pod adresem 10.40.2.10, serwer WWW nasłuchujący na tcp 80, 8080 i 22, z trasą domyślną przez 10.40.2.254. Sieć wewnętrzna 10.40.3.0/24 zawiera lab-netsec-db pod adresem 10.40.3.10, usługę udającą bazę danych na tcp 5432 i 22, z trasą domyślną przez 10.40.3.254. Zapora stosuje tabelę nftables inet lab_fw w haku forward z policy drop: reguła 1 akceptuje ruch established i related, reguła 2 akceptuje nowe połączenia z net0 do dmz0 na tcp 80, reguła 3 akceptuje nowe połączenia z dmz0 do int0 na tcp 5432, a reguła 4 zapisuje do grupy nflog 1 i odrzuca całą resztę.</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="20" y="150" width="300" height="230" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 163) 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="62" y="177" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-netsec-internet · 203.0.113.0/24</text></g>
<g class="dg-l4"><rect class="dg-tint" x="820" y="20" width="340" height="230" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(836 33) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g>
<text x="862" y="47" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">lab-netsec-dmz · 10.40.2.0/24</text></g>
<g class="dg-l2"><rect class="dg-tint" x="820" y="290" width="340" height="230" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(836 303) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g>
<text x="862" y="317" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">lab-netsec-internal · 10.40.3.0/24</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M300 265H430" stroke="#0369a1" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M740 140H840" stroke="#c2410c" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><path class="dg-stroke" d="M740 410H840" stroke="#15803d" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<rect class="dg-card" x="40" y="200" width="260" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 216) scale(1.2500)" fill="none" stroke="#0369a1" 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-l1"><text x="98" y="237" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">lab-netsec-client</text></g>
<text x="58" y="268" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 203.0.113.10/24</text>
<text x="58" y="288" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">route 10.40.0.0/16 via .254</text>
<text x="58" y="308" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Klient zewnętrzny: nmap, nc, curl</text>
<rect class="dg-card" x="430" y="80" width="310" height="400" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(446 96) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"/></g></g>
<g class="dg-l3"><text x="488" y="117" font-size="15" class="dg-ink" fill="#b45309" font-weight="700">lab-netsec-fw</text></g>
<text x="448" y="148" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">net0 203.0.113.254</text>
<text x="448" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dmz0 10.40.2.254</text>
<text x="448" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">int0 10.40.3.254</text>
<text x="448" y="248" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">table inet lab_fw · hook forward</text>
<text x="448" y="268" font-size="12.5" class="dg-ink" fill="#b91c1c" font-weight="700" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">policy drop</text>
<rect class="dg-tint" x="444" y="294" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="315" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">1 established,related accept</text>
<rect class="dg-tint" x="444" y="334" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="355" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">2 net0 → dmz0 tcp 80 accept</text>
<rect class="dg-tint" x="444" y="374" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="395" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">3 dmz0 → int0 tcp 5432 accept</text>
<rect class="dg-tint" x="444" y="414" width="282" height="32" rx="8" fill="#f9eded" stroke="#e3a4a4"/>
<text x="454" y="435" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">4 log group 1, then drop</text>
<rect class="dg-card" x="840" y="66" width="300" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(856 82) 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="898" y="103" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">lab-netsec-web</text></g>
<text x="858" y="134" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.40.2.10/24 · tcp 80 8080 22</text>
<text x="858" y="154" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.40.2.254</text>
<text x="858" y="174" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Serwer WWW w DMZ</text>
<rect class="dg-card" x="840" y="336" width="300" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(856 352) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l2"><text x="898" y="373" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">lab-netsec-db</text></g>
<text x="858" y="404" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.40.3.10/24 · tcp 5432 22</text>
<text x="858" y="424" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.40.3.254</text>
<text x="858" y="444" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Usługa udająca bazę danych</text>
<g class="dg-l1"><rect class="dg-bg-plain" x="342.58" y="253" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="365" y="269.5" font-size="11" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">net0</text></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="767.58" y="128" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="790" y="144.5" font-size="11" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dmz0</text></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="767.58" y="398" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="790" y="414.5" font-size="11" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">int0</text></g>
<g class="dg-l1"><rect class="dg-tint" x="297" y="526" width="586" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="543.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Wszystkie trzy sieci Podmana są --internal: nic nie opuszcza Twojego komputera</text></g>
</svg></figure>
*Rysunek 1. Jeden kontener zapory łączy trzy strefy. Na końcu mogą ją przekroczyć tylko dwa przepływy z jej listy reguł.*
| Kontener | Sieć i adres | Rola |
|---|---|---|
| `lab-netsec-client` | `lab-netsec-internet`, `203.0.113.10` | Świat zewnętrzny: odwiedzający albo atakujący, z `nmap`, `nc` i `curl` |
| `lab-netsec-web` | `lab-netsec-dmz`, `10.40.2.10` | Publiczny serwer WWW (TCP 80) oraz dwie usługi, które **nie** powinny być publiczne: TCP 8080 i fałszywy baner SSH na TCP 22 |
| `lab-netsec-db` | `lab-netsec-internal`, `10.40.3.10` | Nasłuch podobny do bazy danych na TCP 5432 (odpowiada `lab-db ready`) i fałszywy baner SSH na TCP 22 |
| `lab-netsec-fw` | `203.0.113.254`, `10.40.2.254`, `10.40.3.254` | Router i zapora między strefami |
> [!NOTE]
> Usługi „SSH” i „bazy danych” to maleńkie nasłuchy `nc`, które wypisują jedną linię. Wystarczą, aby skan je znalazł i aby przyjmowały lub odrzucały połączenia, a tylko tego potrzebuje to laboratorium. W prawdziwej sieci serwer WWW potrzebowałby też adresu publicznego (lub tłumaczonego); tutaj klient po prostu kieruje ruch do niego przez zaporę.
Podman uruchamia polecenie w kontenerze za pomocą `podman exec lab-netsec-<nazwa> <polecenie>`. Laboratorium robi to bez przerwy, więc każde polecenie jest podane w całości.
## 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-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
mkdir -p ~/netsec-lab && cd ~/netsec-lab
```
Oczekiwane wyjście (Twoja wersja może się różnić):
```text
podman version 5.8.7
netavark rootless=true
```
Dwa polecenia `ls` nic nie wypisują. Jeśli wypisują nazwy `lab-netsec-`, najpierw wykonaj [Sprzątanie](#sprzątanie). Wszystkie pliki i polecenia poniżej zakładają, że znajdujesz się w `~/netsec-lab`.
### Krok 2 — Zbuduj obraz z narzędziami (5 min)
Alpine Linux jest maleńki, ale nie ma żadnego z potrzebnych narzędzi. Budujesz jeden obraz z `nftables` (linuksowa zapora), `nmap` (skaner), `tcpdump` (do czytania logu zapory), `curl`, pełnym poleceniem `ip` i `busybox-extras` (mały serwer WWW). Tag jest przypięty do Alpine 3.20, więc uzyskasz te same wyniki co w poniższych wyjściach.
```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache nftables nmap curl iproute2 busybox-extras tcpdump
EOT
podman build -t lab-netsec-tools:1 .
podman run --rm lab-netsec-tools:1 sh -c 'nft --version; nmap --version | head -1; tcpdump --version 2>&1 | head -1; cat /etc/alpine-release'
```
Oczekiwane wyjście (koniec budowania, potem wersje; wersje pakietów mogą się nieznacznie różnić):
```text
OK: 47 MiB in 49 packages
COMMIT lab-netsec-tools:1
Successfully tagged localhost/lab-netsec-tools:1
nftables v1.0.9 (Old Doc Yak #3)
Nmap version 7.95 ( https://nmap.org )
tcpdump version 4.99.4
3.20.10
```
### Krok 3 — Utwórz trzy strefy (3 min)
Każda sieć Podmana to jedna strefa: mostek z własnym zakresem adresów. `--internal` oznacza, że Podman nie dodaje trasy do świata zewnętrznego ani NAT do hosta, więc nic w laboratorium nie może opuścić Twojego komputera i nic nie może przechodzić między strefami inaczej niż przez zaporę, którą zbudujesz. „Internet” używa zakresu dokumentacyjnego ([RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)); DMZ i strefa wewnętrzna używają zakresów prywatnych ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).
```bash
podman network create --internal --subnet 203.0.113.0/24 lab-netsec-internet
podman network create --internal --subnet 10.40.2.0/24 lab-netsec-dmz
podman network create --internal --subnet 10.40.3.0/24 lab-netsec-internal
podman network inspect lab-netsec-internet lab-netsec-dmz lab-netsec-internal \
--format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
```
Oczekiwane wyjście:
```text
lab-netsec-internet
lab-netsec-dmz
lab-netsec-internal
lab-netsec-internet subnet=203.0.113.0/24 internal=true
lab-netsec-dmz subnet=10.40.2.0/24 internal=true
lab-netsec-internal subnet=10.40.3.0/24 internal=true
```
### Krok 4 — Uruchom zaporę (4 min)
Kontener zapory ma po jednym interfejsie w każdej strefie, z ostatnim użytecznym adresem (`.254`) każdego zakresu. `interface_name` nadaje interfejsom czytelne nazwy: `net0`, `dmz0` i `int0`. `--cap-add NET_ADMIN` pozwala mu edytować własne reguły zapory, a `--sysctl net.ipv4.ip_forward=1` zamienia go w router. `sleep infinity` utrzymuje go przy życiu.
```bash
podman run -d --name lab-netsec-fw \
--network lab-netsec-internet:ip=203.0.113.254,interface_name=net0 \
--network lab-netsec-dmz:ip=10.40.2.254,interface_name=dmz0 \
--network lab-netsec-internal:ip=10.40.3.254,interface_name=int0 \
--cap-add NET_ADMIN --sysctl net.ipv4.ip_forward=1 \
lab-netsec-tools:1 sleep infinity
podman exec lab-netsec-fw ip -br addr
podman exec lab-netsec-fw sysctl net.ipv4.ip_forward
podman exec lab-netsec-fw nft list ruleset
```
Oczekiwane wyjście (identyfikator kontenera, kolejność interfejsów, numery `@if` i adresy `fe80::` są różne):
```text
0864d79130acc3d47b16a11b13019e9c56a6e87d68de7908d9aed6cf13f1fd69
lo UNKNOWN 127.0.0.1/8 ::1/128
int0@if4 UP 10.40.3.254/24 fe80::3813:93ff:fe04:a0c8/64
dmz0@if6 UP 10.40.2.254/24 fe80::58f6:56ff:fe7b:1dba/64
net0@if8 UP 203.0.113.254/24 fe80::6c81:b4ff:feb7:80d7/64
net.ipv4.ip_forward = 1
```
Ostatnie polecenie, `nft list ruleset`, **nic** nie wypisuje: zapora nie ma jeszcze żadnych reguł, więc przekazuje wszystko. Zapamiętaj to: to Twój punkt wyjścia.
### Krok 5 — Uruchom trzy hosty (6 min)
Każdy host dołącza do jednej strefy. Sieć wewnętrzna nie daje kontenerowi trasy domyślnej, więc każdy host dodaje trasę w stronę zapory: serwer WWW i baza danych używają jej jako bramy domyślnej, a klient kieruje do niej zakres `10.40.0.0/16`. `NET_ADMIN` jest potrzebne tylko do `ip route add`.
Serwer WWW uruchamia serwer WWW BusyBox `httpd` na TCP 80 i 8080 oraz nasłuch `nc` na TCP 22, który wypisuje fałszywy baner SSH. Baza danych uruchamia dwa nasłuchy `nc`: TCP 22 (ten sam baner) i TCP 5432, który odpowiada `lab-db ready`. Reprezentują usługi, które istnieją na prawdziwych maszynach i nie powinny być osiągalne zewsząd.
```bash
I=lab-netsec-tools:1
podman run -d --name lab-netsec-web --network lab-netsec-dmz:ip=10.40.2.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add default via 10.40.2.254; mkdir -p /www; echo "hello from the DMZ web server" > /www/index.html; httpd -p 80 -h /www; httpd -p 8080 -h /www; exec nc -lk -p 22 -e echo SSH-2.0-lab-fake'
podman run -d --name lab-netsec-db --network lab-netsec-internal:ip=10.40.3.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add default via 10.40.3.254; nc -lk -p 22 -e echo SSH-2.0-lab-fake & exec nc -lk -p 5432 -e echo lab-db ready'
podman run -d --name lab-netsec-client --network lab-netsec-internet:ip=203.0.113.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add 10.40.0.0/16 via 203.0.113.254; exec sleep infinity'
podman ps --filter name=lab-netsec --format 'table {{.Names}}\t{{.Status}}'
```
Oczekiwane wyjście (najpierw trzy identyfikatory kontenerów; czasy są różne):
```text
NAMES STATUS
lab-netsec-fw Up 3 seconds
lab-netsec-web Up 2 seconds
lab-netsec-db Up 2 seconds
lab-netsec-client Up 2 seconds
```
Sprawdź trasy i porty, na których nasłuchuje każdy serwer:
```bash
podman exec lab-netsec-client ip route
podman exec lab-netsec-web netstat -tln
podman exec lab-netsec-db netstat -tln
```
Oczekiwane wyjście:
```text
10.40.0.0/16 via 203.0.113.254 dev eth0
203.0.113.0/24 dev eth0 proto kernel scope link src 203.0.113.10
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 :::80 :::* LISTEN
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::8080 :::* LISTEN
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::5432 :::* LISTEN
```
Znasz teraz **prawdę**: serwer WWW nasłuchuje na 80, 8080 i 22; baza danych na 5432 i 22. W następnym kroku sprawdzisz, co widzi obca osoba.
### Krok 6 — Stan wyjściowy: wszystko jest otwarte i skan to pokazuje (10 min)
Przy włączonym przekazywaniu i braku reguł zapora przepuszcza wszystko. Przetestuj to z klienta zewnętrznego, a potem przeskanuj. Najpierw dwa zwykłe żądania:
```bash
podman exec lab-netsec-client curl -sS -m 3 http://10.40.2.10
podman exec lab-netsec-client nc -w 2 10.40.3.10 5432
podman exec lab-netsec-client nc -w 2 -z -v 10.40.3.10 22
```
Oczekiwane wyjście:
```text
hello from the DMZ web server
lab-db ready
10.40.3.10 (10.40.3.10:22) open
```
Klient w „Internecie” rozmawiał **bezpośrednio z bazą danych**. To płaska sieć z opowieści otwierającej lekcję. Teraz przeskanuj oba serwery z klienta:
```bash
podman exec lab-netsec-client nmap -n -Pn -sT --reason --max-retries 1 -T4 -p 1-1024,5432,8080 10.40.2.10 10.40.3.10
```
Co oznaczają opcje:
- `-n` pomija rozwiązywanie nazw; `-p 1-1024,5432,8080` skanuje dobrze znane porty oraz dwa dodatkowe.
- `-sT` to **skan connect** TCP: kończy uzgadnianie TCP zwykłym wywołaniem `connect()`. Nie wymaga specjalnych uprawnień, dlatego działa w kontenerze bez roota (szybszy skan SYN, `-sS`, wymaga surowych gniazd i tutaj zawodzi).
- `-Pn` pomija wykrywanie „czy host działa?”, które w tym kontenerze również wymagałoby surowych gniazd. Każda sonda jest traktowana jako sonda portu.
- `--reason` pokazuje, dlaczego każdy stan został ustalony; `--max-retries 1 -T4` przyspiesza skan na tyle, by pasował do laboratorium.
Oczekiwane wyjście (wartości opóźnień i data są różne):
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.2.10
Host is up, received user-set (0.00028s latency).
Not shown: 1023 closed tcp ports (conn-refused)
PORT STATE SERVICE REASON
22/tcp open ssh syn-ack
80/tcp open http syn-ack
8080/tcp open http-proxy syn-ack
Nmap scan report for 10.40.3.10
Host is up, received user-set (0.00030s latency).
Not shown: 1024 closed tcp ports (conn-refused)
PORT STATE SERVICE REASON
22/tcp open ssh syn-ack
5432/tcp open postgresql syn-ack
Nmap done: 2 IP addresses (2 hosts up) scanned in 0.08 seconds
```
Przeczytaj to. Klient zewnętrzny widzi **pięć otwartych portów na dwóch hostach**, w tym bazę danych, która nigdy nie powinna być osiągalna, oraz usługi „SSH” i 8080, których nikt nie zamierzał publikować. Pozostałe porty są `closed`: host odpowiedział na każdą sondę odmową (`conn-refused`), dlatego skan trwał 0,08 sekundy. Skan właśnie zbudował inwentarz powierzchni ataku. Zapisz otwarte porty: porównasz je z następnym skanem.
> [!NOTE]
> Nazwy usług (`ssh`, `postgresql`, `http-proxy`) są domysłami na podstawie numeru portu, a nie tego, co odpowiada. `nmap` przypisuje nazwy portom z tabeli. Fałszywe usługi z tego laboratorium nie oszukałyby skanu wersji, który wymaga plików skryptów `nmap`, niezawartych w tym małym obrazie.
### Krok 7 — Zastosuj politykę domyślnej odmowy (10 min)
Piszesz teraz politykę z przykładu praktycznego w lekcji. Umieść ją w pliku, a potem załaduj do zapory. Przeczytaj ją przed załadowaniem.
```bash
cat > fw.nft <<'EOT'
table inet lab_fw
delete table inet lab_fw
table inet lab_fw {
chain forward {
type filter hook forward priority 0; policy drop;
ct state invalid drop
ct state established,related counter accept comment "return traffic"
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter accept comment "internet to web: 80"
iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter accept comment "web to db: 5432"
limit rate 5/second burst 10 packets log group 1 prefix "lab-netsec DROP: "
counter drop comment "default deny"
}
}
EOT
podman exec -i lab-netsec-fw nft -f - < fw.nft
podman exec lab-netsec-fw nft list chain inet lab_fw forward
```
Co robi każda część:
- Pierwsze dwie linie czynią plik bezpiecznym do ponownego załadowania: tworzą tabelę, jeśli nie istnieje, a potem ją usuwają, więc każde ładowanie zaczyna się od czystej tabeli.
- `table inet` dotyczy IPv4 i IPv6. `chain forward` z `hook forward` filtruje ruch, który **przechodzi przez** zaporę; to ścieżka między strefami.
- `policy drop` to domyślna odmowa: pakiet, który nie pasuje do żadnego `accept`, jest odrzucany.
- `ct state invalid drop` odrzuca pakiety, które nie należą do żadnego prawidłowego połączenia.
- `ct state established,related ... accept` to część stanowa: **odpowiedzi** na dozwolone połączenia nie potrzebują własnej reguły. Stoi na początku, bo pasuje do większości pakietów.
- Dwie reguły `ct state new ... accept` to **jedyne** dozwolone nowe przepływy. Każda wymienia interfejsy, dokładny cel (a w drugiej regule także źródło) i port. Słowo kluczowe `counter` zlicza pakiety każdej reguły.
- `limit ... log group 1` zapisuje rekord odrzuconych pakietów do kanału **nflog** numer 1 w jądrze, najwyżej 5 na sekundę (po serii 10), aby skan nie mógł zalać logu. Reguły bez werdyktu, takie jak `log`, pozwalają pakietowi przejść do następnej reguły.
- Ostatnia reguła zlicza i odrzuca całą resztę (polityka też by odrzuciła, ale jawna reguła daje licznik).
`podman exec -i ... nft -f -` czyta plik ze standardowego wejścia, więc zostaje on na Twoim komputerze. Ładowanie niczego nie wypisuje. Oczekiwane wyjście polecenia `list` (wszystkie liczniki są na tym etapie zerowe):
```text
table inet lab_fw {
chain forward {
type filter hook forward priority filter; policy drop;
ct state invalid drop
ct state established,related counter packets 0 bytes 0 accept comment "return traffic"
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter packets 0 bytes 0 accept comment "internet to web: 80"
iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter packets 0 bytes 0 accept comment "web to db: 5432"
limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1
counter packets 0 bytes 0 drop comment "default deny"
}
}
```
> [!NOTE]
> Zwykła reguła `log` (bez `group`) zapisuje do logu jądra, który czyta się przez `dmesg` lub `journalctl -k`. W kontenerze ten log jest niedostępny: w tym teście `dmesg` w kontenerze zawiódł z komunikatem „Operation not permitted”, a domyślnie jądro loguje tylko z przestrzeni nazw sieci samego hosta. Kanał `nflog` działa bez specjalnych uprawnień i `tcpdump` potrafi go czytać, dlatego laboratorium z niego korzysta. Jeśli Twoja konfiguracja jest inna, liczniki z Kroku 9 nadal dowodzą, co zostało odrzucone.
### Krok 8 — Skanuj ponownie i porównaj (8 min)
Powtórz **dokładnie** ten sam skan, a potem wypróbuj dwa dozwolone przepływy:
```bash
podman exec lab-netsec-client nmap -n -Pn -sT --reason --max-retries 1 -T4 -p 1-1024,5432,8080 10.40.2.10 10.40.3.10
podman exec lab-netsec-client curl -sS -m 3 http://10.40.2.10
podman exec lab-netsec-web nc -w 2 10.40.3.10 5432
```
Oczekiwane wyjście (skan trwa teraz kilka sekund: odrzucone sondy nie dostają odpowiedzi, więc `nmap` na nie czeka. Czasy są różne):
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.2.10
Host is up, received user-set (0.00020s latency).
Not shown: 1025 filtered tcp ports (no-response)
PORT STATE SERVICE REASON
80/tcp open http syn-ack
Nmap scan report for 10.40.3.10
Host is up, received user-set.
All 1026 scanned ports on 10.40.3.10 are in ignored states.
Not shown: 1026 filtered tcp ports (no-response)
Nmap done: 2 IP addresses (2 hosts up) scanned in 7.14 seconds
hello from the DMZ web server
lab-db ready
```
Porównaj z Krokiem 6:
| | Przed (wszystko otwarte) | Po (domyślna odmowa) |
|---|---|---|
| Serwer WWW, port 80 | `open` | `open` (dozwolony) |
| Serwer WWW, porty 22 i 8080 | `open` | `filtered` |
| Baza danych, porty 22 i 5432 | `open` | `filtered` |
| Pozostałe porty | `closed` (odmowa) | `filtered` (brak odpowiedzi) |
| Czas skanu | 0,08 s | kilka sekund |
Powierzchnia ataku widoczna z zewnątrz zmniejszyła się z pięciu otwartych portów do jednego. Zauważ też **zmianę słowa**: `closed` oznacza „host odmówił”, `filtered` oznacza „nic nie wróciło”, czyli tak wygląda **odrzucenie** (drop). Baza danych nie jest już nawet widocznym celem: wszystkie 1026 portów jest filtrowanych. Serwer WWW nadal obsługuje port 80, a drugi dozwolony przepływ działa: serwer WWW dotarł do bazy danych.
> [!NOTE]
> Linia „Host is up, received user-set” to `nmap` powtarzający to, co mu polecono (`-Pn`): przyjmij, że host działa. Nie dowodzi, że host odpowiedział. Bez `-Pn` `nmap` najpierw próbowałby wykrywania hostów: w tym kontenerze kończy się to komunikatem „Couldn't open a raw socket”, a wobec prawdziwej zapory, która odrzuca pingi, błędnie zgłosiłby „Host seems down”.
Teraz spójrz na politykę z **DMZ**, gdzie stałby atakujący, który przejął serwer WWW. Przeskanuj bazę danych i klienta „Internetu” z serwera WWW:
```bash
podman exec lab-netsec-web nmap -n -Pn -sT --max-retries 1 -T4 -p 22,80,443,5432,8080 10.40.3.10 203.0.113.10
```
Oczekiwane wyjście:
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.3.10
Host is up (0.000095s latency).
PORT STATE SERVICE
22/tcp filtered ssh
80/tcp filtered http
443/tcp filtered https
5432/tcp open postgresql
8080/tcp filtered http-proxy
Nmap scan report for 203.0.113.10
Host is up.
PORT STATE SERVICE
22/tcp filtered ssh
80/tcp filtered http
443/tcp filtered https
5432/tcp filtered postgresql
8080/tcp filtered http-proxy
Nmap done: 2 IP addresses (2 hosts up) scanned in 1.23 seconds
```
Z DMZ baza danych pokazuje **jeden** otwarty port (5432, dozwolony przepływ), a klient „Internetu” żadnego: serwer WWW nie może otwierać połączeń na zewnątrz (**filtrowanie ruchu wychodzącego**). Jeśli serwer WWW zostanie przejęty, atakujący może rozmawiać z portem bazy danych i z niczym więcej. Skanowanie z każdej strefy to sposób testowania reguł wewnętrznych, których skan z obwodu nie widzi.
### Krok 9 — Przeczytaj log i liczniki (12 min)
Skany i testy nie dowodzą, że pakiety zostały zablokowane **przez Twoje reguły**. Dowodzą tego liczniki i log. Najpierw wyzeruj liczniki, aby poniższe liczby pochodziły tylko z tego kroku. Potem uruchom w tle przechwytywanie na kanale nflog zapory, zapisujące do pliku wewnątrz kontenera zapory. Zatrzymuje się samo po 60 sekundach.
```bash
podman exec lab-netsec-fw nft reset rules chain inet lab_fw forward > /dev/null
podman exec -d lab-netsec-fw sh -c 'timeout 60 tcpdump -n -l -q -i nflog:1 > /tmp/drops.log 2>&1'
sleep 1
```
`nflog:1` to interfejs przechwytywania dla grupy logowania 1, czyli `group 1` z reguły. `-n` pomija wyszukiwanie nazw, a `-q` wypisuje krótką linię na pakiet. Teraz wypróbuj pięć przepływów, które **nie** mogą działać. Każde `nc -z` sprawdza tylko, czy połączenie się otwiera; `-w 2` poddaje się po 2 sekundach.
```bash
podman exec lab-netsec-client nc -w 2 -z -v 10.40.3.10 5432; echo rc=$?
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 22; echo rc=$?
podman exec lab-netsec-web nc -w 2 -z -v 10.40.3.10 22; echo rc=$?
podman exec lab-netsec-db nc -w 2 -z -v 10.40.2.10 80; echo rc=$?
podman exec lab-netsec-web nc -w 2 -z -v 203.0.113.10 80; echo rc=$?
```
Pięć testów to: Internet do **bazy danych** (5432), Internet do portu **SSH** serwera WWW, serwer WWW do portu **SSH** bazy danych, baza danych do serwera WWW (połączenie zainicjowane od wewnątrz) oraz serwer WWW do „Internetu” (ruch wychodzący). Oczekiwane wyjście (przekroczenia czasu trwają około 2 sekundy każde, pięć razy):
```text
nc: 10.40.3.10 (10.40.3.10:5432): Operation timed out
rc=1
nc: 10.40.2.10 (10.40.2.10:22): Operation timed out
rc=1
nc: 10.40.3.10 (10.40.3.10:22): Operation timed out
rc=1
nc: 10.40.2.10 (10.40.2.10:80): Operation timed out
rc=1
nc: 203.0.113.10 (203.0.113.10:80): Operation timed out
rc=1
```
Wszystkie pięć kończy się **przekroczeniem czasu** (nie ma odmowy): zapora odrzuca pakiet i nic nie mówi. Teraz przeczytaj log odrzuceń i liczniki:
```bash
sleep 3
podman exec lab-netsec-fw cat /tmp/drops.log
podman exec lab-netsec-fw nft list chain inet lab_fw forward | tail -6
```
Oczekiwane wyjście (znaczniki czasu i porty źródłowe są różne):
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on nflog:1, link-type NFLOG (Linux netfilter log messages), snapshot length 262144 bytes
19:38:34.206451 IP 203.0.113.10.45915 > 10.40.3.10.5432: tcp 0
19:38:35.231427 IP 203.0.113.10.45915 > 10.40.3.10.5432: tcp 0
19:38:36.254469 IP 203.0.113.10.34173 > 10.40.2.10.22: tcp 0
19:38:37.278435 IP 203.0.113.10.34173 > 10.40.2.10.22: tcp 0
19:38:38.366492 IP 10.40.2.10.35221 > 10.40.3.10.22: tcp 0
19:38:39.391417 IP 10.40.2.10.35221 > 10.40.3.10.22: tcp 0
19:38:40.414413 IP 10.40.3.10.41825 > 10.40.2.10.80: tcp 0
19:38:41.438422 IP 10.40.3.10.41825 > 10.40.2.10.80: tcp 0
19:38:42.526436 IP 10.40.2.10.33531 > 203.0.113.10.80: tcp 0
19:38:43.550426 IP 10.40.2.10.33531 > 203.0.113.10.80: tcp 0
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter packets 0 bytes 0 accept comment "internet to web: 80"
iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter packets 0 bytes 0 accept comment "web to db: 5432"
limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1
counter packets 10 bytes 600 drop comment "default deny"
}
}
```
Przeczytaj dowody:
- Log ma **dziesięć linii pakietów, w pięciu parach** (`tcpdump` wypisuje podsumowanie „packets captured” dopiero po zakończeniu przechwytywania, czyli po 60 sekundach). Każda para to jedna zablokowana próba połączenia: TCP SYN (pierwszy pakiet połączenia, `tcp 0` oznacza brak danych) wysłany dwa razy, bo nadawca ponowił próbę po około sekundzie. Pary odpowiadają Twoim pięciu testom, od źródła do celu i portu.
- Licznik `default deny` pokazuje **10 pakietów, 600 bajtów**: te same dziesięć pakietów (po 60 bajtów każdy). Dwie reguły `accept` dla nowych połączeń pokazują **0**, więc żaden z zablokowanych przepływów nie prześlizgnął się przez regułę zezwalającą przez pomyłkę.
- Ponieważ log i licznik się zgadzają, wiadomo, że każde zablokowanie wynikało z domyślnej odmowy, a nie z literówki ani brakującej trasy.
Liczby mogą się różnić o kilka pakietów, jeśli Twoje przekroczenia czasu lub ponowienia są inne, ale log i licznik muszą się ze sobą zgadzać.
> [!NOTE]
> `tcpdump` nie wypisuje tu tekstu `prefix` reguły logującej. W konfiguracji produkcyjnej demon logów, taki jak `ulogd`, zapisuje rekordy nflog, razem z prefiksem, do pliku albo na serwer logów. Czytanie ich przez `tcpdump` wystarcza w laboratorium.
### Krok 10 — Kolejność reguł: gdzie trafia nowa reguła (8 min)
Załóżmy, że zespół WWW prosi o opublikowanie także usługi na porcie 8080. Dodajesz regułę w oczywisty sposób, przez `nft add rule`, które **dopisuje** regułę na końcu łańcucha.
```bash
podman exec lab-netsec-fw nft add rule inet lab_fw forward iifname net0 oifname dmz0 ip daddr 10.40.2.10 tcp dport 8080 ct state new counter accept comment '"internet to web: 8080 (added)"'
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 8080; echo rc=$?
podman exec lab-netsec-fw nft -a list chain inet lab_fw forward | tail -5
```
Oczekiwane wyjście:
```text
nc: 10.40.2.10 (10.40.2.10:8080): Operation timed out
rc=1
limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1 # handle 6
counter packets 12 bytes 720 drop comment "default deny" # handle 7
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 8080 ct state new counter packets 0 bytes 0 accept comment "internet to web: 8080 (added)" # handle 8
}
}
```
Reguła istnieje, a port **nadal się nie otwiera**. Nowa reguła (handle 8) stoi **po** `drop` (handle 7), więc pakiet jest odrzucany, zanim zdąży do niej pasować, a licznik nowej reguły pozostaje na 0. Opcja `-a` pokazuje **uchwyt** (handle) każdej reguły, jej stały numer. Usuń bezużyteczną regułę i wstaw nową **przed** regułą logującą, na pozycji uchwytu 6:
```bash
podman exec lab-netsec-fw nft delete rule inet lab_fw forward handle 8
podman exec lab-netsec-fw nft insert rule inet lab_fw forward position 6 iifname net0 oifname dmz0 ip daddr 10.40.2.10 tcp dport 8080 ct state new counter accept comment '"internet to web: 8080 (inserted)"'
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 8080; echo rc=$?
podman exec lab-netsec-fw nft list chain inet lab_fw forward | grep 8080
```
Oczekiwane wyjście (wpisane numery uchwytów muszą odpowiadać Twojemu własnemu wydrukowi `nft -a`):
```text
10.40.2.10 (10.40.2.10:8080) open
rc=0
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 8080 ct state new counter packets 1 bytes 60 accept comment "internet to web: 8080 (inserted)"
```
Teraz port jest otwarty, a licznik reguły pokazuje jedno połączenie. To dokładnie ta ekspozycja, którą usuwała polityka domyślnej odmowy, więc to dobry moment, aby ją cofnąć: załaduj ponownie oryginalną politykę, która usuwa i odtwarza całą tabelę.
```bash
podman exec -i lab-netsec-fw nft -f - < fw.nft
```
Ładowanie niczego nie wypisuje, a tabela wraca do pięciu reguł z Kroku 7.
> [!TIP]
> W prawdziwym życiu trzymaj plik z regułami w systemie kontroli wersji i **ładuj ponownie plik**, zamiast wpisywać pojedyncze reguły. Wtedy plik jest zawsze źródłem prawdy, osoba przeglądająca może przeczytać zmianę i nie da się zostawić w zaporze zapomnianej reguły testowej.
## Weryfikacja
Polityka jest poprawna, gdy każdy test pozytywny przechodzi, a każdy test negatywny jest zablokowany. Zapisz kontrole w skrypcie. `t` uruchamia jeden test: używa `nc` z kontenera do celu i portu i porównuje wynik z oczekiwanym.
```bash
cat > check.sh <<'EOT'
#!/bin/sh
# usage: ./check.sh (run from ~/netsec-lab); prints PASS or FAIL for every flow in the policy
pass=0; fail=0
t() { # t <expected: open|blocked> <from-container> <dst-ip> <port>
if podman exec "lab-netsec-$2" nc -w 2 -z "$3" "$4" >/dev/null 2>&1; then got=open; else got=blocked; fi
if [ "$got" = "$1" ]; then r=PASS; pass=$((pass+1)); else r=FAIL; fail=$((fail+1)); fi
printf '%s %-7s -> %-12s :%-5s expected %-7s got %s\n' "$r" "$2" "$3" "$4" "$1" "$got"
}
t open client 10.40.2.10 80
t blocked client 10.40.2.10 22
t blocked client 10.40.2.10 8080
t blocked client 10.40.3.10 5432
t blocked client 10.40.3.10 22
t open web 10.40.3.10 5432
t blocked web 10.40.3.10 22
t blocked web 203.0.113.10 80
t blocked db 10.40.2.10 80
echo "passed=$pass failed=$fail"
[ "$fail" -eq 0 ]
EOT
chmod +x check.sh
./check.sh; echo rc=$?
```
Oczekiwane wyjście (uruchomienie trwa około 15 sekund, bo każdy test zablokowany czeka 2 sekundy):
```text
PASS client -> 10.40.2.10 :80 expected open got open
PASS client -> 10.40.2.10 :22 expected blocked got blocked
PASS client -> 10.40.2.10 :8080 expected blocked got blocked
PASS client -> 10.40.3.10 :5432 expected blocked got blocked
PASS client -> 10.40.3.10 :22 expected blocked got blocked
PASS web -> 10.40.3.10 :5432 expected open got open
PASS web -> 10.40.3.10 :22 expected blocked got blocked
PASS web -> 203.0.113.10 :80 expected blocked got blocked
PASS db -> 10.40.2.10 :80 expected blocked got blocked
passed=9 failed=0
rc=0
```
Kryteria zaliczenia:
- Wszystkie dziewięć linii mówi `PASS`, a skrypt kończy się z `rc=0`. Dwie linie `open` to Twoje dwa dozwolone przepływy; siedem linii `blocked` to testy negatywne.
- `podman exec lab-netsec-fw nft list chain inet lab_fw forward` pokazuje tylko pięć reguł z Kroku 7 (bez reguły 8080), z niezerowymi licznikami na dwóch regułach accept i na regule drop.
- Skan z klienta (Krok 8) pokazuje tylko port 80 otwarty na `10.40.2.10` i nic otwartego na `10.40.3.10`.
> [!NOTE]
> Ten skrypt traktuje „połączenie się nie udało” jako „zablokowane”. Odmowa i przekroczenie czasu liczą się tak samo. W tym laboratorium to wystarcza, bo testowane usługi nasłuchują, więc niepowodzenie oznacza, że zapora odrzuciła pakiet. W prawdziwej sieci pamiętaj o różnicy: odmowa oznacza, że pakiet dotarł, przekroczenie czasu oznacza, że coś go odrzuciło.
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `nmap` wypisuje „Couldn't open a raw socket” | Użyto `-sS` albo pominięto `-Pn`: oba wymagają surowych gniazd, których kontener bez roota nie ma | Użyj `-sT -Pn`, jak w laboratorium |
| Wszystko kończy się przekroczeniem czasu z klienta, nawet port 80, zanim załadujesz jakąkolwiek regułę | Brakuje trasy: klient potrzebuje `10.40.0.0/16 via 203.0.113.254`, serwery potrzebują trasy domyślnej | Porównaj `podman exec lab-netsec-client ip route` z Krokiem 5. Utwórz ponownie kontener, w którym brakuje trasy |
| Port 80 jest zablokowany po załadowaniu polityki | Nazwy interfejsów lub adresy w regule nie pasują albo plik został zmieniony | `nft list chain inet lab_fw forward`: jeśli licznik `internet to web` wynosi 0, a licznik drop rośnie, reguła nie pasuje. Sprawdź `net0`, `dmz0` i `10.40.2.10` |
| Log odrzuceń (`/tmp/drops.log`) jest pusty, ale licznik drop rośnie | Przechwytywanie nie działało podczas testu, brakuje reguły logującej albo grupa logowania jest inna | Najpierw uruchom przechwytywanie (Krok 9) i testuj w ciągu jego 60 sekund. Sprawdź, czy reguła mówi `group 1` |
| `Error: No such file or directory` przy ładowaniu reguł | Binarka `nft` nie może utworzyć tabeli: kontenerowi brakuje `NET_ADMIN` albo w pliku jest literówka | Sprawdź `--cap-add NET_ADMIN` w `podman run` z Kroku 4. Przeczytaj numer linii wypisany razem z błędem |
| `the container name "lab-netsec-fw" is already in use` | Pozostał kontener z poprzedniej próby | Wykonaj [Sprzątanie](#sprzątanie), a potem zacznij od nowa |
| Nowa reguła nie otwiera portu | Reguła została dopisana po końcowym odrzuceniu | Wypisz przez `nft -a`, usuń po uchwycie i `insert ... position <handle>` przed regułą logującą (Krok 10) |
## Wyzwanie (opcjonalne)
Rozszerz politykę bez pomocy krok po kroku:
1. Serwer WWW musi pobierać aktualizacje. Uruchom mały serwer WWW w kontenerze klienta na TCP 8000 (`httpd -p 8000` z wybranym przez Ciebie folderem) i napisz **najwęższą** regułę, która pozwala `lab-netsec-web` (i tylko jemu) otwierać połączenia do `203.0.113.10` na TCP 8000. Udowodnij za pomocą `./check.sh` (dodaj test) i skanu, że nic innego nie zostało otwarte.
2. Dodaj czwarty host w strefie wewnętrznej, `lab-netsec-admin` pod adresem `10.40.3.20`, który może otwierać połączenia do serwera WWW na TCP 22, a nikt inny nie może. Gdzie umieszczasz regułę i który test dowodzi, że baza danych nie może zrobić tego samego?
3. Zamień regułę wystawioną na Internet na **reject** zamiast drop (`reject with tcp reset`) dla jednego portu i porównaj, jak skan raportuje to w zestawieniu z `filtered`.
## Sprzątanie
Usuń wszystkie kontenery, sieci i obraz utworzone przez to laboratorium, a potem folder. `-t 0` pomija 10-sekundowe oczekiwanie na kontenery, które ignorują sygnał zatrzymania.
```bash
podman rm -f -t 0 lab-netsec-client lab-netsec-web lab-netsec-db lab-netsec-fw
podman network rm lab-netsec-internet lab-netsec-dmz lab-netsec-internal
podman rmi lab-netsec-tools:1
cd ~ && rm -rf ~/netsec-lab
podman ps -a --filter name=lab-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
```
Dwa ostatnie polecenia nic nie wypisują, gdy sprzątanie jest zakończone. Bazowy obraz Alpine pozostaje w magazynie Podmana (około 8 MB); usuń go przez `podman rmi docker.io/library/alpine:3.20.10`, jeśli żadne inne laboratorium go nie potrzebuje.
## Co już umiesz
- Skanowanie z zewnątrz pokazuje prawdziwą powierzchnię ataku; skanowanie z każdej strefy testuje także reguły wewnętrzne.
- Stanowy zestaw reguł domyślnej odmowy potrzebuje reguł tylko dla przepływów, których chcesz: tutaj wystarczyły dwie reguły nowych połączeń i jedna reguła `established`.
- `closed` oznacza odmowę, a `filtered` odrzucenie: odrzucenia zapory wyglądają jak cisza.
- Filtrowanie ruchu wychodzącego i ograniczanie skutków w DMZ sprawiają, że przejęty serwer WWW może dotrzeć do jednego portu bazy danych i do niczego więcej.
- Liczniki reguł i log odrzuceń muszą się zgadzać; razem dowodzą, że przepływ został zablokowany przez Twoją politykę.
- Kolejność reguł ma znaczenie: reguła po końcowym odrzuceniu nigdy nie pasuje. Trzymaj reguły w pliku i ładuj ponownie plik.