Viene mostrato il Markdown grezzo: non è stato possibile caricare il visualizzatore.
## Obiettivo
Usa `dig` per seguire una vera risoluzione di nomi a partire dalla radice, leggere ogni parte di una risposta DNS e confrontare i trasporti DNS. Poi esegui il tuo server DNS autorevole in un container, che serve la zona `lab.example`, interrogalo, modifica un record e osserva come il serial del SOA decide quando la modifica diventa effettiva.
## Obiettivi
- Seguire una risoluzione dalla radice ai server autorevoli con `dig +trace` e vedere la cache al lavoro mentre il TTL scende.
- Interrogare e riconoscere i tipi di record più comuni: A, AAAA, CNAME, MX, NS, TXT, PTR, SOA e CAA.
- Leggere l'output di `dig`: stato, flag (`qr`, `aa`, `rd`, `ra`, `ad`, `tc`) e le sezioni answer, authority e additional.
- Inviare la stessa query via UDP, TCP, DNS su TLS e DNS su HTTPS, e vedere il troncamento innescare un nuovo tentativo via TCP.
- Eseguire un server autorevole per una zona tua, modificare un record e confermare la modifica con il serial del SOA.
## Prerequisiti
- `dig` di BIND 9.18 o successivo (`dig -v`). Su Fedora/RHEL: `bind-utils`; su Debian/Ubuntu: `bind9-dnsutils`; su macOS: `brew install bind` (il `dig` fornito con macOS è più vecchio e non ha `+tls` né `+https`). Su Windows, usa una distribuzione Linux in WSL2.
- Podman 4 o successivo (testato con Podman 5.8, rootless, senza `sudo`), oppure Docker 20.10 o successivo: sostituisci `podman` con `docker` in ogni comando.
- Accesso a Internet per la parte 1. I passaggi 3, 5 (la query diretta), 8 e 9 parlano con server diversi dal resolver della tua rete, quindi falliscono sulle reti che consentono il DNS solo verso il proprio resolver; vedi Risoluzione dei problemi.
- Circa 75 MB di spazio su disco per l'immagine di CoreDNS.
- [La lezione sul DNS](lesson.it.md) di questo modulo.
> [!WARNING]
> La parte 1 invia normali ricerche di nomi pubblici a resolver pubblici; è un uso normale del DNS. Non andare oltre: niente tentativi di trasferimento di zona (AXFR), raffiche, scansioni né test di "open resolver" contro server che non possiedi. La parte 2 esegue un server legato solo a `127.0.0.1`, quindi nulla fuori dalla tua macchina può raggiungerlo, e l'unico trasferimento di zona che provi è contro quel server. Il laboratorio è gratuito e non modifica nulla nel tuo sistema al di fuori di una cartella e di un'immagine di container, entrambe rimosse alla fine.
> [!NOTE]
> Gli output qui sotto sono stati acquisiti a novembre 2026. Indirizzi, TTL, name server e firme dei domini reali (come `example.com`, che IANA ospita presso un provider DNS commerciale) cambiano nel tempo, quindi i tuoi saranno diversi. Ciò che devi confrontare sono la struttura, i flag e i codici di stato. La tua zona usa solo indirizzi di documentazione (RFC 5737 e RFC 3849).
## Architettura
<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-it-title dns-lab-architecture-it-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="it">
<title id="dns-lab-architecture-it-title">Architettura del laboratorio: dig interroga resolver pubblici e un container CoreDNS locale</title>
<desc id="dns-lab-architecture-it-desc">Il tuo computer esegue dig in un terminale. Nella parte 1, dig interroga resolver pubblici come 1.1.1.1, 9.9.9.9 e 8.8.8.8, o il resolver di sistema, via UDP o TCP sulla porta 53, TLS sulla 853 o HTTPS sulla 443; i resolver fanno query iterative alla gerarchia DNS: la radice, com ed example.com. Nella parte 2, dig interroga un container Podman chiamato dns-lab su 127.0.0.1 porta 5300, mappata sulla porta 53 dentro il container, dove CoreDNS 1.12.0 è autorevole per la zona lab.example. Il Corefile e il file di zona db.lab.example si trovano nella cartella ~/dns-lab, montata in sola lettura nel container.</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">Il tuo computer</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">Container 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 @<server> <name></text>
<text x="62" y="152" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">il tuo terminale</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">autorevole: 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">in ascolto su :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">Resolver pubblici</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">o il resolver di sistema</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">Gerarchia 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">e altre zone reali</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">Parte 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="812.7" y="219" width="114.6" 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">query iterative</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">Parte 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>
*Figura 1. La parte 1 parla con il DNS reale tramite resolver; la parte 2 parla con il tuo server autorevole su `127.0.0.1:5300`.*
Si usa la porta 5300 perché la porta 53 richiede privilegi di amministratore ed è di solito occupata dal resolver del tuo sistema, e la porta 5353 è usata dal DNS multicast (mDNS, per esempio Avahi o Bonjour).
## Passaggi
### Passo 1 — Controlla gli strumenti e crea una cartella di lavoro
Conferma prima le versioni: `+tls` e `+https` richiedono BIND 9.18 o successivo. Terrai i file di zona in un'unica cartella, così la pulizia è facile.
```bash
dig -v
podman --version
mkdir -p ~/dns-lab && cd ~/dns-lab
```
> [!WARNING]
> Esegui tutti i comandi seguenti da `~/dns-lab`. Il passo 11 monta la cartella corrente nel container con `:Z`, che la rietichetta per SELinux; eseguito dalla tua cartella home, rietichetterebbe ed esporrebbe tutto il suo contenuto.
Output atteso (le versioni possono essere più recenti):
```text
DiG 9.18.50
podman version 5.8.7
```
Verifica che nulla sia già in ascolto sulla porta 5300 (Linux):
```bash
ss -lntu | grep ':5300 ' || echo "port 5300 is free"
```
Output atteso:
```text
port 5300 is free
```
Se compare qualcosa, scegli un'altra porta alta (per esempio 5301) e usala ovunque questo laboratorio dica `5300`. Su macOS usa invece `lsof -nP -i :5300`; nessun output significa che la porta è libera.
## Parte 1 — Il DNS reale, in sola lettura
### Passo 2 — La tua prima ricerca, letta per intero
Inizia con una semplice query al resolver del tuo sistema e leggi ogni sezione, come nella figura 2 della lezione.
```bash
dig example.com
```
Output atteso:
```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
```
Annota nei tuoi appunti:
- **Stato** `NOERROR` e flag `qr rd ra`: una risposta (`qr`), hai chiesto la ricorsione (`rd`) e il server la offre (`ra`). Non c'è `aa`: ha risposto un resolver, non il server autorevole. Non c'è nemmeno `ad`: questo resolver non ha segnalato la validazione DNSSEC.
- **Answer**: due record A (un RRset), ciascuno con nome, TTL, classe `IN`, tipo e indirizzo.
- **SERVER**: quale resolver ha risposto e con quale trasporto. `127.0.0.53` è lo stub locale di systemd-resolved su molti sistemi Linux; il tuo può essere l'indirizzo del tuo router o del tuo ISP. Il valore alto `udp: 65494` viene da quello stub locale; i resolver veri di solito annunciano 1232.
### Passo 3 — Segui la delega dalla radice
`+trace` fa fare a `dig` stesso ciò che fa un resolver ricorsivo: chiedere alla radice, seguire ogni referral e finire presso i server autorevoli.
```bash
dig +trace example.com
```
Output atteso (le lunghe righe di firma `RRSIG` abbreviate con `…`):
```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
```
Abbina ogni blocco alla figura 5 della lezione:
1. Il tuo resolver fornisce i 13 nomi dei root server, da `a` a `m` (come le root hints).
2. Un root server (qui `b.root-servers.net`) ti rimanda ai 13 server di `com`. Invia anche un record **DS** per `com`: il collegamento DNSSEC dalla radice a `com`.
3. Un server di `com` ti rimanda ai name server di `example.com`, con un record DS per `example.com`.
4. Uno di quei server risponde con i record A. Il suo TTL è il valore pieno, 300, perché è la copia autorevole, non una copia in cache.
Prendi nota dei name server che `example.com` usa oggi; te ne servirà uno al passo 5.
### Passo 4 — Conosci i tipi di record
Chiedi diversi tipi di dati. `+noall +answer` nasconde tutto tranne la sezione answer.
```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
```
Output atteso:
```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"
```
Leggili con la tabella dei record della lezione:
- **AAAA**: gli indirizzi IPv6.
- **NS**: i server autorevoli, come al passo 3.
- **SOA**: server primario, casella di contatto (`dns@cloudflare.com`, con la `@` scritta come punto), serial `2418004112`, poi refresh, retry, expire e minimum (TTL della cache negativa, 1800 s).
- **MX `0 .`** è un **MX nullo** (RFC 7505): `example.com` non accetta posta. Il TXT `v=spf1 -all` aggiunge che nessun server può inviare posta per suo conto. Insieme proteggono un dominio che non dovrebbe mai inviare né ricevere posta dall'essere usato per posta contraffatta.
- La seconda stringa TXT è un tipico token di proprietà del dominio.
Ora un record **CNAME** e uno **CAA**, su domini molto noti:
```bash
dig www.wikipedia.org +noall +answer
dig wikipedia.org CAA +noall +answer
```
Output atteso:
```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"
```
Il resolver ha seguito il CNAME per te e ha restituito l'intera catena: prima l'alias, poi il record A della destinazione. Ogni record ha il proprio TTL. I record CAA consentono a due CA di emettere certificati (`issue`) e indicano un contatto per le segnalazioni (`iodef`). L'indirizzo A dipende da dove ti trovi: i grandi siti rispondono con un data center vicino.
### Passo 5 — Risposte dalla cache e autorevoli
Interroga il tuo resolver due volte, a circa 10 secondi di distanza, e osserva il TTL.
```bash
dig www.ietf.org +noall +answer; sleep 10; dig www.ietf.org +noall +answer
```
Output atteso:
```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
```
Il TTL è sceso di circa il tempo trascorso: entrambe le risposte provengono dalla stessa copia in cache. Quando arriva a 0, il resolver recupera una copia fresca e il TTL torna al valore della zona. (L'ordine dei record in un RRset può cambiare tra una risposta e l'altra; non ha significato.)
> [!TIP]
> Se provi con un grande resolver pubblico come `1.1.1.1`, il TTL può saltare invece di scendere con regolarità: anycast e bilanciamento del carico possono inviare le tue due query a cache diverse.
Ora interroga direttamente uno dei server autorevoli che hai annotato al passo 3, con la ricorsione disattivata:
```bash
dig @<ns> example.com +norec
```
`<ns>` è uno dei name server di `example.com` del passo 3, per esempio `hera.ns.cloudflare.com`.
Output atteso (header e answer):
```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` è impostato e `ra` no: un server autorevole, che non fa ricorsione per te. Eseguilo di nuovo: il TTL resta a 300, perché il server possiede i dati invece di metterli in cache.
### Passo 6 — Un nome che non esiste
Anche le risposte negative portano informazioni.
```bash
dig nonexistent.iana.org
```
Output atteso (dall'header alla sezione authority):
```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` con answer vuota e il SOA della zona nella sezione authority. Il resolver mette in cache questo "non esiste" per il minore tra il TTL del SOA e il suo ultimo campo (entrambi 3600 qui): cache negativa, RFC 2308. Questo output proviene da un resolver validante, quindi porta anche `ad`: la non esistenza stessa è stata dimostrata con DNSSEC.
> [!NOTE]
> Alcuni provider DNS rispondono alle query per nomi inesistenti in zone firmate con `NOERROR` e una answer vuota invece di `NXDOMAIN` (una tecnica per rendere più piccole le risposte di negazione DNSSEC). Se provi altri domini e vedi questo, è una scelta del provider, non un tuo errore.
### Passo 7 — Ricerche inverse
`-x` costruisce per te il nome inverso sotto `in-addr.arpa` o `ip6.arpa` e chiede il suo record PTR.
```bash
dig -x 8.8.8.8 +noall +question +answer
dig -x 2001:4860:4860::8888 +short
```
Output atteso:
```text
;8.8.8.8.in-addr.arpa. IN PTR
8.8.8.8.in-addr.arpa. 17593 IN PTR dns.google.
dns.google.
```
La question mostra l'indirizzo invertito. Per l'indirizzo IPv6, `dig` scrive al contrario tutte le 32 cifre esadecimali, una etichetta ciascuna, sotto `ip6.arpa`; aggiungi `+noall +answer` al posto di `+short` per vedere quel nome.
### Passo 8 — Trasporti: UDP, TCP, TLS, HTTPS
Invia la stessa query su ogni trasporto e leggi la riga `SERVER`. Si usa `1.1.1.1` perché li supporta tutti e quattro; andrebbe bene qualsiasi resolver che offra DoT e 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
```
Output atteso:
```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)
```
Stessa domanda, stessa risposta, quattro trasporti: porta 53 su UDP e TCP (in chiaro), 853 per DNS su TLS, 443 per DNS su HTTPS.
Vediamo ora il **troncamento**. L'insieme di chiavi della zona radice con le firme pesa circa 1.100 byte. Fingi che il tuo client possa ricevere solo 512 byte via UDP, e di' a `dig` di non riprovare (`+ignore`):
```bash
dig @1.1.1.1 . DNSKEY +dnssec +bufsize=512 +ignore | grep -E 'flags|SERVER'
```
Output atteso:
```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` è impostato e la answer è vuota. Eseguilo di nuovo senza `+ignore`:
```bash
dig @1.1.1.1 . DNSKEY +dnssec +bufsize=512 | grep -E 'Truncated|flags:|SERVER|MSG'
```
Output atteso:
```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
```
Per questo TCP 53 non va mai bloccato: le risposte grandi, come quelle firmate, dipendono da esso.
### Passo 9 — DNSSEC: validato, e fallito di proposito
Chiedi dati firmati a un resolver validante e cerca `ad`:
```bash
dig @1.1.1.1 example.com +dnssec +noall +comments | grep flags
```
Output atteso:
```text
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
```
`ad`: il resolver ha validato la catena di fiducia. Il terzo record della risposta è la firma RRSIG (aggiungi `+answer` per vederlo).
`dnssec-failed.org` è un dominio di prova il cui operatore mantiene deliberatamente rotto il DNSSEC perché si possa vedere cosa succede. Interrogalo normalmente, poi con il controllo disabilitato (`+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'
```
Output atteso:
```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.)
```
Il resolver validante rifiuta i dati falsi con `SERVFAIL`. Con `+cd` ottieni comunque i dati, senza `ad`, e un Extended DNS Error (EDE, RFC 8914) spiega perché la validazione è fallita: la chiave nella zona non corrisponde al record DS nel genitore. Nota che tutto ciò che hai visto in questo passo è viaggiato in chiaro: DNSSEC dimostra l'autenticità, non la riservatezza.
## Parte 2 — Il tuo server autorevole
### Passo 10 — Scrivi il file di zona e la configurazione del server
Un server autorevole ha bisogno di due cose: i dati della zona e una configurazione che dica quale zona servire. Userai **CoreDNS**, un piccolo server DNS open source, con il suo plugin `file`. La zona `lab.example` è sicura da usare: il TLD `example` è riservato alla documentazione (RFC 2606) e non esiste mai su Internet.
Crea il file di zona in `~/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
```
Poi la configurazione di CoreDNS, il `Corefile`:
```bash
cat > Corefile <<'EOF'
lab.example {
file /etc/coredns/db.lab.example {
reload 10s
}
log
errors
}
EOF
```
Dice: per i nomi in `lab.example`, rispondi dal file di zona; controlla il file ogni 10 secondi per vedere se c'è un nuovo serial; registra ogni query. I nomi fuori da `lab.example` vengono rifiutati: è un server solo autorevole, non un resolver.
Non è previsto alcun output. `ls` dovrebbe mostrare `Corefile` e `db.lab.example`.
### Passo 11 — Avvia il server in un container
Esegui CoreDNS con la tua cartella montata in sola lettura e la porta 53 del container pubblicata su `127.0.0.1:5300`, sia per UDP sia per 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` e `/tcp`: solo la tua macchina può raggiungere il server; il DNS ha bisogno di entrambi i protocolli.
- `-v "$PWD":/etc/coredns:ro,Z`: monta la cartella corrente in sola lettura. `Z` la rietichetta per SELinux (Fedora, RHEL); sui sistemi senza SELinux non fa danni, e puoi toglierlo se la tua versione di Docker si lamenta. Viene montata l'intera cartella, non singoli file, così le modifiche fatte da qualsiasi editor di testo sono visibili dentro il container.
- Il tag dell'immagine è fissato a `1.12.0` perché il laboratorio si comporti allo stesso modo per tutti.
Poi controlla che sia in esecuzione:
```bash
podman ps --filter name=dns-lab
podman logs dns-lab
```
Output atteso (gli ID differiscono):
```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` conferma che la zona è stata caricata e che il server è in ascolto sulla porta 53 dentro il container.
### Passo 12 — Interroga la tua zona
Interroga direttamente il tuo server. `-p 5300` imposta la porta; `+norec` perché non è un resolver.
```bash
dig @127.0.0.1 -p 5300 www.lab.example +norec
```
Output atteso (dall'header alla riga del server):
```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`: ora l'autorità sei tu. Questo server elenca anche il record NS della zona nella sezione authority. La riga `COOKIE` è un DNS cookie (RFC 7873), una protezione leggera contro le query falsificate.
Ora interroga ogni tipo di record che hai pubblicato:
```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
```
Output atteso:
```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` è solo una variabile di shell che risparmia digitazione. Ogni record ha il TTL predefinito della zona, 300, da `$TTL`. Per `app`, il server ha seguito il CNAME all'interno della propria zona e ha aggiunto il record A della destinazione.
Poi, tre risposte che non sono dati:
```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
```
Output atteso:
```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` con il tuo SOA. CoreDNS invia il SOA con il proprio TTL (300); secondo la RFC 2308 un resolver mette in cache la risposta negativa per il minore tra quel TTL e l'ultimo campo del SOA, quindi 60 secondi.
- `REFUSED` per `www.example.com`: il tuo server non è autorevole per quel nome e non fa ricorsione.
- Il trasferimento di zona fallisce perché CoreDNS non consente trasferimenti a meno che tu non li configuri (con il suo plugin `transfer`). È l'impostazione predefinita sicura: solo i tuoi server secondari dovrebbero poter copiare una zona.
Infine, guarda il log delle query:
```bash
podman logs dns-lab 2>&1 | tail -3
```
Output atteso (l'indirizzo del client dipende da come è configurata la rete di Podman sulla tua macchina):
```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
```
Ogni riga mostra indirizzo e porta del client, l'ID del messaggio, la question, il trasporto (nota `tcp` per l'AXFR), il codice di risposta, i flag, la dimensione della risposta e il tempo impiegato. La query rifiutata per `www.example.com` non c'è: la riga `log` nel `Corefile` si applica solo al blocco `lab.example`.
### Passo 13 — Cambia un record e osserva il serial
Sposterai `www` da `192.0.2.10` a `192.0.2.11`. Per prima cosa cambia solo l'indirizzo e **non** toccare il serial. Apri `db.lab.example` in un editor di testo e cambia la riga `www IN A`, oppure su Linux:
```bash
sed -i 's/192\.0\.2\.10/192.0.2.11/' db.lab.example
grep '^www' db.lab.example
```
Output atteso:
```text
www IN A 192.0.2.11
www IN AAAA 2001:db8::10
```
Attendi almeno 15 secondi (l'intervallo di `reload` è 10 s), poi interroga:
```bash
dig @127.0.0.1 -p 5300 www.lab.example +short
```
Output atteso:
```text
192.0.2.10
```
Ancora il vecchio indirizzo. CoreDNS (come i server secondari) ricarica una zona solo quando il **serial** aumenta. Ora porta il serial da `2026110601` a `2026110602`:
```bash
sed -i 's/2026110601 ; serial/2026110602 ; serial/' db.lab.example
```
Attendi altri 15 secondi e ripeti la query e il controllo del log:
```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
```
Output atteso:
```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
```
Il nuovo indirizzo è attivo appena il serial sale. Sulla vera Internet ci sarebbe un ulteriore ritardo: i resolver che hanno messo in cache il vecchio record A continuano a restituirlo finché non si esaurisce il suo TTL di 300 secondi.
> [!NOTE]
> Su macOS, `sed -i` richiede un argomento vuoto: `sed -i '' 's/…/…/' db.lab.example`. Oppure modifica semplicemente il file con un qualsiasi editor di testo.
## Verifica
Hai completato il laboratorio se tutte queste condizioni sono vere:
| Controllo | Condizione di superamento |
|---|---|
| Trace | Al passo 3 sai nominare il server che ha risposto a ogni livello (radice, `com`, `example.com`) e indicare i record DS che li collegano. |
| Cache | Al passo 5 il TTL del tuo resolver è diminuito tra due query, e il TTL del server autorevole è rimasto uguale con `aa` impostato. |
| Record | Hai identificato risposte A, AAAA, NS, SOA, MX (MX nullo), TXT, CNAME, CAA (passo 4) e PTR (passo 7). |
| Trasporti | Il passo 8 ha mostrato `(UDP)`, `(TCP)`, `(TLS)` sulla porta 853 e `(HTTPS)` sulla porta 443, e una risposta `tc` ripetuta via TCP. |
| DNSSEC | Il passo 9 ha mostrato `ad` per `example.com` e `SERVFAIL` per `dnssec-failed.org`. |
| La tua zona | `dig @127.0.0.1 -p 5300 www.lab.example +norec` mostra `flags: qr aa` e, dopo il passo 13, l'indirizzo `192.0.2.11` con serial `2026110602`. |
## Risoluzione dei problemi
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| `dig +trace` si ferma con `communications error … timed out` dopo l'elenco della radice | La tua rete blocca il DNS in uscita verso qualsiasi cosa diversa dal proprio resolver (comune in aziende, hotel e alcuni router domestici). | Salta il passo 3 o eseguilo su un'altra rete che ti è consentito usare; il resto della parte 1 passa dai resolver. |
| `+tls` o `+https` stampa `Invalid option` | `dig` precedente alla 9.18 (per esempio quello integrato in macOS) o compilato senza supporto DoH. | Installa un BIND aggiornato (`brew install bind`, o il pacchetto del tuo Linux) e controlla `dig -v`. |
| `+tls` o `+https` va in timeout | La rete blocca la porta 853, o filtra DoH. | Annotalo come una scoperta: è il compromesso della lezione. Prova un'altra rete che ti è consentito usare. |
| `podman run` fallisce con `address already in use` | Qualcosa è già in ascolto su `127.0.0.1:5300`. | Scegli un'altra porta (per esempio 5301) nelle opzioni `-p` e in ogni comando `dig -p`. |
| `dig @127.0.0.1 -p 5300 …` restituisce `connection refused` o va in timeout | Il container non è in esecuzione: un errore nel `Corefile` o nel file di zona ferma CoreDNS. | `podman logs dns-lab` mostra l'errore e il numero di riga. Correggi il file, poi `podman rm -f dns-lab` e ripeti il passo 11. |
| `permission denied` nella lettura di `/etc/coredns/Corefile` nei log | SELinux ha bloccato la cartella montata. | Assicurati che l'opzione del volume includa `Z` (`:ro,Z`). |
| `REFUSED` per `www.lab.example` | La zona non è stata caricata (per esempio un errore di battitura in `$ORIGIN` o un punto finale mancante), quindi il server non ha una zona `lab.example`. | Controlla `podman logs dns-lab` e confronta il tuo file di zona con il passo 10. |
| Un record modificato non compare | Il serial non è stato aumentato, oppure sono passati meno di 10 secondi. | Aumenta il serial e attendi 15 secondi; cerca `Successfully reloaded zone` nei log. |
| `podman: command not found` | Podman non è installato. | Installalo dai pacchetti della tua distribuzione, oppure usa Docker e sostituisci `podman` con `docker` in ogni comando. |
## Sfida (facoltativa)
Aggiungi al tuo server una zona inversa per `192.0.2.0/24`: un secondo blocco `file` nel `Corefile` per `2.0.192.in-addr.arpa`, e un file di zona con un SOA, un NS e record PTR per `192.0.2.10`, `192.0.2.25` e `192.0.2.53`. Verificalo con `dig @127.0.0.1 -p 5300 -x 192.0.2.10 +norec`. Poi abbassa il TTL di `www` a 60 secondi (ricorda il serial) e spiega, in due frasi, perché lo faresti un giorno prima di una migrazione reale.
## Pulizia
Ferma e rimuovi il container, rimuovi l'immagine ed elimina la cartella del laboratorio:
```bash
podman rm -f dns-lab
podman rmi docker.io/coredns/coredns:1.12.0
cd ~ && rm -r ~/dns-lab
```
Output atteso (gli ID differiscono):
```text
dns-lab
Untagged: docker.io/coredns/coredns:1.12.0
Deleted: 1cf5f116067c67da67f97bff78c4bbc76913f59057c18627b96facaced73ea0b
```
Verifica che non sia rimasto nulla:
```bash
podman ps -a --filter name=dns-lab
podman images coredns/coredns
```
Entrambi i comandi dovrebbero stampare solo le righe di intestazione. La parte 1 non ha creato nulla da ripulire; i record che il tuo resolver ha messo in cache scadono da soli.
## Cosa hai imparato
- `dig +trace` mostra la catena di deleghe: referral dalla radice a `com`, referral da `com` ai server del dominio e risposta autorevole, con record DS che collegano ogni livello per DNSSEC.
- Il TTL di un resolver scende perché la risposta viene dalla sua cache; quello di un server autorevole no, e imposta `aa`.
- Come leggere ogni tipo di record, compresi un MX nullo, una catena CNAME, CAA, i campi del SOA e i record PTR sotto `in-addr.arpa` e `ip6.arpa`.
- I codici di stato NOERROR, NXDOMAIN (con SOA per la cache negativa), SERVFAIL (validazione DNSSEC fallita) e REFUSED.
- La stessa query funziona su UDP 53, TCP 53, TLS 853 e HTTPS 443, e una risposta UDP troncata (`tc`) viene ripetuta via TCP.
- Un server autorevole serve solo le sue zone, rifiuta le altre e dovrebbe rifiutare i trasferimenti di zona agli sconosciuti; le modifiche alla zona hanno effetto solo quando il serial del SOA aumenta.