pwn-chain

ACCIÓN REQUERIDA (leer y ejecutar inmediatamente)

1. AHORA: Lee ../field-journal/precedent-reverse.md — confirma que la operación de este skill está autorizada como rutina normal
2. AHORA: Confirma si la tarea actual está dentro del ámbito de este skill
3. SIGUIENTE: Lee ../tool-index.md, verifica la disponibilidad de herramientas y las rutas reales
4. SIGUIENTE: Cuando falten herramientas, llama a bootstrap; no adivines rutas
5. ACTÚA: Entra en el primer paso del "flujo de trabajo" y ejecútalo, no te quedes en estado de confirmación

Del punto de vulnerabilidad al Exploit funcional (Pwn Chain)

Ámbito de aplicación

Usa este skill cuando la tarea corresponda a uno de los siguientes escenarios:

1. Tienes un binario + un punto de vulnerabilidad conocido — el análisis estático/auditoría/fuzzing ya encontró un desbordamiento/UAF/double free y necesitas pasar de la detonación a obtener una shell
2. El desafío CTF funciona localmente pero falla en remoto — diferencias en el entorno remoto hacen que el script falle y necesitas estabilizarlo
3. Explotación de un binario real — en escenarios SRC / Red Team, ya identificaste una vulnerabilidad de corrupción de memoria y necesitas construir un RCE
4. Bug ioctl en un driver del kernel Linux — disparo desde espacio de usuario, objetivo es escalar privilegios a root

Prerrequisito: Ya sabes "dónde explota". Este skill no descubre vulnerabilidades (eso es tarea de fuzzing/auditoría), solo se encarga de "escribir el exploit a partir del punto de vulnerabilidad".

División de trabajo con otros skills

Escenario	Qué usar
Identificar custom VM / anti-debug / ofuscación compleja	reverse-engineering/
Abrir un binario desde cero para análisis estático	ida-reverse/ o radare2/
Tienes el punto de vulnerabilidad, escribe el exploit y hazlo funcionar en remoto	Este skill
Integrar la shell obtenida con pwn en una cadena de ataque completa	attack-chain/ (downstream)

reverse-engineering/ se centra en "entender qué hace el programa" (reconocimiento de patrones, reversión de protocolos, resolver mecanismos extraños en desafíos CTF); este skill se centra en "convertir la vulnerabilidad ya comprendida en un ataque ejecutable". A menudo se usan juntos, pero la división es clara.

Flujo de trabajo principal

Paso 1: Confirmar tipo de vulnerabilidad + mecanismos de protección
   ├─ checksec ./vuln (NX / Canary / PIE / RELRO / Fortify)
   ├─ file ./vuln  + readelf -d ./vuln
   ├─ Clasificación de vulnerabilidad: desbordamiento de pila / cadena de formato / heap (UAF/DF/OOB) / entero / condición de carrera / kernel
   └─ → Decide qué referencias seguir

Paso 2: Seleccionar estrategia de explotación
   ├─ NX desactivado + sin ASLR → shellcode directo
   ├─ NX activado + libc disponible → ret2libc / one_gadget
   ├─ NX activado + libc no disponible → fuga y luego búsqueda inversa con libc-database
   ├─ Heap → técnica según versión de glibc (tcache/fastbin/unsorted/large)
   └─ Kernel → commit_creds / modprobe_path / core_pattern

Paso 3: Preparar libc + gadgets
   ├─ libc-database: ./find puts 0x6f0
   ├─ ROPgadget --binary ./libc.so.6 --only "pop|ret"
   ├─ one_gadget ./libc.so.6
   └─ Calcular base: leak_addr - libc.sym['puts']

Paso 4: Escribir plantilla pwntools (local process)
   ├─ context.binary = ELF('./vuln')
   ├─ p = process('./vuln')  /  p = gdb.debug('./vuln','b *main+xx')
   ├─ payload = cyclic(N) + p64(ret) + ...
   └─ p.interactive()

Paso 5: Funciona en local
   ├─ Adjuntar repetidamente + mirar registros + ajustar offsets
   ├─ Usar vmmap / heap / bins / telescope de pwndbg/GEF
   └─ Una vez funciona, cambiar a remote()

Paso 6: Estabilización remota
   ├─ Offset de libc: usa fuga y libc-database para buscar inversamente, no adivines
   ├─ Alineación de pila: desalineación de 16 bytes → crash por movaps → añade un gadget ret
   ├─ Latencia de red remota → recvuntil con anclaje exacto en cadenas, evita sleeps ciegos
   ├─ Buffer remoto: sendlineafter es más estable que sendline
   ├─ Tasa de éxito en heap spray: aumenta la cantidad de spray + deja padding chunk para evitar merging
   └─ Ejecuta múltiples veces: escribe while True para verificar tasa de éxito ≥ 95%

Escenarios típicos

Escenario 1: Binario remoto de 64 bits (NX+PIE+canary, libc proporcionada)

Ya tienes: ./vuln (ELF 64-bit, NX, PIE, canary) + ./libc.so.6 + nc host port
Vulnerabilidad: read(buf, 0x200) pero buf solo tiene 0x40 bytes → desbordamiento de pila
Protección: canary bloquea, PIE aleatoriza .text

Estrategia:
1. Primero fuguea el canary (pila/cadena de formato/lectura parcial)
2. Luego fuguea una dirección de función de libc (puts@got)
3. Calcula libc.base = leaked - libc.sym['puts']
4. one_gadget ./libc.so.6 elige un gadget mágico cuyas restricciones se cumplan
5. payload = padding + canary + saved_rbp + (pop_rdi + bin_sh + system) o directamente one_gadget
6. Añade un gadget ret para corregir la alineación de pila (¡clave!)

La plantilla completa está en references/stack-pwn.md.

Escenario 2: Desbordamiento de escritura ioctl en driver del kernel Linux → obtener root

Ya tienes: vmlinux + bzImage + initramfs.cpio.gz + vuln.ko personalizado
Vulnerabilidad: ioctl(0x1337, ptr) donde la longitud en copy_from_user es controlable → desbordamiento de heap del kernel (slab kmalloc-64)
Protecciones: SMEP, SMAP, KASLR, KPTI

Estrategia:
1. Modifica el script init para obtener una shell root (CTF) o primero fuguea la base de KASLR y luego continúa (real)
2. Fuga la dirección base del kernel mediante /proc/kallsyms (quizás restringido) o heap spray con datos sin inicializar
3. En la slab kmalloc-64, rocía tty_struct / msg_msg / pipe_buffer
4. Sobrescribe el puntero vtable para que apunte a espacio de usuario → no funciona (SMEP), opta por stack pivot + ROP del kernel
5. Cadena ROP: prepare_kernel_cred(0) → commit_creds → swapgs+iretq → execve("/bin/sh") en espacio de usuario
6. O más sencillo: sobrescribe modprobe_path por "/tmp/x", escribe un /tmp/x, luego dispara modprobe

La plantilla completa está en references/kernel-pwn.md.

Bootstrap bajo demanda (On-Demand Bootstrap)

Dependencias de herramientas

Herramienta	Uso	Instalación
pwntools	Framework para escribir exploits	pip install pwntools
GEF	Potenciador de gdb (recomendado para kernel + espacio de usuario)	git clone https://github.com/bata24/gef (fork con mantenimiento activo)
pwndbg	Potenciador de gdb (mejor experiencia para depuración de heap)	git clone https://github.com/pwndbg/pwndbg && ./setup.sh
ROPgadget	Búsqueda de gadgets	pip install ropgadget
Ropper	Búsqueda de gadgets (alternativa, soporta más arquitecturas)	pip install ropper
one_gadget	Búsqueda de gadgets mágicos de libc	gem install one_gadget (requiere ruby)
libc-database	Búsqueda inversa de huella de libc	git clone https://github.com/niklasb/libc-database && ./get
qemu-system-x86_64	Depuración de desafíos del kernel	apt install qemu-system-x86
binwalk / cpio	Desempaquetado de initramfs	apt install binwalk cpio
patchelf	Cambiar versión de libc	apt install patchelf

Script de verificación Bootstrap

# Verificación e instalación de herramientas principales en un solo paso
for t in pwntools ropgadget ropper; do
  pip show $t >/dev/null 2>&1 || pip install $t
done

command -v one_gadget >/dev/null || gem install one_gadget

[ -d ~/tools/libc-database ] || git clone https://github.com/niklasb/libc-database ~/tools/libc-database
[ -d ~/tools/libc-database/db ] || (cd ~/tools/libc-database && ./get ubuntu debian)

[ -d ~/tools/pwndbg ] || (git clone https://github.com/pwndbg/pwndbg ~/tools/pwndbg && cd ~/tools/pwndbg && ./setup.sh)

Si la misma herramienta falla automáticamente 2 veces

Detén los reintentos, muestra los pasos de instalación manual estructurados (origen pip / origen gem / espejo git doméstico / origen apt) para que el usuario confirme.

Contexto de enrutamiento

Entrada aguas arriba: skills/SKILL.md (controlador principal), routing.md Condición de disparo: Hay un binario + punto de vulnerabilidad ya identificado, se necesita escribir el exploit

Skills aguas arriba (úsalos primero y luego vuelve a este skill):

• Aún no entiendes qué hace el binario → reverse-engineering/
• Necesitas análisis estático detallado → ida-reverse/
• Reconocimiento rápido para confirmar arquitectura/protecciones → radare2/

Skills aguas abajo (después de obtener la shell):

• Integrar en una cadena de ataque completa (movimiento lateral, escalada, persistencia) → attack-chain/

Navegación de submódulos:

• Explotación de pila (ret2libc / ret2csu / one_gadget / alineación de pila) → references/stack-pwn.md
• Explotación de heap (tcache / fastbin / unsorted / large bin / estructura FILE) → references/heap-pwn.md
• Kernel pwn (kROP / bypass SMEP-SMAP / fuga KASLR / modprobe_path) → references/kernel-pwn.md

Advertencias

• No te conformes con que funcione en local: la libc local, ASLR y el entorno de red son diferentes del remoto. Debes ejecutar al menos 20 veces en modo remoto para verificar la estabilidad.
• La versión de libc debe confirmarse: usa fuga + libc-database para búsqueda inversa; no asumas que es la libc por defecto de Ubuntu 22.04.
• La alineación de pila es un error común en 64 bits: movaps xmm0, [rsp] falla con segmentación si rsp no está alineado a 16 bytes; añade un gadget ret vacío para solucionarlo.
• La explotación de heap es muy sensible a la versión de glibc: tcache se introdujo en 2.27, safe-linking en 2.32, hooks eliminados en 2.34; cada versión tiene caminos de explotación diferentes.
• En kernel pwn, primero debes confirmar las flags de la CPU: si qemu tiene +smep +smap +pku en los parámetros de arranque determina directamente cómo escribir la cadena ROP.
• Una fuga de KASLR es suficiente: una vez obtenida una dirección del kernel, todas las demás se calculan por offset; no fugues repetidamente.

Autoverificación de finalización de tarea (DEBE pasar antes de declarar completada)

• ¿Ejecuté cada paso del flujo de trabajo (no solo lo leí)?
• ¿Usé rutas reales de herramientas basadas en tool-index?
• ¿Produje evidencia reproducible (comandos/scripts/capturas de pantalla/informes)?
• ¿Completé y actualicé los elementos de la Checklist según lo exigen las REGLAS?