---
title: "Laboratório: investigar uma conta comprometida a partir dos registos"
domain: cybersecurity
level: intermediate
duration: "60 min"
cost: "gratuito"
environment: "o seu próprio computador: um terminal Linux, macOS ou WSL2 com grep, awk, sed, sort, uniq e sha256sum; sem rede e sem conta na cloud"
lang: pt
source_hash: 67a0cb069cb6
---

# Laboratório: investigar uma conta comprometida a partir dos registos

## Objetivo
É o primeiro a responder numa empresa inventada. Dois ficheiros de registo mostram que algo correu mal durante a noite. Descobre que conta foi comprometida, o que fez o atacante, quão grave é e o que fazer a seguir. Depois, redige um breve relatório de incidente.

## Objetivos
- Analisar registos de autenticação e de servidores web para construir a cronologia de um incidente.
- Classificar e priorizar o incidente pelo impacto funcional, pelo impacto na informação e pela recuperabilidade.
- Escolher ações de contenção, erradicação e recuperação, e indicar como preservar as provas ao fazê-lo.
- Redigir um relatório de incidente breve com a causa de raiz, o impacto e as lições aprendidas.

## Pré-requisitos
- Um terminal em Linux, macOS ou Windows com WSL2 (Windows Subsystem for Linux), com `grep`, `awk`, `sed`, `sort` e `uniq`. Vêm instalados por predefinição. Verifique com `grep --version`.
- `sha256sum` para o passo das provas. No macOS, use `shasum -a 256` (o laboratório mostra ambos).
- Um editor de texto (o `nano` serve).
- A [lição de Resposta a incidentes](lesson.pt.md) deste módulo. Leia pelo menos por alto as secções sobre triagem, provas e contenção.
- Sem conta, sem acesso à rede, sem instalação. Custo: **gratuito**.
- Não precisa de conhecer previamente as ferramentas. Todos os comandos estão prontos a colar e o laboratório explica cada resultado em palavras simples.

> [!WARNING]
> **Tudo aqui é inventado.** A empresa (Harbor Light Books), as pessoas, o servidor e os registos são fictícios. Todos os endereços pertencem aos intervalos de documentação reservados pela RFC 5737 (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`), que nunca são encaminháveis na Internet real, e os nomes usam `example.com`. Não analise, teste nem inicie sessão em nenhum endereço real. As técnicas deste laboratório são defensivas: lê registos que **são seus**. Investigue apenas registos e sistemas que sejam seus ou que esteja explicitamente autorizado a examinar.

## Arquitetura
![Cenário do laboratório. À esquerda, a zona da Internet contém um atacante em 203.0.113.45 e colaboradores e clientes habituais em 192.0.2.0/24 e 198.51.100.0/24. No meio, a zona da empresa inventada Harbor Light Books mostra o anfitrião web01.example.com a executar o sshd na porta 22, que escreve o auth.log, e uma aplicação web na porta 443 com a loja e as páginas /admin/, que escreve o web.log. Setas vão da Internet para os dois serviços. À direita, a zona do seu terminal mostra a pasta ~/ir-lab com cópias dos dois registos, analisados com grep, awk, sort e uniq; uma seta leva de cada ficheiro de registo até ela.](../../../assets/diagrams/ir-lab-architecture.pt.svg)

*Figura 1. Um servidor, dois registos: o `auth.log` regista os inícios de sessão SSH e o `web.log` regista os pedidos web. Só trabalha com as cópias em `~/ir-lab`.*

**Sobre os registos.** Ambos os ficheiros estão em UTC (Tempo Universal Coordenado), pelo que as suas horas coincidem. Nesta empresa inventada, os colaboradores usam o mesmo nome de utilizador e a mesma palavra-passe para o SSH e para as páginas web `/admin/`. O servidor web pede essa palavra-passe (autenticação HTTP básica) e escreve o nome de utilizador no terceiro campo de cada linha. Essa reutilização é cómoda e, como vai ver, também ajuda o atacante.

## Passos

### Passo 1 — Criar a área de trabalho e os dois ficheiros de registo (7 min)
Num incidente real, copiaria os registos do servidor. Aqui, cria-os você. Comece por criar uma pasta:

```bash
mkdir -p ~/ir-lab
cd ~/ir-lab
pwd
```

Resultado esperado (o seu nome de utilizador será diferente):
```text
/home/<your-user>/ir-lab
```

O `mkdir -p` cria a pasta (e não se queixa se já existir), o `cd` entra nela e o `pwd` mostra onde está. Todos os passos seguintes começam aqui.

Agora crie o registo SSH. Copie o bloco **inteiro**, desde `cat` até ao `EOF` final, e cole-o no terminal. As aspas à volta de `'EOF'` são importantes: impedem que a shell altere quaisquer carateres.

```bash
cat > auth.log <<'EOF'
Nov  3 17:42:10 web01 sshd[2012]: Accepted password for alice from 192.0.2.10 port 50611 ssh2
Nov  3 17:58:31 web01 sshd[2018]: Accepted password for bob from 192.0.2.22 port 52937 ssh2
Nov  3 18:05:44 web01 sshd[2055]: Failed password for carol from 198.51.100.7 port 42373 ssh2
Nov  3 18:05:52 web01 sshd[2081]: Accepted password for carol from 198.51.100.7 port 43084 ssh2
Nov  3 19:12:09 web01 sshd[2087]: Accepted password for dave from 192.0.2.50 port 59096 ssh2
Nov  3 22:30:15 web01 sshd[2103]: Failed password for erin from 192.0.2.77 port 56627 ssh2
Nov  3 22:30:21 web01 sshd[2111]: Failed password for erin from 192.0.2.77 port 41228 ssh2
Nov  3 22:30:29 web01 sshd[2140]: Accepted password for erin from 192.0.2.77 port 54209 ssh2
Nov  4 02:11:05 web01 sshd[2148]: Invalid user admin from 203.0.113.45 port 47886
Nov  4 02:11:05 web01 sshd[2186]: Failed password for invalid user admin from 203.0.113.45 port 47886 ssh2
Nov  4 02:11:07 web01 sshd[2225]: Invalid user test from 203.0.113.45 port 41936
Nov  4 02:11:07 web01 sshd[2235]: Failed password for invalid user test from 203.0.113.45 port 41936 ssh2
Nov  4 02:11:08 web01 sshd[2275]: Invalid user oracle from 203.0.113.45 port 60664
Nov  4 02:11:08 web01 sshd[2281]: Failed password for invalid user oracle from 203.0.113.45 port 60664 ssh2
Nov  4 02:11:11 web01 sshd[2309]: Failed password for alice from 203.0.113.45 port 59187 ssh2
Nov  4 02:11:12 web01 sshd[2314]: Failed password for bob from 203.0.113.45 port 47244 ssh2
Nov  4 02:11:15 web01 sshd[2335]: Failed password for carol from 203.0.113.45 port 44363 ssh2
Nov  4 02:11:17 web01 sshd[2372]: Failed password for dave from 203.0.113.45 port 44726 ssh2
Nov  4 02:11:18 web01 sshd[2394]: Failed password for erin from 203.0.113.45 port 58707 ssh2
Nov  4 02:12:43 web01 sshd[2403]: Invalid user admin from 203.0.113.45 port 45922
Nov  4 02:12:43 web01 sshd[2443]: Failed password for invalid user admin from 203.0.113.45 port 45922 ssh2
Nov  4 02:12:46 web01 sshd[2458]: Invalid user test from 203.0.113.45 port 60935
Nov  4 02:12:46 web01 sshd[2484]: Failed password for invalid user test from 203.0.113.45 port 60935 ssh2
Nov  4 02:12:47 web01 sshd[2491]: Invalid user oracle from 203.0.113.45 port 57948
Nov  4 02:12:47 web01 sshd[2530]: Failed password for invalid user oracle from 203.0.113.45 port 57948 ssh2
Nov  4 02:12:48 web01 sshd[2546]: Failed password for alice from 203.0.113.45 port 60283 ssh2
Nov  4 02:12:50 web01 sshd[2576]: Failed password for bob from 203.0.113.45 port 57423 ssh2
Nov  4 02:12:52 web01 sshd[2616]: Failed password for carol from 203.0.113.45 port 55256 ssh2
Nov  4 02:12:54 web01 sshd[2638]: Failed password for dave from 203.0.113.45 port 51848 ssh2
Nov  4 02:12:55 web01 sshd[2656]: Failed password for erin from 203.0.113.45 port 45890 ssh2
Nov  4 02:14:16 web01 sshd[2678]: Invalid user admin from 203.0.113.45 port 58822
Nov  4 02:14:16 web01 sshd[2714]: Failed password for invalid user admin from 203.0.113.45 port 58822 ssh2
Nov  4 02:14:18 web01 sshd[2745]: Invalid user test from 203.0.113.45 port 51255
Nov  4 02:14:18 web01 sshd[2766]: Failed password for invalid user test from 203.0.113.45 port 51255 ssh2
Nov  4 02:14:21 web01 sshd[2776]: Invalid user oracle from 203.0.113.45 port 42398
Nov  4 02:14:21 web01 sshd[2811]: Failed password for invalid user oracle from 203.0.113.45 port 42398 ssh2
Nov  4 02:14:23 web01 sshd[2835]: Failed password for alice from 203.0.113.45 port 45405 ssh2
Nov  4 02:14:24 web01 sshd[2864]: Failed password for bob from 203.0.113.45 port 56022 ssh2
Nov  4 02:14:25 web01 sshd[2902]: Failed password for carol from 203.0.113.45 port 42543 ssh2
Nov  4 02:14:28 web01 sshd[2926]: Accepted password for dave from 203.0.113.45 port 50280 ssh2
Nov  4 02:14:31 web01 sshd[2960]: Failed password for erin from 203.0.113.45 port 51474 ssh2
Nov  4 02:41:18 web01 sshd[3000]: Disconnected from user dave 203.0.113.45 port 50280
Nov  4 05:20:11 web01 sshd[3007]: Invalid user ubuntu from 198.51.100.99 port 54948
Nov  4 05:20:11 web01 sshd[3015]: Failed password for invalid user ubuntu from 198.51.100.99 port 54948 ssh2
Nov  4 05:20:19 web01 sshd[3048]: Invalid user ubuntu from 198.51.100.99 port 48845
Nov  4 05:20:19 web01 sshd[3055]: Failed password for invalid user ubuntu from 198.51.100.99 port 48845 ssh2
Nov  4 07:58:20 web01 sshd[3077]: Accepted password for alice from 192.0.2.10 port 41988 ssh2
Nov  4 08:52:41 web01 sshd[3108]: Accepted password for dave from 192.0.2.50 port 58938 ssh2
Nov  4 09:15:03 web01 sshd[3135]: Failed password for bob from 192.0.2.22 port 49325 ssh2
Nov  4 09:15:12 web01 sshd[3139]: Accepted password for bob from 192.0.2.22 port 51370 ssh2
EOF
```

A seguir, o registo do servidor web, no «formato de registo combinado» usado por muitos servidores web:

```bash
cat > web.log <<'EOF'
198.51.100.23 - - [03/Nov/2026:17:45:02 +0000] "GET / HTTP/1.1" 200 5120 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.23 - - [03/Nov/2026:17:45:03 +0000] "GET /products HTTP/1.1" 200 18733 "https://www.example.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.23 - - [03/Nov/2026:17:46:40 +0000] "GET /products/42 HTTP/1.1" 200 9402 "https://www.example.com/products" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
192.0.2.10 - alice [03/Nov/2026:18:20:15 +0000] "GET /admin/ HTTP/1.1" 200 3310 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
192.0.2.10 - alice [03/Nov/2026:18:20:31 +0000] "GET /admin/orders HTTP/1.1" 200 22450 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
192.0.2.50 - dave [03/Nov/2026:19:14:50 +0000] "GET /admin/ HTTP/1.1" 200 3310 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
192.0.2.50 - dave [03/Nov/2026:19:15:20 +0000] "GET /admin/orders HTTP/1.1" 200 22988 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
198.51.100.7 - - [03/Nov/2026:20:03:11 +0000] "GET / HTTP/1.1" 200 5120 "-" "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1"
198.51.100.7 - - [03/Nov/2026:21:30:44 +0000] "POST /cart/add HTTP/1.1" 302 0 "https://www.example.com/products/42" "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1"
198.51.100.31 - - [03/Nov/2026:22:41:07 +0000] "GET /products/9 HTTP/1.1" 200 9017 "https://www.example.com/products" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.23 - - [03/Nov/2026:23:05:52 +0000] "GET /cart HTTP/1.1" 200 2210 "https://www.example.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.31 - - [04/Nov/2026:00:12:09 +0000] "GET /products HTTP/1.1" 200 18733 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.31 - - [04/Nov/2026:01:15:20 +0000] "GET /about HTTP/1.1" 200 4012 "https://www.example.com/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.31 - - [04/Nov/2026:01:47:55 +0000] "GET /products/17 HTTP/1.1" 200 9120 "https://www.example.com/products" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
203.0.113.45 - - [04/Nov/2026:02:17:30 +0000] "GET /.env HTTP/1.1" 404 196 "-" "curl/7.88.1"
203.0.113.45 - - [04/Nov/2026:02:17:31 +0000] "GET /wp-login.php HTTP/1.1" 404 196 "-" "curl/7.88.1"
203.0.113.45 - - [04/Nov/2026:02:17:33 +0000] "GET /phpmyadmin/ HTTP/1.1" 404 196 "-" "curl/7.88.1"
203.0.113.45 - - [04/Nov/2026:02:18:40 +0000] "GET /admin/ HTTP/1.1" 401 381 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:19:05 +0000] "GET /admin/ HTTP/1.1" 200 3310 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:19:20 +0000] "GET /admin/users HTTP/1.1" 200 6021 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:20:33 +0000] "GET /admin/export/customers.csv HTTP/1.1" 200 4812034 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:21:10 +0000] "GET /admin/orders HTTP/1.1" 200 22790 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:23:45 +0000] "POST /admin/users/new HTTP/1.1" 302 0 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:24:02 +0000] "GET /admin/users HTTP/1.1" 200 6188 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:31:50 +0000] "GET /admin/export/orders.csv HTTP/1.1" 200 1930466 "-" "curl/7.88.1"
203.0.113.45 - dave [04/Nov/2026:02:38:12 +0000] "GET /admin/settings HTTP/1.1" 200 4417 "-" "curl/7.88.1"
198.51.100.23 - - [04/Nov/2026:03:02:18 +0000] "GET /products/42 HTTP/1.1" 200 9402 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.23 - - [04/Nov/2026:04:33:27 +0000] "GET /products HTTP/1.1" 200 18733 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.99 - - [04/Nov/2026:05:20:40 +0000] "GET / HTTP/1.1" 200 5120 "-" "Mozilla/5.0 (compatible; scanner)"
198.51.100.31 - - [04/Nov/2026:06:41:09 +0000] "GET /cart HTTP/1.1" 200 2210 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
198.51.100.31 - - [04/Nov/2026:07:12:44 +0000] "GET /products/42 HTTP/1.1" 200 9402 "https://www.example.com/products" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
192.0.2.10 - alice [04/Nov/2026:07:59:12 +0000] "GET /admin/ HTTP/1.1" 200 3310 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
198.51.100.7 - - [04/Nov/2026:08:30:45 +0000] "GET /products HTTP/1.1" 200 18733 "-" "Mozilla/5.0 (iPhone; CPU iPhone OS 17_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Mobile/15E148 Safari/604.1"
192.0.2.50 - dave [04/Nov/2026:08:55:03 +0000] "GET /admin/ HTTP/1.1" 200 3310 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
192.0.2.50 - dave [04/Nov/2026:08:55:30 +0000] "GET /admin/orders HTTP/1.1" 200 23105 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
192.0.2.77 - - [04/Nov/2026:09:10:01 +0000] "GET /admin/ HTTP/1.1" 401 381 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
192.0.2.77 - erin [04/Nov/2026:09:10:09 +0000] "GET /admin/ HTTP/1.1" 200 3310 "-" "Mozilla/5.0 (X11; Linux x86_64; rv:128.0) Gecko/20100101 Firefox/128.0"
198.51.100.23 - - [04/Nov/2026:09:12:44 +0000] "POST /cart/add HTTP/1.1" 302 0 "https://www.example.com/products/42" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
EOF
```

Verifique se os ficheiros estão completos contando as linhas:

```bash
wc -l auth.log web.log
```

Resultado esperado:
```text
   50 auth.log
   38 web.log
   88 total
```

O `wc -l` conta linhas. Se os seus números forem diferentes, a colagem correu mal: apague o ficheiro com `rm auth.log` (ou `rm web.log`) e cole-o de novo.

Veja uma linha de cada ficheiro:

```bash
head -n 1 auth.log
head -n 1 web.log
```

Resultado esperado:
```text
Nov  3 17:42:10 web01 sshd[2012]: Accepted password for alice from 192.0.2.10 port 50611 ssh2
198.51.100.23 - - [03/Nov/2026:17:45:02 +0000] "GET / HTTP/1.1" 200 5120 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36"
```

Como as ler:

- **`auth.log`:** data e hora, o anfitrião (`web01`), o programa (`sshd`, o servidor SSH) e uma mensagem. `Accepted password for alice from 192.0.2.10` significa que `alice` iniciou sessão com a sua palavra-passe a partir desse endereço. `Failed password` significa uma palavra-passe errada. `Invalid user` significa que o nome não existe no servidor.
- **`web.log`:** endereço, um traço, o **nome de utilizador** (`-` significa «sem sessão iniciada»), a hora entre parênteses retos, o pedido entre aspas (`GET / HTTP/1.1` é o método, a página e o protocolo), o **código de estado** (`200` OK, `302` redirecionamento, `401` é preciso iniciar sessão, `404` não encontrado), os **bytes** enviados, a página de origem e o nome do navegador ou da ferramenta.

### Passo 2 — Preservar as provas antes de tocar em qualquer coisa (4 min)
Bom hábito número um: antes de analisar, guarde uma cópia intacta e anote a sua impressão digital (um **hash**). Se alguém duvidar mais tarde da cópia, a impressão digital prova que não mudou. Faz isto sobre os **registos**, as provas de que dispõe.

```bash
mkdir -p evidence
cp -p auth.log web.log evidence/
sha256sum evidence/auth.log evidence/web.log | tee evidence/SHA256SUMS
chmod a-w evidence/*
```

No macOS, use `shasum -a 256` em vez de `sha256sum` (neste passo e no seguinte).

Resultado esperado (os hashes só são iguais se colou os registos exatamente como mostrados):
```text
dfe4d86bd5c3efcebf6da2358834f0a1e938b8669a7c5064b8e90d210c368ce2  evidence/auth.log
8085aadf6b08696521f310a85f242a670dc2f4bb1999301cc97b95aa2b45afb9  evidence/web.log
```

O que fez cada comando: o `cp -p` copiou os ficheiros e manteve as suas marcas temporais; o `sha256sum` calculou uma impressão digital de 64 carateres de cada ficheiro; o `tee` mostrou-a **e** guardou-a em `evidence/SHA256SUMS`; o `chmod a-w` tornou as cópias só de leitura, para que não as possa alterar por acidente.

Comprove que as cópias estão intactas:

```bash
sha256sum -c evidence/SHA256SUMS
```

Resultado esperado:
```text
evidence/auth.log: OK
evidence/web.log: OK
```

`OK` significa que o ficheiro coincide com a sua impressão digital guardada. Se um único carater tivesse sido alterado, veria `FAILED`. Num caso real, anotaria também quem fez a cópia, quando e onde está guardada: isso é a cadeia de custódia. A partir de agora, analise os ficheiros em `~/ir-lab`, nunca os de `evidence/`.

### Passo 3 — Contar os inícios de sessão falhados por endereço (6 min)
Pergunta: *alguém está a tentar adivinhar palavras-passe?* Conte as linhas `Failed password` por endereço de origem. Leia o comando da esquerda para a direita; cada `|` (pipe) passa o resultado de uma ferramenta à seguinte:

```bash
grep 'Failed password' auth.log | grep -oE 'from [0-9.]+' | awk '{print $2}' | sort | uniq -c | sort -rn
```

Resultado esperado:
```text
     23 203.0.113.45
      2 198.51.100.99
      2 192.0.2.77
      1 198.51.100.7
      1 192.0.2.22
```

O que faz cada parte:

| Parte | O que faz |
|---|---|
| `grep 'Failed password' auth.log` | Mantém apenas as linhas sobre palavras-passe erradas |
| `grep -oE 'from [0-9.]+'` | Imprime só o excerto que coincide: a palavra `from` e o endereço a seguir |
| `awk '{print $2}'` | Imprime a segunda palavra de cada linha, que é o endereço |
| `sort` | Põe os endereços iguais lado a lado (exigido pela ferramenta seguinte) |
| `uniq -c` | Agrupa as repetições e coloca a contagem à frente |
| `sort -rn` | Ordena numericamente, do maior para o menor |

**Ler o resultado.** O endereço `203.0.113.45` tem 23 falhas: muito mais do que qualquer outro. Os outros têm uma ou duas: erros de digitação de pessoas que depois conseguem entrar (confirmará isso mais adiante). Um endereço destaca-se, pelo que `203.0.113.45` é o seu **endereço suspeito**.

### Passo 4 — Que contas experimentou o suspeito? (5 min)
Veja agora que nomes esse endereço experimentou:

```bash
grep 'Failed password' auth.log | grep '203.0.113.45' | grep -oE 'for (invalid user )?[a-z]+' | sed 's/for //; s/invalid user //' | sort | uniq -c | sort -rn
```

Resultado esperado:
```text
      3 test
      3 oracle
      3 erin
      3 carol
      3 bob
      3 alice
      3 admin
      2 dave
```

A nova ferramenta é `sed 's/for //; s/invalid user //'`: apaga as palavras `for ` e `invalid user `, para que fique só o nome.

**Ler o resultado.** Oito nomes diferentes, cada um experimentado três vezes (`dave` só duas: a terceira tentativa não falhou, como verá no passo seguinte). Três dos nomes (`admin`, `test`, `oracle`) são palpites comuns. Verifique quais não existem no servidor:

```bash
grep 'Invalid user' auth.log | grep '203.0.113.45' | awk '{print $8}' | sort -u
```

Resultado esperado:
```text
admin
oracle
test
```

As linhas `Invalid user` só são escritas para nomes que não existem, pelo que estes três são palpites. Os outros cinco (`alice`, `bob`, `carol`, `dave`, `erin`) são contas reais de colaboradores. O atacante conhece, ou adivinhou, nomes de utilizador reais. Poucas tentativas por conta e muitas contas é o padrão do **password spraying**: evita bloquear qualquer conta isolada. Uma vista de olhos às horas mostra três rondas, às 02:11, às 02:12 e às 02:14.

### Passo 5 — Algum palpite funcionou? (5 min)
Pergunta: *o suspeito entrou?* Procure inícios de sessão bem-sucedidos a partir desse endereço:

```bash
grep 'Accepted' auth.log | grep '203.0.113.45'
```

Resultado esperado:
```text
Nov  4 02:14:28 web01 sshd[2926]: Accepted password for dave from 203.0.113.45 port 50280 ssh2
```

**Esta é a linha-chave.** Às 02:14:28 de 4 de novembro, a conta `dave` iniciou sessão a partir do endereço suspeito. Repare que `dave` teve apenas duas falhas: a terceira tentativa teve êxito. O atacante entrou na terceira ronda.

Será possível que o próprio Dave tenha iniciado sessão a partir de um novo local? Compare com o seu comportamento habitual:

```bash
grep 'Accepted password for dave' auth.log
```

Resultado esperado:
```text
Nov  3 19:12:09 web01 sshd[2087]: Accepted password for dave from 192.0.2.50 port 59096 ssh2
Nov  4 02:14:28 web01 sshd[2926]: Accepted password for dave from 203.0.113.45 port 50280 ssh2
Nov  4 08:52:41 web01 sshd[3108]: Accepted password for dave from 192.0.2.50 port 58938 ssh2
```

O Dave inicia normalmente sessão a partir de `192.0.2.50`. O início de sessão das 02:14 vem do endereço que acabara de falhar 22 vezes, sobretudo contra outras contas, a meio da noite: não é o Dave. (Pode também ver todos os inícios de sessão aceites por utilizador e endereço com `grep 'Accepted' auth.log | awk '{print $9, $11}' | sort | uniq -c`.)

Quando terminou essa sessão?

```bash
grep '203.0.113.45' auth.log | tail -n 1
```

Resultado esperado:
```text
Nov  4 02:41:18 web01 sshd[3000]: Disconnected from user dave 203.0.113.45 port 50280
```

O número da porta (`50280`) é o mesmo da linha de início de sessão, pelo que é o fim da mesma sessão: durou cerca de 27 minutos (02:14:28 a 02:41:18).

> [!NOTE]
> O `auth.log` diz-lhe que o atacante iniciou sessão e durante quanto tempo. **Não** lhe diz o que escreveu nessa sessão SSH. Para isso, precisaria de outras provas: o histórico da shell, registos do `auditd` ou dados de EDR. Anote sempre o que os seus registos *não* conseguem mostrar.

### Passo 6 — O que fez o atacante no servidor web? (7 min)
O mesmo endereço aparece no `web.log`. Liste os seus pedidos, mostrando apenas as colunas úteis (hora, utilizador, método, página, estado, bytes):

```bash
grep '203.0.113.45' web.log | awk '{print substr($4,2), $3, substr($6,2), $7, $9, $10}'
```

Resultado esperado:
```text
04/Nov/2026:02:17:30 - GET /.env 404 196
04/Nov/2026:02:17:31 - GET /wp-login.php 404 196
04/Nov/2026:02:17:33 - GET /phpmyadmin/ 404 196
04/Nov/2026:02:18:40 - GET /admin/ 401 381
04/Nov/2026:02:19:05 dave GET /admin/ 200 3310
04/Nov/2026:02:19:20 dave GET /admin/users 200 6021
04/Nov/2026:02:20:33 dave GET /admin/export/customers.csv 200 4812034
04/Nov/2026:02:21:10 dave GET /admin/orders 200 22790
04/Nov/2026:02:23:45 dave POST /admin/users/new 302 0
04/Nov/2026:02:24:02 dave GET /admin/users 200 6188
04/Nov/2026:02:31:50 dave GET /admin/export/orders.csv 200 1930466
04/Nov/2026:02:38:12 dave GET /admin/settings 200 4417
```

O `substr($4,2)` remove o `[` à frente da hora e o `substr($6,2)` remove as aspas de abertura do pedido. Leia a história:

- **02:17:30 a 02:17:33.** Três pedidos de páginas que não existem (`404`): `/.env`, `/wp-login.php`, `/phpmyadmin/`. São os ficheiros habituais que um atacante procura. O atacante está a tatear.
- **02:18:40.** `/admin/` devolve `401`: exige uma palavra-passe.
- **02:19:05.** `/admin/` devolve `200` e o utilizador é **`dave`**. O atacante reutilizou a palavra-passe roubada do Dave nas páginas web.
- **02:20:33.** `GET /admin/export/customers.csv`, `200`, **4 812 034 bytes**: a lista de clientes foi descarregada.
- **02:23:45.** `POST /admin/users/new`, `302`: foi submetido um formulário para criar algo, e o redirecionamento (`302`) é típico de êxito. Pode ser uma **conta nova**, uma forma de voltar a entrar mais tarde.
- **02:31:50.** `orders.csv`, 1 930 466 bytes: o histórico de encomendas também foi descarregado.

Encontre os descarregamentos grandes sem ler todas as linhas:

```bash
awk '$10 > 1000000 {print $1, $3, $7, $10}' web.log
```

Resultado esperado:
```text
203.0.113.45 dave /admin/export/customers.csv 4812034
203.0.113.45 dave /admin/export/orders.csv 1930466
```

O `awk '$10 > 1000000'` mantém as linhas em que o 10.º campo (os bytes) é superior a um milhão. Só as duas exportações do atacante qualificam. Some-as para ver quantos dados saíram:

```bash
awk '$1=="203.0.113.45" {s+=$10} END {printf "%d bytes\n", s}' web.log
```

Resultado esperado:
```text
6786195 bytes
```

São cerca de 6,8 MB enviados para o endereço do atacante (o total inclui também as páginas pequenas, mas as duas exportações são quase tudo).

Por fim, veja se algo semelhante veio de mais alguém. Verifique quem mais usou `/admin/`:

```bash
awk '$7 ~ /^\/admin/ && $1 != "203.0.113.45" {print $1, $3}' web.log | sort | uniq -c
```

Resultado esperado:
```text
      3 192.0.2.10 alice
      4 192.0.2.50 dave
      1 192.0.2.77 -
      1 192.0.2.77 erin
```

Todos os outros usam os seus endereços habituais (o `-` isolado é o navegador do `erin` a pedir a página antes de enviar a palavra-passe). Nada mais parece errado.

> [!NOTE]
> Um registo de acesso web regista a **linha do pedido**, não os dados do formulário. Consegue ver que o `POST /admin/users/new` devolveu `302`, mas não *que* conta foi criada. Teria de procurar na própria aplicação (na sua lista de utilizadores e na sua própria trilha de auditoria) para o descobrir.

### Passo 7 — Construir a cronologia (8 min)
Uma cronologia reúne eventos de registos diferentes numa só lista, por ordem temporal. Abra um ficheiro e escreva os eventos principais, um por linha, com a hora, o registo de origem e o que aconteceu:

```bash
nano timeline.txt
```

Use os resultados dos passos 3 a 6. Uma boa cronologia precisa de cerca de oito linhas. Experimente antes de ver a resposta.

<details>
<summary>Mostrar uma cronologia modelo</summary>

Todas as horas de 4 de novembro de 2026, UTC. As duas pistas (SSH do `auth.log`, WEB do `web.log`) são fundidas por ordem temporal.

![Cronologia do incidente. Uma cronologia vertical de oito eventos em 4 de novembro de 2026 (UTC), todos de 203.0.113.45. Às 02:11:05, no auth.log, começa o password spraying: 23 inícios de sessão falhados em 3 rondas, em 8 nomes. Às 02:14:28, no auth.log, é aceite um início de sessão de dave. Às 02:17:30, no web.log, sondagens a /.env, /wp-login.php e /phpmyadmin/ devolvem 404. Às 02:19:05, no web.log, /admin/ abre como dave com estado 200. Às 02:20:33, no web.log, é descarregado o customers.csv: 4 812 034 bytes. Às 02:23:45, no web.log, um POST para /admin/users/new devolve 302, possivelmente uma conta nova. Às 02:31:50, no web.log, é descarregado o orders.csv: 1 930 466 bytes. Às 02:41:18, no auth.log, termina a sessão SSH de dave.](../../../assets/diagrams/ir-lab-timeline.pt.svg)

*Figura 2. O incidente inteiro durou 30 minutos. Fonte: os dois registos. O primeiro evento (02:11:05) é o início do spraying; o último (02:41:18) é o fim da sessão SSH.*

Aspetos a notar:

- O atacante passou de adivinhar palavras-passe a usar uma em **3 minutos e 23 segundos** (02:11:05 a 02:14:28).
- A atividade web (02:17 a 02:38) ocorreu *durante* a sessão SSH (02:14 a 02:41), pelo que o atacante estava em dois sítios ao mesmo tempo.
- **O que não sabemos:** o que fez na sessão SSH e se a conta criada às 02:23:45 existe.
- **O que sabemos que se perdeu:** pelo menos dois ficheiros com dados de clientes e de encomendas.

</details>

### Passo 8 — Classificar e priorizar (5 min)
Use os três fatores da lição (as categorias são do NIST SP 800-61r2). Decida cada um, com uma razão. Lembre-se: a loja nunca esteve em baixo.

1. **Impacto funcional:** Nenhum, Baixo, Médio ou Alto?
2. **Impacto na informação:** Nenhum, Violação de privacidade, Violação de dados proprietários ou Perda de integridade?
3. **Recuperabilidade:** Regular, Suplementada, Prolongada ou Não recuperável?
4. **Prioridade:** baixa, média ou alta, e é preciso informar alguém fora das TI?

<details>
<summary>Mostrar as respostas</summary>

| Fator | Categoria | Razão |
|---|---|---|
| Impacto funcional | **Nenhum** | O sítio web e o SSH continuaram a funcionar; não foi comunicada nenhuma paragem. |
| Impacto na informação | **Violação de privacidade** (e possivelmente de dados proprietários) | O `customers.csv` contém muito provavelmente dados pessoais e o `orders.csv` contém dados comerciais. Confirmaria abrindo o resultado da função de exportação, mas parta do princípio de que há dados pessoais até prova em contrário. Uma conta nova (se for real) é também um possível problema de integridade. |
| Recuperabilidade | **Não recuperável** para os dados roubados; **Regular** para o sistema | Pode repor a conta e remover o novo utilizador com a equipa e as ferramentas de que dispõe. Não pode fazer o atacante esquecer os ficheiros. |
| Prioridade | **Alta** | Só pelo impacto funcional diria «baixa», que é a armadilha. Dados de clientes roubados são graves. |

Quem informar: o gestor de incidentes e a direção já, e o responsável pela privacidade ou pelo aconselhamento jurídico **de imediato**. Se os clientes estiverem na UE, uma violação de dados pessoais pode ter de ser notificada à autoridade de proteção de dados no prazo de 72 horas após a empresa ter tomado conhecimento (RGPD, artigo 33.º). Saber se se aplica é um juízo jurídico, feito pelo responsável pela privacidade ou pelo aconselhamento jurídico com os seus factos. A sua tarefa é entregar os factos depressa.

</details>

### Passo 9 — Escolher ações de contenção, erradicação e recuperação (7 min)
São agora 09:00 de 4 de novembro. A sessão do atacante terminou às 02:41, mas ele continua a ter a palavra-passe do Dave e possivelmente uma conta nova. Eis dez ações possíveis. Ordene-as: quais faria **agora** (conter), **a seguir** (erradicar), **depois** (recuperar e melhorar) ou **de forma nenhuma**? Escolha as três primeiras ações por ordem e diga porquê.

1. Desativar a conta de `dave` e forçar a alteração da palavra-passe.
2. Bloquear `203.0.113.45` na firewall.
3. Copiar os registos, anotar o estado do servidor (quem tem sessão iniciada, ligações abertas) e registar quem o fez.
4. Encontrar e apagar a conta criada através de `/admin/users/new` e verificar `~/.ssh/authorized_keys` e as tarefas agendadas em `web01` à procura de algo que o atacante tenha deixado.
5. Reiniciar o `web01` para «limpar as coisas».
6. Forçar a reposição das palavras-passe das cinco contas de colaboradores que foram alvo.
7. Ativar um segundo fator (MFA) para o SSH e para `/admin/`, e deixar de usar a mesma palavra-passe nos dois.
8. Acrescentar um limite aos inícios de sessão falhados (por exemplo, bloqueio temporário ou limitação de tentativas) para o SSH e para `/admin/`.
9. Informar o responsável pela privacidade, a direção e (após aconselhamento jurídico) a autoridade e os clientes afetados.
10. Iniciar sessão em `203.0.113.45` para ver o que lá está, ou enviar-lhe uma mensagem.

<details>
<summary>Mostrar as respostas</summary>

| Ordem | Ação | Fase | Porquê |
|---|---|---|---|
| Primeiro (agora) | **3.** Preservar as provas | Provas | Custa cinco minutos e tem de acontecer antes de alterar qualquer coisa. Sem isso, não pode provar o que aconteceu. (Já preservou os registos no passo 2; registe também o estado em execução.) |
| Agora | **1.** Desativar `dave` e repor a palavra-passe | Contenção (curto prazo) | Fecha a porta que o atacante usou. |
| Agora | **9.** Notificar as pessoas certas | Comunicação | Os prazos de notificação e as decisões sobre os clientes começam no momento em que toma conhecimento. |
| Agora (pouco valor) | **2.** Bloquear o endereço | Contenção (curto prazo) | Barato, mas os atacantes mudam facilmente de endereço. Não é uma solução. |
| A seguir | **4.** Apagar a conta nova e procurar outra persistência | Erradicação | Desativar o Dave não basta se o atacante tiver outra forma de entrar. |
| A seguir | **6.** Repor todas as contas visadas | Erradicação | Não há provas de que as outras tenham sido adivinhadas, mas repor é barato e o atacante viu os seus nomes. |
| Depois | **7.** MFA e sem reutilização de palavras-passe | Recuperação / melhoria | Ataca a causa de raiz: bastava uma palavra-passe. |
| Depois | **8.** Limitar os inícios de sessão falhados | Recuperação / melhoria | Teria transformado 23 palpites num bloqueio. |
| **Nunca** | **5.** Reiniciar | | Destrói provas voláteis e não mostra nada de útil. |
| **Nunca** | **10.** Contactar ou iniciar sessão no endereço do atacante | | «Contra-atacar» é ilegal na maioria dos sítios, e o endereço pode pertencer a uma pessoa inocente cujo computador foi sequestrado. |

**Isolar ou monitorizar?** O atacante já saiu e os dados já saíram, pelo que não há vantagem em esperar: isole (desative a conta, remova a persistência). Observar faria sentido se o atacante ainda estivesse ligado e fosse preciso saber até onde chegou, mas só brevemente e com um plano para o cortar.

**Por que ordem?** Preserve primeiro (ou ao mesmo tempo que as restantes), depois contenha, depois erradique, depois recupere. Com as provas em primeiro lugar, as outras ações não as podem destruir.

</details>

### Passo 10 — Redigir o relatório de incidente (6 min)
Crie um relatório a partir deste modelo e preencha depois cada parte:

```bash
cat > report.md <<'EOF'
# Relatório de incidente: <título curto>

- ID do incidente: IR-2026-001
- Comunicado por: <o seu nome>, <data e hora>
- Estado: <aberto | contido | encerrado>

## Resumo
<Duas ou três frases para um leitor não técnico: o que aconteceu e o que foi afetado.>

## Cronologia (UTC)
- <hora> - <evento> (<registo de origem>)

## Impacto
- Impacto funcional: <categoria e razão>
- Impacto na informação: <categoria e razão>
- Recuperabilidade: <categoria e razão>
- Notificações: <quem tem de ser informado e até quando>

## Causa de raiz e fatores contribuintes
- <a condição que tornou o incidente possível>

## Resposta
- <o que foi feito para preservar, conter, erradicar e recuperar>

## Lições aprendidas e ações
| Ação | Responsável | Prazo |
|---|---|---|
| <ação> | <nome> | <data> |
EOF
nano report.md
```

Preencha o `report.md` com a sua cronologia e a sua classificação. Mantenha o resumo curto e sem jargão, como se fosse para o dono da empresa.

<details>
<summary>Mostrar um exemplo de relatório preenchido</summary>

```markdown
# Relatório de incidente: Conta de colaborador comprometida usada para descarregar dados de clientes

- ID do incidente: IR-2026-001
- Comunicado por: Analista, 4 de novembro de 2026 09:00 UTC
- Estado: contido

## Resumo
A 4 de novembro, entre as 02:11 e as 02:41 UTC, um atacante adivinhou a palavra-passe de um
colaborador (dave) experimentando palavras-passe comuns em muitas contas. Iniciou sessão por
SSH e usou a mesma palavra-passe nas páginas web de administração, onde descarregou as listas
de clientes e de encomendas e pode ter criado uma conta nova. O sítio web não foi interrompido.

## Cronologia (UTC)
- 02:11:05 - Começa a tentativa de adivinhar palavras-passe de 8 nomes a partir de 203.0.113.45 (auth.log)
- 02:14:28 - Início de sessão como dave aceite a partir de 203.0.113.45 (auth.log)
- 02:17:30 - Sondagens a /.env, /wp-login.php, /phpmyadmin/ (web.log)
- 02:19:05 - /admin/ aberto como dave (web.log)
- 02:20:33 - customers.csv descarregado, 4 812 034 bytes (web.log)
- 02:23:45 - POST /admin/users/new devolveu 302, possível conta nova (web.log)
- 02:31:50 - orders.csv descarregado, 1 930 466 bytes (web.log)
- 02:41:18 - Terminou a sessão SSH de dave (auth.log)

## Impacto
- Impacto funcional: Nenhum. O sítio e o SSH continuaram a funcionar.
- Impacto na informação: Violação de privacidade (lista de clientes) e de dados proprietários (encomendas).
- Recuperabilidade: Não recuperável para os dados roubados; regular para os sistemas.
- Notificações: Responsável pela privacidade informado de imediato; o jurídico decide sobre a
  notificação à autoridade de controlo (72 horas a partir do conhecimento, se o RGPD se aplicar)
  e aos clientes.

## Causa de raiz e fatores contribuintes
- Causa de raiz: o SSH e o /admin/ aceitavam apenas uma palavra-passe a partir de qualquer
  endereço da Internet, sem bloqueio nem segundo fator.
- Contribuintes: a mesma palavra-passe para o SSH e para as páginas web; nenhum alerta para
  23 inícios de sessão falhados em três minutos; os registos só foram lidos na manhã seguinte.

## Resposta
- Registos copiados em modo só de leitura e com hash (SHA-256) antes da análise.
- Conta dave desativada e palavra-passe reposta; 203.0.113.45 bloqueado.
- Previsto: remover a conta criada às 02:23, rever o authorized_keys e as tarefas agendadas,
  repor todas as contas visadas.

## Lições aprendidas e ações
| Ação | Responsável | Prazo |
|---|---|---|
| Exigir MFA para o SSH e o /admin/ | Responsável de TI | 2026-11-18 |
| Bloquear ou limitar a taxa após falhas repetidas | Responsável de TI | 2026-11-11 |
| Alertar para mais de 10 inícios de sessão falhados por endereço em 5 minutos | Responsável de TI | 2026-11-18 |
| Usar credenciais separadas para o SSH e para a administração web | Responsável de TI | 2026-11-25 |
| Rever e apagar a conta criada às 02:23 | Responsável da aplicação | 2026-11-04 |
```

</details>

## Verificação
Verifique se as suas conclusões coincidem. Execute estes comandos e compare:

```bash
grep 'Failed password' auth.log | grep -c '203.0.113.45'
grep 'Accepted' auth.log | grep -c '203.0.113.45'
awk '$1=="203.0.113.45" && $10 > 1000000' web.log | wc -l
sha256sum -c evidence/SHA256SUMS
```

Resultado esperado:
```text
23
1
2
evidence/auth.log: OK
evidence/web.log: OK
```

- [ ] 23 inícios de sessão falhados e 1 aceite a partir de `203.0.113.45`.
- [ ] 2 descarregamentos grandes (`customers.csv` e `orders.csv`) pelo mesmo endereço.
- [ ] As cópias das provas verificam-se como `OK`.
- [ ] A sua cronologia tem os eventos SSH e os eventos web por ordem temporal.
- [ ] Classificou o incidente como de alta prioridade apesar de o impacto funcional ser nenhum e sabe dizer porquê.
- [ ] O seu relatório tem uma causa de raiz que é um controlo em falta, não «o Dave escolheu uma palavra-passe fraca».

## Resolução de problemas
| Sintoma | Causa provável | Solução |
|---|---|---|
| O `wc -l` mostra contagens de linhas diferentes | Uma colagem ficou cortada ou a linha `EOF` foi copiada duas vezes | Apague o ficheiro com `rm auth.log` (ou `rm web.log`) e cole de novo o bloco inteiro, desde `cat` até `EOF` |
| `bash: warning: here-document ... delimited by end-of-file` ou o terminal fica à espera com um prompt `>` | Falta o `EOF` final ou tem espaços à frente | Prima `Ctrl+C` e cole de novo o bloco, incluindo o último `EOF` numa linha própria |
| O `grep` não imprime nada | Um erro de digitação no endereço ou no nome do ficheiro, ou está na pasta errada | Execute `pwd` (tem de terminar em `ir-lab`) e `ls`; verifique `203.0.113.45` |
| `sha256sum: command not found` (macOS) | O macOS usa outro comando | Use `shasum -a 256` em vez de `sha256sum`; para a verificação use `shasum -a 256 -c evidence/SHA256SUMS` |
| O `sha256sum -c` diz `FAILED`, ou os hashes diferem dos do laboratório | O texto do registo difere num carater, por exemplo um espaço | Compare as contagens de linhas e cole de novo. Só o texto exato do laboratório dá os mesmos hashes |
| `cp: cannot create regular file ... Permission denied` depois de executar o passo 2 duas vezes | Os ficheiros de provas são só de leitura | Normal: é para isso que serve o `chmod a-w`. Salte o passo 2 à segunda vez |
| Um número aparece como `6.78619e+06` | O seu `awk` imprime números grandes em notação científica | Use a forma `printf "%d bytes\n"` do comando do passo 6 |

## Desafio (opcional)
Sem instruções passo a passo:

1. Escreva um único comando `awk` que imprima apenas a **primeira** e a **última** marca temporal dos eventos do atacante no `web.log`.
2. Escreva um pipeline com `grep` e `awk` que mostre, para cada endereço no `auth.log`, quantos nomes de utilizador *diferentes* experimentou. Que endereço experimentou mais?
3. Conceba por palavras uma regra de alerta simples (limiar e janela temporal) que teria detetado este ataque. Quantos inícios de sessão falhados de um endereço em quantos minutos? Que falsos positivos poderia ter (pense nas pessoas do registo que se enganaram a escrever)?
4. No relatório, a causa de raiz é um controlo em falta. Indique dois outros fatores contribuintes e a ação que corrige cada um.

## Limpeza
Remova tudo o que o laboratório criou. As cópias em `evidence` são só de leitura, pelo que deve primeiro restaurar a permissão de escrita:

```bash
cd ~
chmod -R u+w ~/ir-lab
rm -r ~/ir-lab
ls ~/ir-lab
```

Resultado esperado:
```text
ls: cannot access '/home/<your-user>/ir-lab': No such file or directory
```

A pasta `~/ir-lab` e o seu conteúdo (os dois registos, as cópias das provas, `timeline.txt` e `report.md`) desapareceram. Nada mais foi instalado nem alterado. (No macOS, a última mensagem é `ls: /Users/<your-user>/ir-lab: No such file or directory`.)

## O que aprendeu
- Ordenar os endereços de origem com `grep | awk | sort | uniq -c | sort -rn` mostra depressa quem está a tentar adivinhar palavras-passe.
- O password spraying experimenta algumas palavras-passe em muitas contas; um início de sessão bem-sucedido logo a seguir a uma rajada de falhas de um só endereço significa um provável comprometimento.
- Dois registos dizem mais do que um: o registo SSH mostrou *como* o atacante entrou, o registo web mostrou *o que* fez.
- Uma cronologia, construída a partir de várias fontes, transforma linhas dispersas numa história e revela o que ainda não se sabe.
- A triagem pondera o impacto funcional, o impacto na informação e a recuperabilidade: aqui o impacto foi silencioso e a prioridade alta.
- Preserve primeiro as provas (copiar, calcular o hash, registar), depois contenha, erradique e recupere; nunca reinicie nem «contra-ataque».
- Um bom relatório indica uma causa de raiz que é um controlo em falta e enumera ações com responsável e data.
