---
title: "Laboratorio: investigar una cuenta comprometida a partir de sus registros"
domain: cybersecurity
level: intermediate
duration: "60 min"
cost: "gratuito"
environment: "tu propio ordenador: un terminal de Linux, macOS o WSL2 con grep, awk, sed, sort, uniq y sha256sum; sin red y sin cuenta en la nube"
lang: es
source_hash: 67a0cb069cb6
---

# Laboratorio: investigar una cuenta comprometida a partir de sus registros

## Objetivo
Eres la primera persona en responder en una empresa inventada. Dos archivos de registro muestran que algo salió mal durante la noche. Averiguas qué cuenta se comprometió, qué hizo el atacante, qué gravedad tiene y qué hacer al respecto. Después redactas un informe breve del incidente.

## Objetivos
- Analizar registros de autenticación y de servidor web para construir la cronología de un incidente.
- Clasificar y priorizar el incidente según el impacto funcional, el impacto en la información y la capacidad de recuperación.
- Elegir acciones de contención, erradicación y recuperación, e indicar cómo conservar las pruebas mientras tanto.
- Redactar un informe breve de incidente con la causa raíz, el impacto y las lecciones aprendidas.

## Requisitos previos
- Un terminal en Linux, macOS o Windows con WSL2 (Windows Subsystem for Linux), con `grep`, `awk`, `sed`, `sort` y `uniq`. Vienen instalados por defecto. Compruébalo con `grep --version`.
- `sha256sum` para el paso de las pruebas. En macOS usa `shasum -a 256` en su lugar (el laboratorio muestra ambos).
- Un editor de texto (`nano` sirve).
- La [lección de respuesta a incidentes](lesson.es.md) de este módulo. Repasa al menos las secciones sobre triaje, pruebas y contención.
- Sin cuenta, sin acceso a la red, sin instalar nada. Coste: **gratuito**.
- No necesitas conocer las herramientas de antemano. Cada comando está listo para pegar y el laboratorio explica cada resultado con palabras sencillas.

> [!WARNING]
> **Todo lo de aquí es inventado.** La empresa (Harbor Light Books), las personas, el servidor y los registros son ficticios. Todas las direcciones pertenecen a los rangos de documentación reservados por el RFC 5737 (`192.0.2.0/24`, `198.51.100.0/24`, `203.0.113.0/24`), que nunca son enrutables en la Internet real, y los nombres usan `example.com`. No escanees, pruebes ni inicies sesión en ninguna dirección real. Las técnicas de este laboratorio son defensivas: lees registros que **son tuyos**. Investiga únicamente registros y sistemas que sean tuyos o que estés explícitamente autorizado a examinar.

## Arquitectura
![Escenario del laboratorio. A la izquierda, la zona de Internet contiene a un atacante en 203.0.113.45 y al personal y los clientes habituales en 192.0.2.0/24 y 198.51.100.0/24. En el centro, la zona de la empresa inventada Harbor Light Books muestra el equipo web01.example.com con sshd en el puerto 22, que escribe auth.log, y una aplicación web en el puerto 443 con la tienda y las páginas /admin/, que escribe web.log. Unas flechas van desde Internet a ambos servicios. A la derecha, la zona de tu terminal muestra la carpeta ~/ir-lab con copias de los dos registros, analizados con grep, awk, sort y uniq; una flecha lleva a ella desde cada archivo de registro.](../../../assets/diagrams/ir-lab-architecture.es.svg)

*Figura 1. Un servidor, dos registros: `auth.log` registra los inicios de sesión SSH y `web.log` registra las peticiones web. Solo trabajas con las copias de `~/ir-lab`.*

**Sobre los registros.** Los dos archivos están en UTC (Tiempo Universal Coordinado), así que sus horas coinciden. En esta empresa inventada, el personal usa el mismo nombre de usuario y contraseña para SSH y para las páginas web `/admin/`. El servidor web pide esa contraseña (autenticación básica HTTP) y escribe el nombre de usuario en el tercer campo de cada línea. Esa reutilización es cómoda y, como verás, también ayuda al atacante.

## Pasos

### Paso 1 — Crea el espacio de trabajo y los dos archivos de registro (7 min)
En un incidente real copiarías los registros del servidor. Aquí los creas tú. Primero crea una carpeta:

```bash
mkdir -p ~/ir-lab
cd ~/ir-lab
pwd
```

Salida esperada (tu nombre de usuario será distinto):
```text
/home/<your-user>/ir-lab
```

`mkdir -p` crea la carpeta (y no se queja si ya existe), `cd` entra en ella y `pwd` muestra dónde estás. Cada paso posterior empieza aquí.

Ahora crea el registro de SSH. Copia el bloque **entero**, desde `cat` hasta el `EOF` final, y pégalo en el terminal. Las comillas alrededor de `'EOF'` son importantes: impiden que la shell cambie ningún carácter.

```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 continuación, el registro del servidor web, en el «formato de registro combinado» que usan muchos 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
```

Comprueba que los archivos están completos contando sus líneas:

```bash
wc -l auth.log web.log
```

Salida esperada:
```text
   50 auth.log
   38 web.log
   88 total
```

`wc -l` cuenta líneas. Si tus números son distintos, algo falló al pegar: borra el archivo con `rm auth.log` (o `rm web.log`) y pégalo de nuevo.

Echa un primer vistazo a una línea de cada archivo:

```bash
head -n 1 auth.log
head -n 1 web.log
```

Salida esperada:
```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"
```

Cómo leerlas:

- **`auth.log`:** fecha y hora, el equipo (`web01`), el programa (`sshd`, el servidor SSH) y un mensaje. `Accepted password for alice from 192.0.2.10` significa que `alice` inició sesión con su contraseña desde esa dirección. `Failed password` significa una contraseña incorrecta. `Invalid user` significa que el nombre no existe en el servidor.
- **`web.log`:** dirección, un guion, el **nombre de usuario** (`-` significa «sin sesión iniciada»), la hora entre corchetes, la petición entre comillas (`GET / HTTP/1.1` es el método, la página y el protocolo), el **código de estado** (`200` correcto, `302` redirección, `401` hace falta iniciar sesión, `404` no encontrado), los **bytes** enviados, la página de origen y el nombre del navegador o de la herramienta.

### Paso 2 — Conserva las pruebas antes de tocar nada (4 min)
Buen hábito número uno: antes de analizar, guarda una copia intacta y anota su huella (un **hash**). Si alguien duda más adelante de la copia, la huella demuestra que no ha cambiado. Lo harás con los **registros**, las pruebas que tienes.

```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/*
```

En macOS, usa `shasum -a 256` en lugar de `sha256sum` (en este paso y en el siguiente).

Salida esperada (los hashes solo coinciden si pegaste los registros exactamente como se muestran):
```text
dfe4d86bd5c3efcebf6da2358834f0a1e938b8669a7c5064b8e90d210c368ce2  evidence/auth.log
8085aadf6b08696521f310a85f242a670dc2f4bb1999301cc97b95aa2b45afb9  evidence/web.log
```

Qué hizo cada comando: `cp -p` copió los archivos y conservó sus marcas de tiempo; `sha256sum` calculó una huella de 64 caracteres de cada archivo; `tee` la mostró **y** la guardó en `evidence/SHA256SUMS`; `chmod a-w` dejó las copias de solo lectura, para que no puedas cambiarlas por accidente.

Demuestra que las copias están intactas:

```bash
sha256sum -c evidence/SHA256SUMS
```

Salida esperada:
```text
evidence/auth.log: OK
evidence/web.log: OK
```

`OK` significa que el archivo coincide con su huella guardada. Si se cambiara un solo carácter, verías `FAILED`. En un caso real anotarías además quién hizo la copia, cuándo y dónde se guarda: eso es la cadena de custodia. A partir de ahora, analiza los archivos de `~/ir-lab`, nunca los de `evidence/`.

### Paso 3 — Cuenta los inicios de sesión fallidos por dirección (6 min)
Pregunta: *¿alguien está adivinando contraseñas?* Cuenta las líneas `Failed password` de cada dirección de origen. Lee el comando de izquierda a derecha; cada `|` (tubería) pasa la salida de una herramienta a la siguiente:

```bash
grep 'Failed password' auth.log | grep -oE 'from [0-9.]+' | awk '{print $2}' | sort | uniq -c | sort -rn
```

Salida esperada:
```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
```

Qué hace cada parte:

| Parte | Qué hace |
|---|---|
| `grep 'Failed password' auth.log` | Se queda solo con las líneas sobre contraseñas incorrectas |
| `grep -oE 'from [0-9.]+'` | Imprime solo el fragmento coincidente: la palabra `from` y la dirección que la sigue |
| `awk '{print $2}'` | Imprime la segunda palabra de cada línea, que es la dirección |
| `sort` | Pone juntas las direcciones iguales (lo necesita la siguiente herramienta) |
| `uniq -c` | Colapsa las repeticiones y pone delante el recuento |
| `sort -rn` | Ordena numéricamente, de mayor a menor |

**Cómo leer el resultado.** La dirección `203.0.113.45` tiene 23 fallos: muchos más que cualquier otra. Las demás tienen uno o dos: erratas de personas que después aciertan (lo confirmarás más adelante). Una dirección destaca, así que `203.0.113.45` es tu **dirección sospechosa**.

### Paso 4 — ¿Qué cuentas probó la dirección sospechosa? (5 min)
Ahora mira qué nombres probó esa dirección:

```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
```

Salida esperada:
```text
      3 test
      3 oracle
      3 erin
      3 carol
      3 bob
      3 alice
      3 admin
      2 dave
```

La herramienta nueva es `sed 's/for //; s/invalid user //'`: borra las palabras `for ` e `invalid user ` para que solo quede el nombre.

**Cómo leer el resultado.** Ocho nombres distintos, cada uno probado tres veces (`dave` solo dos: su tercer intento no falló, como verás en el siguiente paso). Tres de los nombres (`admin`, `test`, `oracle`) son intentos habituales. Comprueba cuáles no existen en el servidor:

```bash
grep 'Invalid user' auth.log | grep '203.0.113.45' | awk '{print $8}' | sort -u
```

Salida esperada:
```text
admin
oracle
test
```

Las líneas `Invalid user` se escriben solo para nombres que no existen, así que esos tres son suposiciones. Los otros cinco (`alice`, `bob`, `carol`, `dave`, `erin`) son cuentas reales del personal. El atacante conoce, o ha adivinado, nombres de usuario reales. Pocos intentos por cuenta y muchas cuentas es el patrón del **password spraying**: evita bloquear una cuenta concreta. Un vistazo rápido a las horas muestra tres rondas, a las 02:11, las 02:12 y las 02:14.

### Paso 5 — ¿Funcionó alguna de las pruebas? (5 min)
Pregunta: *¿consiguió entrar la dirección sospechosa?* Busca los inicios de sesión correctos desde esa dirección:

```bash
grep 'Accepted' auth.log | grep '203.0.113.45'
```

Salida esperada:
```text
Nov  4 02:14:28 web01 sshd[2926]: Accepted password for dave from 203.0.113.45 port 50280 ssh2
```

**Esta es la línea clave.** A las 02:14:28 del 4 de noviembre, la cuenta `dave` inició sesión desde la dirección sospechosa. Fíjate en que `dave` tuvo solo dos fallos: el tercer intento funcionó. El atacante entró en la tercera ronda.

¿Es posible que el propio Dave iniciara sesión desde un sitio nuevo? Compáralo con su comportamiento habitual:

```bash
grep 'Accepted password for dave' auth.log
```

Salida esperada:
```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
```

Dave suele iniciar sesión desde `192.0.2.50`. El inicio de sesión de las 02:14 viene de la dirección que acababa de fallar 22 veces, sobre todo contra otras cuentas, en plena noche: ese no es Dave. (También puedes ver todos los inicios de sesión correctos por usuario y dirección con `grep 'Accepted' auth.log | awk '{print $9, $11}' | sort | uniq -c`.)

¿Cuándo terminó esa sesión?

```bash
grep '203.0.113.45' auth.log | tail -n 1
```

Salida esperada:
```text
Nov  4 02:41:18 web01 sshd[3000]: Disconnected from user dave 203.0.113.45 port 50280
```

El número de puerto (`50280`) es el mismo que en la línea de inicio de sesión, así que es el final de la misma sesión: duró unos 27 minutos (de 02:14:28 a 02:41:18).

> [!NOTE]
> `auth.log` te dice que el atacante inició sesión y durante cuánto tiempo. **No** te dice qué escribió en esa sesión SSH. Para eso necesitarías otras pruebas: el historial del shell, registros de `auditd` o datos del EDR. Anota siempre lo que tus registros *no pueden* mostrar.

### Paso 6 — ¿Qué hizo el atacante en el servidor web? (7 min)
La misma dirección aparece en `web.log`. Lista sus peticiones, mostrando solo las columnas útiles (hora, usuario, 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}'
```

Salida esperada:
```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
```

`substr($4,2)` quita el `[` delante de la hora y `substr($6,2)` quita las comillas de apertura de la petición. Lee la historia:

- **02:17:30 a 02:17:33.** Tres peticiones de páginas que no existen (`404`): `/.env`, `/wp-login.php`, `/phpmyadmin/`. Son los archivos habituales que busca un atacante. El atacante va tanteando.
- **02:18:40.** `/admin/` devuelve `401`: pide una contraseña.
- **02:19:05.** `/admin/` devuelve `200` y el usuario es **`dave`**. El atacante reutilizó la contraseña robada de Dave en las páginas web.
- **02:20:33.** `GET /admin/export/customers.csv`, `200`, **4.812.034 bytes**: se descargó la lista de clientes.
- **02:23:45.** `POST /admin/users/new`, `302`: se envió un formulario para crear algo, y la redirección (`302`) es típica de un éxito. Puede ser una **cuenta nueva**, una vía para volver a entrar más tarde.
- **02:31:50.** `orders.csv`, 1.930.466 bytes: también se descargó el historial de pedidos.

Encuentra las descargas grandes sin leer cada línea:

```bash
awk '$10 > 1000000 {print $1, $3, $7, $10}' web.log
```

Salida esperada:
```text
203.0.113.45 dave /admin/export/customers.csv 4812034
203.0.113.45 dave /admin/export/orders.csv 1930466
```

`awk '$10 > 1000000'` se queda con las líneas en las que el campo 10 (los bytes) supera el millón. Solo cumplen las dos exportaciones del atacante. Súmalas para ver cuántos datos salieron:

```bash
awk '$1=="203.0.113.45" {s+=$10} END {printf "%d bytes\n", s}' web.log
```

Salida esperada:
```text
6786195 bytes
```

Son unos 6,8 MB enviados a la dirección del atacante (el total incluye también las páginas pequeñas, pero las dos exportaciones son casi todo).

Por último, comprueba si vino algo parecido de otra persona. Mira quién más usó `/admin/`:

```bash
awk '$7 ~ /^\/admin/ && $1 != "203.0.113.45" {print $1, $3}' web.log | sort | uniq -c
```

Salida esperada:
```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 los demás usan sus direcciones habituales (el `-` suelto es el navegador de `erin` pidiendo la página antes de enviar su contraseña). No hay nada más que parezca raro.

> [!NOTE]
> Un registro de acceso web guarda la **línea de petición**, no los datos del formulario. Puedes ver que `POST /admin/users/new` devolvió `302`, pero no *qué* cuenta se creó. Para averiguarlo tendrías que mirar en la propia aplicación (su lista de usuarios y su propio registro de auditoría).

### Paso 7 — Construye la cronología (8 min)
Una cronología junta en una sola lista, por orden de tiempo, eventos de registros distintos. Abre un archivo y escribe los eventos clave, uno por línea, con la hora, el registro de origen y lo que pasó:

```bash
nano timeline.txt
```

Usa los resultados de los pasos 3 a 6. Una buena cronología necesita unas ocho líneas. Inténtalo antes de mirar la respuesta.

<details>
<summary>Mostrar una cronología modelo</summary>

Todas las horas son del 4 de noviembre de 2026, UTC. Los dos carriles (SSH de `auth.log`, WEB de `web.log`) se combinan por orden de tiempo.

![Cronología del incidente. Una cronología vertical de ocho eventos del 4 de noviembre de 2026 (UTC), todos desde 203.0.113.45. A las 02:11:05, en auth.log, empieza el password spraying: 23 inicios de sesión fallidos en 3 rondas con 8 nombres. A las 02:14:28, en auth.log, se acepta un inicio de sesión de dave. A las 02:17:30, en web.log, los sondeos de /.env, /wp-login.php y /phpmyadmin/ devuelven 404. A las 02:19:05, en web.log, /admin/ se abre como dave con estado 200. A las 02:20:33, en web.log, se descarga customers.csv: 4.812.034 bytes. A las 02:23:45, en web.log, un POST a /admin/users/new devuelve 302, posiblemente una cuenta nueva. A las 02:31:50, en web.log, se descarga orders.csv: 1.930.466 bytes. A las 02:41:18, en auth.log, termina la sesión SSH de dave.](../../../assets/diagrams/ir-lab-timeline.es.svg)

*Figura 2. Todo el incidente duró 30 minutos. Fuente: los dos registros. El primer evento (02:11:05) es el inicio del spraying; el último (02:41:18) es el final de la sesión SSH.*

Cosas en las que fijarse:

- El atacante pasó de adivinar contraseñas a usar una en **3 minutos y 23 segundos** (de 02:11:05 a 02:14:28).
- La actividad web (de 02:17 a 02:38) ocurrió *durante* la sesión SSH (de 02:14 a 02:41), así que el atacante estaba en dos sitios a la vez.
- **Lo que no sabemos:** qué hizo en la sesión SSH y si existe la cuenta creada a las 02:23:45.
- **Lo que sabemos que se perdió:** al menos dos archivos con datos de clientes y de pedidos.

</details>

### Paso 8 — Clasifica y prioriza (5 min)
Usa los tres factores de la lección (las categorías son de NIST SP 800-61r2). Decide cada uno, con una razón. Recuerda: la tienda nunca estuvo caída.

1. **Impacto funcional:** ¿Ninguno, Bajo, Medio o Alto?
2. **Impacto en la información:** ¿Ninguno, Filtración de datos personales, Filtración de información propietaria o Pérdida de integridad?
3. **Capacidad de recuperación:** ¿Regular, Complementada, Extendida o No recuperable?
4. **Prioridad:** ¿baja, media o alta, y hay que avisar a alguien ajeno a TI?

<details>
<summary>Mostrar las respuestas</summary>

| Factor | Categoría | Razón |
|---|---|---|
| Impacto funcional | **Ninguno** | El sitio web y SSH siguieron funcionando; no se informó de ningún tiempo de inactividad. |
| Impacto en la información | **Filtración de datos personales** (y posiblemente de información propietaria) | `customers.csv` muy probablemente contiene datos personales y `orders.csv` contiene datos del negocio. Lo confirmarías abriendo el resultado de la función de exportación, pero da por hecho que hay datos personales hasta que se demuestre lo contrario. Una cuenta nueva (si es real) es además un posible problema de integridad. |
| Capacidad de recuperación | **No recuperable** para los datos robados; **Regular** para el sistema | Puedes restablecer la cuenta y eliminar el usuario nuevo con el equipo y las herramientas que tienes. No puedes hacer que el atacante olvide los archivos. |
| Prioridad | **Alta** | Solo con el impacto funcional diría «baja», que es la trampa. Los datos de clientes robados son graves. |

A quién avisar: al responsable del incidente y a la dirección ahora, y a la persona responsable de privacidad o asesoramiento jurídico **de inmediato**. Si los clientes están en la UE, puede que haya que notificar una violación de datos personales a la autoridad de protección de datos en un plazo de 72 horas desde que la empresa tiene conocimiento de ella (RGPD, artículo 33). Que se aplique o no es un juicio jurídico, que hace el responsable de privacidad o el asesor jurídico con tus datos. Tu trabajo es entregar los hechos con rapidez.

</details>

### Paso 9 — Elige acciones de contención, erradicación y recuperación (7 min)
Son las 09:00 del 4 de noviembre. La sesión del atacante terminó a las 02:41, pero este sigue teniendo la contraseña de Dave y posiblemente una cuenta nueva. Aquí tienes diez acciones posibles. Clasifícalas: ¿cuáles harías **ahora** (contener), **después** (erradicar), **más tarde** (recuperar y mejorar) o **en ningún caso**? Elige las tres primeras acciones, por orden, y explica por qué.

1. Deshabilitar la cuenta de `dave` y forzar un cambio de contraseña.
2. Bloquear `203.0.113.45` en el cortafuegos.
3. Copiar los registros, anotar el estado del servidor (quién tiene sesión iniciada, conexiones abiertas) y registrar quién lo hizo.
4. Encontrar y borrar la cuenta creada mediante `/admin/users/new`, y comprobar en `web01` `~/.ssh/authorized_keys` y las tareas programadas por si el atacante dejó algo.
5. Reiniciar `web01` para «dejarlo todo limpio».
6. Forzar el restablecimiento de contraseña de las cinco cuentas del personal que fueron objetivo del ataque.
7. Activar un segundo factor (MFA) para SSH y para `/admin/`, y dejar de usar la misma contraseña para ambos.
8. Añadir un límite de inicios de sesión fallidos (por ejemplo, bloqueo temporal o limitación de tasa) para SSH y para `/admin/`.
9. Avisar al responsable de privacidad, a la dirección y (tras el asesoramiento jurídico) a la autoridad y a los clientes afectados.
10. Iniciar sesión en `203.0.113.45` para ver qué hay en él, o enviarle un mensaje.

<details>
<summary>Mostrar las respuestas</summary>

| Orden | Acción | Fase | Por qué |
|---|---|---|---|
| Primero (ahora) | **3.** Conservar las pruebas | Pruebas | Cuesta cinco minutos y debe hacerse antes de cambiar nada. Sin ello no puedes demostrar qué pasó. (Ya conservaste los registros en el paso 2; anota también el estado en vivo.) |
| Ahora | **1.** Deshabilitar `dave` y restablecer la contraseña | Contención (a corto plazo) | Cierra la puerta que usó el atacante. |
| Ahora | **9.** Avisar a las personas adecuadas | Comunicación | Los plazos de notificación y las decisiones sobre los clientes empiezan en el momento en que tienes conocimiento. |
| Ahora (poco valor) | **2.** Bloquear la dirección | Contención (a corto plazo) | Es barato, pero los atacantes cambian de dirección con facilidad. No es una solución. |
| Después | **4.** Borrar la cuenta nueva y buscar otros mecanismos de persistencia | Erradicación | Deshabilitar a Dave no basta si el atacante tiene otra vía de entrada. |
| Después | **6.** Restablecer todas las cuentas que fueron objetivo | Erradicación | No hay pruebas de que adivinara las demás, pero los restablecimientos son baratos y el atacante ha visto sus nombres. |
| Más tarde | **7.** MFA y sin reutilizar contraseñas | Recuperación / mejora | Ataca la causa raíz: bastaba con una contraseña. |
| Más tarde | **8.** Limitar los inicios de sesión fallidos | Recuperación / mejora | Habría convertido 23 intentos en un bloqueo. |
| **Nunca** | **5.** Reiniciar | | Destruye pruebas volátiles y no aporta nada útil. |
| **Nunca** | **10.** Contactar o iniciar sesión en la dirección del atacante | | «Devolver el golpe» (hacking back) es ilegal en la mayoría de los lugares, y la dirección puede pertenecer a una persona inocente cuyo ordenador ha sido secuestrado. |

**¿Aislar o vigilar?** El atacante se ha ido y los datos ya han salido, así que no hay ninguna ventaja en esperar: aísla (deshabilita la cuenta, elimina la persistencia). Vigilar tendría sentido si el atacante siguiera conectado y necesitaras saber hasta dónde ha llegado, pero solo brevemente y con un plan para cortarle el acceso.

**¿En qué orden?** Primero conservar (o a la vez que las demás), después contener, después erradicar, después recuperar. Con las pruebas primero, las demás acciones no pueden destruirlas.

</details>

### Paso 10 — Redacta el informe del incidente (6 min)
Crea un informe a partir de esta plantilla y rellena cada parte:

```bash
cat > report.md <<'EOF'
# Informe de incidente: <título breve>

- ID del incidente: IR-2026-001
- Informado por: <tu nombre>, <fecha y hora>
- Estado: <abierto | contenido | cerrado>

## Resumen
<Dos o tres frases para un lector no técnico: qué ocurrió y qué se vio afectado.>

## Cronología (UTC)
- <hora> - <suceso> (<registro de origen>)

## Impacto
- Impacto funcional: <categoría y motivo>
- Impacto en la información: <categoría y motivo>
- Capacidad de recuperación: <categoría y motivo>
- Notificaciones: <a quién hay que avisar y para cuándo>

## Causa raíz y factores contribuyentes
- <la condición que hizo posible el incidente>

## Respuesta
- <qué se hizo para conservar, contener, erradicar y recuperar>

## Lecciones aprendidas y acciones
| Acción | Responsable | Fecha límite |
|---|---|---|
| <acción> | <nombre> | <fecha> |
EOF
nano report.md
```

Rellena `report.md` con tu cronología y tu clasificación. Mantén el resumen breve y sin jerga, como si fuera para el dueño de la empresa.

<details>
<summary>Mostrar un ejemplo de informe completado</summary>

```markdown
# Informe de incidente: cuenta de un empleado comprometida y usada para descargar datos de clientes

- ID del incidente: IR-2026-001
- Informado por: Analista, 4 de noviembre de 2026 09:00 UTC
- Estado: contenido

## Resumen
El 4 de noviembre, entre las 02:11 y las 02:41 UTC, un atacante adivinó la contraseña de un
empleado (dave) probando contraseñas habituales en muchas cuentas. Inició sesión por SSH y
usó la misma contraseña en las páginas web de administración, donde descargó las listas de
clientes y de pedidos y es posible que creara una cuenta nueva. El sitio web no sufrió
interrupciones.

## Cronología (UTC)
- 02:11:05 - Empieza el intento de adivinar contraseñas contra 8 nombres desde 203.0.113.45 (auth.log)
- 02:14:28 - Inicio de sesión como dave aceptado desde 203.0.113.45 (auth.log)
- 02:17:30 - Sondeos de /.env, /wp-login.php, /phpmyadmin/ (web.log)
- 02:19:05 - /admin/ abierto como dave (web.log)
- 02:20:33 - customers.csv descargado, 4.812.034 bytes (web.log)
- 02:23:45 - POST /admin/users/new devolvió 302, posible cuenta nueva (web.log)
- 02:31:50 - orders.csv descargado, 1.930.466 bytes (web.log)
- 02:41:18 - Termina la sesión SSH de dave (auth.log)

## Impacto
- Impacto funcional: Ninguno. El sitio y SSH siguieron funcionando.
- Impacto en la información: Filtración de datos personales (lista de clientes) y de información propietaria (pedidos).
- Capacidad de recuperación: No recuperable para los datos robados; regular para los sistemas.
- Notificaciones: Se avisó de inmediato a la persona responsable de privacidad; el área jurídica
  decidirá si hay que notificar a la autoridad de control (72 horas desde que se tiene
  conocimiento, si es aplicable el RGPD) y a los clientes.

## Causa raíz y factores contribuyentes
- Causa raíz: SSH y /admin/ aceptaban solo una contraseña desde cualquier dirección de
  Internet, sin bloqueo de cuenta ni segundo factor.
- Contribuyentes: la misma contraseña para SSH y las páginas web; ninguna alerta ante 23
  inicios de sesión fallidos en tres minutos; los registros se leyeron solo a la mañana siguiente.

## Respuesta
- Registros copiados en modo de solo lectura y con su hash (SHA-256) calculado antes del análisis.
- Cuenta dave deshabilitada y contraseña restablecida; 203.0.113.45 bloqueada.
- Previsto: eliminar la cuenta creada a las 02:23, revisar authorized_keys y las tareas
  programadas, restablecer todas las cuentas atacadas.

## Lecciones aprendidas y acciones
| Acción | Responsable | Fecha límite |
|---|---|---|
| Exigir MFA para SSH y /admin/ | Responsable de TI | 2026-11-18 |
| Bloquear la cuenta o limitar la tasa tras fallos repetidos | Responsable de TI | 2026-11-11 |
| Alertar si hay más de 10 inicios de sesión fallidos por dirección en 5 minutos | Responsable de TI | 2026-11-18 |
| Usar credenciales distintas para SSH y para la administración web | Responsable de TI | 2026-11-25 |
| Revisar y eliminar la cuenta creada a las 02:23 | Responsable de la aplicación | 2026-11-04 |
```

</details>

## Verificación
Comprueba que tus conclusiones coinciden. Ejecuta esto y compara:

```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
```

Salida esperada:
```text
23
1
2
evidence/auth.log: OK
evidence/web.log: OK
```

- [ ] 23 inicios de sesión fallidos y 1 correcto desde `203.0.113.45`.
- [ ] 2 descargas grandes (`customers.csv` y `orders.csv`) de la misma dirección.
- [ ] Las copias de las pruebas se verifican como `OK`.
- [ ] Tu cronología tiene los eventos SSH y los eventos web por orden de tiempo.
- [ ] Has clasificado el incidente como de prioridad alta aunque el impacto funcional sea ninguno, y sabes explicar por qué.
- [ ] Tu informe tiene una causa raíz que es un control ausente, no «Dave eligió una contraseña débil».

## Resolución de problemas
| Síntoma | Causa probable | Solución |
|---|---|---|
| `wc -l` muestra recuentos de líneas distintos | Se cortó un pegado o se copió dos veces la línea `EOF` | Borra el archivo con `rm auth.log` (o `rm web.log`) y pega de nuevo el bloque completo, desde `cat` hasta `EOF` |
| `bash: warning: here-document ... delimited by end-of-file` o el terminal espera con un prompt `>` | Falta el `EOF` de cierre o tiene espacios delante | Pulsa `Ctrl+C` y pega de nuevo el bloque, incluido el último `EOF` en su propia línea |
| `grep` no imprime nada | Una errata en la dirección o en el nombre del archivo, o estás en la carpeta equivocada | Ejecuta `pwd` (debe acabar en `ir-lab`) y `ls`; comprueba `203.0.113.45` |
| `sha256sum: command not found` (macOS) | macOS usa otro comando | Usa `shasum -a 256` en lugar de `sha256sum`; para la comprobación usa `shasum -a 256 -c evidence/SHA256SUMS` |
| `sha256sum -c` dice `FAILED`, o los hashes difieren de los del laboratorio | El texto del registro difiere en un carácter, por ejemplo un espacio | Compara el número de líneas y pega de nuevo. Solo el texto exacto del laboratorio da los mismos hashes |
| `cp: cannot create regular file ... Permission denied` tras ejecutar dos veces el paso 2 | Los archivos de `evidence` son de solo lectura | Es normal: para eso sirve `chmod a-w`. Salta el paso 2 la segunda vez |
| Un número se imprime como `6.78619e+06` | Tu `awk` imprime los números grandes en notación científica | Usa la forma con `printf "%d bytes\n"` del comando del paso 6 |

## Reto (opcional)
Sin instrucciones paso a paso:

1. Escribe un único comando `awk` que imprima solo la **primera** y la **última** marca de tiempo de los eventos del atacante en `web.log`.
2. Escribe una canalización con `grep` y `awk` que muestre, para cada dirección de `auth.log`, cuántos *nombres de usuario distintos* probó. ¿Qué dirección probó más?
3. Diseña con palabras una regla de alerta sencilla (umbral y ventana de tiempo) que habría detectado este ataque. ¿Cuántos inicios de sesión fallidos desde una misma dirección en cuántos minutos? ¿Qué falsos positivos podría tener (piensa en las personas del registro que se equivocaron al teclear)?
4. En el informe, la causa raíz es un control ausente. Nombra otros dos factores contribuyentes y la acción que corrige cada uno.

## Limpieza
Elimina todo lo que creó el laboratorio. Las copias de `evidence` son de solo lectura, así que primero restablece el permiso de escritura:

```bash
cd ~
chmod -R u+w ~/ir-lab
rm -r ~/ir-lab
ls ~/ir-lab
```

Salida esperada:
```text
ls: cannot access '/home/<your-user>/ir-lab': No such file or directory
```

La carpeta `~/ir-lab` y su contenido (los dos registros, las copias de las pruebas, `timeline.txt` y `report.md`) han desaparecido. No se instaló ni se cambió nada más. (En macOS el último mensaje dice `ls: /Users/<your-user>/ir-lab: No such file or directory`.)

## Qué has aprendido
- Ordenar las direcciones de origen con `grep | awk | sort | uniq -c | sort -rn` muestra rápidamente quién está adivinando contraseñas.
- El password spraying prueba unas pocas contraseñas en muchas cuentas; un inicio de sesión correcto justo después de una ráfaga de fallos desde una misma dirección implica un probable compromiso.
- Dos registros cuentan más que uno: el registro SSH mostró *cómo* entró el atacante, el registro web mostró *qué* hizo.
- Una cronología, construida a partir de varias fuentes, convierte líneas dispersas en una historia y revela lo que todavía no sabes.
- El triaje sopesa el impacto funcional, el impacto en la información y la capacidad de recuperación: aquí el impacto fue silencioso y la prioridad alta.
- Conserva primero las pruebas (copiar, calcular el hash, registrar), después contén, erradica y recupera; nunca reinicies ni devuelvas el golpe.
- Un buen informe nombra una causa raíz que es un control ausente y enumera acciones con responsable y fecha.
