---
title: "Laboratorium: poznawanie IPv6 na własnym komputerze"
domain: networking
level: intermediate
duration: "45 min"
cost: "bezpłatnie"
environment: "twój własny komputer (Linux, macOS lub Windows) w twojej własnej sieci"
lang: pl
source_hash: c2e8e0d971ba
---

# Laboratorium: poznawanie IPv6 na własnym komputerze

## Cel
Znajdziesz adresy IPv6, które Twój komputer już ma, rozpoznasz typ i zasięg każdego z nich, zobaczysz, jak Neighbor Discovery wypełnia pamięć podręczną sąsiadów, i użyjesz Pythona do skracania, klasyfikowania i planowania adresów IPv6. Nie potrzebujesz IPv6 od dostawcy Internetu: wszystko w łączu działa na adresach link-local.

## Cele
- Wypisać adresy IPv6 swoich interfejsów i rozpoznać typ oraz zasięg każdego z nich (link-local, globalny unicast, ULA, loopback), łącznie z adresami tymczasowymi.
- Odczytać tablicę routingu IPv6 i znaleźć router domyślny poznany z Router Advertisement.
- Obejrzeć pamięć podręczną sąsiadów i zobaczyć, jak Neighbor Discovery Protocol (NDP, protokół wykrywania sąsiadów) dodaje wpisy.
- Dotrzeć do adresów link-local i multicast za pomocą ID strefy.
- Użyć modułu `ipaddress` w Pythonie, aby zastosować RFC 5952, klasyfikować adresy, wyprowadzać adresy multicast solicited-node i dzielić `/48` na podsieci `/64`.

## Wymagania wstępne
- Komputer z aktualną wersją Linuksa, macOS lub Windows 10/11, z włączonym IPv6 (domyślnie we wszystkich trzech).
- Python 3.8 lub nowszy (`python3 --version`; w Windows `py --version`). Używana jest tylko biblioteka standardowa.
- Terminal. Nie są potrzebne uprawnienia administratora ani `sudo`: wszystkie polecenia w tym laboratorium tylko odczytują stan.
- Połączenie z siecią, która jest Twoja lub z której wolno Ci korzystać, na przykład z siecią domową. Sieć z IPv6 od dostawcy Internetu to bonus, nie wymóg.
- [Lekcja o IPv6](lesson.pl.md) z tego modułu, zwłaszcza typy adresów, NDP i SLAAC.

> [!WARNING]
> Krok 5 wysyła ping na adres multicast wszystkich węzłów `ff02::1`, który dociera do każdego urządzenia w Twoim łączu. Rób to tylko we własnej sieci (na przykład w domu) lub za zgodą właściciela sieci. Nie uruchamiaj tego w sieciach publicznych, firmowych ani szkolnych bez upoważnienia. Laboratorium nie zmienia żadnej konfiguracji; tworzy tylko jeden folder z plikiem Pythona, który usuwasz na końcu.

> [!NOTE]
> Poniższe wyniki używają wartości dokumentacyjnych: `2001:db8::/32` (RFC 3849) dla adresów globalnych, `fd8f:3c2a:61e4::/48` dla ULA oraz adresów MAC z zakresu dokumentacyjnego RFC 7042. Twoje prawdziwe adresy, nazwy interfejsów i czasy życia będą inne. Jeśli udostępniasz wyniki, najpierw zastąp swoje adresy globalne: identyfikują Twoją sieć.

## Architektura
![Architektura laboratorium: Twój komputer, router domowy i inne urządzenia w jednym łączu. Router wysyła Router Advertisement na ff02::1, komputer i router wymieniają Neighbor Solicitation i Advertisement, a ping na ff02::1 z ID strefy interfejsu dociera do wszystkich urządzeń. Internet jest opcjonalny](../../../assets/diagrams/ipv6-lab-architecture.pl.svg)

*Rysunek 1. Wszystko w tym laboratorium dzieje się w Twoim własnym łączu. Komputer potrzebuje tylko adresu link-local; adres globalny pojawia się wyłącznie wtedy, gdy Twój ISP zapewnia IPv6.*

Wszystko, co robisz, dzieje się w Twoim własnym łączu. Routery nigdy nie przekazują ruchu link-local ani `ff02::`, więc nic z tego laboratorium nie opuszcza Twojej sieci.

## Kroki

### Krok 1 — Utwórz folder roboczy
Będziesz tu trzymać mały skrypt pomocniczy w Pythonie, więc końcowe sprzątanie to jedno polecenie.

Linux i macOS:
```bash
mkdir -p ~/ipv6-lab && cd ~/ipv6-lab
```

Windows (PowerShell):
```powershell
New-Item -ItemType Directory -Force "$HOME\ipv6-lab" | Out-Null; Set-Location "$HOME\ipv6-lab"
```

Nie oczekuje się żadnego wyniku.

### Krok 2 — Wypisz swoje adresy IPv6
Każdy interfejs z włączonym IPv6 ma co najmniej jeden adres link-local, a zwykle kilka więcej. Wypisanie ich to pierwsza rzecz, jaką robisz przy diagnozowaniu IPv6.

Linux:
```bash
ip -6 addr show
```

macOS (`<iface>` to zwykle `en0`):
```bash
ifconfig <iface> inet6
```

Windows:
```powershell
netsh interface ipv6 show addresses
```

`<iface>` to nazwa Twojego aktywnego interfejsu sieciowego. W Linuksie widać ją w wyniku `ip` (na przykład `eth0`, `enp3s0`, `wlan0` lub `wlp2s0`); w macOS `en0` to zwykle Wi-Fi lub wbudowany Ethernet.

Oczekiwany wynik w Linuksie, w sieci z IPv6 od dostawcy (Twój będzie inny):
```text
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 state UNKNOWN qlen 1000
    inet6 ::1/128 scope host noprefixroute
       valid_lft forever preferred_lft forever
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 state UP qlen 1000
    inet6 2001:db8:acad:10:91d4:2e6b:c07a:3f58/64 scope global temporary dynamic
       valid_lft 85912sec preferred_lft 13912sec
    inet6 2001:db8:acad:10:4c3e:9b12:a7f0:6d21/64 scope global dynamic mngtmpaddr noprefixroute
       valid_lft 86395sec preferred_lft 14395sec
    inet6 fd8f:3c2a:61e4:10:5a7e:21c9:8b04:e3f6/64 scope global dynamic mngtmpaddr noprefixroute
       valid_lft 86395sec preferred_lft 14395sec
    inet6 fe80::4c3e:9b12:a7f0:6d21/64 scope link noprefixroute
       valid_lft forever preferred_lft forever
```

W macOS szukaj słów kluczowych `secured` (adres stabilnej prywatności), `temporary` i `autoconf` (zbudowany przez SLAAC); adresy link-local są pokazywane ze swoją strefą, jak w `fe80::…%en0`. W Windows kolumna `Addr Type` pokazuje `Public` (stały), `Temporary` i `Other` (link-local), a adresy link-local kończą się `%<indeks>`.

Jeśli Twój dostawca nie ma IPv6, zobaczysz tylko `::1` i adres `fe80::`. To wystarczy do reszty laboratorium.

### Krok 3 — Rozpoznaj typ i zasięg każdego adresu
Skopiuj tę tabelę do notatek i wypełnij ją dla każdego adresu z kroku 2. Użyj tabeli typów adresów z lekcji i tych wskazówek z wyniku w Linuksie:

| Słowo kluczowe Linuksa | Znaczenie |
|---|---|
| `scope host` | Ważny tylko wewnątrz tej maszyny (`::1`). |
| `scope link` | Link-local (`fe80::/10`). |
| `scope global` | Globalny unicast **lub** ULA: Linux zgłasza oba jako global; sprawdź prefiks (`2000::/3` kontra `fd00::/8`). |
| `temporary` | Adres tymczasowy (prywatności) z RFC 8981, używany do połączeń wychodzących. |
| `mngtmpaddr` | Stały adres, z którego jądro zarządza adresami tymczasowymi. |
| `dynamic` | Poznany automatycznie (SLAAC lub DHCPv6) i mający czasy życia; adresy statyczne pokazują `forever`. |
| `tentative` / `dadfailed` | Wykrywanie zduplikowanych adresów jeszcze trwa / znalazło duplikat. |
| `deprecated` | Preferowany czas życia wygasł: adres zachowany dla istniejących połączeń, nieużywany dla nowych. |

| Adres | Długość prefiksu | Typ | Zasięg | Jak został skonfigurowany |
|---|---|---|---|---|
| `::1` | `/128` | Loopback | Host | Wbudowany |
| `fe80::4c3e:9b12:a7f0:6d21` | `/64` | Link-local | Łącze | Wygenerowany po uaktywnieniu łącza |
| `2001:db8:acad:10:4c3e:9b12:a7f0:6d21` | `/64` | Globalny unicast, stały | Globalny | SLAAC |
| `2001:db8:acad:10:91d4:2e6b:c07a:3f58` | `/64` | Globalny unicast, tymczasowy | Globalny | SLAAC (RFC 8981) |
| `fd8f:3c2a:61e4:10:5a7e:21c9:8b04:e3f6` | `/64` | Unikalny lokalny (ULA) | Globalny (routowany tylko wewnątrz lokalizacji) | SLAAC |

> [!TIP]
> Spójrz na identyfikator interfejsu swojego adresu link-local. Jeśli zawiera `ff:fe` pośrodku (na przykład `fe80::200:5eff:fe00:5310`), Twój system używa zmodyfikowanego EUI-64, który zawiera adres MAC. IID wyglądający na losowy oznacza, że używana jest stabilna prywatność lub losowe IID.

### Krok 4 — Znajdź swój router domyślny
Hosty IPv6 poznają router domyślny z Router Advertisement, nigdy z DHCPv6. Tablica routingu pokazuje, skąd pochodzi trasa.

Linux:
```bash
ip -6 route show
```

macOS:
```bash
netstat -rn -f inet6 | grep -i default
```

Windows:
```powershell
netsh interface ipv6 show route
```

Oczekiwany wynik w Linuksie (z routerem IPv6 w łączu):
```text
2001:db8:acad:10::/64 dev eth0 proto ra metric 100 pref medium
fd8f:3c2a:61e4:10::/64 dev eth0 proto ra metric 100 pref medium
fe80::/64 dev eth0 proto kernel metric 1024 pref medium
default via fe80::1 dev eth0 proto ra metric 100 pref medium
```

Zwróć uwagę na trzy rzeczy:
- Następnym przeskokiem trasy domyślnej jest adres **link-local** (tu `fe80::1`; w wielu routerach domowych jest to długi adres EUI-64 lub losowy) plus interfejs (`dev eth0`). Dlatego adresy link-local potrzebują strefy.
- `proto ra` oznacza, że trasa została poznana z Router Advertisement.
- Trasy `/64` on-link pochodzą z informacji o prefiksie w RA (flaga L).

Zapisz adres link-local swojego routera i nazwę interfejsu. Jeśli nie ma linii `default`, Twoja sieć nie ma routera IPv6; kontynuuj mimo to i pomiń ping bramy w kroku 5.

### Krok 5 — Dotrzyj do swojego łącza przez multicast i adresy link-local
Teraz wygeneruj trochę ruchu NDP i zobacz go w pamięci podręcznej sąsiadów. Najpierw spójrz na pamięć podręczną taką, jaka jest.

Linux:
```bash
ip -6 neigh show
```

macOS:
```bash
ndp -an
```

Windows:
```powershell
netsh interface ipv6 show neighbors
```

Następnie wyślij ping do grupy multicast **wszystkich węzłów** w swoim łączu. Odbiera go każde urządzenie IPv6 w łączu; te skonfigurowane do odpowiadania odpowiedzą ze swoich adresów link-local. ID strefy `%<iface>` mówi systemowi, którego łącza użyć.

Linux (iputils; w starszych systemach użyj `ping6 -c 2 ff02::1%<iface>`):
```bash
ping -c 2 ff02::1%<iface>
```

macOS:
```bash
ping6 -c 2 ff02::1%<iface>
```

Oczekiwany wynik w Linuksie (jedna linia na każde urządzenie, które odpowiada; dodatkowe odpowiedzi na ten sam numer sekwencyjny są oznaczone `DUP!`):
```text
PING ff02::1%eth0 (ff02::1%eth0) 56 data bytes
64 bytes from fe80::4c3e:9b12:a7f0:6d21%eth0: icmp_seq=1 ttl=64 time=0.062 ms
64 bytes from fe80::1%eth0: icmp_seq=1 ttl=64 time=0.814 ms (DUP!)
64 bytes from fe80::200:5eff:fe00:5325%eth0: icmp_seq=1 ttl=64 time=3.21 ms (DUP!)
64 bytes from fe80::4c3e:9b12:a7f0:6d21%eth0: icmp_seq=2 ttl=64 time=0.058 ms
...
```

Pierwsza odpowiedź często pochodzi z Twojej własnej maszyny, która też jest członkiem `ff02::1`. Wiele urządzeń, w tym Windows z domyślnymi regułami zapory, nie odpowiada na pingi, więc zobaczenie tylko własnego adresu jest normalne. `ttl=` w wyniku to Hop Limit IPv6.

> [!NOTE]
> W Windows ID strefy to numeryczny indeks interfejsu (pokazany jako `%<indeks>` po adresach link-local w kroku 2 albo w kolumnie `Idx` polecenia `netsh interface ipv6 show interfaces`). `ping -n 2 ff02::1%<indeks>` jest akceptowany, ale `ping` w Windows zazwyczaj nie wyświetla odpowiedzi na adres multicast. W Windows pomiń ping multicast i wykonaj ping bramy poniżej.

Następnie wyślij ping na adres link-local swojego routera domyślnego z kroku 4:

Linux / macOS (`ping6` w macOS):
```bash
ping -c 2 <router-link-local>%<iface>
```

Windows:
```powershell
ping -n 2 <router-link-local>%<index>
```

`<router-link-local>` to adres po `via` w kroku 4 (na przykład `fe80::1`); `<indeks>` to indeks Twojego interfejsu w Windows.

Oczekiwany wynik w Linuksie:
```text
PING fe80::1%eth0 (fe80::1%eth0) 56 data bytes
64 bytes from fe80::1%eth0: icmp_seq=1 ttl=64 time=0.791 ms
64 bytes from fe80::1%eth0: icmp_seq=2 ttl=64 time=0.705 ms
```

Teraz spójrz ponownie na pamięć podręczną sąsiadów tym samym poleceniem co wcześniej:
```text
fe80::1 dev eth0 lladdr 00:00:5e:00:53:01 router REACHABLE
fe80::200:5eff:fe00:5325 dev eth0 lladdr 00:00:5e:00:53:25 STALE
```

Każdy wpis odwzorowuje adres IPv6 na adres MAC (`lladdr`), poznany dzięki komunikatom Neighbor Solicitation i Neighbor Advertisement. `router` oznacza sąsiada, który wysyła RA. `REACHABLE` znaczy niedawno potwierdzony; `STALE` znaczy, że zostanie sprawdzony ponownie przy następnym użyciu. Porównaj wpisy z tym, co widziałeś przed pingami.

### Krok 6 — Zbuduj mały skrypt pomocniczy IPv6 w Pythonie
Ręczne skracanie według RFC 5952, klasyfikowanie i liczenie solicited-node jest podatne na błędy. Standardowy moduł `ipaddress` w Pythonie wykonuje obliczenia; poniższy skrypt dodaje klasyfikację z lekcji.

Zapisz to jako `ipv6_tool.py` w folderze `ipv6-lab` (dowolnym edytorem tekstu):

```python
"""IPv6 helper for the CloudAcademia IPv6 lab (standard library only)."""
import ipaddress
import sys

# Most specific first: the first match wins.
TYPES = [
    ("::/128", "unspecified"),
    ("::1/128", "loopback"),
    ("::ffff:0:0/96", "IPv4-mapped"),
    ("64:ff9b::/96", "NAT64 well-known prefix"),
    ("fe80::/10", "link-local unicast"),
    ("fc00::/7", "unique local (ULA)"),
    ("ff00::/8", "multicast"),
    ("2001:db8::/32", "global unicast (documentation)"),
    ("2000::/3", "global unicast"),
]
TYPES = [(ipaddress.ip_network(net), name) for net, name in TYPES]
MCAST_SCOPES = {1: "interface-local", 2: "link-local", 5: "site-local", 8: "organization-local", 14: "global"}


def parse(text):
    """Return (address, zone ID or None). Accepts fe80::1%eth0 and 2001:db8::1/64."""
    text = text.split("/")[0]
    addr, _, zone = text.partition("%")
    return ipaddress.IPv6Address(addr), zone or None


def classify(addr):
    for net, name in TYPES:
        if addr in net:
            if name == "multicast":
                scope = int(addr) >> 112 & 0xF          # 4th hex digit: ff0X::
                return f"multicast, {MCAST_SCOPES.get(scope, f'scope {scope:x}')} scope"
            return name
    return "other / reserved"


def solicited_node(addr):
    """ff02::1:ff00:0/104 + the last 24 bits of the unicast address."""
    return ipaddress.IPv6Address(int(ipaddress.IPv6Address("ff02::1:ff00:0")) | (int(addr) & 0xFFFFFF))


def describe(text):
    addr, zone = parse(text)
    print(f"input          : {text}")
    print(f"compressed     : {addr.compressed}")
    print(f"exploded       : {addr.exploded}")
    print(f"type           : {classify(addr)}")
    if zone:
        print(f"zone ID        : {zone}")
    if not (addr.is_multicast or addr.is_unspecified or addr.is_loopback or addr.ipv4_mapped):
        print(f"solicited-node : {solicited_node(addr)}")
    print()


def plan(prefix, count):
    net = ipaddress.IPv6Network(prefix)
    subnets = net.subnets(new_prefix=64)
    print(f"{net} contains {2 ** (64 - net.prefixlen)} /64 subnets. The first {count}:")
    for _, sub in zip(range(count), subnets):
        print(f"  {sub}")
    print()


def selftest():
    def addr(text):
        return parse(text)[0]
    assert addr("2001:0DB8:0000:0000:0000:ff00:0042:8329").compressed == "2001:db8::ff00:42:8329"
    assert addr("2001:db8:0:0:1:0:0:1").compressed == "2001:db8::1:0:0:1"
    assert addr("2001:db8:0:1:1:1:1:1").compressed == "2001:db8:0:1:1:1:1:1"
    assert parse("fe80::1%eth0") == (ipaddress.IPv6Address("fe80::1"), "eth0")
    assert classify(addr("fe80::1%eth0")) == "link-local unicast"
    assert classify(addr("fd8f:3c2a:61e4:10::1")) == "unique local (ULA)"
    assert classify(addr("ff02::2")) == "multicast, link-local scope"
    assert str(solicited_node(addr("2001:db8:acad:10:4c3e:9b12:a7f0:6d21"))) == "ff02::1:fff0:6d21"
    assert len(list(ipaddress.IPv6Network("2001:db8:acad::/56").subnets(new_prefix=64))) == 256
    print("All self-tests passed.")


if __name__ == "__main__":
    args = sys.argv[1:]
    if not args:
        sys.exit("usage: ipv6_tool.py ADDRESS... | --plan PREFIX [COUNT] | --selftest")
    try:
        if args[0] == "--selftest":
            selftest()
        elif args[0] == "--plan":
            plan(args[1], int(args[2]) if len(args) > 2 else 4)
        else:
            for a in args:
                describe(a)
    except ValueError as err:
        sys.exit(f"error: {err}")
```

Kilka uwag o kodzie:
- `parse()` odcina ID strefy i długość prefiksu przed analizą. Strefa jest zachowywana tylko do wyświetlenia.
- `classify()` używa własnej tabeli zamiast właściwości `ipaddress`, takich jak `is_global` i `is_private`, których dokładne zachowanie zmieniało się między wersjami Pythona.
- `solicited_node()` stosuje regułę z lekcji: `ff02::1:ff` plus ostatnie 24 bity.

Uruchom autotest (w Windows użyj `py` zamiast `python3` w tym i kolejnych krokach):
```bash
python3 ipv6_tool.py --selftest
```

Oczekiwany wynik:
```text
All self-tests passed.
```

### Krok 7 — Skracaj, rozwijaj i klasyfikuj adresy
Uruchom skrypt na mieszance adresów zapisanych w postaci długiej i krótkiej:

```bash
python3 ipv6_tool.py 2001:0DB8:0000:0000:0000:ff00:0042:8329 fe80::4c3e:9b12:a7f0:6d21%eth0 fd8f:3c2a:61e4:10::25 ff02::1 ::1
```

Oczekiwany wynik:
```text
input          : 2001:0DB8:0000:0000:0000:ff00:0042:8329
compressed     : 2001:db8::ff00:42:8329
exploded       : 2001:0db8:0000:0000:0000:ff00:0042:8329
type           : global unicast (documentation)
solicited-node : ff02::1:ff42:8329

input          : fe80::4c3e:9b12:a7f0:6d21%eth0
compressed     : fe80::4c3e:9b12:a7f0:6d21
exploded       : fe80:0000:0000:0000:4c3e:9b12:a7f0:6d21
type           : link-local unicast
zone ID        : eth0
solicited-node : ff02::1:fff0:6d21

input          : fd8f:3c2a:61e4:10::25
compressed     : fd8f:3c2a:61e4:10::25
exploded       : fd8f:3c2a:61e4:0010:0000:0000:0000:0025
type           : unique local (ULA)
solicited-node : ff02::1:ff00:25

input          : ff02::1
compressed     : ff02::1
exploded       : ff02:0000:0000:0000:0000:0000:0000:0001
type           : multicast, link-local scope

input          : ::1
compressed     : ::1
exploded       : 0000:0000:0000:0000:0000:0000:0000:0001
type           : loopback

```

Porównaj wynik z lekcją:
- Pierwszy adres jest teraz zapisany małymi literami, bez zer wiodących, a ciąg trzech grup zer to `::`.
- Adres link-local i jego globalny odpowiednik z lekcji (`2001:db8:acad:10:4c3e:9b12:a7f0:6d21`) mają te same ostatnie 24 bity, więc dzielą jedną grupę solicited-node, `ff02::1:fff0:6d21`. Jedno Neighbor Solicitation dociera do właściciela obu.

Uruchom go teraz na **własnych** adresach z kroku 2 (wklej je tak, jak się pojawiają, z `/64` lub `%<iface>`, jeśli występują) i porównaj wiersz `type` z tabelą wypełnioną w kroku 3. Nie wklejaj swoich adresów globalnych w żadnym publicznym miejscu.

Na koniec spróbuj nieprawidłowego wejścia (dwa `::`), by zobaczyć, co odrzuca parser:
```bash
python3 ipv6_tool.py 2001:db8::1::2
```

Oczekiwany wynik:
```text
error: At most one '::' permitted in '2001:db8::1::2'
```

### Krok 8 — Zaplanuj podsieci `/64` z prefiksu lokalizacji
Użyj przykładu praktycznego z lekcji: Example Corp ma `2001:db8:acad::/48`. Wypisz pierwsze `/64`, a potem zobacz, ile mieści `/56`:

```bash
python3 ipv6_tool.py --plan 2001:db8:acad::/48 4
python3 ipv6_tool.py --plan 2001:db8:acad:1000::/56 3
```

Oczekiwany wynik:
```text
2001:db8:acad::/48 contains 65536 /64 subnets. The first 4:
  2001:db8:acad::/64
  2001:db8:acad:1::/64
  2001:db8:acad:2::/64
  2001:db8:acad:3::/64

2001:db8:acad:1000::/56 contains 256 /64 subnets. The first 3:
  2001:db8:acad:1000::/64
  2001:db8:acad:1001::/64
  2001:db8:acad:1002::/64

```

ID podsieci to po prostu czwarta grupa. Aby wybrać `/64` dla danego ID podsieci, zaindeksuj listę ID zapisanym szesnastkowo. W planie z lekcji budynek 0 VLAN 10 to ID podsieci `0010`, a budynek 1 VLAN 10 to `1010`:

```bash
python3 -c "import ipaddress as i; s = list(i.ip_network('2001:db8:acad::/48').subnets(new_prefix=64)); print(s[0x0010], s[0x1010])"
```

Oczekiwany wynik:
```text
2001:db8:acad:10::/64 2001:db8:acad:1010::/64
```

Zauważ, że `s[0x0010]` to indeks 16, nie 10: ID podsieci są szesnastkowe.

## Weryfikacja
Laboratorium jest ukończone, jeśli wszystkie poniższe warunki są spełnione:

| Sprawdzenie | Warunek zaliczenia |
|---|---|
| Wypisane adresy | Twoja tabela z kroku 3 zawiera co najmniej `::1` i adres `fe80::`, każdy z poprawnym typem i zasięgiem. |
| Router domyślny | Znalazłeś trasę domyślną w kroku 4 i potrafisz powiedzieć, czy pochodzi z RA (`proto ra` w Linuksie), albo potwierdziłeś, że w Twoim łączu nie ma routera IPv6. |
| Neighbor Discovery | Po kroku 5 pamięć podręczna sąsiadów ma co najmniej jeden wpis, którego wcześniej nie miała (lub Twoja brama jest `REACHABLE`). |
| ID strefy | Ping na adres link-local lub `ff02::` zadziałał z `%<iface>` (Linux/macOS) lub `%<indeks>` (Windows). |
| Skrypt | `python3 ipv6_tool.py --selftest` wypisuje `All self-tests passed.` |
| Planowanie | `python3 ipv6_tool.py --plan 2001:db8:acad::/56 1` zgłasza `256 /64 subnets`. |

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| Pojawiają się tylko `::1` i adres `fe80::` | Twoja sieć lub dostawca nie oferuje IPv6, więc nie przychodzi żaden RA z prefiksem. | Nie ma czego naprawiać: kontynuuj z adresami link-local. Adresy globalne są w tym laboratorium opcjonalne. |
| Brak jakiegokolwiek adresu `fe80::` | IPv6 jest wyłączony na interfejsie (na przykład przez klienta VPN lub skrypt utwardzający). | Odnotuj to jako ustalenie. Ponowne włączenie IPv6 to zmiana konfiguracji poza tym laboratorium tylko do odczytu; zapytaj osobę zarządzającą maszyną. |
| `ping: Warning: IPv6 link-local address on ICMP datagram socket may require ifname or scope-id` i brak odpowiedzi | Pingowałeś `fe80::…` lub `ff02::1` bez ID strefy. | Dodaj `%<iface>` (Linux/macOS) lub `%<indeks>` (Windows). |
| `ping: ff02::1%wlan1: Name or service not known` | Nazwa interfejsu po `%` nie istnieje. | Użyj dokładnej nazwy interfejsu z kroku 2. |
| `ping6: command not found` (Linux) | Niektóre nowsze dystrybucje nie dostarczają już osobnego `ping6`; `ping` obsługuje oba. | Użyj `ping` (rozpoznaje IPv6 po adresie; w razie potrzeby dodaj `-6`). |
| Ping multicast pokazuje tylko Twój adres | Inne urządzenia nie odpowiadają na echo request wysyłane na multicast (częste przy zaporach i niektórych telefonach). | Normalne. Zamiast tego pingnij adres link-local bramy, a potem sprawdź pamięć podręczną sąsiadów. |
| Adres pokazuje `dadfailed` | Inne urządzenie w łączu używa tego samego adresu. | Zanotuj, który to adres i urządzenie; to realny problem sieciowy, o którym warto powiadomić właściciela sieci. |
| `SyntaxError` lub `AttributeError` przy uruchamianiu skryptu | Python starszy niż 3.8 albo błąd kopiowania (utracone wcięcia). | Sprawdź `python3 --version`; skopiuj blok kodu ponownie do zwykłego edytora tekstu. |

## Wyzwanie (opcjonalne)
Sprawdź, czy zapora hosta na Twoim komputerze stosuje do IPv6 tę samą politykę co do IPv4. W Linuksie obejrzyj zestaw reguł nftables (czy używa tablicy `inet`, czy osobnych tablic `ip` i `ip6`?); w Windows porównaj reguły ICMPv4 i ICMPv6 w Zaporze Windows Defender; w macOS obejrzyj Application Firewall i ustawienia `pf`. Potem sprawdź, czy reguły przepuściłyby ICMPv6 Packet Too Big (typ 2) i komunikaty NDP (typy 133–137), jak zaleca RFC 4890. Niektóre z tych poleceń wymagają uprawnień administratora; uruchamiaj je tylko na własnej maszynie i niczego nie zmieniaj.

## Sprzątanie
Laboratorium utworzyło tylko folder `ipv6-lab`. Wpisy w pamięci podręcznej sąsiadów z kroku 5 wygasają samoczynnie.

Linux i macOS:
```bash
cd ~ && rm -r ~/ipv6-lab
```

Windows (PowerShell):
```powershell
Set-Location $HOME; Remove-Item -Recurse -Force "$HOME\ipv6-lab"
```

Usuń notatki, w które wkleiłeś swoje prawdziwe adresy globalne IPv6, jeśli już ich nie potrzebujesz.

## Co już umiesz
- Twój komputer już używa IPv6: każdy interfejs ma adres link-local, a z routerem IPv6 także stały i tymczasowy adres globalny (czasem też ULA).
- Linux pokazuje zasięg (`host`, `link`, `global`) i pochodzenie (`temporary`, `mngtmpaddr`, `dynamic`) każdego adresu; ULA widnieją z zasięgiem `global`, więc sprawdzaj prefiks.
- Trasa domyślna wskazuje adres link-local routera i pochodzi z Router Advertisement.
- Adresy link-local i multicast o zasięgu łącza potrzebują ID strefy; NDP wypełnia pamięć podręczną sąsiadów w miarę rozmów z sąsiadami.
- Moduł `ipaddress` w Pythonie stosuje RFC 5952, rozwija adresy i dzieli prefiksy na podsieci `/64`; adresy solicited-node to `ff02::1:ff` plus ostatnie 24 bity.
