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/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

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

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

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