---
title: "Laboratorio: tracciare una risoluzione e gestire la tua zona"
domain: networking
level: beginner
duration: "60 min"
cost: "gratuito"
environment: "il tuo computer (Linux, oppure WSL2 su Windows, oppure macOS) con Podman o Docker"
lang: it
source_hash: 551cfe9c1290
---

# Laboratorio: tracciare una risoluzione e gestire la tua zona

## 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
![Architettura del laboratorio. Sul tuo computer, dig gira in un terminale. 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 53, TLS 853 o HTTPS 443; i resolver fanno query iterative alla gerarchia DNS: radice, com. e example.com. Parte 2: dig interroga 127.0.0.1 porta 5300, mappata sulla porta 53 del container Podman dns-lab, dove CoreDNS 1.12.0 è autorevole per lab.example. La cartella ~/dns-lab, con il Corefile e il file di zona db.lab.example, è montata in sola lettura nel container](../../../assets/diagrams/dns-lab-architecture.it.svg)

*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.
