CloudAcademia
ES

Redes · Módulo 11 · DNS: cómo los nombres se convierten en direcciones

Laboratorio: sigue una resolución y ejecuta tu propia zona

Laboratorio60 minPrincipianteMarkdown

Mostrando el Markdown sin formato: no se pudo cargar el visor.

## Objetivo
Usa `dig` para seguir una resolución de nombres real desde la raíz, leer cada parte de una respuesta DNS y comparar los transportes DNS. Después, ejecuta tu propio servidor DNS autoritativo en un contenedor, que sirva la zona `lab.example`, consúltalo, cambia un registro y observa cómo el serial del SOA decide cuándo entra en vigor el cambio.

## Objetivos
- Seguir una resolución desde la raíz hasta los servidores autoritativos con `dig +trace`, y ver la caché en acción mientras el TTL va en cuenta atrás.
- Consultar y reconocer los tipos de registro más comunes: A, AAAA, CNAME, MX, NS, TXT, PTR, SOA y CAA.
- Leer la salida de `dig`: estado, indicadores (`qr`, `aa`, `rd`, `ra`, `ad`, `tc`) y las secciones de respuesta, autoridad e información adicional.
- Enviar la misma consulta por UDP, TCP, DNS sobre TLS y DNS sobre HTTPS, y ver cómo el truncamiento provoca un reintento por TCP.
- Ejecutar un servidor autoritativo para una zona propia, cambiar un registro y confirmar el cambio con el serial del SOA.

## Requisitos previos
- `dig` de BIND 9.18 o posterior (`dig -v`). En Fedora/RHEL: `bind-utils`; en Debian/Ubuntu: `bind9-dnsutils`; en macOS: `brew install bind` (el `dig` que viene con macOS es más antiguo y no tiene `+tls` ni `+https`). En Windows, usa una distribución de Linux en WSL2.
- Podman 4 o posterior (probado con Podman 5.8, sin privilegios de root, sin `sudo`), o Docker 20.10 o posterior: sustituye `podman` por `docker` en cada comando.
- Acceso a Internet para la parte 1. Los pasos 3, 5 (la consulta directa), 8 y 9 hablan con servidores distintos del resolutor de tu propia red, así que fallan en redes que solo permiten DNS hacia su propio resolutor; consulta Resolución de problemas.
- Unos 75 MB de espacio en disco para la imagen de CoreDNS.
- [La lección de DNS](lesson.es.md) de este módulo.

> [!WARNING]
> La parte 1 envía búsquedas normales de nombres públicos a resolutores públicos; es un uso normal de DNS. No vayas más allá: nada de intentos de transferencia de zona (AXFR), avalanchas, escaneos ni pruebas de "resolutor abierto" contra servidores que no sean tuyos. La parte 2 ejecuta un servidor enlazado solo a `127.0.0.1`, así que nada fuera de tu equipo puede alcanzarlo, y la única transferencia de zona que intentas es contra ese servidor. El laboratorio es gratuito y no cambia nada en tu sistema fuera de una carpeta y una imagen de contenedor, que se eliminan al final.

> [!NOTE]
> Las salidas de abajo se capturaron en noviembre de 2026. Las direcciones, los TTL, los servidores de nombres y las firmas de dominios reales (como `example.com`, que IANA aloja con un proveedor de DNS comercial) cambian con el tiempo, así que las tuyas serán distintas. Lo que debes comparar es la estructura, los indicadores y los códigos de estado. Tu propia zona usa solo direcciones de documentación (RFC 5737 y RFC 3849).

## Arquitectura
<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-es-title dns-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="dns-lab-architecture-es-title">Arquitectura del laboratorio: dig consulta resolutores públicos y un contenedor CoreDNS local</title>
<desc id="dns-lab-architecture-es-desc">Tu ordenador ejecuta dig en una terminal. En la parte 1, dig consulta resolutores públicos como 1.1.1.1, 9.9.9.9 y 8.8.8.8, o el resolutor del sistema, por UDP o TCP en el puerto 53, TLS en el 853 o HTTPS en el 443; los resolutores hacen consultas iterativas a la jerarquía DNS: la raíz, com y example.com. En la parte 2, dig consulta un contenedor Podman llamado dns-lab en 127.0.0.1 puerto 5300, que se asigna al puerto 53 dentro del contenedor, donde CoreDNS 1.12.0 es autoritativo para la zona lab.example. El Corefile y el archivo de zona db.lab.example están en la carpeta ~/dns-lab, montada en el contenedor en solo lectura.</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">Tu ordenador</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">Contenedor 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">tu 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">autoritativo: 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">escucha en :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">Resolutores públicos</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 el resolutor de tu 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">Jerarquía 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">y otras zonas reales</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="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">consultas iterativas</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 habla con el DNS real a través de resolutores; la parte 2 habla con tu propio servidor autoritativo en `127.0.0.1:5300`.*

Se usa el puerto 5300 porque el puerto 53 requiere derechos de administrador y normalmente lo ocupa el resolutor de tu sistema, y el puerto 5353 lo usa el DNS multidifusión (mDNS, por ejemplo Avahi o Bonjour).

## Pasos

### Paso 1 — Comprueba tus herramientas y crea una carpeta de trabajo
Confirma primero las versiones: `+tls` y `+https` necesitan BIND 9.18 o posterior. Guardarás los archivos de zona en una sola carpeta, para que la limpieza sea fácil.

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

> [!WARNING]
> Ejecuta todos los comandos siguientes desde `~/dns-lab`. El paso 11 monta la carpeta actual en el contenedor con `:Z`, que la reetiqueta para SELinux; si lo ejecutas desde tu carpeta personal, reetiquetaría y expondría toda ella.

Salida esperada (las versiones pueden ser más recientes):
```text
DiG 9.18.50
podman version 5.8.7
```

Comprueba que nada escucha ya en el puerto 5300 (Linux):
```bash
ss -lntu | grep ':5300 ' || echo "port 5300 is free"
```

Salida esperada:
```text
port 5300 is free
```

Si aparece algo, elige otro puerto alto (por ejemplo 5301) y úsalo en todos los sitios donde este laboratorio dice `5300`. En macOS, usa `lsof -nP -i :5300` en su lugar; si no hay salida, el puerto está libre.

## Parte 1 — El DNS real, solo lectura

### Paso 2 — Tu primera búsqueda, leída por completo
Empieza con una consulta simple al resolutor de tu sistema y lee cada sección, como en la figura 2 de la lección.

```bash
dig example.com
```

Salida esperada:
```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
```

Anota en tus apuntes:
- **Estado** `NOERROR` e indicadores `qr rd ra`: una respuesta (`qr`), pediste recursión (`rd`) y el servidor la ofrece (`ra`). No hay `aa`: respondió un resolutor, no el servidor autoritativo. Tampoco hay `ad`: este resolutor no informó de validación DNSSEC.
- **Respuesta**: dos registros A (un RRset), cada uno con nombre, TTL, clase `IN`, tipo y dirección.
- **SERVER**: qué resolutor respondió y por qué transporte. `127.0.0.53` es el stub local de systemd-resolved en muchos sistemas Linux; el tuyo puede ser la dirección de tu router o de tu ISP. El valor alto `udp: 65494` viene de ese stub local; los resolutores reales suelen anunciar 1232.

### Paso 3 — Sigue la delegación desde la raíz
`+trace` hace que `dig` haga por sí mismo lo que hace un resolutor recursivo: preguntar a la raíz, seguir cada referencia y terminar en los servidores autoritativos.

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

Salida esperada (líneas largas de firma `RRSIG` abreviadas 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
```

Relaciona cada bloque con la figura 5 de la lección:
1. Tu resolutor aporta los 13 nombres de servidores raíz, de la `a` a la `m` (como las root hints).
2. Un servidor raíz (aquí `b.root-servers.net`) te remite a los 13 servidores de `com`. También envía un registro **DS** de `com`: el enlace DNSSEC de la raíz a `com`.
3. Un servidor de `com` te remite a los servidores de nombres de `example.com`, con un registro DS de `example.com`.
4. Uno de esos servidores responde con los registros A. Su TTL es el valor completo, 300, porque es la copia autoritativa, no una copia en caché.

Fíjate en los servidores de nombres que usa hoy `example.com`; necesitarás uno de ellos en el paso 5.

### Paso 4 — Conoce los tipos de registro
Pide distintos tipos de datos. `+noall +answer` oculta todo salvo la sección de respuesta.

```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
```

Salida esperada:
```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"
```

Léelos con la tabla de registros de la lección:
- **AAAA**: las direcciones IPv6.
- **NS**: los servidores autoritativos, como en el paso 3.
- **SOA**: servidor primario, buzón de contacto (`dns@cloudflare.com`, con la `@` escrita como punto), serial `2418004112`, y después refresh, retry, expire y minimum (TTL de caché negativa, 1800 s).
- **MX `0 .`** es un **MX nulo** (RFC 7505): `example.com` no acepta correo. El TXT `v=spf1 -all` añade que ningún servidor puede enviar correo en su nombre. Juntos protegen a un dominio que nunca debería enviar ni recibir correo para que no se use en correo suplantado.
- La segunda cadena TXT es un típico token de propiedad del dominio.

Ahora un registro **CNAME** y uno **CAA**, en dominios muy conocidos:

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

Salida esperada:
```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"
```

El resolutor siguió el CNAME por ti y devolvió la cadena completa: primero el alias, luego el registro A del destino. Cada registro tiene su propio TTL. Los registros CAA permiten a dos CA emitir certificados (`issue`) y dan un contacto para informes (`iodef`). La dirección A depende de dónde estés: los sitios grandes responden con un centro de datos cercano.

### Paso 5 — Respuestas de caché frente a autoritativas
Pregunta a tu resolutor dos veces, con unos 10 segundos de diferencia, y observa el TTL.

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

Salida esperada:
```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
```

El TTL bajó aproximadamente el tiempo transcurrido: ambas respuestas vinieron de la misma copia en caché. Cuando llega a 0, el resolutor obtiene una copia nueva y el TTL vuelve al valor de la zona. (El orden de los registros de un RRset puede cambiar entre respuestas; no tiene significado.)

> [!TIP]
> Si lo pruebas contra un resolutor público grande como `1.1.1.1`, el TTL puede saltar de un valor a otro en lugar de bajar con suavidad: el anycast y el reparto de carga pueden enviar tus dos consultas a cachés distintas.

Ahora pregunta directamente a uno de los servidores autoritativos que anotaste en el paso 3, con la recursión desactivada:

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

`<ns>` es uno de los servidores de nombres de `example.com` del paso 3, por ejemplo `hera.ns.cloudflare.com`.

Salida esperada (cabecera y respuesta):
```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` está activado y `ra` no: un servidor autoritativo, que no hace recursión por ti. Ejecútalo otra vez: el TTL se mantiene en 300, porque el servidor es dueño de los datos en lugar de guardarlos en caché.

### Paso 6 — Un nombre que no existe
Las respuestas negativas también aportan información.

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

Salida esperada (de la cabecera a la sección de autoridad):
```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 la respuesta vacía y el SOA de la zona en la sección de autoridad. El resolutor guarda en caché este "no existe" durante el menor valor entre el TTL del SOA y su último campo (ambos 3600 aquí): caché negativa, RFC 2308. Esta salida vino de un resolutor validador, así que también lleva `ad`: la propia inexistencia se demostró con DNSSEC.

> [!NOTE]
> Algunos proveedores de DNS responden a las consultas de nombres inexistentes en zonas firmadas con `NOERROR` y una respuesta vacía en lugar de `NXDOMAIN` (una técnica para hacer más pequeñas las respuestas de denegación de DNSSEC). Si pruebas otros dominios y ves eso, es una decisión del proveedor, no un error por tu parte.

### Paso 7 — Consultas inversas
`-x` construye por ti el nombre inverso bajo `in-addr.arpa` o `ip6.arpa` y pide su registro PTR.

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

Salida esperada:
```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 pregunta muestra la dirección invertida. Para la dirección IPv6, `dig` escribe al revés los 32 dígitos hexadecimales, una etiqueta cada uno, bajo `ip6.arpa`; añade `+noall +answer` en lugar de `+short` para ver ese nombre.

### Paso 8 — Transportes: UDP, TCP, TLS, HTTPS
Envía la misma consulta por cada transporte y lee la línea `SERVER`. Se usa `1.1.1.1` porque admite los cuatro; serviría cualquier resolutor que ofrezca DoT y 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
```

Salida esperada:
```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)
```

La misma pregunta, la misma respuesta, cuatro transportes: puerto 53 por UDP y TCP (en claro), 853 para DNS sobre TLS, 443 para DNS sobre HTTPS.

Ahora veamos el **truncamiento**. El conjunto de claves de la zona raíz con firmas ocupa unos 1100 bytes. Finge que tu cliente solo puede recibir 512 bytes por UDP, e indica a `dig` que no reintente (`+ignore`):

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

Salida esperada:
```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` está activado y la respuesta está vacía. Ejecútalo de nuevo sin `+ignore`:

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

Salida esperada:
```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
```

Por eso nunca se debe bloquear TCP 53: las respuestas grandes, como las firmadas, dependen de él.

### Paso 9 — DNSSEC: validado, y fallido a propósito
Pide a un resolutor validador datos firmados y busca `ad`:

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

Salida esperada:
```text
;; flags: qr rd ra ad; QUERY: 1, ANSWER: 3, AUTHORITY: 0, ADDITIONAL: 1
; EDNS: version: 0, flags: do; udp: 1232
```

`ad`: el resolutor validó la cadena de confianza. El tercer registro de la respuesta es la firma RRSIG (añade `+answer` para verlo).

`dnssec-failed.org` es un dominio de prueba cuyo operador mantiene deliberadamente roto su DNSSEC para que la gente vea qué ocurre. Consúltalo normalmente y luego con la comprobación desactivada (`+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'
```

Salida esperada:
```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.)
```

El resolutor validador rechaza los datos falsos con `SERVFAIL`. Con `+cd` obtienes los datos de todos modos, sin `ad`, y un error DNS extendido (EDE, Extended DNS Error, RFC 8914) explica por qué falló la validación: la clave de la zona no coincide con el registro DS del padre. Ten en cuenta que todo lo que viste en este paso viajó en claro: DNSSEC demuestra autenticidad, no confidencialidad.

## Parte 2 — Tu propio servidor autoritativo

### Paso 10 — Escribe el archivo de zona y la configuración del servidor
Un servidor autoritativo necesita dos cosas: los datos de la zona y una configuración que indique qué zona servir. Usarás **CoreDNS**, un pequeño servidor DNS de código abierto, con su plugin `file`. La zona `lab.example` es segura de usar: el TLD `example` está reservado para documentación (RFC 2606) y nunca existe en Internet.

Crea el archivo de zona en `~/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
```

Después la configuración de CoreDNS, el `Corefile`:

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

Dice: para los nombres de `lab.example`, responde desde el archivo de zona; comprueba el archivo cada 10 segundos por si hay un serial nuevo; registra cada consulta. Los nombres fuera de `lab.example` se rechazan: es un servidor solo autoritativo, no un resolutor.

No se espera salida. `ls` debería mostrar `Corefile` y `db.lab.example`.

### Paso 11 — Inicia el servidor en un contenedor
Ejecuta CoreDNS con tu carpeta montada en solo lectura y el puerto 53 del contenedor publicado en `127.0.0.1:5300`, tanto para UDP como para 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` y `/tcp`: solo tu propia máquina puede alcanzar el servidor; DNS necesita ambos protocolos.
- `-v "$PWD":/etc/coredns:ro,Z`: monta la carpeta actual en solo lectura. `Z` la reetiqueta para SELinux (Fedora, RHEL); en sistemas sin SELinux no hace daño, y puedes quitarla si tu versión de Docker se queja. Se monta la carpeta entera, no archivos sueltos, para que las ediciones hechas con cualquier editor de texto se vean dentro del contenedor.
- La etiqueta de la imagen está fijada a `1.12.0` para que el laboratorio se comporte igual para todos.

Después comprueba que se ejecuta:
```bash
podman ps --filter name=dns-lab
podman logs dns-lab
```

Salida esperada (los ID serán distintos):
```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` confirma que la zona se cargó y que el servidor escucha en el puerto 53 dentro del contenedor.

### Paso 12 — Consulta tu zona
Pregunta directamente a tu servidor. `-p 5300` fija el puerto; `+norec` porque no es un resolutor.

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

Salida esperada (de la cabecera a la línea del servidor):
```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`: ahora tú eres la autoridad. Este servidor también lista el registro NS de la zona en la sección de autoridad. La línea `COOKIE` es una cookie DNS (RFC 7873), una protección ligera contra consultas falsificadas.

Ahora consulta cada tipo de registro que publicaste:

```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
```

Salida esperada:
```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` es solo una variable de shell que ahorra escritura. Todos los registros tienen el TTL predeterminado de la zona, 300, de `$TTL`. Para `app`, el servidor siguió el CNAME dentro de su propia zona y añadió el registro A del destino.

A continuación, tres respuestas que no son datos:

```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
```

Salida esperada:
```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 tu SOA. CoreDNS envía el SOA con su propio TTL (300); según la RFC 2308, un resolutor guarda en caché la respuesta negativa durante el menor valor entre ese TTL y el último campo del SOA, es decir, 60 segundos.
- `REFUSED` para `www.example.com`: tu servidor no es autoritativo para él y no hace recursión.
- La transferencia de zona falla porque CoreDNS no permite transferencias salvo que las configures (con su plugin `transfer`). Ese es el valor predeterminado seguro: solo tus propios servidores secundarios deberían poder copiar una zona.

Por último, mira el registro de consultas:
```bash
podman logs dns-lab 2>&1 | tail -3
```

Salida esperada (la dirección del cliente depende de cómo esté configurada la red de Podman en tu máquina):
```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
```

Cada línea muestra la dirección y el puerto del cliente, el ID del mensaje, la pregunta, el transporte (fíjate en `tcp` para el AXFR), el código de respuesta, los indicadores, el tamaño de la respuesta y el tiempo empleado. La consulta rechazada de `www.example.com` no aparece: la línea `log` del `Corefile` solo se aplica al bloque `lab.example`.

### Paso 13 — Cambia un registro y observa el serial
Vas a mover `www` de `192.0.2.10` a `192.0.2.11`. Primero cambia solo la dirección y **no** toques el serial. Abre `db.lab.example` en un editor de texto y cambia la línea `www IN A`, o en Linux:

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

Salida esperada:
```text
www     IN  A     192.0.2.11
www     IN  AAAA  2001:db8::10
```

Espera al menos 15 segundos (el intervalo de `reload` es de 10 s) y pregunta:

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

Salida esperada:
```text
192.0.2.10
```

Sigue la dirección antigua. CoreDNS (como los servidores secundarios) solo recarga una zona cuando el **serial** aumenta. Ahora sube el serial de `2026110601` a `2026110602`:

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

Espera otros 15 segundos y repite la consulta y la comprobación del registro:

```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
```

Salida esperada:
```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
```

La nueva dirección está activa en cuanto sube el serial. En la Internet real habría un retraso más: los resolutores que guardaron en caché el registro A antiguo siguen devolviéndolo hasta que se agota su TTL de 300 segundos.

> [!NOTE]
> En macOS, `sed -i` necesita un argumento vacío: `sed -i '' 's/…/…/' db.lab.example`. O edita el archivo simplemente con cualquier editor de texto.

## Verificación
Has completado el laboratorio si todo lo siguiente es cierto:

| Comprobación | Condición para aprobar |
|---|---|
| Traza | En el paso 3 puedes nombrar el servidor que respondió en cada nivel (raíz, `com`, `example.com`) y señalar los registros DS que los enlazan. |
| Caché | En el paso 5 el TTL de tu resolutor disminuyó entre dos consultas, y el TTL del servidor autoritativo se mantuvo igual con `aa` activado. |
| Registros | Identificaste respuestas A, AAAA, NS, SOA, MX (MX nulo), TXT, CNAME, CAA (paso 4) y PTR (paso 7). |
| Transportes | El paso 8 mostró `(UDP)`, `(TCP)`, `(TLS)` en el puerto 853 y `(HTTPS)` en el puerto 443, y una respuesta `tc` reintentada por TCP. |
| DNSSEC | El paso 9 mostró `ad` para `example.com` y `SERVFAIL` para `dnssec-failed.org`. |
| Tu zona | `dig @127.0.0.1 -p 5300 www.lab.example +norec` muestra `flags: qr aa` y, tras el paso 13, la dirección `192.0.2.11` con el serial `2026110602`. |

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `dig +trace` se detiene con `communications error … timed out` tras la lista de la raíz | Tu red bloquea el DNS saliente hacia cualquier sitio que no sea su propio resolutor (habitual en empresas, hoteles y algunos routers domésticos). | Omite el paso 3 o ejecútalo en otra red que puedas usar; el resto de la parte 1 pasa por resolutores. |
| `+tls` o `+https` muestra `Invalid option` | `dig` anterior a la 9.18 (por ejemplo el integrado en macOS) o compilado sin soporte para DoH. | Instala un BIND actual (`brew install bind`, o el paquete de tu Linux) y comprueba `dig -v`. |
| `+tls` o `+https` agota el tiempo | La red bloquea el puerto 853 o filtra DoH. | Anótalo como un hallazgo: es el compromiso de la lección. Prueba otra red que puedas usar. |
| `podman run` falla con `address already in use` | Algo ya escucha en `127.0.0.1:5300`. | Elige otro puerto (por ejemplo 5301) en las opciones `-p` y en cada comando `dig -p`. |
| `dig @127.0.0.1 -p 5300 …` devuelve `connection refused` o agota el tiempo | El contenedor no se está ejecutando: un error en el `Corefile` o en el archivo de zona detiene CoreDNS. | `podman logs dns-lab` muestra el error y el número de línea. Corrige el archivo, luego `podman rm -f dns-lab` y repite el paso 11. |
| `permission denied` al leer `/etc/coredns/Corefile` en los registros | SELinux bloqueó la carpeta montada. | Asegúrate de que la opción del volumen incluye `Z` (`:ro,Z`). |
| `REFUSED` para `www.lab.example` | La zona no se cargó (por ejemplo, un error tipográfico en `$ORIGIN` o falta el punto final), así que el servidor no tiene la zona `lab.example`. | Revisa `podman logs dns-lab` y compara tu archivo de zona con el paso 10. |
| Un registro cambiado no aparece | No se aumentó el serial, o pasaron menos de 10 segundos. | Sube el serial y espera 15 segundos; busca `Successfully reloaded zone` en los registros. |
| `podman: command not found` | Podman no está instalado. | Instálalo desde los paquetes de tu distribución, o usa Docker y sustituye `podman` por `docker` en cada comando. |

## Reto (opcional)
Añade a tu servidor una zona inversa para `192.0.2.0/24`: un segundo bloque `file` en el `Corefile` para `2.0.192.in-addr.arpa`, y un archivo de zona con un SOA, un NS y registros PTR para `192.0.2.10`, `192.0.2.25` y `192.0.2.53`. Compruébalo con `dig @127.0.0.1 -p 5300 -x 192.0.2.10 +norec`. Después baja el TTL de `www` a 60 segundos (recuerda el serial) y explica, en dos frases, por qué lo harías un día antes de una migración real.

## Limpieza
Detén y elimina el contenedor, elimina la imagen y borra la carpeta del laboratorio:

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

Salida esperada (los ID serán distintos):
```text
dns-lab
Untagged: docker.io/coredns/coredns:1.12.0
Deleted: 1cf5f116067c67da67f97bff78c4bbc76913f59057c18627b96facaced73ea0b
```

Comprueba que no queda nada:
```bash
podman ps -a --filter name=dns-lab
podman images coredns/coredns
```

Ambos comandos deberían imprimir solo sus líneas de cabecera. La parte 1 no creó nada que limpiar; los registros que guardó tu resolutor en caché caducan por sí solos.

## Qué has aprendido
- `dig +trace` muestra la cadena de delegación: referencia de la raíz a `com`, referencia de `com` a los servidores del dominio y una respuesta autoritativa, con registros DS que enlazan cada nivel para DNSSEC.
- El TTL de un resolutor va en cuenta atrás porque la respuesta sale de su caché; el TTL de un servidor autoritativo no, y este activa `aa`.
- Cómo leer cada tipo de registro, incluidos un MX nulo, una cadena CNAME, CAA, los campos del SOA y los registros PTR bajo `in-addr.arpa` e `ip6.arpa`.
- Los códigos de estado NOERROR, NXDOMAIN (con SOA para la caché negativa), SERVFAIL (validación DNSSEC fallida) y REFUSED.
- La misma consulta funciona por UDP 53, TCP 53, TLS 853 y HTTPS 443, y una respuesta UDP truncada (`tc`) se reintenta por TCP.
- Un servidor autoritativo sirve solo sus zonas, rechaza las demás y debería rechazar las transferencias de zona a desconocidos; los cambios de zona solo surten efecto cuando aumenta el serial del SOA.