---
title: "Laboratório: segmentar uma rede com uma firewall de negação por omissão"
domain: cybersecurity
level: intermediate
duration: "75 min"
cost: "gratuito"
environment: "contentores (Podman sem privilégios de root numa máquina Linux local)"
lang: pt
source_hash: 7bced89cee8a
---

# Laboratório: segmentar uma rede com uma firewall de negação por omissão

## 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
![Três redes Podman internas encontram-se no contentor de firewall lab-netsec-fw, que tem 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 lab-netsec-client em 203.0.113.10, 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 lab-netsec-web em 10.40.2.10 à escuta em tcp 80, 8080 e 22. A rede internal 10.40.3.0/24 contém lab-netsec-db em 10.40.3.10 à escuta em tcp 5432 e 22. A tabela nftables da firewall inet lab_fw no gancho forward tem política drop e quatro regras: aceitar established e related; aceitar net0 para dmz0 em tcp 80; aceitar dmz0 para int0 em tcp 5432; registar no grupo 1 e depois descartar.](../../../assets/diagrams/netsec-lab-architecture.pt.svg)

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