A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.
## Objetivo
Constrói três zonas de rede (uma «Internet», uma DMZ e uma zona interna) ligadas por um contentor de firewall. Analisa a rede a partir do exterior enquanto tudo está aberto, aplica uma política nftables de negação por omissão que permite apenas dois fluxos, analisa de novo, lê os contadores e o registo de descartes da firewall e prova com testes que todos os fluxos indesejados estão bloqueados.
## Objetivos
- Construir três zonas isoladas e encaminhá-las através de uma só firewall.
- Analisar a rede a partir do exterior com o `nmap` e ler os resultados `open`, `closed` e `filtered`.
- Escrever um conjunto de regras com estado e negação por omissão que permita apenas Internet para web (TCP 80) e web para base de dados (TCP 5432).
- Ler os contadores das regras da firewall e o seu registo de descartes para confirmar que o tráfego bloqueado foi bloqueado pelas suas regras.
- Verificar a política com uma tabela de testes positivos e negativos e mostrar por que razão a ordem das regras importa.
## Pré-requisitos
- Uma máquina Linux com **Podman 4 ou posterior** a funcionar **sem privilégios de root** (como utilizador normal; nunca precisa de `sudo`) e com o *backend* de rede netavark. Testado com o Podman 5.8.7 no Fedora com o kernel 7.2. Verifique com `podman info --format '{{.Host.NetworkBackend}}'`: deve imprimir `netavark`.
- Acesso à Internet uma vez, para descarregar a imagem do Alpine Linux (cerca de 8 MB) e alguns pacotes (cerca de 40 MB no total). Depois disso, nada no laboratório precisa da Internet.
- Cerca de 400 MB de espaço livre em disco.
- A [lição](lesson.pt.md) deste módulo e [Redes 08 — Camada de transporte: TCP, UDP e portas](../../networking/08-tcp-udp/README.pt.md). As técnicas de contentores são as do [laboratório de redes na cloud](../../cloud-computing/06-cloud-networking/lab.pt.md); aqui, o foco são as zonas, a negação por omissão, o registo e a verificação.
> [!WARNING]
> **Autorização e ética.** A análise de portas é uma técnica de ataque quando dirigida a sistemas que não controla, e pode ser ilegal. Neste laboratório, analisa apenas os três contentores que cria, em redes criadas com `--internal` (nada sai da sua máquina). Nunca aponte o `nmap` a um sistema que não lhe pertença ou que não esteja explicitamente autorizado, por escrito, a testar. Analisar o seu próprio laboratório isolado para verificar a sua própria firewall é a utilização defensiva da ferramenta.
## Arquitetura
<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-pt-title netsec-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="netsec-lab-architecture-pt-title">Arquitetura do laboratório: três zonas e uma firewall com negação por omissão</title>
<desc id="netsec-lab-architecture-pt-desc">Três redes internas do Podman convergem num contentor firewall, lab-netsec-fw, com as interfaces net0 203.0.113.254, dmz0 10.40.2.254 e int0 10.40.3.254. A rede internet 203.0.113.0/24 contém o lab-netsec-client em 203.0.113.10, o cliente externo com nmap, nc e curl e uma rota para 10.40.0.0/16 via 203.0.113.254. A rede dmz 10.40.2.0/24 contém o lab-netsec-web em 10.40.2.10, um servidor web que escuta em tcp 80, 8080 e 22, com rota por omissão via 10.40.2.254. A rede interna 10.40.3.0/24 contém o lab-netsec-db em 10.40.3.10, um serviço tipo base de dados em tcp 5432 e 22, com rota por omissão via 10.40.3.254. A firewall aplica a tabela nftables inet lab_fw no hook forward com policy drop: a regra 1 aceita o tráfego established e related, a regra 2 aceita novas ligações de net0 para dmz0 por tcp 80, a regra 3 aceita novas ligações de dmz0 para int0 por tcp 5432 e a regra 4 regista no grupo nflog 1 e descarta tudo o resto.</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 da 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">Serviço tipo base de dados</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="362" y="526" width="456" 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">As três redes Podman são --internal: nada sai da sua máquina</text></g>
</svg></figure>
*Figura 1. Um contentor de firewall liga três zonas. No fim, só os dois fluxos da sua lista de regras a podem atravessar.*
| Contentor | Rede e endereço | Função |
|---|---|---|
| `lab-netsec-client` | `lab-netsec-internet`, `203.0.113.10` | O exterior: um visitante, ou um atacante, com `nmap`, `nc` e `curl` |
| `lab-netsec-web` | `lab-netsec-dmz`, `10.40.2.10` | O servidor web público (TCP 80), mais dois serviços que **não** deviam ser públicos: TCP 8080 e um banner SSH falso em TCP 22 |
| `lab-netsec-db` | `lab-netsec-internal`, `10.40.3.10` | Um serviço semelhante a uma base de dados em TCP 5432 (responde `lab-db ready`) e um banner SSH falso em TCP 22 |
| `lab-netsec-fw` | `203.0.113.254`, `10.40.2.254`, `10.40.3.254` | O router e firewall entre as zonas |
> [!NOTE]
> Os serviços «SSH» e «base de dados» são pequenos serviços `nc` à escuta que imprimem uma linha. Chegam para serem encontrados por uma análise e para aceitarem ou recusarem ligações, que é tudo o que este laboratório precisa. Numa rede real, o servidor web precisaria também de um endereço público (ou traduzido); aqui, o cliente limita-se a chegar até ele através da firewall.
O Podman executa um comando num contentor com `podman exec lab-netsec-<nome> <comando>`. O laboratório usa isto constantemente, por isso cada comando está escrito por extenso.
## Passos
### Passo 1 — Verificar as ferramentas e criar uma pasta de trabalho (3 min)
Confirme que o Podman está sem privilégios de root e usa o netavark, e que não ficou nada de uma tentativa 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
```
Resultado esperado (a sua versão pode diferir):
```text
podman version 5.8.7
netavark rootless=true
```
Os dois comandos `ls` não imprimem nada. Se listarem nomes `lab-netsec-`, execute primeiro a [Limpeza](#limpeza). Todos os ficheiros e comandos seguintes assumem que está em `~/netsec-lab`.
### Passo 2 — Construir a imagem de ferramentas (5 min)
O Alpine Linux é minúsculo, mas não tem nenhuma das ferramentas de que precisa. Constrói uma imagem com o `nftables` (a firewall do Linux), o `nmap` (o analisador de portas), o `tcpdump` (para ler o registo da firewall), o `curl`, o comando `ip` completo e o `busybox-extras` (um pequeno servidor web). A etiqueta está fixada no Alpine 3.20, para obter os mesmos resultados que os das saídas abaixo.
```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'
```
Resultado esperado (o fim da construção e depois as versões; as versões dos pacotes podem diferir ligeiramente):
```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
```
### Passo 3 — Criar as três zonas (3 min)
Cada rede Podman é uma zona: uma bridge com o seu próprio intervalo de endereços. `--internal` significa que o Podman não adiciona nenhuma rota para o mundo exterior nem NAT para o seu anfitrião, pelo que nada no laboratório pode sair da sua máquina, e nada pode passar entre zonas exceto através da firewall que vai construir. A «Internet» usa um intervalo de documentação ([RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)); a DMZ e a zona interna usam intervalos 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}}'
```
Resultado esperado:
```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
```
### Passo 4 — Arrancar a firewall (4 min)
O contentor da firewall tem uma interface em cada zona, com o último endereço utilizável (`.254`) de cada intervalo. `interface_name` dá nomes legíveis às interfaces: `net0`, `dmz0` e `int0`. `--cap-add NET_ADMIN` permite-lhe editar as suas próprias regras de firewall e `--sysctl net.ipv4.ip_forward=1` transforma-o num router. `sleep infinity` mantém-no em execução.
```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
```
Resultado esperado (o ID do contentor, a ordem das interfaces, os números `@if` e os endereços `fe80::` variam):
```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
```
O último comando, `nft list ruleset`, **não imprime nada**: a firewall ainda não tem regras, pelo que reencaminha tudo. Fique com isto presente: é o seu ponto de partida.
### Passo 5 — Arrancar os três anfitriões (6 min)
Cada anfitrião junta-se a uma zona. Uma rede interna não dá ao contentor nenhuma rota predefinida, por isso cada anfitrião adiciona uma rota para a firewall: o servidor web e a base de dados usam-na como gateway predefinido, e o cliente envia-lhe o intervalo `10.40.0.0/16`. A `NET_ADMIN` só é necessária para o `ip route add`.
O servidor web executa o servidor web BusyBox `httpd` em TCP 80 e 8080, e um serviço `nc` à escuta em TCP 22 que imprime um banner SSH falso. A base de dados executa dois serviços `nc` à escuta: TCP 22 (o mesmo banner) e TCP 5432, que responde `lab-db ready`. Representam serviços que existem em máquinas reais e que não deviam ser acessíveis a partir de todo o lado.
```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}}'
```
Resultado esperado (primeiro três IDs de contentores; os tempos variam):
```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
```
Verifique as rotas e as portas em que cada servidor está à escuta:
```bash
podman exec lab-netsec-client ip route
podman exec lab-netsec-web netstat -tln
podman exec lab-netsec-db netstat -tln
```
Resultado esperado:
```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
```
Já conhece a **verdade**: o servidor web está à escuta nas portas 80, 8080 e 22; a base de dados na 5432 e na 22. No passo seguinte, vai descobrir o que um estranho vê.
### Passo 6 — Referência: tudo está aberto, e uma análise mostra-o (10 min)
Com o reencaminhamento ligado e sem regras, a firewall deixa passar tudo. Teste a partir do cliente exterior e depois analise. Primeiro, dois pedidos normais:
```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
```
Resultado esperado:
```text
hello from the DMZ web server
lab-db ready
10.40.3.10 (10.40.3.10:22) open
```
O cliente na «Internet» falou **diretamente com a base de dados**. Esta é a rede plana da história de abertura da lição. Agora, analise os dois servidores a partir do 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
```
O que significam as opções:
- `-n` dispensa a resolução de nomes; `-p 1-1024,5432,8080` analisa as portas bem conhecidas mais as duas extra.
- `-sT` é uma análise TCP **connect**: completa o handshake TCP com a chamada normal `connect()`. Não precisa de privilégios especiais, e é por isso que funciona num contentor sem privilégios de root (a análise SYN, mais rápida, `-sS`, precisa de sockets em bruto e falha aqui).
- `-Pn` dispensa a deteção «o anfitrião está ativo?», que também precisaria de sockets em bruto neste contentor. Cada sonda é tratada como uma sonda de porta.
- `--reason` mostra o motivo pelo qual cada estado foi decidido; `--max-retries 1 -T4` torna a análise suficientemente rápida para um laboratório.
Resultado esperado (os valores de latência e a data variam):
```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
```
Leia-o. O cliente exterior vê **cinco portas abertas em dois anfitriões**, incluindo a base de dados que nunca devia ser acessível e os serviços «SSH» e 8080 que ninguém pretendia publicar. As outras portas estão `closed`: o anfitrião respondeu a cada sonda com uma recusa (`conn-refused`), pelo que a análise demorou 0,08 segundos. A análise acabou de construir um inventário da superfície de ataque. Anote as portas abertas: vai compará-las com a análise seguinte.
> [!NOTE]
> Os nomes dos serviços (`ssh`, `postgresql`, `http-proxy`) são suposições a partir do número da porta, não do que responde. O `nmap` mapeia portas para nomes a partir de uma tabela. Os serviços falsos deste laboratório não enganariam uma análise de versões, que precisa dos ficheiros de scripts do `nmap` que esta pequena imagem não inclui.
### Passo 7 — Aplicar a política de negação por omissão (10 min)
Vai agora escrever a política do exemplo prático da lição. Ponha-a num ficheiro e depois carregue-a na firewall. Leia-a antes de a carregar.
```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
```
O que faz cada parte:
- As duas primeiras linhas tornam seguro voltar a carregar o ficheiro: criam a tabela se não existir e depois apagam-na, pelo que cada carregamento parte de uma tabela limpa.
- `table inet` aplica-se a IPv4 e IPv6. `chain forward` com `hook forward` filtra o tráfego que **atravessa** a firewall; é o caminho entre as zonas.
- `policy drop` é a negação por omissão: um pacote que não corresponde a nenhum `accept` é descartado.
- `ct state invalid drop` descarta os pacotes que não pertencem a nenhuma ligação válida.
- `ct state established,related ... accept` é a parte com estado: as **respostas** a ligações permitidas não precisam de uma regra própria. Vem primeiro porque corresponde à maioria dos pacotes.
- As duas regras `ct state new ... accept` são os **únicos** fluxos novos permitidos. Cada uma indica as interfaces, o destino exato (e a origem, na segunda regra) e a porta. A palavra-chave `counter` conta os pacotes de cada regra.
- `limit ... log group 1` escreve um registo dos pacotes descartados no canal **nflog** número 1 do kernel, no máximo 5 por segundo (após uma rajada de 10), para que uma análise não possa inundar o registo. As regras sem veredicto, como `log`, deixam o pacote continuar para a regra seguinte.
- A última regra conta e descarta tudo o resto (a política também descartaria, mas uma regra explícita dá-lhe um contador).
`podman exec -i ... nft -f -` lê o ficheiro a partir da entrada padrão, pelo que fica na sua máquina. O carregamento não imprime nada. Resultado esperado do comando `list` (todos os contadores estão a zero neste momento):
```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]
> Uma regra `log` simples (sem `group`) escreve no registo do kernel, que se lê com `dmesg` ou `journalctl -k`. Num contentor, esse registo não está disponível: neste teste, o `dmesg` dentro do contentor falhou com «Operation not permitted», e por omissão o kernel só regista a partir do espaço de nomes de rede do próprio anfitrião. O canal `nflog` funciona sem qualquer permissão especial e o `tcpdump` consegue lê-lo, por isso o laboratório usa-o. Se a sua configuração for diferente, os contadores do Passo 9 continuam a provar o que foi descartado.
### Passo 8 — Analisar de novo e comparar (8 min)
Repita **exatamente** a mesma análise e depois experimente os dois fluxos que permitiu:
```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
```
Resultado esperado (a análise demora agora vários segundos: as sondas descartadas não recebem resposta, por isso o `nmap` espera por elas. Os tempos variam):
```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
```
Compare com o Passo 6:
| | Antes (tudo aberto) | Depois (negação por omissão) |
|---|---|---|
| Servidor web, porta 80 | `open` | `open` (permitida) |
| Servidor web, portas 22 e 8080 | `open` | `filtered` |
| Base de dados, portas 22 e 5432 | `open` | `filtered` |
| Outras portas | `closed` (recusada) | `filtered` (sem resposta) |
| Tempo da análise | 0,08 s | vários segundos |
A superfície de ataque vista do exterior passou de cinco portas abertas para uma. Note também a **mudança da palavra**: `closed` significa «o anfitrião recusou», `filtered` significa «nada voltou», que é o aspeto de um **drop**. A base de dados já nem sequer é um alvo visível: todas as 1026 portas estão filtradas. O servidor web continua a servir a porta 80 e o segundo fluxo permitido funciona: o servidor web chegou à base de dados.
> [!NOTE]
> A linha «Host is up, received user-set» é o `nmap` a repetir o que lhe disse (`-Pn`): para assumir que o anfitrião está ativo. Não prova que o anfitrião tenha respondido. Sem `-Pn`, o `nmap` tentaria primeiro a deteção de anfitriões: neste contentor isso falha com «Couldn't open a raw socket» e, perante uma firewall real que descarta pings, comunicaria erradamente «Host seems down».
Agora, veja a política a partir da **DMZ**, onde estaria um atacante que tivesse tomado conta do servidor web. Analise a base de dados e o cliente «Internet» a partir do 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
```
Resultado esperado:
```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
```
A partir da DMZ, a base de dados mostra **uma** porta aberta (5432, o fluxo permitido) e o cliente «Internet» não mostra nenhuma: o servidor web não consegue abrir ligações para o exterior (**filtragem de saída**). Se o servidor web for tomado, o atacante consegue falar com a porta da base de dados e com mais nada. Analisar a partir de cada zona é a forma de testar as regras internas, que uma análise de perímetro não vê.
### Passo 9 — Ler o registo e os contadores (12 min)
As análises e os testes não provam que os pacotes foram bloqueados **pelas suas regras**. Os contadores e o registo provam. Primeiro, reponha os contadores a zero, para que os números abaixo sejam só deste passo. Depois, inicie uma captura no canal nflog da firewall, em segundo plano, a escrever para um ficheiro dentro do contentor da firewall. Para sozinha ao fim de 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` é a interface de captura do grupo de registo 1, o `group 1` da regra. `-n` dispensa a resolução de nomes e `-q` imprime uma linha curta por pacote. Agora, experimente cinco fluxos que **não** devem funcionar. Cada `nc -z` só testa se a ligação abre; `-w 2` desiste ao fim de 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=$?
```
Os cinco testes são: Internet para a **base de dados** (5432), Internet para a porta **SSH** do servidor web, servidor web para a porta **SSH** da base de dados, base de dados para o servidor web (uma ligação iniciada a partir do interior) e servidor web para a «Internet» (saída). Resultado esperado (cada tempo de espera esgotado demora cerca de 2 segundos, cinco vezes):
```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
```
Todos os cinco **esgotam o tempo** (não há recusa): a firewall descarta o pacote e não diz nada. Agora, leia o registo de descartes e os 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
```
Resultado esperado (as marcas temporais e as portas de origem variam):
```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"
}
}
```
Leia as provas:
- O registo tem **dez linhas de pacotes, em cinco pares** (o `tcpdump` só imprime o seu resumo «packets captured» quando a captura termina, ao fim dos 60 segundos). Cada par é uma tentativa de ligação bloqueada: um TCP SYN (o primeiro pacote de uma ligação; `tcp 0` significa sem dados) enviado duas vezes, porque o emissor repetiu o envio ao fim de cerca de um segundo. Os pares correspondem aos seus cinco testes, da origem ao destino e à porta.
- O contador `default deny` mostra **10 pacotes, 600 bytes**: os mesmos dez pacotes (60 bytes cada). As duas regras `accept` de ligações novas mostram **0**, pelo que nenhum dos fluxos bloqueados passou por engano por uma regra de permissão.
- Como o registo e o contador concordam, sabe que cada bloqueio veio da negação por omissão e não de um erro de digitação ou de uma rota em falta.
As suas contagens podem diferir em alguns pacotes se os seus tempos de espera ou repetições diferirem, mas o registo e o contador têm de coincidir entre si.
> [!NOTE]
> O `tcpdump` não imprime aqui o texto do `prefix` da regra de registo. Numa configuração de produção, um serviço de registo como o `ulogd` guarda os registos nflog, com o prefixo, num ficheiro ou num servidor de registos. Lê-los com o `tcpdump` chega para o laboratório.
### Passo 10 — Ordem das regras: onde vai uma regra nova (8 min)
Suponha que a equipa web lhe pede para publicar também o serviço da porta 8080. Adiciona a regra da forma óbvia, com `nft add rule`, que **acrescenta** a regra ao fim da cadeia.
```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
```
Resultado esperado:
```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
}
}
```
A regra existe, e a porta **continua sem abrir**. A regra nova (handle 8) fica **depois** do `drop` (handle 7), pelo que o pacote é descartado antes de poder corresponder, e o contador da regra nova fica a 0. A opção `-a` mostra o **handle** de cada regra, o seu número permanente. Apague a regra inútil e insira uma nova **antes** da regra de registo, na posição do 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
```
Resultado esperado (os números de handle que escreveu têm de coincidir com a sua própria listagem `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)"
```
Agora a porta está aberta e o contador da regra mostra a ligação única. Esta é exatamente a exposição que a política de negação por omissão estava a remover, por isso é um bom momento para a desfazer: volte a carregar a política original, que apaga e recria a tabela inteira.
```bash
podman exec -i lab-netsec-fw nft -f - < fw.nft
```
O carregamento não imprime nada e a tabela volta às cinco regras do Passo 7.
> [!TIP]
> Na vida real, mantenha o ficheiro de regras num sistema de controlo de versões e **volte a carregar o ficheiro** em vez de escrever regras avulsas. Assim, o ficheiro é sempre a verdade, um revisor pode ler a alteração e não corre o risco de deixar uma regra de teste esquecida na firewall.
## Verificação
A política está correta quando todos os testes positivos passam e todos os testes negativos são bloqueados. Escreva as verificações num script. O `t` executa um teste: usa o `nc` a partir de um contentor para um destino e uma porta e compara o resultado com o que espera.
```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=$?
```
Resultado esperado (a execução demora cerca de 15 segundos, porque cada teste bloqueado 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
```
Critérios de êxito:
- As nove linhas dizem `PASS` e o script termina com `rc=0`. As duas linhas `open` são os seus dois fluxos permitidos; as sete linhas `blocked` são os testes negativos.
- `podman exec lab-netsec-fw nft list chain inet lab_fw forward` mostra apenas as cinco regras do Passo 7 (sem regra 8080), com contadores diferentes de zero nas duas regras de aceitação e no descarte.
- Uma análise a partir do cliente (Passo 8) mostra apenas a porta 80 aberta em `10.40.2.10` e nada aberto em `10.40.3.10`.
> [!NOTE]
> Este script trata «a ligação falhou» como «bloqueado». Uma recusa e um tempo de espera esgotado contam ambos. Neste laboratório isso não é problema, porque os serviços que testa estão à escuta, pelo que uma falha significa que a firewall a descartou. Numa rede real, lembre-se da diferença: uma recusa significa que o pacote chegou, um tempo de espera esgotado significa que algo o descartou.
## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| O `nmap` imprime «Couldn't open a raw socket» | Usou `-sS` ou omitiu `-Pn`: ambos precisam de sockets em bruto, que o contentor sem privilégios de root não tem | Use `-sT -Pn`, como no laboratório |
| Tudo esgota o tempo a partir do cliente, mesmo a porta 80, antes de carregar qualquer regra | Falta uma rota: o cliente precisa de `10.40.0.0/16 via 203.0.113.254` e os servidores precisam da sua rota predefinida | Compare `podman exec lab-netsec-client ip route` com o Passo 5. Recrie o contentor a que falta a rota |
| A porta 80 está bloqueada depois de carregar a política | Os nomes das interfaces ou os endereços na regra não coincidem, ou o ficheiro foi editado | `nft list chain inet lab_fw forward`: se o contador de `internet to web` estiver a 0 enquanto o contador do descarte cresce, a regra não corresponde. Verifique `net0`, `dmz0` e `10.40.2.10` |
| O registo de descartes (`/tmp/drops.log`) está vazio mas o contador do descarte cresce | A captura não estava em execução quando testou, ou falta a regra de registo, ou o grupo de registo é diferente | Inicie primeiro a captura (Passo 9) e teste nos 60 segundos seguintes. Verifique se a regra diz `group 1` |
| `Error: No such file or directory` ao carregar as regras | O binário `nft` não consegue criar a tabela: o contentor não tem `NET_ADMIN`, ou há um erro de digitação no ficheiro | Verifique o `--cap-add NET_ADMIN` do `podman run` no Passo 4. Leia o número da linha impresso com o erro |
| `the container name "lab-netsec-fw" is already in use` | Ficou um contentor de uma tentativa anterior | Execute a [Limpeza](#limpeza) e comece de novo |
| Uma regra nova não abre a porta | A regra foi acrescentada depois do descarte final | Liste com `nft -a`, apague por handle e use `insert ... position <handle>` antes da regra de registo (Passo 10) |
## Desafio (opcional)
Alargue a política sem ajuda passo a passo:
1. O servidor web precisa de descarregar atualizações. Arranque um pequeno servidor web no contentor do cliente em TCP 8000 (`httpd -p 8000` com uma pasta à sua escolha) e escreva a regra **mais restrita** que permita ao `lab-netsec-web` (e só a ele) abrir ligações para `203.0.113.10` em TCP 8000. Prove com o `./check.sh` (acrescente o teste) e com uma análise que mais nada foi aberto.
2. Acrescente um quarto anfitrião na zona interna, `lab-netsec-admin` em `10.40.3.20`, que possa abrir ligações para o servidor web em TCP 22, e mais ninguém. Onde põe a regra e que teste prova que a base de dados não pode fazer o mesmo?
3. Faça com que a regra virada para a Internet seja um **reject** em vez de um drop (`reject with tcp reset`) para uma única porta e compare como uma análise a comunica em relação a `filtered`.
## Limpeza
Remova todos os contentores, redes e a imagem criados por este laboratório e depois a pasta. `-t 0` dispensa a espera de 10 segundos por contentores que ignoram o sinal de paragem.
```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}}'
```
Os dois últimos comandos não imprimem nada quando a limpeza está completa. A imagem base do Alpine fica no armazenamento do seu Podman (cerca de 8 MB); remova-a com `podman rmi docker.io/library/alpine:3.20.10` se nenhum outro laboratório precisar dela.
## O que aprendeu
- Analisar a partir do exterior mostra a superfície de ataque real; analisar a partir de cada zona testa também as regras internas.
- Um conjunto de regras com estado e negação por omissão só precisa de regras para os fluxos que quer: aqui, duas regras de ligação nova e uma regra `established` bastaram.
- `closed` significa recusado e `filtered` significa descartado: os descartes de uma firewall parecem silêncio.
- A filtragem de saída e a contenção da DMZ fazem com que um servidor web tomado consiga chegar a uma porta da base de dados e a mais nada.
- Os contadores das regras e o registo de descartes têm de concordar; em conjunto, provam que um fluxo foi bloqueado pela sua política.
- A ordem das regras importa: uma regra depois do descarte final nunca corresponde. Mantenha as regras num ficheiro e volte a carregar o ficheiro.