Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.
## Cel
Przechwytujesz własne zapytanie systemu nazw domen (DNS, Domain Name System) i własne żądanie protokołu przesyłania hipertekstu (HTTP, Hypertext Transfer Protocol), a potem rozkładasz każdy pakiet na części, warstwa po warstwie. Na koniec potrafisz wskazać w prawdziwym zrzucie ruchu nagłówki Ethernet, protokołu internetowego (IP, Internet Protocol), protokołu kontroli transmisji (TCP, Transmission Control Protocol) i HTTP oraz powiedzieć, do której warstwy modelu połączonych systemów otwartych (OSI, Open Systems Interconnection) należy każdy z nich.
## Cele
- Przechwycić własny ruch za pomocą Wiresharka lub, alternatywnie, `tcpdump`.
- Rozpoznać w przechwyconej ramce nagłówki Ethernet, IP, protokołu datagramów użytkownika (UDP, User Datagram Protocol) lub TCP oraz nagłówki aplikacji.
- Przypisać każde widoczne pole nagłówka do jego warstwy OSI i jednostki danych protokołu (PDU, protocol data unit).
- Opisać enkapsulację i dekapsulację na prawdziwych danych, w tym pola służące do demultipleksacji (EtherType, Protocol w IP, port).
- Znaleźć maksymalny rozmiar segmentu TCP (MSS, maximum segment size) w segmencie SYN i wyjaśnić, dlaczego w standardowym Ethernecie wynosi 1460 bajtów.
## Wymagania wstępne
- Komputer, który jest twój lub który administrujesz, z systemem Linux, macOS albo Windows 10/11, połączony przez Ethernet lub Wi-Fi.
- **Wireshark 4.0 lub nowszy** ([wireshark.org](https://www.wireshark.org/)). W systemie Windows instalator instaluje też Npcap, czyli sterownik przechwytywania.
- Alternatywa dla Linuksa i macOS: **tcpdump 4.99 lub nowszy** (sprawdź poleceniem `tcpdump --version`). macOS ma go w systemie.
- **curl 7.68 lub nowszy**. W systemie Windows 10/11 `curl.exe` jest wbudowany.
- Narzędzie do zapytań DNS: `dig` (BIND 9) w Linuksie i macOS albo `nslookup` w systemie Windows.
- Uprawnienia do przechwytywania pakietów: prawa administratora albo członkostwo w grupie `wireshark` w Linuksie (Krok 2).
- Lekcja: [Model OSI: jak komunikują się sieci](lesson.pl.md), zwłaszcza przykład praktyczny.
> [!WARNING]
> **Zgoda i etyka.** Przechwytuj wyłącznie ruch na własnym komputerze i w sieci, która jest twoja lub którą wyraźnie wolno ci monitorować. Przechwytywanie cudzego ruchu bez zgody może być przestępstwem i naruszać regulaminy w pracy czy w szkole, nawet we współdzielonej sieci Wi-Fi. W sieci firmowej lub szkolnej najpierw sprawdź regulamin dopuszczalnego użytkowania albo wykonaj laboratorium w domu. Pliki z przechwyconym ruchem mogą zawierać prywatne dane (na przykład nazwy DNS, o które pytają inne aplikacje). Nie udostępniaj ich i usuń je w sekcji Sprzątanie.
>
> **Koszt:** bezpłatnie. Używasz tylko narzędzi open source i wysyłasz kilka kilobajtów ruchu.
## Architektura
<figure class="diagram" style="--dg-w: 900px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 900 420" width="900" height="420" role="img" aria-labelledby="osi-lab-architecture-pl-title osi-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="osi-lab-architecture-pl-title">Architektura laboratorium: co i gdzie przechwytujesz</title>
<desc id="osi-lab-architecture-pl-desc">Twój komputer, 192.0.2.10, uruchamia dig i curl w warstwie 7. Ich żądania schodzą przez stos sieciowy systemu operacyjnego (warstwa 4 TCP lub UDP, warstwa 3 IP, warstwa 2 Ethernet) do interfejsu sieciowego, który jest punktem przechwytywania dla Wiresharka i tcpdump. Stamtąd ramki trafiają do routera, bramy domyślnej 192.0.2.1, który przekazuje je do resolvera DNS 198.51.100.53 na port UDP 53 i do serwera WWW example.com 203.0.113.80 na port TCP 80.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="899" height="419" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<rect class="dg-panel" x="24" y="24" width="384" height="372" rx="14" fill="#f0f0ec"/>
<g class="dg-icon-neutral" transform="translate(44 40) scale(1.2500)" fill="none" stroke="#17171c" 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>
<text x="86" y="56" font-size="16" class="dg-text" fill="#17171c" font-weight="700">Twój komputer</text>
<text x="86" y="76" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.10</text>
<g class="dg-l7"><rect class="dg-tint" x="42" y="100" width="348" height="64" rx="12" fill="#f3eefc" stroke="#c5a9f0" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 118) scale(1.1667)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect x="2" y="4" width="20" height="16" rx="2"/><path d="M2 9h20"/><path d="M6 6.5h.01"/><path d="M9 6.5h.01"/></g>
<text x="98" y="128" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">Aplikacje</text>
<text x="98" y="148" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dig · curl</text>
</g>
<g class="dg-l7"><rect class="dg-solid" x="328" y="118" width="46" height="28" rx="14" fill="#6d28d9"/><text x="351.0" y="137" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L7</text></g>
<path class="dg-line" d="M216.0 168V186M210.0 175l6-7 6 7M210.0 179l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<rect class="dg-card" x="42" y="190" width="348" height="92" rx="12" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-icon-neutral" transform="translate(58 204) scale(1.0833)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="16" height="16" x="4" y="4" rx="2"/><rect width="6" height="6" x="9" y="9" rx="1"/><path d="M15 2v2"/><path d="M15 20v2"/><path d="M2 15h2"/><path d="M2 9h2"/><path d="M20 15h2"/><path d="M20 9h2"/><path d="M9 2v2"/><path d="M9 20v2"/></g>
<text x="96" y="222" font-size="14.5" class="dg-text" fill="#17171c" font-weight="700">Stos sieciowy systemu operacyjnego</text>
<g class="dg-l4"><rect class="dg-solid" x="52" y="240" width="104" height="28" rx="14" fill="#c2410c"/><text x="104.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L4 · TCP/UDP</text></g>
<g class="dg-l3"><rect class="dg-solid" x="164" y="240" width="104" height="28" rx="14" fill="#b45309"/><text x="216.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L3 · IP</text></g>
<g class="dg-l2"><rect class="dg-solid" x="276" y="240" width="104" height="28" rx="14" fill="#15803d"/><text x="328.0" y="259" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">L2 · Ethernet</text></g>
<path class="dg-line" d="M216.0 286V304M210.0 293l6-7 6 7M210.0 297l6 7 6-7" stroke="#cfcfc8" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<g class="dg-l1"><rect class="dg-tint" x="42" y="308" width="348" height="70" rx="12" fill="#ebf3f7" stroke="#9ac3d9" stroke-width="1.2"/>
<g class="dg-icon" transform="translate(58 318) scale(1.0833)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="m15 20 3-3h2a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2H4a2 2 0 0 0-2 2v9a2 2 0 0 0 2 2h2l3 3z"/><path d="M6 8v1"/><path d="M10 8v1"/><path d="M14 8v1"/><path d="M18 8v1"/></g>
<text x="96" y="336" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Interfejs sieciowy</text>
</g>
<g class="dg-l6"><rect class="dg-solid" x="56" y="346" width="320" height="24" rx="12" fill="#a21caf"/>
<g class="dg-icon-on" transform="translate(66 350) scale(0.6667)" fill="none" stroke="#ffffff" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"/><path d="m21 21-4.3-4.3"/></g>
<text x="88" y="362.5" font-size="12" class="dg-on" fill="#ffffff" font-weight="600">Punkt przechwytywania: Wireshark · tcpdump</text>
</g>
<rect class="dg-card" x="436" y="168" width="186" height="68" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(452 184) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6.01 18H6"/><path d="M10.01 18H10"/><path d="M15 10v4"/><path d="M17.84 7.17a4 4 0 0 0-5.66 0"/><path d="M20.66 4.34a8 8 0 0 0-11.31 0"/></g>
<text x="492" y="198" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Router</text>
<text x="492" y="217" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">Brama domyślna</text>
<text x="529.0" y="258" font-size="13" class="dg-text" fill="#17171c" font-weight="500" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">192.0.2.1</text>
<rect class="dg-card" x="664" y="60" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 76) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><path d="M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20"/><path d="M2 12h20"/></g>
<text x="720" y="90" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Resolver DNS</text>
<text x="720" y="109" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500"></text>
<text x="680" y="140" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">198.51.100.53</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="124" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="143" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">UDP 53</text></g>
<rect class="dg-card" x="664" y="262" width="212" height="100" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(680 278) scale(1.2500)" fill="none" stroke="#17171c" 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>
<text x="720" y="292" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Serwer WWW</text>
<text x="720" y="311" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500">example.com</text>
<text x="680" y="342" font-size="13" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">203.0.113.80</text>
<g class="dg-l4"><rect class="dg-solid" x="790" y="326" width="70" height="28" rx="14" fill="#c2410c"/><text x="825.0" y="345" font-size="12.5" class="dg-on" fill="#ffffff" font-weight="700" text-anchor="middle">TCP 80</text></g>
<path class="dg-line" d="M390 343H422V202.0H436" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M622 202.0H643V110.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M643 202.0V312.0H664" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M427 196.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 104.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<path class="dg-line" d="M655 306.0l7 6-7 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
<circle class="dg-solid dg-l6" cx="390" cy="343" r="5" fill="#a21caf"/>
</svg></figure>
*Rysunek 1. Co przechwytujesz i gdzie. Punktem przechwytywania jest twój własny interfejs sieciowy, więc widzisz wszystkie nagłówki, które twój komputer wysyła i odbiera.*
Wireshark i `tcpdump` kopiują każdą ramkę, gdy przechodzi przez twój interfejs sieciowy. Widzisz pełną ramkę ze wszystkimi nagłówkami, dokładnie tak, jak twój komputer ją wysyła lub odbiera.
> [!NOTE]
> Adresy w tym laboratorium to wartości dokumentacyjne, te same, których używa lekcja: adresy IP z RFC 5737 oraz adresy kontroli dostępu do nośnika (MAC, Media Access Control) z bloku dokumentacyjnego RFC 7042 (`00:00:5e:00:53:xx`). **Twoje prawdziwe wartości będą inne.** Twój komputer ma prawdopodobnie adres prywatny, taki jak `192.168.1.x`, a `example.com` rozwiązuje się na prawdziwe adresy publiczne. Zapisuj własne wartości na bieżąco.
## Kroki
### Krok 1 — Znajdź interfejs, adresy i MTU
Zanim zaczniesz przechwytywać, musisz wiedzieć, który interfejs przenosi twój ruch. Potrzebujesz też własnych adresów IP i MAC oraz adresu bramy, żeby rozpoznać je w zrzucie. Maksymalna jednostka transmisji (MTU, maximum transmission unit) pozwala przewidzieć MSS, zanim go zobaczysz.
W Linuksie:
```bash
ip -4 route show default
ip link show <interface>
resolvectl dns
```
`<interface>` to nazwa po `dev` w wyniku pierwszego polecenia (na przykład `enp3s0` lub `wlp2s0`). Jeśli `resolvectl` jest niedostępny, uruchom zamiast niego `cat /etc/resolv.conf`.
Oczekiwany wynik:
```text
default via 192.0.2.1 dev enp3s0 proto dhcp src 192.0.2.10 metric 100
2: enp3s0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP mode DEFAULT group default qlen 1000
link/ether 00:00:5e:00:53:10 brd ff:ff:ff:ff:ff:ff
Global:
Link 2 (enp3s0): 198.51.100.53
```
W macOS i Windows użyj zamiast tego poniższych poleceń:
| Informacja | macOS | Windows (Wiersz polecenia) |
|---|---|---|
| Interfejs i brama | `route -n get default` (linie `gateway:` i `interface:`) | `ipconfig /all` (`Default Gateway`) |
| Twój adres MAC i MTU | `ifconfig <interface>` (linie `ether` i `mtu`) | `ipconfig /all` (`Physical Address`); `netsh interface ipv4 show subinterfaces` (MTU) |
| Serwer DNS | `scutil --dns \| grep nameserver` | `ipconfig /all` (`DNS Servers`) |
Zapisz: nazwę interfejsu, swój adres IPv4, swój adres MAC, adres IP bramy, adres jednego serwera DNS IPv4 i MTU. Przy MTU równym 1500 lekcja przewiduje MSS równe 1500 − 20 (IPv4) − 20 (TCP) = 1460 bajtów.
> [!NOTE]
> Windows pokazuje adresy MAC z myślnikami (`00-00-5E-00-53-10`). Wireshark pokazuje ten sam adres z dwukropkami.
### Krok 2 — Przygotuj folder i uprawnienia do przechwytywania
Przechwytywanie pakietów wymaga specjalnych uprawnień, bo zrzut może zawierać cały ruch na interfejsie. Nadaj sobie tylko te uprawnienia, których potrzebujesz, i trzymaj pliki laboratorium w jednym folderze, żeby łatwo było posprzątać.
```bash
mkdir -p ~/osi-lab
cd ~/osi-lab
```
Oczekiwany wynik: brak. Polecenia kończą się po cichu.
Następnie skonfiguruj uprawnienia do przechwytywania dla swojego systemu:
- **Linux, Wireshark:** jeśli Wireshark nie wyświetla żadnych interfejsów albo mówi, że nie masz uprawnień, dodaj siebie do grupy `wireshark` (w Debianie i Ubuntu najpierw uruchom `sudo dpkg-reconfigure wireshark-common` i odpowiedz **Yes**). Potem wyloguj się i zaloguj ponownie.
```bash
sudo usermod -aG wireshark "$USER"
```
Zapamiętaj, że to zrobiłeś: Sprzątanie to cofa.
- **Linux i macOS, tcpdump:** `tcpdump` uruchamiasz z `sudo` w Kroku 3. Żadna konfiguracja nie jest potrzebna.
- **macOS, Wireshark:** zaakceptuj komponent **ChmodBPF**, gdy instalator go zaproponuje.
- **Windows, Wireshark:** upewnij się, że Npcap został zainstalowany razem z Wiresharkiem.
> [!TIP]
> Nigdy nie uruchamiaj całej graficznej aplikacji Wireshark jako root ani administrator. Wireshark zawiera dużo kodu do analizy protokołów, a uruchomienie go z pełnymi uprawnieniami zwiększa szkody, jakie mógłby wyrządzić złośliwy pakiet. Konfiguracja oparta na grupie daje tylko małemu pomocniczemu programowi przechwytującemu (`dumpcap`) prawa, których potrzebuje.
Sprawdź członkostwo w grupie w Linuksie (po ponownym zalogowaniu):
```bash
id -nG
```
Oczekiwany wynik (twoja lista będzie inna, ale musi zawierać `wireshark`):
```text
learner wheel wireshark
```
### Krok 3 — Rozpocznij przechwytywanie
Chcesz tylko dwóch rodzajów ruchu: DNS (port UDP 53) i zwykłego HTTP (port TCP 80). **Filtr przechwytywania** mówi silnikowi przechwytywania, żeby zachował tylko te pakiety, dzięki czemu plik jest mały i zawiera jak najmniej niepowiązanych danych.
**Wireshark:** otwórz Wireshark. Na ekranie powitalnym wpisz to w polu filtra przechwytywania („…using this filter”), a potem kliknij dwukrotnie swój interfejs z Kroku 1:
```text
tcp port 80 or udp port 53
```
Oczekiwany efekt: otwiera się lista pakietów, która jest pusta albo pokazuje kilka pakietów DNS od innych aplikacji. Pasek stanu pokazuje nazwę interfejsu i licznik pakietów.
**tcpdump (Linux i macOS):** uruchom to w terminalu i zostaw działające.
```bash
cd ~/osi-lab
sudo tcpdump -i <interface> -nn -Z "$USER" -w osi-lab.pcap 'tcp port 80 or udp port 53'
```
- `<interface>` to nazwa interfejsu z Kroku 1.
- `-nn` wypisuje adresy i numery portów zamiast nazw.
- `-Z "$USER"` sprawia, że `tcpdump` porzuca uprawnienia roota i zapisuje plik jako ty, więc możesz go czytać i usuwać bez `sudo`.
- `-w osi-lab.pcap` zapisuje surowe pakiety do pliku zamiast je wypisywać.
Oczekiwany wynik:
```text
tcpdump: listening on enp3s0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
```
`EN10MB (Ethernet)` oznacza, że każdy przechwycony pakiet zaczyna się od nagłówka Ethernet. Zobaczysz to także w Wi-Fi: w trybie normalnym (nie monitor) system operacyjny przekazuje przechwytywaniu ramki Wi-Fi jako ramki Ethernet.
### Krok 4 — Wygeneruj ruch DNS i HTTP
Teraz tworzysz ruch, który będziesz analizować. Pytasz DNS bezpośrednio swój resolwer, żeby zapytanie przeszło przez sieć, a nie zostało obsłużone z lokalnej pamięci podręcznej. Potem pobierasz stronę zwykłym HTTP: przy bezpiecznym HTTP (HTTPS, HTTP Secure) szyfrowanie ukryłoby przed tobą warstwę HTTP. Opcja `-4` wymusza IPv4, żeby twoje wyniki zgadzały się z lekcją.
Otwórz **drugi** terminal i uruchom:
```bash
dig @<dns-server> example.com A +short
curl -4 -s -o /dev/null -w '%{http_code} %{remote_ip}\n' http://example.com/
```
- `<dns-server>` to adres serwera DNS IPv4 z Kroku 1.
- `-o /dev/null` odrzuca treść strony; `-w` wypisuje kod stanu HTTP i adres IP serwera.
W systemie Windows uruchom zamiast tego w Wierszu polecenia:
```bat
nslookup example.com <dns-server>
curl.exe -4 -s -o NUL -w "%{http_code} %{remote_ip}\n" http://example.com/
```
Oczekiwany wynik (Linux i macOS; prawdziwe adresy będą inne i możesz zobaczyć więcej niż jeden):
```text
203.0.113.80
200 203.0.113.80
```
`200` oznacza, że serwer WWW odpowiedział na żądanie pomyślnie.
### Krok 5 — Zatrzymaj przechwytywanie i wyświetl pakiety
Zatrzymaj przechwytywanie, żeby plik był kompletny, a potem zobacz przegląd, zanim przybliżysz pojedyncze pakiety.
**Wireshark:** kliknij czerwony kwadrat (**Stop**), potem **File → Save As** i zapisz jako `~/osi-lab/osi-lab.pcapng`. Wpisz `dns || http || tcp.port == 80` na pasku filtra wyświetlania i naciśnij Enter.
**tcpdump:** naciśnij **Ctrl+C** w pierwszym terminalu, a potem odczytaj plik z powrotem. Do odczytu nie potrzebujesz `sudo`.
```bash
tcpdump -nn -r osi-lab.pcap
```
Oczekiwany wynik (skrócony; twoje czasy, adresy i numery sekwencyjne będą inne):
```text
reading from file osi-lab.pcap, link-type EN10MB (Ethernet), snapshot length 262144
10:15:02.120000 IP 192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
10:15:02.135000 IP 198.51.100.53.53 > 192.0.2.10.41000: 6699 1/0/1 A 203.0.113.80 (56)
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
10:15:02.180000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [.], ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 0
10:15:02.195000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], seq 1:75, ack 1, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP: GET / HTTP/1.1
10:15:02.210000 IP 203.0.113.80.80 > 192.0.2.10.50514: Flags [P.], seq 1:79, ack 75, win 1050, options [nop,nop,TS val 5010 ecr 1001], length 78: HTTP: HTTP/1.1 200 OK
```
Powinieneś rozpoznać tę historię: pytanie i odpowiedź DNS, trójetapowe uzgadnianie TCP (`[S]`, `[S.]`, `[.]`), żądanie HTTP i odpowiedź HTTP. Następują kolejne pakiety (reszta strony i zamknięcie połączenia). Możesz też zobaczyć pakiety DNS samego `curl` i innych aplikacji.
### Krok 6 — Rozbierz zapytanie DNS
DNS to najprostszy pakiet w zrzucie: jeden datagram UDP niosący jedno pytanie. Użyj go do ćwiczenia czytania warstw od zewnątrz do wewnątrz.
**Wireshark:** przefiltruj po `dns`, a potem kliknij pierwsze zapytanie (`Standard query … A example.com`). Panel szczegółów pakietu pokazuje jedną linię na warstwę:
```text
Frame 1: 82 bytes on wire (656 bits), 82 bytes captured (656 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 198.51.100.53
User Datagram Protocol, Src Port: 41000, Dst Port: 53
Domain Name System (query)
```
Wireshark może dodać nazwę producenta przed każdym adresem MAC. Rozwiń każdą linię strzałką i znajdź: **Type** w Ethernet, **Protocol** i **Time to Live** (TTL) w IP oraz **Destination Port** w UDP.
**tcpdump:** dodaj `-e`, żeby wypisać nagłówek Ethernet, i `-v`, żeby wypisać szczegóły nagłówka IP.
```bash
tcpdump -nn -e -v -r osi-lab.pcap 'udp port 53'
```
Oczekiwany wynik (pokazany pierwszy pakiet):
```text
10:15:02.120000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 82: (tos 0x0, ttl 64, id 4242, offset 0, flags [DF], proto UDP (17), length 68)
192.0.2.10.41000 > 198.51.100.53.53: 6699+ [1au] A? example.com. (40)
```
Przeczytaj to warstwa po warstwie:
| Warstwa | Co widzisz | Znaczenie |
|---|---|---|
| L2 Łącza danych | `00:00:5e:00:53:10 > 00:00:5e:00:53:01`, `ethertype IPv4 (0x0800)` | Twój adres MAC wysyła do adresu MAC bramy. EtherType `0x0800` mówi „ładunek to IPv4”. |
| L3 Sieciowa | `192.0.2.10 > 198.51.100.53`, `ttl 64`, `proto UDP (17)` | Adresy IP identyfikują oba hosty od końca do końca. Protokół `17` mówi „ładunek to UDP”. |
| L4 Transportowa | `.41000 > .53` | Losowy port źródłowy po twojej stronie; port 53 to DNS. PDU to **datagram**. |
| L7 Aplikacji | `A? example.com.` | Samo pytanie DNS: „jaki jest adres IPv4 example.com?” |
Sprawdź docelowy adres MAC: to adres twojej bramy, mimo że serwer DNS może być w innej sieci. Jeśli twoim serwerem DNS jest domowy router, brama i serwer DNS to to samo urządzenie.
> [!NOTE]
> `length 82` to ramka bez 4-bajtowej sekwencji kontrolnej ramki (FCS, frame check sequence). Większość kart sieciowych sprawdza i usuwa FCS, zanim przechwytywanie zobaczy ramkę, więc zrzuty zwykle jej nie pokazują.
### Krok 7 — Odczytaj MSS w uzgadnianiu TCP
Na lekcji obliczyłeś, że 1460 bajtów danych aplikacji mieści się w jednym segmencie TCP na łączu z MTU 1500 bajtów. TCP ogłasza tę liczbę w **opcji MSS** segmentu SYN (synchronize, synchronizacja), pierwszego pakietu uzgadniania. Teraz widzisz ją w kablu.
**Wireshark:** zastosuj ten filtr wyświetlania, a potem kliknij pierwszy pakiet (twój SYN, wysłany z twojego adresu IP):
```text
tcp.flags.syn == 1
```
Rozwiń **Transmission Control Protocol → Options**. Oczekiwany efekt:
```text
TCP Option - Maximum segment size: 1460 bytes
```
Możesz też filtrować bezpośrednio po tej wartości przez `tcp.options.mss_val == 1460`.
**tcpdump:**
```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp[tcpflags] & tcp-syn != 0'
```
Filtr zachowuje segmenty z ustawioną flagą SYN: twój SYN i SYN-ACK serwera. Oczekiwany wynik:
```text
10:15:02.150000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4244, offset 0, flags [DF], proto TCP (6), length 60)
192.0.2.10.50514 > 203.0.113.80.80: Flags [S], cksum 0x42da (correct), seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
10:15:02.165000 00:00:5e:00:53:01 > 00:00:5e:00:53:10, ethertype IPv4 (0x0800), length 74: (tos 0x0, ttl 64, id 4245, offset 0, flags [DF], proto TCP (6), length 60)
203.0.113.80.80 > 192.0.2.10.50514: Flags [S.], cksum 0xa590 (correct), seq 2000000, ack 1000001, win 65535, options [mss 1460,sackOK,TS val 5000 ecr 1000,nop,wscale 10], length 0
```
Znajdź `mss 1460` w swoim SYN. Teraz spójrz na surowe bajty tej samej ramki, żeby zobaczyć enkapsulację w zapisie szesnastkowym:
```bash
tcpdump -nn -XX -c 1 -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
```
Oczekiwany wynik (bajty w twoim zrzucie będą inne):
```text
10:15:02.150000 IP 192.0.2.10.50514 > 203.0.113.80.80: Flags [S], seq 1000000, win 64240, options [mss 1460,sackOK,TS val 1000 ecr 0,nop,wscale 7], length 0
0x0000: 0000 5e00 5301 0000 5e00 5310 0800 4500 ..^.S...^.S...E.
0x0010: 003c 1094 4000 4006 2bcd c000 020a cb00 .<..@.@.+.......
0x0020: 7150 c552 0050 000f 4240 0000 0000 a002 qP.R.P..B@......
0x0030: faf0 42da 0000 0204 05b4 0402 080a 0000 ..B.............
0x0040: 03e8 0000 0000 0103 0307 ..........
```
- Bajty 0–13 to nagłówek Ethernet: docelowy MAC, źródłowy MAC, a potem `0800` (IPv4).
- `45` rozpoczyna nagłówek IPv4: wersja 4, długość nagłówka 5 × 4 = 20 bajtów. Dziesiąty bajt nagłówka IP, `06`, to pole Protocol (TCP).
- W opcjach TCP `02 04 05b4` to opcja MSS: rodzaj 2, długość 4, wartość `0x05b4` = 1460.
> [!NOTE]
> Każda strona ogłasza największy segment, jaki jest gotowa *odebrać*, więc SYN-ACK może pokazywać inne MSS. Wartości poniżej 1460 są normalne w wirtualnych sieciach prywatnych (VPN, virtual private network), na łączach PPP over Ethernet (PPPoE) i w niektórych sieciach chmurowych lub komórkowych, ponieważ ich MTU jest mniejsze albo urządzenie pośredniczące obniża („clamps”) MSS. W pakietach, które wysyłasz, `tcpdump -v` może wypisać `cksum … (incorrect -> …)`. To normalne: karta sieciowa uzupełnia sumę kontrolną po punkcie przechwytywania (odciążenie sumy kontrolnej, checksum offload).
### Krok 8 — Rozbierz żądanie HTTP warstwa po warstwie
Żądanie HTTP to najczystszy przykład pełnej enkapsulacji: dane aplikacji wewnątrz segmentu TCP, wewnątrz pakietu IP, wewnątrz ramki Ethernet. Teraz czytasz wszystkie cztery nagłówki jednej ramki.
**Wireshark:** zastosuj filtr wyświetlania `http.request` i kliknij pakiet `GET / HTTP/1.1`. Rozwiń każdą linię w panelu szczegółów pakietu:
```text
Frame 6: 140 bytes on wire (1120 bits), 140 bytes captured (1120 bits) on interface enp3s0, id 0
Ethernet II, Src: 00:00:5e:00:53:10, Dst: 00:00:5e:00:53:01
Internet Protocol Version 4, Src: 192.0.2.10, Dst: 203.0.113.80
Transmission Control Protocol, Src Port: 50514, Dst Port: 80, Seq: 1, Ack: 1, Len: 74
Hypertext Transfer Protocol
```
Kliknij linię w panelu szczegółów: Wireshark podświetla odpowiadające bajty w panelu bajtów na dole. Kliknij **Ethernet II**, potem **Internet Protocol**, potem **Transmission Control Protocol**, potem **Hypertext Transfer Protocol** i obserwuj, jak podświetlenie przesuwa się w głąb ramki. To jest enkapsulacja oglądana od zewnątrz do wewnątrz.
**tcpdump:**
```bash
tcpdump -nn -e -v -r osi-lab.pcap 'tcp dst port 80 and tcp[tcpflags] & tcp-push != 0'
```
Filtr zachowuje segmenty, które wysłałeś na port 80 i które niosą dane (ustawiona flaga PSH). Oczekiwany wynik:
```text
10:15:02.195000 00:00:5e:00:53:10 > 00:00:5e:00:53:01, ethertype IPv4 (0x0800), length 140: (tos 0x0, ttl 64, id 4247, offset 0, flags [DF], proto TCP (6), length 126)
192.0.2.10.50514 > 203.0.113.80.80: Flags [P.], cksum 0x4260 (correct), seq 1000001:1000075, ack 2000001, win 502, options [nop,nop,TS val 1001 ecr 5000], length 74: HTTP, length: 74
GET / HTTP/1.1
Host: example.com
User-Agent: curl/8.5.0
Accept: */*
```
Sprawdź, czy rozmiary się sumują:
| Element | Bajty w tym przykładzie | Gdzie to odczytać |
|---|---|---|
| Żądanie HTTP (dane aplikacji) | 74 | `length 74` w TCP / `Len: 74` w Wiresharku |
| Nagłówek TCP (20 + 12 bajtów opcji znacznika czasu) | 32 | całkowita długość IP − nagłówek IP − dane |
| Nagłówek IPv4 | 20 | `Header Length: 20 bytes` w IP |
| Pakiet IP (całkowita długość IP) | 74 + 32 + 20 = 126 | `length 126` w IP |
| Nagłówek Ethernet | 14 | |
| Ramka w zrzucie (bez FCS) | 126 + 14 = 140 | `length 140` / `Frame 6: 140 bytes` |
Potem spójrz na odpowiedź serwera (`HTTP/1.1 200 OK`) i porównaj jej nagłówek IP z żądaniem. Źródło i cel są zamienione, a TTL jest zwykle **niższe** niż wartość początkowa serwera (często 64 lub 128). Każdy router na trasie zmniejszył je o jeden.
> [!NOTE]
> Nagłówek TCP w segmentach z danymi ma często 32 bajty zamiast 20, ponieważ wiele systemów dodaje opcję znacznika czasu do każdego segmentu. Twoje rozmiary mogą się różnić: różne wersje curl wysyłają nieco inne nagłówki (na przykład inny `User-Agent`).
### Krok 9 — Przypisz to, co zobaczyłeś, do warstw OSI
Zebranie wszystkiego razem zamienia to, co zobaczyłeś, w model. Skopiuj tę tabelę do notatek i wypełnij ostatnią kolumnę wartościami z **twojego** zrzutu.
| Warstwa OSI | PDU | Linia w Wiresharku | Pole do zapisania | Przykładowa wartość | Twoja wartość |
|---|---|---|---|---|---|
| 7 Aplikacji | Dane | Hypertext Transfer Protocol | Linia żądania i `Host` | `GET / HTTP/1.1`, `example.com` | |
| 4 Transportowa | Segment | Transmission Control Protocol | Port źródłowy, port docelowy, MSS w SYN | `50514`, `80`, `1460` | |
| 4 Transportowa | Datagram | User Datagram Protocol | Port docelowy zapytania DNS | `53` | |
| 3 Sieciowa | Pakiet | Internet Protocol Version 4 | Źródłowy i docelowy IP, TTL, Protocol | `192.0.2.10`, `203.0.113.80`, `64`, `6` | |
| 2 Łącza danych | Ramka | Ethernet II | Źródłowy i docelowy MAC, Type | `00:00:5e:00:53:10`, `00:00:5e:00:53:01`, `0x0800` | |
| 1 Fizyczna | Bit | Frame (metadane przechwytywania) | Bytes on wire | `140` | |
> [!NOTE]
> Linia **Frame** w Wiresharku nie jest nagłówkiem protokołu. To informacje, które dodaje narzędzie przechwytujące (czas nadejścia, długość, interfejs). Jest to najbliższe warstwie 1, jakie zobaczysz, bo zrzut widzi bity dopiero po tym, jak karta sieciowa zamieniła sygnały z powrotem w bajty.
Warstwy 5 i 6 nie mają osobnego wiersza: przy zwykłym HTTP nad TCP w kablu nie pojawia się żaden osobny protokół sesji ani prezentacji. Przy HTTPS Transport Layer Security (TLS) znajdowałoby się między TCP a HTTP (zobacz Wyzwanie).
## Weryfikacja
Laboratorium jest ukończone, gdy wszystkie poniższe sprawdzenia kończą się powodzeniem.
1. Plik z przechwyconym ruchem istnieje i zawiera pakiety. Wireshark: zapisany plik otwiera się ponownie i pokazuje pakiety. tcpdump:
```bash
tcpdump -nn -r osi-lab.pcap 2>/dev/null | wc -l
```
Oczekiwany wynik: liczba równa co najmniej 7 (dokładna liczba się różni).
2. Twój SYN niesie MSS zgodne z twoim MTU. Wireshark: filtr `tcp.flags.syn == 1 && tcp.flags.ack == 0` pokazuje twój SYN z MSS równym 1460 przy MTU 1500 bajtów. tcpdump:
```bash
tcpdump -nn -r osi-lab.pcap 'tcp[tcpflags] == tcp-syn'
```
Oczekiwany wynik: linia zawierająca `Flags [S]` i `mss 1460` (lub MTU − 40, jeśli twoje MTU nie wynosi 1500).
Potem sprawdź swoje zrozumienie na zrzucie:
- [ ] Znalazłeś EtherType `0x0800` w nagłówku Ethernet swoich ramek IPv4.
- [ ] Znalazłeś Protocol w IP równy `17` w zapytaniu DNS i `6` w żądaniu HTTP.
- [ ] Docelowy adres MAC twoich ramek wychodzących to adres twojej bramy, a nie serwera.
- [ ] Potrafisz wyjaśnić, dlaczego MSS wynosi 1460: 1500 (MTU) − 20 (nagłówek IPv4) − 20 (nagłówek TCP).
- [ ] Twoja tabela z Kroku 9 jest kompletna i zawiera twoje własne wartości.
## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| Wireshark nie pokazuje interfejsów albo pokazuje „You don't have permission to capture on that device.” | Twój użytkownik nie ma prawa przechwytywać (grupa `wireshark` w Linuksie, ChmodBPF w macOS, Npcap w Windows). | Linux: wykonaj Krok 2, potem wyloguj się i zaloguj ponownie (`id -nG` musi pokazać `wireshark`). macOS: zainstaluj Wireshark ponownie i zaakceptuj ChmodBPF. Windows: zainstaluj Npcap ponownie z instalatora Wiresharka. |
| `tcpdump: <interface>: You don't have permission to capture on that device` | Uruchomiłeś `tcpdump` bez `sudo`. | Uruchom polecenie z Kroku 3 z `sudo`. |
| `tcpdump: osi-lab.pcap: Permission denied` | `tcpdump` porzucił uprawnienia roota i nie może zapisywać w bieżącym folderze. | Użyj opcji `-Z "$USER"`, jak pokazano, i uruchom polecenie z `~/osi-lab`, który należy do ciebie. |
| Zrzut pozostaje pusty po Kroku 4. | Przechwytujesz na złym interfejsie (na przykład odłączonym porcie Ethernet, moście Dockera lub interfejsie VPN). | Sprawdź interfejs, którym biegnie trasa domyślna (Krok 1), i przechwytuj na nim. W Wiresharku wybierz interfejs, którego wykres ruchu się porusza. |
| Brak pakietów HTTP, tylko TCP port 443 lub TLS. | Użyłeś `https://` albo coś przekierowało cię na HTTPS. Szyfrowanie ukrywa warstwę HTTP. | Użyj dokładnie `http://example.com/` w `curl`, a nie przeglądarki. Przeglądarki często automatycznie przechodzą na HTTPS. |
| Brak zapytania DNS w zrzucie. | Uruchomiłeś `dig` bez `@<dns-server>`, więc odpowiedź przyszła z lokalnej pamięci podręcznej (na przykład `systemd-resolved` pod `127.0.0.53`) lub przez DNS over HTTPS. | Uruchom `dig @<dns-server> example.com A` z serwerem DNS z Kroku 1. Jeśli przechwytywałeś na interfejsie pętli zwrotnej (`lo`), widzisz tylko zapytanie do lokalnej pamięci podręcznej. |
| MSS jest bardzo duże (na przykład 65495 w Linuksie) albo adresy MAC to same zera. | Przechwytywałeś na interfejsie pętli zwrotnej, który ma bardzo duże MTU i nie ma prawdziwej karty sieciowej. | Przechwytuj na swoim interfejsie fizycznym (Krok 1). |
| Pakiety pokazują `ethertype IPv6 (0x86dd)` i MSS równe 1440. | `curl` połączył się przez IPv6. Nagłówek IPv6 ma 40 bajtów, więc MSS wynosi 1500 − 40 − 20 = 1440. | Dodaj `-4` do `curl`, jak pokazano w Kroku 4, albo zachowaj zrzut IPv6 jako dodatkowe porównanie. |
| Brak nagłówka Ethernet (`link-type RAW`) i MSS poniżej 1460. | Aktywne jest VPN, a przechwytywałeś na jego interfejsie tunelu. | Rozłącz VPN na czas laboratorium albo przechwytuj na interfejsie fizycznym. Mniejsze MSS przez VPN jest oczekiwane. |
## Wyzwanie (opcjonalne)
Powtórz przechwytywanie z HTTPS: użyj filtra przechwytywania `tcp port 443` i uruchom `curl -4 -s -o /dev/null https://example.com/`. Bez pomocy krok po kroku odpowiedz na te pytania na podstawie zrzutu:
1. Które nagłówki nadal możesz odczytać (Ethernet, IP, TCP) i gdzie zaczyna się część zaszyfrowana?
2. Znajdź TLS Client Hello. Jaka informacja o witrynie jest nadal widoczna jawnym tekstem? (Wskazówka: poszukaj rozszerzenia Server Name Indication, SNI.)
3. Jak to się ma do stwierdzenia z lekcji, że „szyfrowanie w jednej warstwie chroni tylko warstwy nad nią”?
## Sprzątanie
Zatrzymaj każde przechwytywanie, które nadal trwa (Wireshark: **Stop**; tcpdump: **Ctrl+C**), a potem sprawdź, czy nie został żaden proces `tcpdump`:
```bash
pgrep -a tcpdump
```
Oczekiwany wynik: brak (żaden proces nie jest wyświetlony).
Usuń pliki z przechwyconym ruchem i folder laboratorium. Mogą zawierać prywatne dane.
```bash
rm -rf ~/osi-lab
```
W systemie Windows usuń w Eksploratorze plików folder, w którym zapisałeś `osi-lab.pcapng`.
Jeśli dodałeś siebie do grupy `wireshark` **tylko na potrzeby tego laboratorium** (Krok 2), usuń członkostwo i wyloguj się oraz zaloguj ponownie:
```bash
sudo gpasswd -d "$USER" wireshark
```
Oczekiwany wynik:
```text
Removing user learner from group wireshark
```
Jeśli zainstalowałeś Wireshark, Npcap lub ChmodBPF tylko na potrzeby tego laboratorium, możesz je odinstalować menedżerem pakietów swojego systemu albo deinstalatorem Wiresharka.
> [!NOTE]
> Wireshark pamięta też ostatnio otwierane pliki. Aby wyczyścić listę, użyj **File → Open Recent → Clear Recent Files**.
## Co już umiesz
- Narzędzie do przechwytywania pokazuje ci wszystkie nagłówki ramki, więc widzisz enkapsulację bezpośrednio, a nie tylko na diagramach.
- Nagłówek każdej warstwy mówi odbiorcy, co następuje dalej: EtherType `0x0800` oznacza IPv4, Protocol w IP równe `6` oznacza TCP, a `17` oznacza UDP, zaś port docelowy wybiera aplikację.
- Twoje ramki wychodzące trafiają na adres MAC bramy, podczas gdy adresy IP identyfikują prawdziwe końce połączenia.
- Segment SYN ogłasza MSS: 1460 bajtów na standardowym łączu Ethernet o MTU 1500 bajtów, czyli 1500 − 20 (IPv4) − 20 (TCP).
- Szyfrowanie ukrywa warstwy nad nim. Zwykłe HTTP pokazuje żądanie jawnym tekstem; HTTPS pokazuje tylko warstwy niższe i uzgadnianie TLS.
- Przechwytywanie ruchu jest potężne i wrażliwe: przechwytuj tylko własny ruch, trzymaj pliki prywatnie i usuwaj je, gdy skończysz.