CloudAcademia
PT

Cibersegurança · Módulo 09 · Ataques DDoS: o que são e como se defender

Laboratório: limitar a taxa de pedidos de um servidor web sob uma inundação simulada

Laboratório50 minIntermédioMarkdown

A mostrar o Markdown sem formatação: não foi possível carregar o visualizador.

## Objetivo
Inicia um pequeno servidor web, inunda-o a partir de dois contentores «bot» numa rede isolada e vê um utilizador normal ficar bloqueado. Encontra os atacantes no registo de acesso. Depois ativa a limitação de taxa, repete a inundação e vê os pedidos em excesso serem recusados com o estado HTTP 429, enquanto o utilizador normal é servido à velocidade máxima.

## Objetivos
- Medir a latência normal de um servidor web (linha de base) e a sua latência sob uma inundação.
- Detetar a inundação contando os pedidos por endereço de cliente e por código de estado no registo de acesso.
- Ativar a limitação de taxa (`limit_req`) e a limitação de ligações (`limit_conn`) do nginx e recarregá-lo sem interrupção.
- Mostrar que o limite recusa a inundação (estado 429) mas continua a servir um cliente normal (estado 200).
- Ler a definição de SYN cookies do anfitrião e de um contentor e explicar o que faz.

## 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 em Fedora com o kernel 7.2. Verifique com `podman info --format '{{.Host.NetworkBackend}}'`: deve imprimir `netavark`.
- Acesso à Internet uma vez, para descarregar as imagens do nginx e do Alpine Linux (algumas dezenas de MB no total) e dois pequenos pacotes (cerca de 8 MB). Depois disso, nada no laboratório precisa da Internet.
- Cerca de 400 MB de espaço livre em disco e pelo menos 2 núcleos de CPU.
- A [lição](lesson.pt.md) deste módulo. As técnicas do Podman são as do [laboratório de Segurança de rede](../06-network-security/lab.pt.md): redes `--internal`, imagens fixadas, contentores sem privilégios de root.

> [!WARNING]
> **Autorização e ética.** Inundar um sistema que não é seu, ou que não está explicitamente autorizado por escrito a testar, é ilegal na maioria dos países e prejudica outras pessoas, mesmo que lhe chame um teste. Neste laboratório, o «ataque» corre apenas entre quatro contentores que cria você próprio, numa rede criada com `--internal` (nada sai da sua máquina). A carga é modesta e limitada no tempo (15 segundos) e no número de workers. Nunca aponte as ferramentas deste laboratório a mais nada, nem sequer ao seu próprio servidor num fornecedor de alojamento, sem ler primeiro as regras do fornecedor sobre testes de carga.

## 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="ddos-lab-architecture-pt-title ddos-lab-architecture-pt-desc" font-family="Inter, system-ui, -apple-system, Segoe UI, Roboto, sans-serif" xml:lang="pt">
<title id="ddos-lab-architecture-pt-title">Arquitetura do laboratório: um servidor web, dois bots e um utilizador normal numa rede isolada</title>
<desc id="ddos-lab-architecture-pt-desc">Uma rede interna do Podman, lab-ddos-net, 10.60.0.0/24. O contentor do servidor web lab-ddos-web está em 10.60.0.10, tcp 80, executa nginx 1.31.6-alpine com um limite de CPU de 0,5 e um limite de memória de 128 MB, e serve /report.html, uma página que o nginx comprime com gzip nível 9 em cada pedido. O seu limits.conf começa vazio e mais tarde é preenchido com limit_req de 5 pedidos por segundo com um burst de 10, limit_conn de 10 por endereço e estado 429 ao exceder o limite. Dois contentores bot, lab-ddos-bot1 em 10.60.0.20 e lab-ddos-bot2 em 10.60.0.21, executam cada um o hey durante 15 segundos com 25 trabalhadores em simultâneo e enviam uma inundação de pedidos ao servidor web por linhas vermelhas grossas. Um contentor de utilizador normal, lab-ddos-user em 10.60.0.30, envia um pedido normal com curl por uma linha verde fina. À esquerda, um cartão da pasta ~/ddos-lab do seu computador lista nginx.conf, conf/limits.conf e www/report.html, montados só de leitura no contentor web. Uma nota diz que a rede é interna: nada sai do seu computador.</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="300" y="20" width="860" height="470" rx="16" fill="#f0f6f9" stroke="#9ac3d9" stroke-width="1.2" stroke-dasharray="6 5"/>
<g class="dg-icon" transform="translate(316 33) 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="342" y="47" font-size="13" class="dg-ink" fill="#0369a1" font-weight="700">lab-ddos-net · 10.60.0.0/24 · --internal</text></g>
<rect class="dg-card" x="20" y="130" width="240" height="150" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l3"><g class="dg-icon" transform="translate(36 146) scale(1.2500)" fill="none" stroke="#b45309" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z"/><path d="M14 2v4a2 2 0 0 0 2 2h4"/><path d="M10 9H8"/><path d="M16 13H8"/><path d="M16 17H8"/></g></g>
<g class="dg-l3"><text x="78" y="167" font-size="14" class="dg-ink" fill="#b45309" font-weight="700">~/ddos-lab no computador</text></g>
<text x="38" y="198" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nginx.conf</text>
<text x="38" y="218" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">conf/limits.conf</text>
<text x="38" y="238" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">www/report.html</text>
<g class="dg-l3"><path class="dg-stroke" d="M260 205H460" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round" stroke-dasharray="7 6"/></g>
<g class="dg-l3"><path class="dg-stroke" d="M471 199l8 6-8 6" stroke="#b45309" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<text x="20" y="308" font-size="11.5" class="dg-muted" fill="#5c5c68" font-weight="500">montados só de leitura no contentor web</text>
<rect class="dg-card" x="480" y="80" width="320" height="280" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l4"><g class="dg-icon" transform="translate(496 96) 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="538" y="117" font-size="15" class="dg-ink" fill="#c2410c" font-weight="700">lab-ddos-web</text></g>
<text x="498" y="148" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.10/24 · tcp 80</text>
<text x="498" y="168" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">nginx 1.31.6-alpine</text>
<text x="498" y="188" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">--cpus 0.5 · --memory 128m</text>
<text x="498" y="208" font-size="13" class="dg-muted" fill="#5c5c68" font-weight="500">/report.html: gzip nível 9 em cada pedido</text>
<text x="498" y="250" font-size="12" class="dg-muted" fill="#5c5c68" font-weight="700">limits.conf: primeiro desativado, depois ativado</text>
<rect class="dg-tint" x="494" y="262" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="278.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">limit_req 5r/s, burst 10</text>
<rect class="dg-tint" x="494" y="292" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="308.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">limit_conn 10 por endereço</text>
<rect class="dg-tint" x="494" y="322" width="292" height="24" rx="8" fill="#ecf5ef" stroke="#a1ccb1"/>
<text x="504" y="338.5" font-size="11.5" class="dg-text" fill="#17171c" font-weight="600" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">estado 429 ao exceder o limite</text>
<rect class="dg-card" x="900" y="60" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(916 76) scale(1.2500)" fill="none" stroke="#b91c1c" 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-warn"><text x="958" y="97" font-size="13.5" class="dg-ink" fill="#b91c1c" font-weight="700">lab-ddos-bot1</text></g>
<text x="918" y="128" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.20/24</text>
<text x="918" y="148" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">hey -z 15s -c 25 -q 20</text>
<rect class="dg-card" x="900" y="170" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-warn"><g class="dg-icon" transform="translate(916 186) scale(1.2500)" fill="none" stroke="#b91c1c" 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-warn"><text x="958" y="207" font-size="13.5" class="dg-ink" fill="#b91c1c" font-weight="700">lab-ddos-bot2</text></g>
<text x="918" y="238" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.21/24</text>
<text x="918" y="258" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">hey -z 15s -c 25 -q 20</text>
<g class="dg-warn"><path class="dg-stroke" d="M900 107H850V135H810" stroke="#b91c1c" stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M900 217H850V165H810" stroke="#b91c1c" stroke-width="6" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M811 129l-8 6 8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><path class="dg-stroke" d="M811 159l-8 6 8 6" stroke="#b91c1c" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-warn"><rect class="dg-bg-plain" x="810.76" y="138" width="78.48" height="24" rx="12" fill="#ffffff"/><text x="850" y="154.5" font-size="12" class="dg-ink" fill="#b91c1c" font-weight="600" text-anchor="middle">inundação</text></g>
<rect class="dg-card" x="900" y="330" width="240" height="94" rx="12" fill="#ffffff" stroke="#cfcfc8"/>
<g class="dg-l2"><g class="dg-icon" transform="translate(916 346) scale(1.2500)" fill="none" stroke="#15803d" 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-l2"><text x="958" y="367" font-size="13.5" class="dg-ink" fill="#15803d" font-weight="700">lab-ddos-user</text></g>
<text x="918" y="398" font-size="12.5" class="dg-text" fill="#17171c" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">eth0 10.60.0.30/24</text>
<text x="918" y="418" font-size="12.5" class="dg-muted" fill="#5c5c68" font-weight="500" font-family="JetBrains Mono, ui-monospace, Menlo, Consolas, monospace">curl: um pedido normal</text>
<g class="dg-l2"><path class="dg-stroke" d="M900 377H850V300H810" stroke="#15803d" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><path class="dg-stroke" d="M811 294l-8 6 8 6" stroke="#15803d" stroke-width="2.5" fill="none" stroke-linecap="round" stroke-linejoin="round"/></g>
<g class="dg-l2"><rect class="dg-bg-plain" x="814.12" y="328" width="71.76" height="24" rx="12" fill="#ffffff"/><text x="850" y="344.5" font-size="12" class="dg-ink" fill="#15803d" font-weight="600" text-anchor="middle">1 pedido</text></g>
<g class="dg-l1"><rect class="dg-tint" x="434" y="516" width="312" height="26" rx="13" fill="#e6f0f6" stroke="#8ebcd5" stroke-width="1.2"/><text x="590" y="533.5" font-size="12" class="dg-ink" fill="#0369a1" font-weight="700" text-anchor="middle">Rede interna: nada sai do seu computador</text></g>
</svg></figure>

*Figura 1. Dois bots e um utilizador normal partilham um pequeno servidor web. No início, nada limita os bots; mais tarde, o `limits.conf` limita.*

| Contentor | Endereço | Função |
|---|---|---|
| `lab-ddos-web` | `10.60.0.10`, TCP 80 | nginx, limitado a meio CPU e 128 MB, que serve `/report.html` |
| `lab-ddos-bot1` | `10.60.0.20` | Um «bot»: inunda o servidor web com o `hey` |
| `lab-ddos-bot2` | `10.60.0.21` | Um segundo bot (para que o ataque venha de mais do que um endereço) |
| `lab-ddos-user` | `10.60.0.30` | Um utilizador normal: alguns pedidos `curl` |

**Porque é que esta página é «dispendiosa».** O nginx serve um pequeno ficheiro estático quase de graça, e nenhum laboratório pequeno o conseguiria inundar. Por isso, o `/report.html` é um grande ficheiro de texto (cerca de 900 KB) que o nginx tem de **comprimir com gzip em cada pedido**, o que consome tempo de processador real. O contentor web só pode usar meio CPU, e o nginx executa um processo worker. Isso dá ao servidor uma capacidade de cerca de 20 pedidos por segundo, fácil de exceder num laboratório, e representa qualquer página cara de construir (uma pesquisa, um relatório, uma consulta à base de dados).

> [!NOTE]
> Um endereço a inundar um servidor é, em rigor, um ataque DoS. O laboratório usa dois contentores bot para mostrar que os limites se aplicam por endereço e para o levar a pensar no que acontece com milhares. As conclusões são as mesmas.

## Passos

### Passo 1 — Verificar as ferramentas e criar uma pasta de trabalho (3 min)
Confirme que o Podman funciona 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-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
mkdir -p ~/ddos-lab && cd ~/ddos-lab
```

Resultado esperado (a sua versão pode ser diferente):
```text
podman version 5.8.7
netavark rootless=true
```

Os dois comandos `ls` não imprimem nada. Se listarem nomes `lab-ddos-`, execute primeiro a [Limpeza](#limpeza). Todos os comandos seguintes pressupõem que está em `~/ddos-lab`. Se abrir um novo terminal, execute `cd ~/ddos-lab` outra vez.

### Passo 2 — Construir a imagem das ferramentas (4 min)
Os bots e o utilizador precisam de duas ferramentas: o `curl` (um pedido, com medição de tempo) e o `hey` (um gerador de carga HTTP: muitos pedidos ao mesmo tempo, com um resumo). O Alpine Linux tem ambos em pacotes. A etiqueta está fixada no Alpine 3.20.10.

```bash
cat > Containerfile <<'EOT'
FROM docker.io/library/alpine:3.20.10
RUN apk add --no-cache hey curl
EOT
podman build -t lab-ddos-tools:1 . 2>&1 | tail -4
podman run --rm lab-ddos-tools:1 sh -c 'cat /etc/alpine-release; apk list -I 2>/dev/null | grep -E "^(hey|curl)-"'
```

Resultado esperado (o ID da imagem e as versões dos pacotes podem diferir ligeiramente):
```text
COMMIT lab-ddos-tools:1
--> 5b5d9cc480f1
Successfully tagged localhost/lab-ddos-tools:1
5b5d9cc480f1dd3f292ce2e615536cf0b39fcbd2c72460b0be3b8fc2e8c51b88
3.20.10
curl-8.14.1-r2 x86_64 {curl} (curl) [installed]
hey-0.1.4-r26 x86_64 {hey} (Apache-2.0) [installed]
```

A construção usa a sua rede normal uma vez, para descarregar os pacotes. Os contentores do laboratório não terão nenhuma rede exterior.

### Passo 3 — Escrever os ficheiros do servidor web (5 min)
O nginx precisa de três ficheiros, guardados no seu anfitrião e montados no contentor. Eis o que cada um faz:

- `www/report.html` é a página dispendiosa: 150 000 linhas de números.
- `nginx.conf` é toda a configuração do servidor. Ativa o gzip de nível 9 (a parte cara), envia o registo de acesso para a saída padrão, para o poder ler com `podman logs`, e **define** dois contadores por endereço de cliente (`limit_req_zone`, `limit_conn_zone`). Defini-los ainda não limita nada.
- `conf/limits.conf` é incluído pelo bloco do servidor. Por agora está vazio. No Passo 8 põe lá os limites.

```bash
mkdir -p conf www
seq 1 150000 > www/report.html
echo '# no limits yet' > conf/limits.conf
cat > nginx.conf <<'EOT'
worker_processes 1;
error_log /dev/stderr notice;
pid /tmp/nginx.pid;

events {
    worker_connections 1024;
}

http {
    include /etc/nginx/mime.types;
    access_log /dev/stdout;

    # An "expensive" page: nginx compresses it on every request, which costs CPU.
    gzip on;
    gzip_comp_level 9;

    # Two counters, one per client address. They do nothing until limits.conf uses them.
    limit_req_zone $binary_remote_addr zone=perip:1m rate=5r/s;
    limit_conn_zone $binary_remote_addr zone=connperip:1m;

    server {
        listen 80;
        root /usr/share/nginx/html;

        location /report.html {
            alias /srv/www/report.html;
        }

        include /etc/nginx/lab/limits.conf;
    }
}
EOT
wc -lc www/report.html
```

Resultado esperado:
```text
  150000  938895 www/report.html
```

O ficheiro tem 150 000 linhas e 938 895 bytes (cerca de 0,9 MB). `rate=5r/s` é o limite que vai ativar mais tarde: cinco pedidos por segundo por endereço de cliente.

### Passo 4 — Criar a rede isolada e os quatro contentores (5 min)
Uma rede Podman é todo o laboratório. `--internal` significa que o Podman não acrescenta nenhuma rota para o exterior nem NAT para o seu anfitrião, pelo que nada pode sair da sua máquina. `10.60.0.0/24` é um intervalo privado ([RFC 1918](https://www.rfc-editor.org/rfc/rfc1918)).

O contentor web recebe `--cpus 0.5` e `--memory 128m`: pode usar no máximo meio CPU, pelo que é fácil de sobrecarregar e nunca pode prejudicar a sua máquina. `:ro,Z` monta os ficheiros só de leitura (a etiqueta `Z` torna-os legíveis em sistemas com SELinux, como o Fedora, e não faz nada nos outros). A etiqueta da imagem está fixada numa versão exata. Os outros três contentores limitam-se a executar `sleep infinity`; os comandos são executados neles com `podman exec`.

```bash
podman network create --internal --subnet 10.60.0.0/24 lab-ddos-net
podman network inspect lab-ddos-net --format '{{.Name}} subnet={{(index .Subnets 0).Subnet}} internal={{.Internal}}'
podman run -d --name lab-ddos-web --network lab-ddos-net:ip=10.60.0.10 --cpus 0.5 --memory 128m \
  -v ~/ddos-lab/nginx.conf:/etc/nginx/nginx.conf:ro,Z \
  -v ~/ddos-lab/conf:/etc/nginx/lab:ro,Z \
  -v ~/ddos-lab/www:/srv/www:ro,Z \
  docker.io/library/nginx:1.31.6-alpine
podman run -d --name lab-ddos-bot1 --network lab-ddos-net:ip=10.60.0.20 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-bot2 --network lab-ddos-net:ip=10.60.0.21 lab-ddos-tools:1 sleep infinity
podman run -d --name lab-ddos-user --network lab-ddos-net:ip=10.60.0.30 lab-ddos-tools:1 sleep infinity
podman ps --filter name=lab-ddos --format 'table {{.Names}}\t{{.Status}}'
podman exec lab-ddos-web nginx -v
```

Resultado esperado (os quatro IDs longos dos contentores variam; a primeira execução descarrega a imagem do nginx):
```text
lab-ddos-net
lab-ddos-net subnet=10.60.0.0/24 internal=true
e296e3434133eb65348ff7d7faddaf2d1ef80540dde41d434314abaab37b7fb4
8dbf7b4179c98cbd8c67e41f33c93215f78b912f4e397d48016d7a14a584be7d
1c262b3347113f409267c40260d01089054015daad18efbe960669ee88773df1
24f0c870b1f753edee63a94317a8c675d407a974608211a5982aca0caed2af03
NAMES          STATUS
lab-ddos-web   Up Less than a second
lab-ddos-bot1  Up Less than a second
lab-ddos-bot2  Up Less than a second
lab-ddos-user  Up Less than a second
nginx version: nginx/1.31.6
```

Agora verifique o isolamento. O contentor do utilizador tem uma só rota, apenas para a rede do laboratório, e uma ligação a um endereço exterior (`192.0.2.1` é um endereço de documentação, [RFC 5737](https://www.rfc-editor.org/rfc/rfc5737)) falha logo, porque não há rota:

```bash
podman exec lab-ddos-user ip route
podman exec lab-ddos-user curl -sS -m 3 -o /dev/null http://192.0.2.1/ ; echo "curl exit code: $?"
```

Resultado esperado:
```text
10.60.0.0/24 dev eth0 scope link  src 10.60.0.30 
curl: (7) Failed to connect to 192.0.2.1 port 80 after 0 ms: Could not connect to server
curl exit code: 7
```

O código de saída 7 significa «falha ao ligar». As ferramentas de ataque não conseguem chegar a nada além do servidor web.

### Passo 5 — Linha de base: com que rapidez responde o servidor quando ninguém ataca? (5 min)
Antes de um ataque, é preciso saber como é o normal. Esta é a sua **linha de base**. Primeiro, um pedido do utilizador normal, com a respetiva medição de tempo (`--compressed` pede gzip, como faz qualquer navegador, para que o servidor faça o trabalho caro). Depois, 30 pedidos, um a seguir ao outro (`-c 1` significa um de cada vez), com o `hey`.

```bash
podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
podman exec lab-ddos-user hey -n 30 -c 1 http://10.60.0.10/report.html 2>&1 | grep -E 'Total:|Average:|Slowest:|Requests/sec|^  \[[0-9]+\]'
```

Resultado esperado (os tempos variam; o que importa é a ordem de grandeza):
```text
status=200 time=0.030266s
  Total:	1.6079 secs
  Slowest:	0.1015 secs
  Average:	0.0536 secs
  Requests/sec:	18.6580
  [200]	30 responses
```

Como ler: `status=200` é «OK». Um pedido demora cerca de 30 a 50 milissegundos (ms), por causa da compressão. Todos os 30 obtiveram `[200]`. O servidor trata cerca de **18 pedidos por segundo** quando um cliente pede um de cada vez, que é a sua capacidade aproximada. Anote a linha de base: **cerca de 0,03 segundos para um utilizador normal**.

### Passo 6 — Inundar o servidor e ver o que vê um utilizador normal (8 min)
Agora, o «ataque». Cada bot executa o `hey` durante 15 segundos (`-z 15s`) com 25 workers (`-c 25`), e cada worker tenta 20 pedidos por segundo (`-q 20`): cerca de 500 pedidos por segundo por bot, 1000 no total, contra um servidor que consegue responder a cerca de 18. Os dois comandos `hey` correm em segundo plano (`&`). Três segundos depois, o utilizador normal pede a mesma página uma vez. O `wait` bloqueia até os bots terminarem. A sua shell pode imprimir linhas de tarefas como `[1] 12345`; são inofensivas.

```bash
for b in bot1 bot2; do
  podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood1-$b.txt 2>&1 &
done
sleep 3
podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^  \[[0-9]+\]' flood1-$b.txt; done
```

Resultado esperado (demora cerca de 20 segundos; **os números variam, o quadro não**):
```text
status=200 time=14.640884s
== bot1
  Total:	17.6109 secs
  Average:	16.4463 secs
  Requests/sec:	1.4764
  [200]	26 responses
== bot2
  Total:	16.5475 secs
  Average:	1.3776 secs
  Requests/sec:	17.2232
  [200]	285 responses
```

Leia com atenção:

- O utilizador normal pediu a página uma vez e **esperou cerca de 15 segundos** (na sua execução: muitos segundos, não milissegundos) por uma resposta que antes demorava 0,03 segundos. Ninguém foi alvo de intrusão e não se perdeu nenhum dado, mas o serviço está, na prática, em baixo. Isto é uma negação de serviço.
- Cada bot tentou milhares de pedidos, mas o servidor só concluiu cerca de 300 no total em 15 segundos, a sua capacidade. Os restantes ficaram em fila ou expiraram.
- Um bot obteve a maior parte das respostas (aqui o `bot2`: 285 contra 26). Qual deles varia; o nginx não reparte de forma justa. É normal.

### Passo 7 — Detetar o ataque: ler o registo de acesso (5 min)
O registo de acesso é a sua primeira ferramenta de deteção. O nginx escreve uma linha por pedido **concluído** na sua saída padrão, e o `podman logs` mostra-a. Este comando mantém num ficheiro as linhas dos pedidos reais (`GET`) e conta-as: a primeira coluna é o endereço do cliente, a nona é o estado HTTP.

```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' > access-all.txt
wc -l < access-all.txt
awk '{print $1, $9}' access-all.txt | sort | uniq -c | sort -rn
```

Resultado esperado (as contagens variam ligeiramente):
```text
343
    285 10.60.0.21 200
     32 10.60.0.30 200
     26 10.60.0.20 200
```

O programa `awk` imprime o endereço e o estado de cada linha, `sort | uniq -c` conta os pares iguais e `sort -rn` põe o maior no topo. Ler a tabela:

- Os dois endereços `10.60.0.20` e `10.60.0.21` são os **maiores emissores de tráfego** entre os clientes que passaram e, na realidade, tentaram muito mais. O utilizador normal `10.60.0.30` aparece com os 32 pedidos da linha de base e o único pedido que esperou.
- Note um limite deste método: **o registo lista apenas os pedidos que o servidor concluiu**. A sobrecarga fez o servidor responder a menos, não a mais, pelo que o registo subestima o ataque. Uma deteção real precisa também de contadores ao nível da rede (pacotes e ligações por segundo), da carga, da latência e da taxa de erros vindos da monitorização. No registo, o sinal é que poucos endereços respondem pela maior parte do tráfego.

### Passo 8 — Ativar a limitação de taxa e recarregar (5 min)
Agora, a defesa. O ficheiro `conf/limits.conf` recebe quatro linhas:

- `limit_req zone=perip burst=10 nodelay;` aplica o contador `perip`: cada endereço de cliente pode fazer **5 pedidos por segundo** (definido no `nginx.conf`) e pode excedê-lo por uma **rajada** de 10 pedidos extra. O `nodelay` serve a rajada de uma vez em vez de a abrandar. Os pedidos acima disso são recusados.
- `limit_req_status 429;` faz com que a recusa seja o estado HTTP `429 Too Many Requests` (a predefinição é 503).
- `limit_conn connperip 10;` permite a cada endereço no máximo **10 ligações com um pedido em curso** ao mesmo tempo. Ajuda quando cada pedido demora muito a servir (uma base de dados lenta, um carregamento grande). O nginx só começa a contar um pedido depois de os seus cabeçalhos terem chegado por completo.
- `limit_conn_status 429;` dá-lhe o mesmo estado.

```bash
cat > conf/limits.conf <<'EOT'
# At most 5 requests per second per client address, with a burst of 10 extra requests
limit_req zone=perip burst=10 nodelay;
limit_req_status 429;

# At most 10 simultaneous connections per client address
limit_conn connperip 10;
limit_conn_status 429;
EOT
podman exec lab-ddos-web nginx -t
podman exec lab-ddos-web nginx -s reload
```

Resultado esperado (a linha `notice` mostra a hora do seu recarregamento):
```text
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
2026/11/07 20:08:04 [notice] 28#28: signal process started
```

O `nginx -t` testa primeiro a configuração (faça-o sempre), e o `nginx -s reload` faz o nginx iniciar novos workers com as novas regras e retirar os antigos sem cortar ligações. Se o teste falhar, nada é recarregado e as regras antigas continuam ativas.

### Passo 9 — Inundar outra vez, com o limite ativo (8 min)
O mesmo ataque, os mesmos comandos. Desta vez, o utilizador normal pede três vezes, com um segundo de intervalo, como uma pessoa que recarrega uma página.

```bash
for b in bot1 bot2; do
  podman exec lab-ddos-$b hey -z 15s -c 25 -q 20 http://10.60.0.10/report.html > flood2-$b.txt 2>&1 &
done
sleep 3
for i in 1 2 3; do
  podman exec lab-ddos-user curl -sS --compressed -m 60 -o /dev/null -w 'status=%{http_code} time=%{time_total}s\n' http://10.60.0.10/report.html
  sleep 1
done
wait
for b in bot1 bot2; do echo "== $b"; grep -E 'Total:|Average:|Requests/sec|^  \[[0-9]+\]' flood2-$b.txt; done
```

Resultado esperado (as contagens variam em algumas unidades; o quadro não):
```text
status=200 time=0.030948s
status=200 time=0.029585s
status=200 time=0.029022s
== bot1
  Total:	15.0048 secs
  Average:	0.0193 secs
  Requests/sec:	431.1286
  [200]	81 responses
  [429]	6388 responses
== bot2
  Total:	15.0118 secs
  Average:	0.0201 secs
  Requests/sec:	442.9185
  [200]	85 responses
  [429]	6564 responses
```

Compare com o Passo 6:

| | Passo 6: sem limite | Passo 9: com limite |
|---|---|---|
| Espera do utilizador normal | cerca de 15 segundos | cerca de 0,03 segundos, como na linha de base |
| Respostas que cada bot recebeu | um bot algumas centenas, o outro quase nenhuma | cerca de 85 cada |
| Recusas (estado 429) | nenhuma | cerca de 6400 por bot |
| Tempo médio por pedido de um bot | segundos | cerca de 0,02 segundos |

Duas coisas a notar. Primeiro, o **utilizador normal é servido à velocidade normal**: o limite é por endereço, e o endereço do utilizador está muito abaixo dele. Segundo, cada bot obteve apenas cerca de 85 respostas. Não é acaso: `10 + 5 × 15 = 85`, a rajada mais 5 pedidos por segundo durante 15 segundos. Tudo o resto foi recusado com uma minúscula resposta `429` que custa quase nada a produzir, e é por isso que o servidor volta a estar livre.

### Passo 10 — Detetar e comprovar no registo (4 min)
A mesma análise de registo do Passo 7, agora apenas nas linhas escritas desde a captura do Passo 7 (`tail -n +N` imprime a partir da linha N). Depois, veja um pedido recusado e o registo de erros do próprio nginx.

```bash
podman logs lab-ddos-web 2>&1 | awk '$6=="\"GET"' | tail -n +$(( $(wc -l < access-all.txt) + 1 )) > access-flood2.txt
wc -l < access-flood2.txt
awk '{print $1, $9}' access-flood2.txt | sort | uniq -c | sort -rn
grep ' 429 ' access-flood2.txt | head -1
podman logs lab-ddos-web 2>&1 | grep 'limiting requests' | head -1
podman logs lab-ddos-web 2>&1 | grep -c 'limiting requests'
```

Resultado esperado (as contagens variam):
```text
13121
   6564 10.60.0.21 429
   6388 10.60.0.20 429
     85 10.60.0.21 200
     81 10.60.0.20 200
      3 10.60.0.30 200
10.60.0.21 - - [07/Nov/2026:20:08:05 +0000] "GET /report.html HTTP/1.1" 429 169 "-" "hey/0.0.1"
2026/11/07 20:08:05 [error] 29#29: *54 limiting requests, excess: 10.815 by zone "perip", client: 10.60.0.21, server: , request: "GET /report.html HTTP/1.1", host: "10.60.0.10"
12952
```

Agora o registo conta a história com clareza: 13 121 pedidos em 15 segundos, quase todos `429` de dois endereços, e o utilizador normal com três `200`. Este é o sinal que um sistema de deteção usaria. Mais duas observações:

- O número de linhas `limiting requests` no registo de erros (12 952) é igual ao número de 429 no registo de acesso (6388 + 6564 = 12 952): cada recusa fica registada. Num sistema real, geraria um alerta para uma contagem elevada de 429 dos mesmos endereços e poderia entregar esses endereços a uma firewall ou ao fornecedor.
- O `limit_conn` nunca disparou. O nginx serve aqui cada pedido numa rajada rápida, pelo que um endereço nunca tem mais de um pedido em curso, e os recusados são respondidos logo. O `limit_conn` compensa quando os pedidos ficam em curso durante muito tempo, e não é uma defesa contra ataques lentos que nunca terminam os cabeçalhos (veja o desafio).

### Passo 11 — Ler a definição de SYN cookies (4 min)
Os limites até agora são para inundações HTTP (camada 7). Contra uma inundação SYN (camada 4, veja a lição), o kernel do Linux tem a sua própria defesa, as SYN cookies. Apenas **lê** a definição, tanto na sua máquina como dentro do contentor web, e os contadores do kernel. Não precisa de alterar nada, e uma inundação SYN precisa de pacotes em bruto, que este laboratório deliberadamente não usa.

```bash
cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web cat /proc/sys/net/ipv4/tcp_syncookies
podman exec lab-ddos-web awk '/^TcpExt:/ { if (!h) { split($0, n); h = 1 } else { split($0, v); for (i = 2; i <= NF; i++) if (n[i] ~ /^(SyncookiesSent|SyncookiesRecv|SyncookiesFailed|ListenOverflows|ListenDrops)$/) print n[i], v[i] } }' /proc/net/netstat
```

Resultado esperado:
```text
1
1
SyncookiesSent 0
SyncookiesRecv 0
SyncookiesFailed 0
ListenOverflows 0
ListenDrops 0
```

Como ler:

- Os valores de `net.ipv4.tcp_syncookies` significam: `0` cookies desativadas, `1` cookies **apenas quando a fila de ligações semiabertas transborda** (a predefinição habitual), `2` cookies sempre. Vê `1` nos dois sítios: o seu sistema está protegido contra inundações SYN de origem. O contentor tem a sua própria cópia da definição, dentro do seu próprio espaço de nomes de rede, e começa com o mesmo valor.
- Os contadores do último comando são o registo do próprio kernel para a rede do contentor: `SyncookiesSent` conta as cookies enviadas, e `ListenOverflows` e `ListenDrops` contam as tentativas de ligação perdidas porque a fila estava cheia. São todos `0`: a inundação HTTP abriu ligações completas, não encheu a fila de ligações semiabertas, pelo que as SYN cookies nunca tiveram de atuar. Esse é o ponto da classificação: a defesa certa depende da classe de ataque, e uma definição de SYN cookies não teria salvo o servidor desta inundação, mas o limite de taxa salvou.

> [!NOTE]
> Os seus contadores podem não ser exatamente zero se mais alguma coisa na sua máquina tiver usado a rede do contentor. O significado é o mesmo: só aumentam quando uma fila de ligações semiabertas transborda.

## Verificação
Verifique estes resultados; cada um tem de se cumprir na sua execução:

| Verificação | Resultado esperado |
|---|---|
| Linha de base (Passo 5) | O pedido normal responde `200` em dezenas de milissegundos |
| Inundação sem limite (Passo 6) | O utilizador normal esperou vários segundos, não milissegundos |
| Registo de acesso (Passo 7) | Os dois endereços dos bots respondem pela maior parte das linhas |
| Inundação com limite (Passo 9) | O utilizador normal obteve `200` em cerca de 0,03 s; os bots receberam sobretudo `429` e cerca de 85 `200` cada |
| Registo de acesso (Passo 10) | Linhas `429` apenas para os dois endereços dos bots; `200` para `10.60.0.30` |
| SYN cookies (Passo 11) | `net.ipv4.tcp_syncookies` é `1` no anfitrião e no contentor |

Execute este último teste para provar de novo que o utilizador normal é servido enquanto os limites estão ativos:

```bash
for i in 1 2 3; do podman exec lab-ddos-user curl -sS --compressed -m 5 -o /dev/null -w '%{http_code}\n' http://10.60.0.10/report.html; done
```

Resultado esperado:
```text
200
200
200
```

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| `Error: ... cpu ... controller` ou `--cpus` não é suportado ao iniciar o `lab-ddos-web` | O controlador de CPU não está delegado ao seu utilizador (sistemas mais antigos ou cgroup v1) | Remova `--cpus 0.5` e torne a página mais pesada: `seq 1 600000 > www/report.html`. O efeito da inundação no Passo 6 pode ser menor; use `-c 50` no comando dos bots |
| O `podman run` falha com `permission denied` nos ficheiros montados | Etiqueta SELinux ou caminho errado | Verifique que está em `~/ddos-lab` e que os ficheiros existem; mantenha as opções `:Z`; não monte ficheiros que estejam fora da sua pasta pessoal |
| O Passo 6 não mostra abrandamento para o utilizador normal (cerca de 0,03 s) | O servidor é mais rápido do que o esperado, ou a inundação não começou | Verifique que `flood1-bot1.txt` tem linhas `[200]` e nenhum erro; use uma página maior (`seq 1 600000`) ou `-c 50` |
| `hey: not found` ou `curl: not found` | Executou o comando no seu anfitrião ou no contentor do nginx | Ponha à frente `podman exec lab-ddos-user` (ou `-bot1`, `-bot2`), que têm a imagem das ferramentas |
| Depois do recarregamento, todas as respostas continuam a ser `200` (Passo 9) | O `limits.conf` não foi atualizado ou o recarregamento falhou | `podman exec lab-ddos-web cat /etc/nginx/lab/limits.conf` mostra o ficheiro que o nginx vê; execute `nginx -t` e leia a linha de que se queixa |
| O `nginx -t` diz `unknown directive` ou `invalid parameter` | Um erro de digitação no `limits.conf` | Compare-o com o texto do Passo 8; o nginx mantém as regras antigas até o teste passar |
| O utilizador normal também recebe `429` | O utilizador pediu mais de 5 vezes por segundo, mais a rajada | Espere alguns segundos e peça de novo, devagar. É a regra a funcionar: um limite também pode atingir utilizadores reais que sejam muito rápidos ou partilhem um endereço |
| `Error: ... name "lab-ddos-web" is already in use` | Existe um contentor de uma tentativa anterior | Execute a [Limpeza](#limpeza) e comece de novo |
| As contagens das suas tabelas diferem das desta página | O tempo, a velocidade do CPU e o escalonamento diferem em cada máquina | Compare o *quadro*: segundos contra milissegundos, e milhares de `429` contra cerca de 85 `200` por bot |

## Desafio (opcional)
Sem ajuda passo a passo, tente um ou mais destes, e depois restaure os ficheiros do Passo 8:

1. **Um ataque lento.** Os ataques ao estilo Slowloris abrem uma ligação e enviam um cabeçalho de pedido muito devagar, sem nunca o terminar. A partir do `lab-ddos-bot1`, use o `nc` para abrir uma ligação a `10.60.0.10` na porta 80 e enviar apenas a primeira linha de um pedido, e depois espere. Que definição do nginx acaba por fechar uma ligação destas (procure `client_header_timeout` na documentação do nginx)? Porque é que o `limit_conn` não a vê?
2. **Um limite global.** Acrescente um segundo contador com chave `$server_name` e uma taxa de 30 pedidos por segundo, e aplique-o a `/report.html`. O que acontece agora ao utilizador normal durante uma inundação? O que lhe ensina isto sobre os limites por endereço contra uma botnet de milhares de endereços?
3. **Páginas mais baratas.** Ponha em cache a página comprimida: procure `gzip_static` ou `proxy_cache` na documentação do nginx e meça como muda a capacidade do servidor na linha de base. A que camada da figura de defesa da lição corresponde isto?

## Limpeza
Remova todos os recursos que o laboratório criou. O `-t 0` dispensa a espera de 10 segundos pelos contentores que ignoram o sinal de paragem.

```bash
podman rm -f -t 0 lab-ddos-web lab-ddos-bot1 lab-ddos-bot2 lab-ddos-user
podman network rm lab-ddos-net
podman rmi lab-ddos-tools:1
cd ~ && rm -rf ~/ddos-lab
podman ps -a --filter name=lab-ddos --format '{{.Names}}'
podman network ls --filter name=lab-ddos --format '{{.Name}}'
```

Os dois últimos comandos não imprimem nada quando tudo desapareceu. As imagens descarregadas `docker.io/library/nginx:1.31.6-alpine` e `alpine:3.20.10` continuam no seu armazenamento de imagens (são partilhadas com outros trabalhos); remova-as com `podman rmi` se quiser recuperar o espaço.

## O que aprendeu
- Uma inundação não precisa de ser enorme para prejudicar: um servidor com capacidade limitada transformou um conjunto de pedidos de aspeto inofensivo numa espera de 15 segundos para um utilizador normal.
- Uma linha de base da latência e do tráfego normais diz-lhe logo que algo está errado, e o registo de acesso, contado por endereço e por estado, mostra quem é o responsável.
- Um limite de taxa por endereço (`limit_req`, estado 429) recusa o excesso de forma barata, mantém o servidor responsivo e deixa os utilizadores normais passar; os pedidos recusados custam quase nada a responder.
- A aritmética de um limite é previsível: rajada mais taxa vezes tempo, aqui `10 + 5 × 15 = 85` respostas por bot. Contra milhares de endereços, a soma é grande, pelo que também são precisas camadas a montante.
- As SYN cookies protegem contra uma classe diferente (esgotamento de estado): a definição é `1` por predefinição no Linux, e aqui não fez diferença porque a inundação era HTTP.