Mostrando el Markdown sin formato: no se pudo cargar el visor.
## Objetivo
Construyes tres zonas de red (una «Internet», una DMZ y una zona interna) unidas por un contenedor firewall. Escaneas desde fuera mientras todo está abierto, aplicas una política nftables de denegación por defecto que permite solo dos flujos, vuelves a escanear, lees los contadores y el registro de descartes del firewall, y demuestras con pruebas que todos los flujos no deseados están bloqueados.
## Objetivos
- Construir tres zonas aisladas y enrutarlas a través de un firewall.
- Escanear la red desde fuera con `nmap` e interpretar los resultados `open`, `closed` y `filtered`.
- Escribir un conjunto de reglas con estado y denegación por defecto que permita solo Internet a web (TCP 80) y web a base de datos (TCP 5432).
- Leer los contadores de reglas y el registro de descartes del firewall para confirmar que el tráfico bloqueado lo bloquearon tus reglas.
- Verificar la política con una tabla de pruebas positivas y negativas, y mostrar por qué importa el orden de las reglas.
## Requisitos previos
- Una máquina Linux con **Podman 4 o posterior** ejecutándose **sin privilegios** (*rootless*: como usuario normal; nunca necesitas `sudo`) y con el backend de red netavark. Probado con Podman 5.8.7 en Fedora con el kernel 7.2. Compruébalo con `podman info --format '{{.Host.NetworkBackend}}'`: debe imprimir `netavark`.
- Acceso a Internet una vez, para descargar la imagen de Alpine Linux (unos 8 MB) y algunos paquetes (unos 40 MB en total). Después, nada del laboratorio necesita Internet.
- Unos 400 MB de espacio libre en disco.
- La [lección](lesson.es.md) de este módulo y [Networking 08 — Capa de transporte: TCP, UDP y puertos](../../networking/08-tcp-udp/README.es.md). Las técnicas con contenedores son las del [laboratorio de redes en la nube](../../cloud-computing/06-cloud-networking/lab.es.md); aquí te centras en zonas, denegación por defecto, registro y verificación.
> [!WARNING]
> **Autorización y ética.** El escaneo de puertos es una técnica de ataque cuando se dirige a sistemas que no controlas, y puede ser ilegal. En este laboratorio escaneas solo los tres contenedores que creas tú mismo, en redes creadas con `--internal` (nada sale de tu máquina). No apuntes nunca `nmap` a un sistema que no sea tuyo o que no tengas autorización explícita por escrito para probar. Escanear tu propio laboratorio aislado para comprobar tu propio firewall es el uso defensivo de la herramienta.
## Arquitectura
<figure class="diagram" style="--dg-w: 1180px"><svg xmlns="http://www.w3.org/2000/svg" class="dg" viewBox="0 0 1180 560" width="1180" height="560" role="img" aria-labelledby="netsec-lab-architecture-es-title netsec-lab-architecture-es-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="es">
<title id="netsec-lab-architecture-es-title">Arquitectura del laboratorio: tres zonas y un firewall con denegación por defecto</title>
<desc id="netsec-lab-architecture-es-desc">Tres redes internas de Podman confluyen en un contenedor firewall, lab-netsec-fw, con las interfaces net0 203.0.113.254, dmz0 10.40.2.254 e int0 10.40.3.254. La red internet 203.0.113.0/24 contiene lab-netsec-client en 203.0.113.10, el cliente externo con nmap, nc y curl y una ruta a 10.40.0.0/16 vía 203.0.113.254. La red dmz 10.40.2.0/24 contiene lab-netsec-web en 10.40.2.10, un servidor web que escucha en tcp 80, 8080 y 22, con ruta por defecto vía 10.40.2.254. La red interna 10.40.3.0/24 contiene lab-netsec-db en 10.40.3.10, un servicio tipo base de datos en tcp 5432 y 22, con ruta por defecto vía 10.40.3.254. El firewall aplica la tabla nftables inet lab_fw en el hook forward con policy drop: la regla 1 acepta el tráfico established y related, la regla 2 acepta conexiones nuevas de net0 a dmz0 por tcp 80, la regla 3 acepta conexiones nuevas de dmz0 a int0 por tcp 5432 y la regla 4 registra en el grupo nflog 1 y descarta todo lo demás.</desc>
<rect class="dg-bg" x="0.5" y="0.5" width="1179" height="559" rx="16" fill="#ffffff" stroke="#e3e3dd"/>
<g class="dg-l1"><rect class="dg-tint" x="20" y="150" width="300" height="230" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(36 163) scale(0.7500)" fill="none" stroke="#0369a1" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.5 19H9a7 7 0 1 1 6.71-9h1.79a4.5 4.5 0 1 1 0 9Z"/></g>
<text x="62" y="177" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-netsec-internet · 203.0.113.0/24</text></g>
<g class="dg-l4"><rect class="dg-tint" x="820" y="20" width="340" height="230" rx="16" fill="#fbf4f0" stroke="#e7b39e" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(836 33) scale(0.7500)" fill="none" stroke="#c2410c" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3"/><path d="M12 9v4"/><path d="M12 17h.01"/></g>
<text x="862" y="47" font-size="13" class="dg-ink" fill="#c2410c" font-weight="700">lab-netsec-dmz · 10.40.2.0/24</text></g>
<g class="dg-l2"><rect class="dg-tint" x="820" y="290" width="340" height="230" rx="16" fill="#f1f7f3" stroke="#a1ccb1" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(836 303) scale(0.7500)" fill="none" stroke="#15803d" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="4" y="11" width="16" height="10" rx="2"/><path d="M8 11V7a4 4 0 0 1 8 0v4"/></g>
<text x="862" y="317" font-size="13" class="dg-ink" fill="#15803d" font-weight="700">lab-netsec-internal · 10.40.3.0/24</text></g>
<g class="dg-l1"><path class="dg-stroke" d="M300 265H430" stroke="#0369a1" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l4"><path class="dg-stroke" d="M740 140H840" stroke="#c2410c" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><path class="dg-stroke" d="M740 410H840" stroke="#15803d" stroke-width="3.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<rect class="dg-card" x="40" y="200" width="260" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l1"><g class="dg-icon" transform="translate(56 216) scale(1.2500)" fill="none" stroke="#0369a1" 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></g>
<g class="dg-l1"><text x="98" y="237" font-size="14" class="dg-ink" fill="#0369a1" font-weight="700">lab-netsec-client</text></g>
<text x="58" y="268" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 203.0.113.10/24</text>
<text x="58" y="288" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">route 10.40.0.0/16 via .254</text>
<text x="58" y="308" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Cliente externo: nmap, nc, curl</text>
<rect class="dg-card" x="430" y="80" width="310" height="400" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(446 96) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z"/></g></g>
<g class="dg-l3"><text x="488" y="117" font-size="15" class="dg-ink" fill="#b45309" font-weight="700">lab-netsec-fw</text></g>
<text x="448" y="148" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">net0 203.0.113.254</text>
<text x="448" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dmz0 10.40.2.254</text>
<text x="448" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">int0 10.40.3.254</text>
<text x="448" y="248" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">table inet lab_fw · hook forward</text>
<text x="448" y="268" font-size="12.5" class="dg-ink" fill="#b91c1c" font-weight="700" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">policy drop</text>
<rect class="dg-tint" x="444" y="294" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="315" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">1 established,related accept</text>
<rect class="dg-tint" x="444" y="334" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="355" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">2 net0 → dmz0 tcp 80 accept</text>
<rect class="dg-tint" x="444" y="374" width="282" height="32" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="454" y="395" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">3 dmz0 → int0 tcp 5432 accept</text>
<rect class="dg-tint" x="444" y="414" width="282" height="32" rx="8" fill="#f9eded" stroke="#e3a4a4"/>
<text x="454" y="435" font-size="12" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">4 log group 1, then drop</text>
<rect class="dg-card" x="840" y="66" width="300" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(856 82) scale(1.2500)" fill="none" stroke="#c2410c" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><rect width="20" height="8" x="2" y="2" rx="2"/><rect width="20" height="8" x="2" y="14" rx="2"/><path d="M6 6h.01"/><path d="M6 18h.01"/></g></g>
<g class="dg-l4"><text x="898" y="103" font-size="14" class="dg-ink" fill="#c2410c" font-weight="700">lab-netsec-web</text></g>
<text x="858" y="134" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.40.2.10/24 · tcp 80 8080 22</text>
<text x="858" y="154" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.40.2.254</text>
<text x="858" y="174" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Servidor web de la DMZ</text>
<rect class="dg-card" x="840" y="336" width="300" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(856 352) scale(1.2500)" fill="none" stroke="#15803d" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><ellipse cx="12" cy="5" rx="9" ry="3"/><path d="M3 5V19A9 3 0 0 0 21 19V5"/><path d="M3 12A9 3 0 0 0 21 12"/></g></g>
<g class="dg-l2"><text x="898" y="373" font-size="14" class="dg-ink" fill="#15803d" font-weight="700">lab-netsec-db</text></g>
<text x="858" y="404" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.40.3.10/24 · tcp 5432 22</text>
<text x="858" y="424" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">default via 10.40.3.254</text>
<text x="858" y="444" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">Servicio tipo base de datos</text>
<g class="dg-l1"><rect class="dg-bg-plain" x="342.58" y="253" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="365" y="269.5" font-size="11" class="dg-ink" fill="#0369a1" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">net0</text></g>
<g class="dg-l4"><rect class="dg-bg-plain" x="767.58" y="128" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="790" y="144.5" font-size="11" class="dg-ink" fill="#c2410c" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">dmz0</text></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="767.58" y="398" width="44.84" height="24" rx="12" fill="#ffffff"/><text x="790" y="414.5" font-size="11" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">int0</text></g>
<g class="dg-l1"><rect class="dg-tint" x="351" y="526" width="478" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="543.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Las tres redes de Podman son --internal: nada sale de tu equipo</text></g>
</svg></figure>
*Figura 1. Un contenedor firewall une tres zonas. Al final, solo los dos flujos de su lista de reglas pueden cruzarlo.*
| Contenedor | Red y dirección | Función |
|---|---|---|
| `lab-netsec-client` | `lab-netsec-internet`, `203.0.113.10` | El exterior: un visitante, o un atacante, con `nmap`, `nc` y `curl` |
| `lab-netsec-web` | `lab-netsec-dmz`, `10.40.2.10` | El servidor web público (TCP 80), más dos servicios que **no** deberían ser públicos: TCP 8080 y un banner SSH falso en TCP 22 |
| `lab-netsec-db` | `lab-netsec-internal`, `10.40.3.10` | Un servicio de escucha tipo base de datos en TCP 5432 (responde `lab-db ready`) y un banner SSH falso en TCP 22 |
| `lab-netsec-fw` | `203.0.113.254`, `10.40.2.254`, `10.40.3.254` | El router y firewall entre las zonas |
> [!NOTE]
> Los servicios «SSH» y «base de datos» son pequeños procesos de escucha `nc` que imprimen una línea. Bastan para que un escaneo los encuentre y para aceptar o rechazar conexiones, que es todo lo que necesita este laboratorio. En una red real, el servidor web necesitaría además una dirección pública (o traducida); aquí el cliente simplemente enruta hasta él a través del firewall.
Podman ejecuta un comando en un contenedor con `podman exec lab-netsec-<nombre> <comando>`. El laboratorio lo usa constantemente, así que cada comando se escribe completo.
## Pasos
### Paso 1 — Comprueba tus herramientas y crea una carpeta de trabajo (3 min)
Asegúrate de que Podman funciona sin privilegios y usa netavark, y de que no queda nada de un intento anterior.
```bash
podman --version
podman info --format '{{.Host.NetworkBackend}} rootless={{.Host.Security.Rootless}}'
podman ps -a --filter name=lab-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
mkdir -p ~/netsec-lab && cd ~/netsec-lab
```
Salida esperada (tu versión puede diferir):
```text
podman version 5.8.7
netavark rootless=true
```
Los dos comandos `ls` no imprimen nada. Si listan nombres `lab-netsec-`, ejecuta antes la [Limpieza](#limpieza). Todos los archivos y comandos siguientes suponen que estás en `~/netsec-lab`.
### Paso 2 — Construye la imagen de herramientas (5 min)
Alpine Linux es diminuta, pero no trae ninguna de las herramientas que necesitas. Construyes una imagen con `nftables` (el firewall de Linux), `nmap` (el escáner), `tcpdump` (para leer el registro del firewall), `curl`, el comando `ip` completo y `busybox-extras` (un pequeño servidor web). La etiqueta está fijada a Alpine 3.20, de modo que obtienes los mismos resultados que en las salidas de abajo.
```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache nftables nmap curl iproute2 busybox-extras tcpdump
EOT
podman build -t lab-netsec-tools:1 .
podman run --rm lab-netsec-tools:1 sh -c 'nft --version; nmap --version | head -1; tcpdump --version 2>&1 | head -1; cat /etc/alpine-release'
```
Salida esperada (el final de la construcción y después las versiones; las versiones de los paquetes pueden variar ligeramente):
```text
OK: 47 MiB in 49 packages
COMMIT lab-netsec-tools:1
Successfully tagged localhost/lab-netsec-tools:1
nftables v1.0.9 (Old Doc Yak #3)
Nmap version 7.95 ( https://nmap.org )
tcpdump version 4.99.4
3.20.10
```
### Paso 3 — Crea las tres zonas (3 min)
Cada red de Podman es una zona: un puente (*bridge*) con su propio rango de direcciones. `--internal` significa que Podman no añade ninguna ruta hacia el exterior ni NAT hacia tu host, de modo que nada del laboratorio puede salir de tu máquina, y nada puede cruzar entre zonas salvo a través del firewall que construyes. «Internet» usa un rango de documentación ([RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)); la DMZ y la zona interna usan rangos privados ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).
```bash
podman network create --internal --subnet 203.0.113.0/24 lab-netsec-internet
podman network create --internal --subnet 10.40.2.0/24 lab-netsec-dmz
podman network create --internal --subnet 10.40.3.0/24 lab-netsec-internal
podman network inspect lab-netsec-internet lab-netsec-dmz lab-netsec-internal \
--format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
```
Salida esperada:
```text
lab-netsec-internet
lab-netsec-dmz
lab-netsec-internal
lab-netsec-internet subnet=203.0.113.0/24 internal=true
lab-netsec-dmz subnet=10.40.2.0/24 internal=true
lab-netsec-internal subnet=10.40.3.0/24 internal=true
```
### Paso 4 — Arranca el firewall (4 min)
El contenedor firewall tiene una interfaz en cada zona, con la última dirección utilizable (`.254`) de cada rango. `interface_name` da nombres legibles a las interfaces: `net0`, `dmz0` e `int0`. `--cap-add NET_ADMIN` le permite editar sus propias reglas de firewall, y `--sysctl net.ipv4.ip_forward=1` lo convierte en un router. `sleep infinity` lo mantiene en ejecución.
```bash
podman run -d --name lab-netsec-fw \
--network lab-netsec-internet:ip=203.0.113.254,interface_name=net0 \
--network lab-netsec-dmz:ip=10.40.2.254,interface_name=dmz0 \
--network lab-netsec-internal:ip=10.40.3.254,interface_name=int0 \
--cap-add NET_ADMIN --sysctl net.ipv4.ip_forward=1 \
lab-netsec-tools:1 sleep infinity
podman exec lab-netsec-fw ip -br addr
podman exec lab-netsec-fw sysctl net.ipv4.ip_forward
podman exec lab-netsec-fw nft list ruleset
```
Salida esperada (el ID del contenedor, el orden de las interfaces, los números `@if` y las direcciones `fe80::` varían):
```text
0864d79130acc3d47b16a11b13019e9c56a6e87d68de7908d9aed6cf13f1fd69
lo UNKNOWN 127.0.0.1/8 ::1/128
int0@if4 UP 10.40.3.254/24 fe80::3813:93ff:fe04:a0c8/64
dmz0@if6 UP 10.40.2.254/24 fe80::58f6:56ff:fe7b:1dba/64
net0@if8 UP 203.0.113.254/24 fe80::6c81:b4ff:feb7:80d7/64
net.ipv4.ip_forward = 1
```
El último comando, `nft list ruleset`, **no imprime nada**: el firewall aún no tiene reglas, así que reenvía todo. Recuérdalo: es tu punto de partida.
### Paso 5 — Arranca los tres hosts (6 min)
Cada host se une a una zona. Una red interna no da ninguna ruta por defecto a un contenedor, así que cada host añade una ruta hacia el firewall: el servidor web y la base de datos lo usan como puerta de enlace por defecto, y el cliente le envía el rango `10.40.0.0/16`. `NET_ADMIN` solo se necesita para `ip route add`.
El servidor web ejecuta el servidor web `httpd` de BusyBox en TCP 80 y 8080, y un proceso de escucha `nc` en TCP 22 que imprime un banner SSH falso. La base de datos ejecuta dos procesos de escucha `nc`: TCP 22 (el mismo banner) y TCP 5432, que responde `lab-db ready`. Representan servicios que existen en máquinas reales y que no deberían ser accesibles desde todas partes.
```bash
I=lab-netsec-tools:1
podman run -d --name lab-netsec-web --network lab-netsec-dmz:ip=10.40.2.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add default via 10.40.2.254; mkdir -p /www; echo "hello from the DMZ web server" > /www/index.html; httpd -p 80 -h /www; httpd -p 8080 -h /www; exec nc -lk -p 22 -e echo SSH-2.0-lab-fake'
podman run -d --name lab-netsec-db --network lab-netsec-internal:ip=10.40.3.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add default via 10.40.3.254; nc -lk -p 22 -e echo SSH-2.0-lab-fake & exec nc -lk -p 5432 -e echo lab-db ready'
podman run -d --name lab-netsec-client --network lab-netsec-internet:ip=203.0.113.10 --cap-add NET_ADMIN $I \
sh -c 'ip route add 10.40.0.0/16 via 203.0.113.254; exec sleep infinity'
podman ps --filter name=lab-netsec --format 'table {{.Names}}\t{{.Status}}'
```
Salida esperada (primero tres ID de contenedor; los tiempos varían):
```text
NAMES STATUS
lab-netsec-fw Up 3 seconds
lab-netsec-web Up 2 seconds
lab-netsec-db Up 2 seconds
lab-netsec-client Up 2 seconds
```
Comprueba las rutas y los puertos en los que escucha cada servidor:
```bash
podman exec lab-netsec-client ip route
podman exec lab-netsec-web netstat -tln
podman exec lab-netsec-db netstat -tln
```
Salida esperada:
```text
10.40.0.0/16 via 203.0.113.254 dev eth0
203.0.113.0/24 dev eth0 proto kernel scope link src 203.0.113.10
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 :::80 :::* LISTEN
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::8080 :::* LISTEN
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State
tcp 0 0 :::22 :::* LISTEN
tcp 0 0 :::5432 :::* LISTEN
```
Ya conoces la **verdad**: el servidor web escucha en 80, 8080 y 22; la base de datos, en 5432 y 22. En el siguiente paso descubrirás lo que ve un extraño.
### Paso 6 — Línea base: todo está abierto, y un escaneo lo demuestra (10 min)
Con el reenvío activado y sin reglas, el firewall deja pasar todo. Pruébalo desde el cliente exterior y luego escanea. Primero, dos peticiones normales:
```bash
podman exec lab-netsec-client curl -sS -m 3 http://10.40.2.10
podman exec lab-netsec-client nc -w 2 10.40.3.10 5432
podman exec lab-netsec-client nc -w 2 -z -v 10.40.3.10 22
```
Salida esperada:
```text
hello from the DMZ web server
lab-db ready
10.40.3.10 (10.40.3.10:22) open
```
El cliente de «Internet» habló **directamente con la base de datos**. Esa es la red plana de la historia con la que abre la lección. Ahora escanea ambos servidores desde el cliente:
```bash
podman exec lab-netsec-client nmap -n -Pn -sT --reason --max-retries 1 -T4 -p 1-1024,5432,8080 10.40.2.10 10.40.3.10
```
Qué significan las opciones:
- `-n` omite la resolución de nombres; `-p 1-1024,5432,8080` escanea los puertos bien conocidos más los dos extra.
- `-sT` es un **escaneo de conexión** TCP: completa el saludo de tres vías de TCP con la llamada normal `connect()`. No necesita privilegios especiales, por eso funciona en un contenedor sin privilegios (el escaneo SYN, más rápido, `-sS`, necesita sockets en bruto y aquí falla).
- `-Pn` omite el descubrimiento de «¿está activo el host?», que en este contenedor también necesitaría sockets en bruto. Cada sonda se trata como una sonda de puerto.
- `--reason` muestra por qué se decidió cada estado; `--max-retries 1 -T4` hace el escaneo lo bastante rápido para un laboratorio.
Salida esperada (los valores de latencia y la fecha varían):
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.2.10
Host is up, received user-set (0.00028s latency).
Not shown: 1023 closed tcp ports (conn-refused)
PORT STATE SERVICE REASON
22/tcp open ssh syn-ack
80/tcp open http syn-ack
8080/tcp open http-proxy syn-ack
Nmap scan report for 10.40.3.10
Host is up, received user-set (0.00030s latency).
Not shown: 1024 closed tcp ports (conn-refused)
PORT STATE SERVICE REASON
22/tcp open ssh syn-ack
5432/tcp open postgresql syn-ack
Nmap done: 2 IP addresses (2 hosts up) scanned in 0.08 seconds
```
Léela. El cliente exterior ve **cinco puertos abiertos en dos hosts**, incluida la base de datos, que nunca debería ser accesible, y los servicios «SSH» y 8080 que nadie pensaba publicar. Los demás puertos están `closed`: el host respondió a cada sonda con una negativa (`conn-refused`), por eso el escaneo tardó 0,08 segundos. El escaneo acaba de construir un inventario de la superficie de ataque. Anota los puertos abiertos: los compararás con el siguiente escaneo.
> [!NOTE]
> Los nombres de servicio (`ssh`, `postgresql`, `http-proxy`) son suposiciones a partir del número de puerto, no de lo que responde. `nmap` asigna nombres a los puertos a partir de una tabla. Los servicios falsos de aquí no engañarían a un escaneo de versiones, que necesita los archivos de scripts de `nmap` que esta pequeña imagen no incluye.
### Paso 7 — Aplica la política de denegación por defecto (10 min)
Ahora escribes la política del ejemplo práctico de la lección. Ponla en un archivo y luego cárgala en el firewall. Léela antes de cargarla.
```bash
cat > fw.nft <<'EOT'
table inet lab_fw
delete table inet lab_fw
table inet lab_fw {
chain forward {
type filter hook forward priority 0; policy drop;
ct state invalid drop
ct state established,related counter accept comment "return traffic"
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter accept comment "internet to web: 80"
iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter accept comment "web to db: 5432"
limit rate 5/second burst 10 packets log group 1 prefix "lab-netsec DROP: "
counter drop comment "default deny"
}
}
EOT
podman exec -i lab-netsec-fw nft -f - < fw.nft
podman exec lab-netsec-fw nft list chain inet lab_fw forward
```
Qué hace cada parte:
- Las dos primeras líneas hacen que el archivo se pueda cargar de nuevo sin riesgo: crean la tabla si no existe y luego la borran, de modo que cada carga parte de una tabla limpia.
- `table inet` se aplica a IPv4 e IPv6. `chain forward` con `hook forward` filtra el tráfico que **pasa a través** del firewall; es el camino entre las zonas.
- `policy drop` es la denegación por defecto: un paquete que no coincide con ningún `accept` se descarta.
- `ct state invalid drop` descarta los paquetes que no pertenecen a ninguna conexión válida.
- `ct state established,related ... accept` es la parte con estado: las **respuestas** a conexiones permitidas no necesitan regla propia. Va la primera porque coincide con la mayoría de los paquetes.
- Las dos reglas `ct state new ... accept` son los **únicos** flujos nuevos permitidos. Cada una nombra las interfaces, el destino exacto (y el origen en la segunda regla) y el puerto. La palabra clave `counter` cuenta los paquetes de cada regla.
- `limit ... log group 1` escribe un registro de los paquetes descartados en el canal **nflog** número 1 del kernel, como máximo 5 por segundo (tras una ráfaga de 10), de modo que un escaneo no pueda inundar el registro. Las reglas sin veredicto, como `log`, dejan que el paquete continúe hacia la siguiente regla.
- La última regla cuenta y descarta todo lo demás (la política también descartaría, pero una regla explícita te da un contador).
`podman exec -i ... nft -f -` lee el archivo de la entrada estándar, así que no sale de tu máquina. La carga no imprime nada. Salida esperada del comando `list` (todos los contadores están a cero en este punto):
```text
table inet lab_fw {
chain forward {
type filter hook forward priority filter; policy drop;
ct state invalid drop
ct state established,related counter packets 0 bytes 0 accept comment "return traffic"
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter packets 0 bytes 0 accept comment "internet to web: 80"
iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter packets 0 bytes 0 accept comment "web to db: 5432"
limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1
counter packets 0 bytes 0 drop comment "default deny"
}
}
```
> [!NOTE]
> Una regla `log` simple (sin `group`) escribe en el registro del kernel, que lees con `dmesg` o `journalctl -k`. En un contenedor ese registro no está disponible: en esta prueba, `dmesg` dentro del contenedor falló con «Operation not permitted», y por defecto el kernel solo registra desde el espacio de nombres de red del propio host. El canal `nflog` funciona sin ningún permiso especial y `tcpdump` puede leerlo, así que el laboratorio usa ese. Si tu entorno es distinto, los contadores del Paso 9 siguen demostrando qué se descartó.
### Paso 8 — Vuelve a escanear y compara (8 min)
Repite **exactamente** el mismo escaneo y después prueba los dos flujos que permitiste:
```bash
podman exec lab-netsec-client nmap -n -Pn -sT --reason --max-retries 1 -T4 -p 1-1024,5432,8080 10.40.2.10 10.40.3.10
podman exec lab-netsec-client curl -sS -m 3 http://10.40.2.10
podman exec lab-netsec-web nc -w 2 10.40.3.10 5432
```
Salida esperada (el escaneo tarda varios segundos ahora: las sondas descartadas no reciben respuesta, así que `nmap` las espera. Los tiempos varían):
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.2.10
Host is up, received user-set (0.00020s latency).
Not shown: 1025 filtered tcp ports (no-response)
PORT STATE SERVICE REASON
80/tcp open http syn-ack
Nmap scan report for 10.40.3.10
Host is up, received user-set.
All 1026 scanned ports on 10.40.3.10 are in ignored states.
Not shown: 1026 filtered tcp ports (no-response)
Nmap done: 2 IP addresses (2 hosts up) scanned in 7.14 seconds
hello from the DMZ web server
lab-db ready
```
Compáralo con el Paso 6:
| | Antes (todo abierto) | Después (denegación por defecto) |
|---|---|---|
| Servidor web, puerto 80 | `open` | `open` (permitido) |
| Servidor web, puertos 22 y 8080 | `open` | `filtered` |
| Base de datos, puertos 22 y 5432 | `open` | `filtered` |
| Otros puertos | `closed` (rechazado) | `filtered` (sin respuesta) |
| Tiempo de escaneo | 0,08 s | varios segundos |
La superficie de ataque vista desde fuera pasó de cinco puertos abiertos a uno. Fíjate también en el **cambio de palabra**: `closed` significa «el host rechazó», `filtered` significa «no volvió nada», que es el aspecto de un **drop**. La base de datos ya ni siquiera es un objetivo visible: sus 1026 puertos están filtrados. El servidor web sigue sirviendo el puerto 80, y el segundo flujo permitido funciona: el servidor web llegó a la base de datos.
> [!NOTE]
> La línea «Host is up, received user-set» es `nmap` repitiendo lo que tú le indicaste (`-Pn`): que asuma que el host está activo. No demuestra que el host respondiera. Sin `-Pn`, `nmap` intentaría primero el descubrimiento de hosts: en este contenedor eso falla con «Couldn't open a raw socket», y frente a un firewall real que descarta los pings informaría erróneamente «Host seems down».
Ahora mira la política desde la **DMZ**, donde se situaría un atacante que hubiera tomado el control del servidor web. Escanea la base de datos y el cliente de «Internet» desde el servidor web:
```bash
podman exec lab-netsec-web nmap -n -Pn -sT --max-retries 1 -T4 -p 22,80,443,5432,8080 10.40.3.10 203.0.113.10
```
Salida esperada:
```text
Starting Nmap 7.95 ( https://nmap.org ) at 2026-11-07 19:38 UTC
Nmap scan report for 10.40.3.10
Host is up (0.000095s latency).
PORT STATE SERVICE
22/tcp filtered ssh
80/tcp filtered http
443/tcp filtered https
5432/tcp open postgresql
8080/tcp filtered http-proxy
Nmap scan report for 203.0.113.10
Host is up.
PORT STATE SERVICE
22/tcp filtered ssh
80/tcp filtered http
443/tcp filtered https
5432/tcp filtered postgresql
8080/tcp filtered http-proxy
Nmap done: 2 IP addresses (2 hosts up) scanned in 1.23 seconds
```
Desde la DMZ, la base de datos muestra **un** puerto abierto (5432, el flujo permitido), y el cliente de «Internet» no muestra ninguno: el servidor web no puede abrir conexiones hacia el exterior (**filtrado de salida**). Si se toma el control del servidor web, el atacante puede hablar con el puerto de la base de datos y con nada más. Escanear desde cada zona es la forma de probar las reglas internas, que un escaneo de perímetro no puede ver.
### Paso 9 — Lee el registro y los contadores (12 min)
Los escaneos y las pruebas no demuestran que los paquetes se bloquearon **por tus reglas**. Los contadores y el registro, sí. Primero pon a cero los contadores, para que las cifras de abajo sean solo de este paso. Después inicia una captura en el canal nflog del firewall, en segundo plano, escribiendo en un archivo dentro del contenedor firewall. Se detiene sola a los 60 segundos.
```bash
podman exec lab-netsec-fw nft reset rules chain inet lab_fw forward > /dev/null
podman exec -d lab-netsec-fw sh -c 'timeout 60 tcpdump -n -l -q -i nflog:1 > /tmp/drops.log 2>&1'
sleep 1
```
`nflog:1` es la interfaz de captura del grupo de registro 1, el `group 1` de la regla. `-n` omite las resoluciones de nombres y `-q` imprime una línea corta por paquete. Ahora prueba cinco flujos que **no** deben funcionar. Cada `nc -z` solo comprueba si la conexión se abre; `-w 2` se rinde a los 2 segundos.
```bash
podman exec lab-netsec-client nc -w 2 -z -v 10.40.3.10 5432; echo rc=$?
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 22; echo rc=$?
podman exec lab-netsec-web nc -w 2 -z -v 10.40.3.10 22; echo rc=$?
podman exec lab-netsec-db nc -w 2 -z -v 10.40.2.10 80; echo rc=$?
podman exec lab-netsec-web nc -w 2 -z -v 203.0.113.10 80; echo rc=$?
```
Las cinco pruebas son: Internet a la **base de datos** (5432), Internet al puerto **SSH** del servidor web, servidor web al puerto **SSH** de la base de datos, base de datos al servidor web (una conexión iniciada desde dentro) y servidor web a «Internet» (salida). Salida esperada (cada tiempo de espera dura unos 2 segundos, cinco veces):
```text
nc: 10.40.3.10 (10.40.3.10:5432): Operation timed out
rc=1
nc: 10.40.2.10 (10.40.2.10:22): Operation timed out
rc=1
nc: 10.40.3.10 (10.40.3.10:22): Operation timed out
rc=1
nc: 10.40.2.10 (10.40.2.10:80): Operation timed out
rc=1
nc: 203.0.113.10 (203.0.113.10:80): Operation timed out
rc=1
```
Las cinco **agotan el tiempo de espera** (no hay negativa): el firewall descarta el paquete y no dice nada. Ahora lee el registro de descartes y los contadores:
```bash
sleep 3
podman exec lab-netsec-fw cat /tmp/drops.log
podman exec lab-netsec-fw nft list chain inet lab_fw forward | tail -6
```
Salida esperada (las marcas de tiempo y los puertos de origen varían):
```text
tcpdump: verbose output suppressed, use -v[v]... for full protocol decode
listening on nflog:1, link-type NFLOG (Linux netfilter log messages), snapshot length 262144 bytes
19:38:34.206451 IP 203.0.113.10.45915 > 10.40.3.10.5432: tcp 0
19:38:35.231427 IP 203.0.113.10.45915 > 10.40.3.10.5432: tcp 0
19:38:36.254469 IP 203.0.113.10.34173 > 10.40.2.10.22: tcp 0
19:38:37.278435 IP 203.0.113.10.34173 > 10.40.2.10.22: tcp 0
19:38:38.366492 IP 10.40.2.10.35221 > 10.40.3.10.22: tcp 0
19:38:39.391417 IP 10.40.2.10.35221 > 10.40.3.10.22: tcp 0
19:38:40.414413 IP 10.40.3.10.41825 > 10.40.2.10.80: tcp 0
19:38:41.438422 IP 10.40.3.10.41825 > 10.40.2.10.80: tcp 0
19:38:42.526436 IP 10.40.2.10.33531 > 203.0.113.10.80: tcp 0
19:38:43.550426 IP 10.40.2.10.33531 > 203.0.113.10.80: tcp 0
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 80 ct state new counter packets 0 bytes 0 accept comment "internet to web: 80"
iifname "dmz0" oifname "int0" ip saddr 10.40.2.10 ip daddr 10.40.3.10 tcp dport 5432 ct state new counter packets 0 bytes 0 accept comment "web to db: 5432"
limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1
counter packets 10 bytes 600 drop comment "default deny"
}
}
```
Lee la evidencia:
- El registro tiene **diez líneas de paquete, en cinco pares** (`tcpdump` imprime su resumen de «packets captured» solo cuando termina la captura, pasados los 60 segundos). Cada par es un intento de conexión bloqueado: un TCP SYN (el primer paquete de una conexión; `tcp 0` significa sin datos) enviado dos veces, porque el emisor reintentó tras aproximadamente un segundo. Los pares coinciden con tus cinco pruebas, en origen, destino y puerto.
- El contador `default deny` muestra **10 paquetes, 600 bytes**: los mismos diez paquetes (60 bytes cada uno). Las dos reglas `accept` de conexiones nuevas muestran **0**, así que ninguno de los flujos bloqueados se coló por error a través de una regla de permiso.
- Como el registro y el contador coinciden, sabes que cada bloqueo vino de la denegación por defecto y no de un error tipográfico o de una ruta que falta.
Tus cifras pueden diferir en unos pocos paquetes si tus tiempos de espera o reintentos son distintos, pero el registro y el contador deben coincidir entre sí.
> [!NOTE]
> Aquí `tcpdump` no imprime el texto del `prefix` de la regla de registro. En una instalación de producción, un demonio de registro como `ulogd` almacena los registros nflog, con el prefijo, en un archivo o en un servidor de registros. Leerlo con `tcpdump` basta para el laboratorio.
### Paso 10 — Orden de las reglas: dónde va una regla nueva (8 min)
Supón que el equipo web te pide publicar también el servicio del puerto 8080. Añades la regla de la forma obvia, con `nft add rule`, que **añade al final** de la cadena.
```bash
podman exec lab-netsec-fw nft add rule inet lab_fw forward iifname net0 oifname dmz0 ip daddr 10.40.2.10 tcp dport 8080 ct state new counter accept comment '"internet to web: 8080 (added)"'
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 8080; echo rc=$?
podman exec lab-netsec-fw nft -a list chain inet lab_fw forward | tail -5
```
Salida esperada:
```text
nc: 10.40.2.10 (10.40.2.10:8080): Operation timed out
rc=1
limit rate 5/second burst 10 packets log prefix "lab-netsec DROP: " group 1 # handle 6
counter packets 12 bytes 720 drop comment "default deny" # handle 7
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 8080 ct state new counter packets 0 bytes 0 accept comment "internet to web: 8080 (added)" # handle 8
}
}
```
La regla existe, y el puerto **sigue sin abrirse**. La regla nueva (handle 8) está **después** del `drop` (handle 7), así que el paquete se descarta antes de que pueda coincidir, y el contador de la regla nueva se queda en 0. La opción `-a` muestra el **handle** de cada regla, su número permanente. Borra la regla inútil e inserta una nueva **antes** de la regla de registro, en la posición del handle 6:
```bash
podman exec lab-netsec-fw nft delete rule inet lab_fw forward handle 8
podman exec lab-netsec-fw nft insert rule inet lab_fw forward position 6 iifname net0 oifname dmz0 ip daddr 10.40.2.10 tcp dport 8080 ct state new counter accept comment '"internet to web: 8080 (inserted)"'
podman exec lab-netsec-client nc -w 2 -z -v 10.40.2.10 8080; echo rc=$?
podman exec lab-netsec-fw nft list chain inet lab_fw forward | grep 8080
```
Salida esperada (los números de handle que escribiste deben coincidir con tu propio listado de `nft -a`):
```text
10.40.2.10 (10.40.2.10:8080) open
rc=0
iifname "net0" oifname "dmz0" ip daddr 10.40.2.10 tcp dport 8080 ct state new counter packets 1 bytes 60 accept comment "internet to web: 8080 (inserted)"
```
Ahora el puerto está abierto y el contador de la regla muestra la única conexión. Esa es exactamente la exposición que la política de denegación por defecto estaba eliminando, así que es un buen momento para deshacerla: recarga la política original, que borra y recrea la tabla entera.
```bash
podman exec -i lab-netsec-fw nft -f - < fw.nft
```
La carga no imprime nada, y la tabla vuelve a tener las cinco reglas del Paso 7.
> [!TIP]
> En la vida real, mantén el archivo de reglas en control de versiones y **recarga el archivo** en lugar de escribir reglas sueltas. Así el archivo es siempre la verdad, un revisor puede leer el cambio y no puedes dejar olvidada una regla de prueba en el firewall.
## Verificación
La política es correcta cuando todas las pruebas positivas pasan y todas las negativas quedan bloqueadas. Escribe las comprobaciones en un script. `t` ejecuta una prueba: usa `nc` desde un contenedor hacia un destino y un puerto, y compara el resultado con lo que esperas.
```bash
cat > check.sh <<'EOT'
#!/bin/sh
# usage: ./check.sh (run from ~/netsec-lab); prints PASS or FAIL for every flow in the policy
pass=0; fail=0
t() { # t <expected: open|blocked> <from-container> <dst-ip> <port>
if podman exec "lab-netsec-$2" nc -w 2 -z "$3" "$4" >/dev/null 2>&1; then got=open; else got=blocked; fi
if [ "$got" = "$1" ]; then r=PASS; pass=$((pass+1)); else r=FAIL; fail=$((fail+1)); fi
printf '%s %-7s -> %-12s :%-5s expected %-7s got %s\n' "$r" "$2" "$3" "$4" "$1" "$got"
}
t open client 10.40.2.10 80
t blocked client 10.40.2.10 22
t blocked client 10.40.2.10 8080
t blocked client 10.40.3.10 5432
t blocked client 10.40.3.10 22
t open web 10.40.3.10 5432
t blocked web 10.40.3.10 22
t blocked web 203.0.113.10 80
t blocked db 10.40.2.10 80
echo "passed=$pass failed=$fail"
[ "$fail" -eq 0 ]
EOT
chmod +x check.sh
./check.sh; echo rc=$?
```
Salida esperada (la ejecución tarda unos 15 segundos, porque cada prueba bloqueada espera 2 segundos):
```text
PASS client -> 10.40.2.10 :80 expected open got open
PASS client -> 10.40.2.10 :22 expected blocked got blocked
PASS client -> 10.40.2.10 :8080 expected blocked got blocked
PASS client -> 10.40.3.10 :5432 expected blocked got blocked
PASS client -> 10.40.3.10 :22 expected blocked got blocked
PASS web -> 10.40.3.10 :5432 expected open got open
PASS web -> 10.40.3.10 :22 expected blocked got blocked
PASS web -> 203.0.113.10 :80 expected blocked got blocked
PASS db -> 10.40.2.10 :80 expected blocked got blocked
passed=9 failed=0
rc=0
```
Criterios de aprobación:
- Las nueve líneas dicen `PASS` y el script termina con `rc=0`. Las dos líneas `open` son tus dos flujos permitidos; las siete líneas `blocked` son las pruebas negativas.
- `podman exec lab-netsec-fw nft list chain inet lab_fw forward` muestra solo las cinco reglas del Paso 7 (sin regla para 8080), con contadores distintos de cero en las dos reglas accept y en el drop.
- Un escaneo desde el cliente (Paso 8) muestra solo el puerto 80 abierto en `10.40.2.10` y nada abierto en `10.40.3.10`.
> [!NOTE]
> Este script trata «la conexión falló» como «bloqueado». Una negativa y un tiempo de espera agotado cuentan igual. En este laboratorio no hay problema, porque los servicios que pruebas están escuchando, así que un fallo significa que el firewall lo descartó. En una red real, recuerda la diferencia: una negativa significa que el paquete llegó, un tiempo de espera agotado significa que algo lo descartó.
## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `nmap` imprime «Couldn't open a raw socket» | Usaste `-sS` o te dejaste `-Pn`: ambos necesitan sockets en bruto, que el contenedor sin privilegios no tiene | Usa `-sT -Pn` como en el laboratorio |
| Todo agota el tiempo de espera desde el cliente, incluso el puerto 80, antes de cargar ninguna regla | Falta una ruta: el cliente necesita `10.40.0.0/16 via 203.0.113.254`, los servidores necesitan su ruta por defecto | Compara `podman exec lab-netsec-client ip route` con el Paso 5. Recrea el contenedor al que le falte la ruta |
| El puerto 80 está bloqueado después de cargar la política | Los nombres de interfaz o las direcciones de la regla no coinciden, o se editó el archivo | `nft list chain inet lab_fw forward`: si el contador de `internet to web` está a 0 mientras el del drop crece, la regla no coincide. Comprueba `net0`, `dmz0` y `10.40.2.10` |
| El registro de descartes (`/tmp/drops.log`) está vacío pero el contador del drop crece | La captura no estaba en marcha cuando probaste, falta la regla de registro, o el grupo de registro es distinto | Inicia antes la captura (Paso 9) y prueba dentro de sus 60 segundos. Comprueba que la regla dice `group 1` |
| `Error: No such file or directory` al cargar las reglas | El binario `nft` no puede crear la tabla: al contenedor le falta `NET_ADMIN`, o hay un error tipográfico en el archivo | Revisa el `--cap-add NET_ADMIN` del `podman run` del Paso 4. Lee el número de línea que se imprime con el error |
| `the container name "lab-netsec-fw" is already in use` | Queda un contenedor de un intento anterior | Ejecuta la [Limpieza](#limpieza) y empieza de nuevo |
| Una regla nueva no abre el puerto | La regla se añadió después del drop final | Lista con `nft -a`, borra por handle y usa `insert ... position <handle>` antes de la regla de registro (Paso 10) |
## Reto (opcional)
Amplía la política sin ayuda paso a paso:
1. El servidor web necesita descargar actualizaciones. Arranca un pequeño servidor web en el contenedor cliente en TCP 8000 (`httpd -p 8000` con una carpeta de tu elección) y escribe la regla **más estrecha** que permita que `lab-netsec-web` (y solo él) abra conexiones hacia `203.0.113.10` por TCP 8000. Demuestra con `./check.sh` (añade la prueba) y con un escaneo que no se abrió nada más.
2. Añade un cuarto host en la zona interna, `lab-netsec-admin` en `10.40.3.20`, que pueda abrir conexiones hacia el servidor web por TCP 22, y nadie más. ¿Dónde pones la regla y qué prueba demuestra que la base de datos no puede hacer lo mismo?
3. Haz que la regla orientada a Internet sea un **reject** en lugar de un drop (`reject with tcp reset`) para un solo puerto y compara cómo lo informa un escaneo frente a `filtered`.
## Limpieza
Elimina todos los contenedores, redes y la imagen creados por este laboratorio, y después la carpeta. `-t 0` evita la espera de 10 segundos con los contenedores que ignoran la señal de parada.
```bash
podman rm -f -t 0 lab-netsec-client lab-netsec-web lab-netsec-db lab-netsec-fw
podman network rm lab-netsec-internet lab-netsec-dmz lab-netsec-internal
podman rmi lab-netsec-tools:1
cd ~ && rm -rf ~/netsec-lab
podman ps -a --filter name=lab-netsec --format '{{.Names}}'
podman network ls --filter name=lab-netsec --format '{{.Name}}'
```
Los dos últimos comandos no imprimen nada cuando la limpieza está completa. La imagen base de Alpine permanece en tu almacenamiento de Podman (unos 8 MB); elimínala con `podman rmi docker.io/library/alpine:3.20.10` si ningún otro laboratorio la necesita.
## Qué has aprendido
- Escanear desde fuera muestra la superficie de ataque real; escanear desde cada zona prueba también las reglas internas.
- Un conjunto de reglas con estado y denegación por defecto solo necesita reglas para los flujos que quieres: aquí bastaron dos reglas de conexión nueva y una regla `established`.
- `closed` significa rechazado y `filtered` significa descartado: los descartes de un firewall parecen silencio.
- El filtrado de salida y la contención de la DMZ hacen que un servidor web comprometido pueda llegar a un puerto de la base de datos y a nada más.
- Los contadores de las reglas y el registro de descartes deben coincidir; juntos demuestran que un flujo lo bloqueó tu política.
- El orden de las reglas importa: una regla después del drop final nunca coincide. Mantén las reglas en un archivo y recarga el archivo.