CloudAcademia
PL

Sieci komputerowe · Moduł 11 · DNS: jak nazwy zamieniają się w adresy

Laboratorium: śledzenie rozwiązywania nazwy i uruchomienie własnej strefy

Laboratorium60 minPoczątkującyMarkdown

Wyświetlany jest surowy Markdown: nie udało się wczytać renderera.

## Cel
Za pomocą `dig` śledzisz prawdziwe rozwiązywanie nazwy od korzenia w dół, odczytujesz każdą część odpowiedzi DNS i porównujesz transporty DNS. Następnie uruchamiasz we własnym kontenerze serwer autorytatywny DNS obsługujący strefę `lab.example`, odpytujesz go, zmieniasz rekord i obserwujesz, jak numer seryjny SOA decyduje o tym, kiedy zmiana zaczyna działać.

## Cele
- Prześledzić rozwiązywanie nazwy od korzenia do serwerów autorytatywnych za pomocą `dig +trace` i zobaczyć działanie pamięci podręcznej na odliczającym TTL.
- Odpytywać i rozpoznawać typowe typy rekordów: A, AAAA, CNAME, MX, NS, TXT, PTR, SOA i CAA.
- Odczytywać wynik `dig`: status, flagi (`qr`, `aa`, `rd`, `ra`, `ad`, `tc`) oraz sekcje odpowiedzi, autorytetu i dodatkową.
- Wysłać to samo zapytanie przez UDP, TCP, DNS przez TLS i DNS przez HTTPS oraz zobaczyć, jak ucięcie odpowiedzi wywołuje ponowienie przez TCP.
- Uruchomić serwer autorytatywny dla własnej strefy, zmienić rekord i potwierdzić zmianę za pomocą numeru seryjnego SOA.

## Wymagania wstępne
- `dig` z BIND 9.18 lub nowszego (`dig -v`). W Fedorze/RHEL: `bind-utils`; w Debianie/Ubuntu: `bind9-dnsutils`; w macOS: `brew install bind` (`dig` dostarczany z macOS jest starszy i nie obsługuje `+tls` ani `+https`). W Windows użyj dystrybucji Linuksa w WSL2.
- Podman 4 lub nowszy (testowano z Podmanem 5.8, rootless, bez `sudo`) albo Docker 20.10 lub nowszy: w każdym poleceniu zamień `podman` na `docker`.
- Dostęp do Internetu w Części 1. Kroki 3, 5 (zapytanie bezpośrednie), 8 i 9 komunikują się z serwerami innymi niż resolver Twojej sieci, więc nie działają w sieciach, które zezwalają na DNS tylko do własnego resolvera; zobacz Rozwiązywanie problemów.
- Około 75 MB miejsca na dysku na obraz CoreDNS.
- [Lekcja o DNS](lesson.pl.md) z tego modułu.

> [!WARNING]
> Część 1 wysyła zwykłe zapytania o publiczne nazwy do publicznych resolverów; to normalne użycie DNS. Nie wychodź poza nie: żadnych prób transferu strefy (AXFR), zalewania, skanowania ani testów „otwartego resolvera” wobec serwerów, które nie należą do Ciebie. Część 2 uruchamia serwer związany tylko z `127.0.0.1`, więc nic spoza Twojej maszyny nie może się z nim połączyć, a jedyny transfer strefy, jaki próbujesz, dotyczy tego serwera. Laboratorium jest bezpłatne i poza jednym katalogiem oraz jednym obrazem kontenera niczego w systemie nie zmienia; oba są usuwane na końcu.

> [!NOTE]
> Wyniki poniżej zarejestrowano w listopadzie 2026 r. Adresy, TTL, serwery nazw i podpisy prawdziwych domen (takich jak `example.com`, którą IANA hostuje u komercyjnego dostawcy DNS) zmieniają się w czasie, więc u Ciebie będą inne. Porównuj strukturę, flagi i kody statusu. Własna strefa używa wyłącznie adresów dokumentacyjnych (RFC 5737 i RFC 3849).

## Architektura
<figure class="diagram" style="--dg-w: 1080px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1080 440" width="1080" height="440" role="img" aria-labelledby="dns-lab-architecture-pl-title dns-lab-architecture-pl-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pl">
<title id="dns-lab-architecture-pl-title">Architektura laboratorium: dig odpytuje publiczne resolvery i lokalny kontener CoreDNS</title>
<desc id="dns-lab-architecture-pl-desc">Twój komputer uruchamia dig w terminalu. W części 1 dig odpytuje publiczne resolvery, takie jak 1.1.1.1, 9.9.9.9 i 8.8.8.8, lub resolver systemowy, przez UDP albo TCP na porcie 53, TLS na 853 lub HTTPS na 443; resolvery wysyłają zapytania iteracyjne do hierarchii DNS: korzenia, com i example.com. W części 2 dig odpytuje kontener Podman o nazwie dns-lab pod 127.0.0.1 port 5300, odwzorowany na port 53 wewnątrz kontenera, gdzie CoreDNS 1.12.0 jest autorytatywny dla strefy lab.example. Corefile i plik strefy db.lab.example znajdują się w folderze ~/dns-lab, zamontowanym w kontenerze tylko do odczytu.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1079" height="439" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l2"><rect class="dg-tint" x="20" y="20" width="640" height="400" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 33) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" 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="62" y="47" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">Twój komputer</text></g>
<g class="dg-l1"><rect class="dg-tint" x="680" y="20" width="380" height="400" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(696 33) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" 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="722" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">Internet</text></g>
<g class="dg-l7"><rect class="dg-tint" x="40" y="232" width="600" height="172" rx="16" fill="#f6f2fd" stroke="#c5a9f0" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(56 245) scale(0.7500)" fill="none" stroke="#6d28d9" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7 8.7 5 8.7-5"/><path d="M12 22V12"/></g>
<text x="82" y="259" font-size="13" class="dg-ink" fill="#6d28d9" font-weight="700">Kontener Podman: dns-lab</text></g>
<rect class="dg-card" x="44" y="64" width="260" height="112" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(60 80) 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="102" y="101" font-size="15" class="dg-text" fill="#17171c" font-weight="700">dig</text>
<text x="62" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dig @&lt;server&gt; &lt;name&gt;</text>
<text x="62" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">twój terminal</text>
<rect class="dg-card" x="60" y="278" width="280" height="112" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l7"><g class="dg-icon" transform="translate(76 294) scale(1.2500)" fill="none" stroke="#6d28d9" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 6h16"/><path d="M4 12h10"/><path d="M4 18h6"/><circle cx="18" cy="16" r="3"/><path d="m22 20-1.8-1.8"/></g></g>
<g class="dg-l7"><text x="118" y="315" font-size="15" class="dg-ink" fill="#6d28d9" font-weight="700">CoreDNS 1.12.0</text></g>
<text x="78" y="346" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">autorytatywny: lab.example</text>
<text x="78" y="366" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nasłuchuje na :53 udp/tcp</text>
<rect class="dg-card" x="392" y="278" width="230" height="112" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(408 294) scale(1.2500)" fill="none" stroke="#17171c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g>
<text x="450" y="315" font-size="15" class="dg-text" fill="#17171c" font-weight="700">~/dns-lab</text>
<text x="410" y="346" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">Corefile</text>
<text x="410" y="366" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">db.lab.example</text>
<rect class="dg-card" x="700" y="64" width="340" height="112" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(716 80) scale(1.2500)" fill="none" stroke="#0369a1" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M4 6h16"/><path d="M4 12h10"/><path d="M4 18h6"/><circle cx="18" cy="16" r="3"/><path d="m22 20-1.8-1.8"/></g></g>
<g class="dg-l1"><text x="758" y="101" font-size="15" class="dg-ink" fill="#0369a1" font-weight="700">Publiczne resolvery</text></g>
<text x="718" y="132" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">1.1.1.1 · 9.9.9.9 · 8.8.8.8</text>
<text x="718" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">lub resolver systemowy</text>
<rect class="dg-card" x="700" y="292" width="340" height="112" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-icon-neutral" transform="translate(716 308) 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="758" y="329" font-size="15" class="dg-text" fill="#17171c" font-weight="700">Hierarchia DNS</text>
<text x="718" y="360" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">root → com. → example.com.</text>
<text x="718" y="380" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">i inne prawdziwe strefy</text>
<g class="dg-l1"><path class="dg-stroke" d="M306 110H692" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M687 104l8 6-8 6" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="358.98" y="98" width="282.04" height="24" rx="12" fill="#ffffff"/><text x="500" y="114.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">Część 1: UDP/TCP 53 · TLS 853 · HTTPS 443</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M870 178V284" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><path class="dg-stroke" d="M864 279l6 8 6-8" stroke="#0369a1" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l1"><rect class="dg-bg-plain" x="796.6" y="219" width="146.8" height="24" rx="12" fill="#ffffff"/><text x="870" y="235.5" font-size="11.5" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle">zapytania iteracyjne</text></g>
<g class="dg-l7"><path class="dg-stroke" d="M290 178V270" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><path class="dg-stroke" d="M284 265l6 8 6-8" stroke="#6d28d9" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l7"><rect class="dg-bg-plain" x="307.62" y="192" width="204.76" height="24" rx="12" fill="#ffffff"/><text x="410" y="208.5" font-size="11.5" class="dg-ink" fill="#6d28d9" font-weight="600" text-anchor="middle">Część 2: 127.0.0.1:5300 → :53</text></g>
<path class="dg-line" d="M390 352H346" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/>
<path class="dg-line" d="M353 346l-8 6 8 6" stroke="#cfcfc8" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/>
</svg></figure>

*Rysunek 1. Część 1 komunikuje się z prawdziwym DNS przez resolvery; Część 2 komunikuje się z Twoim własnym serwerem autorytatywnym pod adresem `127.0.0.1:5300`.*

Używany jest port 5300, bo port 53 wymaga uprawnień administratora i zwykle zajmuje go resolver Twojego systemu, a port 5353 jest używany przez multicast DNS (mDNS, na przykład Avahi lub Bonjour).

## Kroki

### Krok 1 — Sprawdź narzędzia i utwórz katalog roboczy
Najpierw potwierdź wersje: `+tls` i `+https` wymagają BIND 9.18 lub nowszego. Pliki strefy trzymasz w jednym katalogu, więc sprzątanie jest łatwe.

```bash
dig -v
podman --version
mkdir -p ~/dns-lab && cd ~/dns-lab
```

> [!WARNING]
> Wszystkie kolejne polecenia wykonuj z `~/dns-lab`. Krok 11 montuje bieżący katalog w kontenerze z opcją `:Z`, która zmienia etykietę dla SELinuksa; uruchomione z katalogu domowego zmieniłoby etykiety całego katalogu i udostępniło go.

Oczekiwane wyjście (wersje mogą być nowsze):
```text
DiG 9.18.50
podman version 5.8.7
```

Sprawdź, czy nic jeszcze nie nasłuchuje na porcie 5300 (Linux):
```bash
ss -lntu | grep ':5300 ' || echo "port 5300 is free"
```

Oczekiwane wyjście:
```text
port 5300 is free
```

Jeśli coś jest wymienione, wybierz inny wysoki port (na przykład 5301) i używaj go wszędzie tam, gdzie to laboratorium podaje `5300`. W macOS użyj zamiast tego `lsof -nP -i :5300`; brak wyjścia oznacza, że port jest wolny.

## Część 1 — Prawdziwy DNS, tylko do odczytu

### Krok 2 — Pierwsze zapytanie, odczytane w całości
Zacznij od zwykłego zapytania do resolvera systemowego i odczytaj każdą sekcję, jak na Rysunku 2 z lekcji.

```bash
dig example.com
```

Oczekiwane wyjście:
```text
; <<>> DiG 9.18.50 <<>> example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 46107
;; flags: qr rd ra; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 65494
;; QUESTION SECTION:
;example.com.			IN	A

;; ANSWER SECTION:
example.com.		176	IN	A	104.20.23.154
example.com.		176	IN	A	172.66.147.243

;; Query time: 2 msec
;; SERVER: 127.0.0.53#53(127.0.0.53) (UDP)
;; WHEN: Fri Nov 06 22:12:34 CET 2026
;; MSG SIZE  rcvd: 72
```

Zapisz w notatkach:
- **Status** `NOERROR` i flagi `qr rd ra`: to odpowiedź (`qr`), zażądano rekurencji (`rd`), a serwer ją oferuje (`ra`). Nie ma `aa`: odpowiedział resolver, nie serwer autorytatywny. Nie ma też `ad`: ten resolver nie zgłosił weryfikacji DNSSEC.
- **Odpowiedź**: dwa rekordy A (zestaw RRset), każdy z nazwą, TTL, klasą `IN`, typem i adresem.
- **SERVER**: który resolver odpowiedział i przez jaki transport. `127.0.0.53` to lokalny stub systemd-resolved w wielu systemach Linux; u Ciebie może to być adres routera lub dostawcy internetu. Duża wartość `udp: 65494` pochodzi z tego lokalnego stuba; prawdziwe resolvery zwykle ogłaszają 1232.

### Krok 3 — Podążaj za delegacją od korzenia
`+trace` sprawia, że `dig` sam robi to, co resolver rekurencyjny: pyta korzeń, podąża za każdym odesłaniem i kończy na serwerach autorytatywnych.

```bash
dig +trace example.com
```

Oczekiwane wyjście (długie linie podpisów `RRSIG` skrócono do `…`):
```text
.			22378	IN	NS	a.root-servers.net.
.			22378	IN	NS	b.root-servers.net.
...
.			22378	IN	NS	m.root-servers.net.
.			23505	IN	RRSIG	NS 8 0 518400 20261119170000 20261106160000 8763 . …
;; Received 1037 bytes from 127.0.0.53#53(127.0.0.53) in 3 ms

com.			172800	IN	NS	a.gtld-servers.net.
...
com.			172800	IN	NS	m.gtld-servers.net.
com.			86400	IN	DS	19718 13 2 8ACBB0CD28F41250A80A491389424D341522D946B0DA0C0291F2D3D7 71D7805A
com.			86400	IN	RRSIG	DS 8 1 86400 20261119170000 20261106160000 8763 . …
;; Received 1171 bytes from 2801:1b8:10::b#53(b.root-servers.net) in 77 ms

example.com.		172800	IN	NS	hera.ns.cloudflare.com.
example.com.		172800	IN	NS	elliott.ns.cloudflare.com.
example.com.		86400	IN	DS	2371 13 2 C988EC423E3880EB8DD8A46FE06CA230EE23F35B578D64E78B29C3E1 C83D245A
example.com.		86400	IN	RRSIG	DS 13 2 86400 20261113013408 20261106002408 65344 com. …
;; Received 506 bytes from 2001:503:d2d::30#53(k.gtld-servers.net) in 37 ms

example.com.		300	IN	A	172.66.147.243
example.com.		300	IN	A	104.20.23.154
example.com.		300	IN	RRSIG	A 13 2 300 20261107221240 20261105201240 34505 example.com. …
;; Received 179 bytes from 2606:4700:50::adf5:3aa2#53(hera.ns.cloudflare.com) in 3 ms
```

Dopasuj każdy blok do Rysunku 5 z lekcji:
1. Resolver podaje 13 nazw serwerów głównych, od `a` do `m` (jak root hints).
2. Serwer główny (tutaj `b.root-servers.net`) odsyła do 13 serwerów `com`. Wysyła też rekord **DS** dla `com`: ogniwo DNSSEC od korzenia do `com`.
3. Serwer `com` odsyła do serwerów nazw `example.com`, z rekordem DS dla `example.com`.
4. Jeden z tych serwerów odpowiada rekordami A. Jego TTL ma pełną wartość, 300, bo to kopia autorytatywna, a nie z pamięci podręcznej.

Zanotuj serwery nazw, których `example.com` używa obecnie; jeden z nich będzie potrzebny w Kroku 5.

### Krok 4 — Poznaj typy rekordów
Poproś o różne typy danych. `+noall +answer` ukrywa wszystko oprócz sekcji odpowiedzi.

```bash
dig example.com AAAA +noall +answer
dig example.com NS +noall +answer
dig example.com SOA +noall +answer
dig example.com MX +noall +answer
dig example.com TXT +noall +answer
```

Oczekiwane wyjście:
```text
example.com.		70	IN	AAAA	2606:4700:10::6814:179a
example.com.		70	IN	AAAA	2606:4700:10::ac42:93f3
example.com.		25054	IN	NS	elliott.ns.cloudflare.com.
example.com.		25054	IN	NS	hera.ns.cloudflare.com.
example.com.		1800	IN	SOA	elliott.ns.cloudflare.com. dns.cloudflare.com. 2418004112 10000 2400 604800 1800
example.com.		300	IN	MX	0 .
example.com.		300	IN	TXT	"v=spf1 -all"
example.com.		300	IN	TXT	"_k2n1y4vw3qtb4skdx9e7dxt97qrmmq9"
```

Odczytaj je, korzystając z tabeli rekordów z lekcji:
- **AAAA**: adresy IPv6.
- **NS**: serwery autorytatywne, jak w Kroku 3.
- **SOA**: serwer główny, skrzynka kontaktowa (`dns@cloudflare.com`, z `@` zapisanym jako kropka), numer seryjny `2418004112`, potem refresh, retry, expire i minimum (TTL pamięci negatywnej, 1800 s).
- **MX `0 .`** to **null MX** (RFC 7505): `example.com` nie przyjmuje poczty. TXT `v=spf1 -all` dodaje, że żaden serwer nie może wysyłać poczty w jej imieniu. Razem chronią domenę, która nigdy nie powinna wysyłać ani odbierać poczty, przed użyciem jej do sfałszowanych wiadomości.
- Drugi ciąg TXT to typowy token potwierdzający własność domeny.

Teraz rekord **CNAME** i rekord **CAA**, na dobrze znanych domenach:

```bash
dig www.wikipedia.org +noall +answer
dig wikipedia.org CAA +noall +answer
```

Oczekiwane wyjście:
```text
www.wikipedia.org.	17574	IN	CNAME	dyna.wikimedia.org.
dyna.wikimedia.org.	109	IN	A	185.15.58.224
wikipedia.org.		600	IN	CAA	0 iodef "mailto:dns-admin@wikimedia.org"
wikipedia.org.		600	IN	CAA	0 issue "pki.goog"
wikipedia.org.		600	IN	CAA	0 issue "letsencrypt.org"
```

Resolver podążył za CNAME za Ciebie i zwrócił cały łańcuch: najpierw alias, potem rekord A celu. Każdy rekord ma własny TTL. Rekordy CAA zezwalają na wystawianie certyfikatów dwóm urzędom certyfikacji (`issue`) i podają kontakt do zgłoszeń (`iodef`). Adres A zależy od Twojej lokalizacji: duże serwisy odpowiadają adresem pobliskiego centrum danych.

### Krok 5 — Odpowiedzi z pamięci podręcznej a autorytatywne
Zapytaj resolver dwa razy, w odstępie około 10 sekund, i obserwuj TTL.

```bash
dig www.ietf.org +noall +answer; sleep 10; dig www.ietf.org +noall +answer
```

Oczekiwane wyjście:
```text
www.ietf.org.		28	IN	A	104.16.45.99
www.ietf.org.		28	IN	A	104.16.44.99
www.ietf.org.		17	IN	A	104.16.44.99
www.ietf.org.		17	IN	A	104.16.45.99
```

TTL zmalał mniej więcej o czas, który upłynął: obie odpowiedzi pochodziły z tej samej kopii w pamięci podręcznej. Gdy osiągnie 0, resolver pobiera świeżą kopię, a TTL wraca do wartości ze strefy. (Kolejność rekordów w RRset może się zmieniać między odpowiedziami; nie ma ona znaczenia.)

> [!TIP]
> Jeśli spróbujesz tego z dużym publicznym resolverem, takim jak `1.1.1.1`, TTL może skakać zamiast odliczać płynnie: anycast i równoważenie obciążenia mogą kierować Twoje dwa zapytania do różnych pamięci podręcznych.

Teraz zapytaj bezpośrednio jeden z serwerów autorytatywnych zanotowanych w Kroku 3, z wyłączoną rekurencją:

```bash
dig @<ns> example.com +norec
```

`<ns>` to jeden z serwerów nazw `example.com` z Kroku 3, na przykład `hera.ns.cloudflare.com`.

Oczekiwane wyjście (nagłówek i odpowiedź):
```text
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 40469
;; flags: qr aa; QUERY: 1, ANSWER: 2, AUTHORITY: 0, ADDITIONAL: 1
...
;; ANSWER SECTION:
example.com.		300	IN	A	172.66.147.243
example.com.		300	IN	A	104.20.23.154
```

`aa` jest ustawione, a `ra` nie: to serwer autorytatywny, który nie wykonuje rekurencji za Ciebie. Uruchom to ponownie: TTL pozostaje na 300, bo serwer jest właścicielem danych, a nie trzyma ich w pamięci podręcznej.

### Krok 6 — Nazwa, która nie istnieje
Odpowiedzi negatywne też niosą informacje.

```bash
dig nonexistent.iana.org
```

Oczekiwane wyjście (od nagłówka do sekcji autorytetu):
```text
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 4050
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 0, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
;; QUESTION SECTION:
;nonexistent.iana.org.		IN	A

;; AUTHORITY SECTION:
iana.org.		3600	IN	SOA	sns.dns.icann.org. noc.dns.icann.org. 2026110301 7200 3600 1209600 3600
```

`NXDOMAIN` z pustą odpowiedzią i rekordem SOA strefy w sekcji autorytetu. Resolver zapamiętuje to „nie istnieje” na krótszy z dwóch czasów: TTL rekordu SOA i jego ostatnie pole (tu oba wynoszą 3600): to pamięć negatywna, RFC 2308. Ten wynik pochodzi z resolvera walidującego, więc zawiera też `ad`: sam brak nazwy został udowodniony za pomocą DNSSEC.

> [!NOTE]
> Niektórzy dostawcy DNS odpowiadają na zapytania o nieistniejące nazwy w strefach podpisanych kodem `NOERROR` i pustą odpowiedzią zamiast `NXDOMAIN` (technika zmniejszająca odpowiedzi DNSSEC o zaprzeczeniu istnienia). Jeśli przy innych domenach zobaczysz coś takiego, to wybór dostawcy, a nie błąd po Twojej stronie.

### Krok 7 — Zapytania odwrotne
`-x` buduje nazwę odwrotną w `in-addr.arpa` lub `ip6.arpa` i pyta o jej rekord PTR.

```bash
dig -x 8.8.8.8 +noall +question +answer
dig -x 2001:4860:4860::8888 +short
```

Oczekiwane wyjście:
```text
;8.8.8.8.in-addr.arpa.		IN	PTR
8.8.8.8.in-addr.arpa.	17593	IN	PTR	dns.google.
dns.google.
```

Pytanie pokazuje odwrócony adres. Dla adresu IPv6 `dig` zapisuje wszystkie 32 cyfry szesnastkowe wspak, po jednej na etykietę, w `ip6.arpa`; aby zobaczyć tę nazwę, dodaj `+noall +answer` zamiast `+short`.

### Krok 8 — Transporty: UDP, TCP, TLS, HTTPS
Wyślij to samo zapytanie każdym transportem i odczytaj linię `SERVER`. Użyto `1.1.1.1`, bo obsługuje wszystkie cztery; zadziała każdy resolver oferujący DoT i DoH.

```bash
dig @1.1.1.1 example.com +noall +answer +stats | grep SERVER
dig @1.1.1.1 example.com +tcp +noall +answer +stats | grep SERVER
dig @1.1.1.1 example.com +tls +noall +answer +stats | grep SERVER
dig @1.1.1.1 example.com +https +noall +answer +stats | grep SERVER
```

Oczekiwane wyjście:
```text
;; SERVER: 1.1.1.1#53(1.1.1.1) (UDP)
;; SERVER: 1.1.1.1#53(1.1.1.1) (TCP)
;; SERVER: 1.1.1.1#853(1.1.1.1) (TLS)
;; SERVER: 1.1.1.1#443(1.1.1.1) (HTTPS)
```

To samo pytanie, ta sama odpowiedź, cztery transporty: port 53 przez UDP i TCP (jawny tekst), 853 dla DNS przez TLS, 443 dla DNS przez HTTPS.

Teraz zobacz **ucięcie (truncation)**. Zestaw kluczy strefy głównej z podpisami ma około 1100 bajtów. Załóż, że klient może odebrać przez UDP tylko 512 bajtów, i każ `dig` nie ponawiać zapytania (`+ignore`):

```bash
dig @1.1.1.1 . DNSKEY +dnssec +bufsize=512 +ignore | grep -E 'flags|SERVER'
```

Oczekiwane wyjście:
```text
;; flags: qr tc rd ra; QUERY: 1, ANSWER: 0, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
;; SERVER: 1.1.1.1#53(1.1.1.1) (UDP)
```

`tc` jest ustawione, a odpowiedź pusta. Uruchom to jeszcze raz bez `+ignore`:

```bash
dig @1.1.1.1 . DNSKEY +dnssec +bufsize=512 | grep -E 'Truncated|flags:|SERVER|MSG'
```

Oczekiwane wyjście:
```text
;; Truncated, retrying in TCP mode.
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 4, AUTHORITY: 0, ADDITIONAL: 1
;; SERVER: 1.1.1.1#53(1.1.1.1) (TCP)
;; MSG SIZE  rcvd: 1139
```

Dlatego TCP 53 nigdy nie może być blokowany: duże odpowiedzi, takie jak podpisane, od niego zależą.

### Krok 9 — DNSSEC: poprawna weryfikacja i celowa porażka
Poproś resolver walidujący o podpisane dane i poszukaj `ad`:

```bash
dig @1.1.1.1 example.com +dnssec +noall +comments | grep flags
```

Oczekiwane wyjście:
```text
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
```

`ad`: resolver zweryfikował łańcuch zaufania. Trzeci rekord odpowiedzi to podpis RRSIG (dodaj `+answer`, aby go zobaczyć).

`dnssec-failed.org` to domena testowa, której operator celowo utrzymuje zepsuty DNSSEC, aby można było zobaczyć, co się dzieje. Odpytaj ją normalnie, a potem z wyłączonym sprawdzaniem (`+cd`):

```bash
dig @1.1.1.1 dnssec-failed.org | grep status
dig @1.1.1.1 dnssec-failed.org +cd | grep -E 'status|flags:|EDE'
```

Oczekiwane wyjście:
```text
;; ->>HEADER<<- opcode: QUERY, status: SERVFAIL, id: 26914
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 18406
;; flags: qr rd ra cd; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags:; udp: 1232
; EDE: 9 (DNSKEY Missing): (no SEP matching the DS found for dnssec-failed.org.)
```

Resolver walidujący odrzuca błędne dane kodem `SERVFAIL`. Z `+cd` dostajesz dane mimo to, bez `ad`, a rozszerzony błąd DNS (EDE, Extended DNS Error, RFC 8914) wyjaśnia, dlaczego walidacja się nie powiodła: klucz w strefie nie pasuje do rekordu DS w strefie nadrzędnej. Zwróć uwagę, że wszystko, co zobaczono w tym kroku, przebiegało jawnym tekstem: DNSSEC dowodzi autentyczności, a nie poufności.

## Część 2 — Własny serwer autorytatywny

### Krok 10 — Napisz plik strefy i konfigurację serwera
Serwer autorytatywny potrzebuje dwóch rzeczy: danych strefy i konfiguracji wskazującej, którą strefę obsługiwać. Użyjesz **CoreDNS**, małego otwartoźródłowego serwera DNS, z jego wtyczką `file`. Strefa `lab.example` jest bezpieczna: TLD `example` jest zarezerwowana do dokumentacji (RFC 2606) i nigdy nie istnieje w Internecie.

Utwórz plik strefy w `~/dns-lab`:

```bash
cat > db.lab.example <<'EOF'
$ORIGIN lab.example.
$TTL 300
@       IN  SOA   ns1.lab.example. hostmaster.lab.example. (
                  2026110601 ; serial (YYYYMMDDnn)
                  3600       ; refresh
                  600        ; retry
                  604800     ; expire
                  60 )       ; minimum: negative-caching TTL
        IN  NS    ns1.lab.example.
        IN  MX    10 mail.lab.example.
        IN  TXT   "v=spf1 mx -all"
        IN  CAA   0 issue "ca.example.net"
ns1     IN  A     192.0.2.53
www     IN  A     192.0.2.10
www     IN  AAAA  2001:db8::10
mail    IN  A     192.0.2.25
app     IN  CNAME www.lab.example.
EOF
```

Potem konfigurację CoreDNS, czyli `Corefile`:

```bash
cat > Corefile <<'EOF'
lab.example {
    file /etc/coredns/db.lab.example {
        reload 10s
    }
    log
    errors
}
EOF
```

Mówi ona: dla nazw w `lab.example` odpowiadaj z pliku strefy; co 10 sekund sprawdzaj plik pod kątem nowego numeru seryjnego; loguj każde zapytanie. Nazwy spoza `lab.example` są odrzucane: to serwer wyłącznie autorytatywny, a nie resolver.

Nie oczekuje się żadnego wyjścia. `ls` powinno pokazać `Corefile` i `db.lab.example`.

### Krok 11 — Uruchom serwer w kontenerze
Uruchom CoreDNS z katalogiem zamontowanym tylko do odczytu i portem 53 kontenera opublikowanym na `127.0.0.1:5300`, zarówno dla UDP, jak i TCP.

```bash
podman run -d --name dns-lab \
  -p 127.0.0.1:5300:53/udp -p 127.0.0.1:5300:53/tcp \
  -v "$PWD":/etc/coredns:ro,Z \
  docker.io/coredns/coredns:1.12.0 -conf /etc/coredns/Corefile
```

- `-p 127.0.0.1:5300:53/udp` i `/tcp`: tylko Twoja maszyna może połączyć się z serwerem; DNS potrzebuje obu protokołów.
- `-v "$PWD":/etc/coredns:ro,Z`: montuje bieżący katalog tylko do odczytu. `Z` zmienia etykietę dla SELinuksa (Fedora, RHEL); w systemach bez SELinuksa nie szkodzi, a jeśli Twoja wersja Dockera zgłasza błąd, można je pominąć. Montowany jest cały katalog, a nie pojedyncze pliki, więc zmiany zapisane przez dowolny edytor tekstu są widoczne wewnątrz kontenera.
- Tag obrazu jest przypięty do `1.12.0`, aby laboratorium zachowywało się tak samo u wszystkich.

Potem sprawdź, czy działa:
```bash
podman ps --filter name=dns-lab
podman logs dns-lab
```

Oczekiwane wyjście (identyfikatory się różnią):
```text
CONTAINER ID  IMAGE                             COMMAND               CREATED        STATUS        PORTS                                           NAMES
b0474e9d2db7  docker.io/coredns/coredns:1.12.0  -conf /etc/coredn...  2 seconds ago  Up 2 seconds  127.0.0.1:5300->53/tcp, 127.0.0.1:5300->53/udp  dns-lab
maxprocs: Leaving GOMAXPROCS=16: CPU quota undefined
lab.example.:53
CoreDNS-1.12.0
linux/amd64, go1.23.3, 51e11f1
```

`lab.example.:53` potwierdza, że strefa została wczytana, a serwer nasłuchuje na porcie 53 wewnątrz kontenera.

### Krok 12 — Odpytaj swoją strefę
Zapytaj bezpośrednio własny serwer. `-p 5300` ustawia port; `+norec`, bo to nie jest resolver.

```bash
dig @127.0.0.1 -p 5300 www.lab.example +norec
```

Oczekiwane wyjście (od nagłówka do linii serwera):
```text
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 42732
;; flags: qr aa; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 1232
; COOKIE: ce837fc3bf088f64 (echoed)
;; QUESTION SECTION:
;www.lab.example.		IN	A

;; ANSWER SECTION:
www.lab.example.	300	IN	A	192.0.2.10

;; AUTHORITY SECTION:
lab.example.		300	IN	NS	ns1.lab.example.

;; Query time: 0 msec
;; SERVER: 127.0.0.1#5300(127.0.0.1) (UDP)
```

`aa`: to Ty jesteś teraz autorytetem. Ten serwer wymienia też rekord NS strefy w sekcji autorytetu. Linia `COOKIE` to ciasteczko DNS (RFC 7873), lekka ochrona przed sfałszowanymi zapytaniami.

Teraz odpytaj każdy opublikowany typ rekordu:

```bash
D="dig @127.0.0.1 -p 5300 +norec +noall +answer"
$D lab.example SOA
$D lab.example MX
$D lab.example TXT
$D lab.example CAA
$D www.lab.example AAAA
$D app.lab.example A
```

Oczekiwane wyjście:
```text
lab.example.		300	IN	SOA	ns1.lab.example. hostmaster.lab.example. 2026110601 3600 600 604800 60
lab.example.		300	IN	MX	10 mail.lab.example.
lab.example.		300	IN	TXT	"v=spf1 mx -all"
lab.example.		300	IN	CAA	0 issue "ca.example.net"
www.lab.example.	300	IN	AAAA	2001:db8::10
app.lab.example.	300	IN	CNAME	www.lab.example.
www.lab.example.	300	IN	A	192.0.2.10
```

`D` to tylko zmienna powłoki, która oszczędza pisanie. Każdy rekord ma domyślny TTL strefy równy 300 z `$TTL`. Dla `app` serwer podążył za CNAME wewnątrz własnej strefy i dołączył rekord A celu.

Dalej trzy odpowiedzi, które nie są danymi:

```bash
dig @127.0.0.1 -p 5300 nope.lab.example +norec | grep -E 'status|SOA'
dig @127.0.0.1 -p 5300 www.example.com +norec | grep status
dig @127.0.0.1 -p 5300 lab.example AXFR
```

Oczekiwane wyjście:
```text
;; ->>HEADER<<- opcode: QUERY, status: NXDOMAIN, id: 32533
lab.example.		300	IN	SOA	ns1.lab.example. hostmaster.lab.example. 2026110601 3600 600 604800 60
;; ->>HEADER<<- opcode: QUERY, status: REFUSED, id: 60198

; <<>> DiG 9.18.50 <<>> @127.0.0.1 -p 5300 lab.example AXFR
; (1 server found)
;; global options: +cmd
; Transfer failed.
```

- `NXDOMAIN` z Twoim SOA. CoreDNS wysyła SOA z jego własnym TTL (300); zgodnie z RFC 2308 resolver zapamiętuje odpowiedź negatywną na krótszy z dwóch czasów: ten TTL i ostatnie pole SOA, czyli 60 sekund.
- `REFUSED` dla `www.example.com`: Twój serwer nie jest dla niej autorytatywny i nie wykonuje rekurencji.
- Transfer strefy kończy się niepowodzeniem, bo CoreDNS nie zezwala na transfery, dopóki ich nie skonfigurujesz (wtyczka `transfer`). To bezpieczna wartość domyślna: tylko Twoje własne serwery wtórne powinny móc kopiować strefę.

Na koniec zobacz dziennik zapytań:
```bash
podman logs dns-lab 2>&1 | tail -3
```

Oczekiwane wyjście (adres klienta zależy od konfiguracji sieci Podmana na Twojej maszynie):
```text
[INFO] <client-ip>:59919 - 48226 "A IN app.lab.example. udp 56 false 1232" NOERROR qr,aa 148 0.000053703s
[INFO] <client-ip>:38194 - 27721 "A IN nope.lab.example. udp 57 false 1232" NXDOMAIN qr,aa 118 0.000072779s
[INFO] <client-ip>:60166 - 21479 "AXFR IN lab.example. tcp 52 false 65535" - - 0 0.000022052s
```

Każda linia pokazuje adres i port klienta, identyfikator wiadomości, pytanie, transport (zwróć uwagę na `tcp` przy AXFR), kod odpowiedzi, flagi, rozmiar odpowiedzi i czas obsługi. Odrzuconego zapytania o `www.example.com` tu nie ma: linia `log` w `Corefile` dotyczy tylko bloku `lab.example`.

### Krok 13 — Zmień rekord i obserwuj numer seryjny
Przeniesiesz `www` z `192.0.2.10` na `192.0.2.11`. Najpierw zmień tylko adres i **nie** ruszaj numeru seryjnego. Otwórz `db.lab.example` w edytorze tekstu i zmień linię `www IN A`, albo w Linuksie:

```bash
sed -i 's/192\.0\.2\.10/192.0.2.11/' db.lab.example
grep '^www' db.lab.example
```

Oczekiwane wyjście:
```text
www     IN  A     192.0.2.11
www     IN  AAAA  2001:db8::10
```

Odczekaj co najmniej 15 sekund (interwał `reload` to 10 s), a potem zapytaj:

```bash
dig @127.0.0.1 -p 5300 www.lab.example +short
```

Oczekiwane wyjście:
```text
192.0.2.10
```

Nadal stary adres. CoreDNS (podobnie jak serwery wtórne) wczytuje strefę ponownie tylko wtedy, gdy **numer seryjny** rośnie. Teraz zwiększ numer seryjny z `2026110601` do `2026110602`:

```bash
sed -i 's/2026110601 ; serial/2026110602 ; serial/' db.lab.example
```

Znów odczekaj 15 sekund i powtórz zapytanie oraz sprawdzenie dziennika:

```bash
dig @127.0.0.1 -p 5300 www.lab.example +short
dig @127.0.0.1 -p 5300 lab.example SOA +short
podman logs dns-lab 2>&1 | grep reloaded
```

Oczekiwane wyjście:
```text
192.0.2.11
ns1.lab.example. hostmaster.lab.example. 2026110602 3600 600 604800 60
[INFO] plugin/file: Successfully reloaded zone "lab.example." in "/etc/coredns/db.lab.example" with 2026110602 SOA serial
```

Nowy adres działa od razu, gdy numer seryjny wzrośnie. W prawdziwym Internecie doszłoby jeszcze jedno opóźnienie: resolvery, które zapamiętały stary rekord A, zwracają go, dopóki nie upłynie jego 300-sekundowy TTL.

> [!NOTE]
> W macOS `sed -i` wymaga pustego argumentu: `sed -i '' 's/…/…/' db.lab.example`. Można też po prostu edytować plik w dowolnym edytorze tekstu.

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

| Sprawdzenie | Warunek zaliczenia |
|---|---|
| Ślad | W Kroku 3 potrafisz nazwać serwer, który odpowiedział na każdym poziomie (korzeń, `com`, `example.com`), i wskazać rekordy DS, które je łączą. |
| Pamięć podręczna | W Kroku 5 TTL z Twojego resolvera zmalał między dwoma zapytaniami, a TTL z serwera autorytatywnego pozostał taki sam przy ustawionym `aa`. |
| Rekordy | Rozpoznane zostały odpowiedzi A, AAAA, NS, SOA, MX (null MX), TXT, CNAME, CAA (Krok 4) i PTR (Krok 7). |
| Transporty | Krok 8 pokazał `(UDP)`, `(TCP)`, `(TLS)` na porcie 853 i `(HTTPS)` na porcie 443 oraz odpowiedź z `tc` ponowioną przez TCP. |
| DNSSEC | Krok 9 pokazał `ad` dla `example.com` i `SERVFAIL` dla `dnssec-failed.org`. |
| Twoja strefa | `dig @127.0.0.1 -p 5300 www.lab.example +norec` pokazuje `flags: qr aa` oraz, po Kroku 13, adres `192.0.2.11` z numerem seryjnym `2026110602`. |

## Rozwiązywanie problemów
| Objaw | Prawdopodobna przyczyna | Rozwiązanie |
|---|---|---|
| `dig +trace` kończy się komunikatem `communications error … timed out` po liście serwerów głównych | Sieć blokuje wychodzący DNS do czegokolwiek poza własnym resolverem (częste w firmach, hotelach i niektórych routerach domowych). | Pomiń Krok 3 albo wykonaj go w innej sieci, z której wolno Ci korzystać; reszta Części 1 przechodzi przez resolvery. |
| `+tls` lub `+https` wypisuje `Invalid option` | `dig` starszy niż 9.18 (na przykład wbudowany w macOS) lub zbudowany bez obsługi DoH. | Zainstaluj aktualny BIND (`brew install bind` lub pakiet z Twojej dystrybucji Linuksa) i sprawdź `dig -v`. |
| `+tls` lub `+https` przekracza limit czasu | Sieć blokuje port 853 lub filtruje DoH. | Zapisz to jako ustalenie: to kompromis z lekcji. Spróbuj w innej sieci, z której wolno Ci korzystać. |
| `podman run` kończy się błędem `address already in use` | Coś już nasłuchuje na `127.0.0.1:5300`. | Wybierz inny port (na przykład 5301) w opcjach `-p` i w każdym poleceniu `dig -p`. |
| `dig @127.0.0.1 -p 5300 …` zwraca `connection refused` lub przekracza limit czasu | Kontener nie działa: błąd w `Corefile` lub pliku strefy zatrzymuje CoreDNS. | `podman logs dns-lab` pokazuje błąd i numer linii. Popraw plik, potem `podman rm -f dns-lab` i powtórz Krok 11. |
| `permission denied` przy odczycie `/etc/coredns/Corefile` w dzienniku | SELinux zablokował zamontowany katalog. | Upewnij się, że opcja woluminu zawiera `Z` (`:ro,Z`). |
| `REFUSED` dla `www.lab.example` | Strefa nie została wczytana (na przykład literówka w `$ORIGIN` lub brak końcowej kropki), więc serwer nie ma strefy `lab.example`. | Sprawdź `podman logs dns-lab` i porównaj plik strefy z Krokiem 10. |
| Zmieniony rekord się nie pojawia | Numer seryjny nie został zwiększony albo upłynęło mniej niż 10 sekund. | Zwiększ numer seryjny i odczekaj 15 sekund; poszukaj w dzienniku `Successfully reloaded zone`. |
| `podman: command not found` | Podman nie jest zainstalowany. | Zainstaluj go z pakietów swojej dystrybucji albo użyj Dockera i w każdym poleceniu zamień `podman` na `docker`. |

## Wyzwanie (opcjonalne)
Dodaj do serwera strefę odwrotną dla `192.0.2.0/24`: drugi blok `file` w `Corefile` dla `2.0.192.in-addr.arpa` oraz plik strefy z rekordami SOA, NS i PTR dla `192.0.2.10`, `192.0.2.25` i `192.0.2.53`. Sprawdź to poleceniem `dig @127.0.0.1 -p 5300 -x 192.0.2.10 +norec`. Potem obniż TTL rekordu `www` do 60 sekund (pamiętaj o numerze seryjnym) i wyjaśnij w dwóch zdaniach, dlaczego robi się to na dobę przed prawdziwą migracją.

## Sprzątanie
Zatrzymaj i usuń kontener, usuń obraz i skasuj katalog laboratorium:

```bash
podman rm -f dns-lab
podman rmi docker.io/coredns/coredns:1.12.0
cd ~ && rm -r ~/dns-lab
```

Oczekiwane wyjście (identyfikatory się różnią):
```text
dns-lab
Untagged: docker.io/coredns/coredns:1.12.0
Deleted: 1cf5f116067c67da67f97bff78c4bbc76913f59057c18627b96facaced73ea0b
```

Sprawdź, czy nic nie zostało:
```bash
podman ps -a --filter name=dns-lab
podman images coredns/coredns
```

Oba polecenia powinny wypisać tylko linie nagłówka. Część 1 niczego nie utworzyła, więc nie ma tam czego sprzątać; rekordy zapamiętane przez resolver wygasają same.

## Co już umiesz
- `dig +trace` pokazuje łańcuch delegacji: odesłanie z korzenia do `com`, odesłanie z `com` do serwerów domeny i odpowiedź autorytatywną, z rekordami DS łączącymi każdy poziom dla DNSSEC.
- TTL resolvera odlicza, bo odpowiedź pochodzi z jego pamięci podręcznej; TTL serwera autorytatywnego nie odlicza, a serwer ustawia `aa`.
- Jak odczytywać każdy typ rekordu, w tym null MX, łańcuch CNAME, CAA, pola SOA i rekordy PTR w `in-addr.arpa` i `ip6.arpa`.
- Kody statusu NOERROR, NXDOMAIN (z SOA dla pamięci negatywnej), SERVFAIL (nieudana walidacja DNSSEC) i REFUSED.
- To samo zapytanie działa przez UDP 53, TCP 53, TLS 853 i HTTPS 443, a ucięta (`tc`) odpowiedź UDP jest ponawiana przez TCP.
- Serwer autorytatywny obsługuje tylko swoje strefy, odrzuca pozostałe i powinien odmawiać transferu strefy obcym; zmiany w strefie zaczynają działać dopiero wtedy, gdy numer seryjny SOA rośnie.