hanuscode 1.0.0__py3-none-any.whl

hanus/plugins/searchsploit.py

@@ -0,0 +1,495 @@
+# plugins/searchsploit.py — SearchSploit Integration
+"""
+Plugin para buscar y gestionar exploits desde Exploit-DB.
+Permite buscar por término, CVE, ver detalles y preparar exploits.
+
+Uso:
+  /searchsploit search <término>        — Buscar exploits
+  /searchsploit cve <CVE>               — Buscar por CVE (ej: 2021-44228)
+  /searchsploit view <id>               — Ver detalles de un exploit
+  /searchsploit copy <id> [dest]        — Copiar exploit a directorio
+  /searchsploit mirror <id> [dest]      — Mirror exploit con archivos
+  /searchsploit nmap <xml>              — Buscar exploits desde Nmap XML
+  /searchsploit update                  — Actualizar base de datos
+"""
+from __future__ import annotations
+import subprocess
+import shlex
+import re
+import os
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple
+
+NAME        = "searchsploit"
+DESCRIPTION = "Buscar exploits en Exploit-DB por término, CVE, etc."
+USAGE       = "<comando> [args...] | search <term> | cve <CVE> | view <id> | copy <id>"
+AGENT_DOC   = """
+Plugin para buscar y gestionar exploits desde Exploit-DB usando SearchSploit.
+
+Comandos disponibles:
+- search <término>           — Buscar exploits por término
+- cve <CVE>                  — Buscar por CVE (ej: cve 2021-44228)
+- view <id>                  — Ver detalles y ruta de un exploit
+- copy <id> [dest]           — Copiar exploit al directorio actual o destino
+- mirror <id> [dest]         — Copiar exploit y archivos relacionados
+- nmap <archivo.xml>         — Buscar exploits basado en scan Nmap
+- update                     — Actualizar base de datos de exploits
+
+Ejemplos:
+<run_plugin name="searchsploit" args="search apache struts"/>
+<run_plugin name="searchsploit" args="cve 2021-44228"/>
+<run_plugin name="searchsploit" args="view 46570"/>
+<run_plugin name="searchsploit" args="copy 46570 ./exploits/"/>
+"""
+
+
+def _run_cmd(cmd: str, timeout: int = 60) -> Tuple[int, str, str]:
+    """Ejecuta un comando y retorna (returncode, stdout, stderr)."""
+    try:
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            capture_output=True,
+            text=True,
+            timeout=timeout
+        )
+        return result.returncode, result.stdout, result.stderr
+    except subprocess.TimeoutExpired:
+        return -1, "", "Timeout expirado"
+    except Exception as e:
+        return -1, "", str(e)
+
+
+def _parse_exploit_table(output: str) -> List[Dict]:
+    """Parsea la salida de searchsploit en formato tabla."""
+    exploits = []
+    lines = output.strip().split('\n')
+
+    for line in lines:
+        # Formato típico: "  Exploit Title                                    |  Path"
+        # Luego: "  Apache Struts 2 RCE                             |  linux/webapps/42324.rb"
+        if '|' not in line:
+            continue
+
+        # Ignorar líneas de header
+        if 'Exploit Title' in line or '---' in line:
+            continue
+
+        parts = line.rsplit('|', 1)
+        if len(parts) != 2:
+            continue
+
+        title = parts[0].strip()
+        path = parts[1].strip()
+
+        # Extraer ID del path
+        match = re.search(r'/(\d+)(?:\.\w+)?$', path)
+        exploit_id = match.group(1) if match else ""
+
+        exploits.append({
+            'id': exploit_id,
+            'title': title,
+            'path': path,
+        })
+
+    return exploits
+
+
+def _search(term: str, exact: bool = False, title_only: bool = False) -> str:
+    """Busca exploits por término."""
+    cmd = "searchsploit"
+
+    if title_only:
+        cmd += " -t"
+
+    if exact:
+        cmd += " -e"
+
+    # Escapar el término
+    cmd += f" {shlex.quote(term)}"
+
+    retcode, stdout, stderr = _run_cmd(cmd)
+
+    if retcode != 0 and not stdout:
+        return f"Error en búsqueda: {stderr}"
+
+    if not stdout.strip():
+        return f"No se encontraron exploits para: {term}"
+
+    exploits = _parse_exploit_table(stdout)
+
+    if not exploits:
+        return stdout  # Devolver salida original si no se pudo parsear
+
+    # Formatear resultados
+    output = [f"Exploits encontrados para '{term}': {len(exploits)} resultados", "━" * 70]
+
+    for e in exploits:
+        output.append(f"  [{e['id']:>6}] {e['title'][:55]:<55}")
+        output.append(f"          {e['path']}")
+
+    output.append(f"\nPara ver detalles: searchsploit view <id>")
+    output.append(f"Para copiar: searchsploit copy <id> [destino]")
+
+    return "\n".join(output)
+
+
+def _search_cve(cve: str) -> str:
+    """Busca exploits por CVE."""
+    # Normalizar CVE (aceptar con o sin prefijo CVE-)
+    cve_num = cve.replace("CVE-", "").replace("cve-", "").replace("-", "")
+
+    cmd = f"searchsploit --cve {shlex.quote(cve_num)}"
+
+    retcode, stdout, stderr = _run_cmd(cmd)
+
+    if retcode != 0 and not stdout:
+        return f"Error buscando CVE {cve}: {stderr}"
+
+    if not stdout.strip():
+        return f"No se encontraron exploits para CVE-{cve_num}"
+
+    exploits = _parse_exploit_table(stdout)
+
+    if not exploits:
+        return stdout
+
+    output = [f"Exploits para CVE-{cve_num}: {len(exploits)} resultados", "━" * 70]
+
+    for e in exploits:
+        output.append(f"  [{e['id']:>6}] {e['title'][:55]:<55}")
+        output.append(f"          {e['path']}")
+
+    return "\n".join(output)
+
+
+def _view_exploit(exploit_id: str) -> str:
+    """Muestra detalles de un exploit."""
+    cmd = f"searchsploit -p {shlex.quote(exploit_id)}"
+
+    retcode, stdout, stderr = _run_cmd(cmd)
+
+    if retcode != 0:
+        return f"Error obteniendo exploit {exploit_id}: {stderr}"
+
+    if not stdout.strip():
+        return f"No se encontró el exploit {exploit_id}"
+
+    # Parsear la salida
+    lines = stdout.strip().split('\n')
+    info = {}
+    current_key = None
+    description_lines = []
+
+    for line in lines:
+        if ':' in line and not line.startswith(' '):
+            key, value = line.split(':', 1)
+            key = key.strip()
+            value = value.strip()
+            info[key] = value
+        elif line.startswith('     '):
+            description_lines.append(line.strip())
+
+    output = [f"Exploit ID: {exploit_id}", "━" * 60]
+
+    for key, value in info.items():
+        if key == 'Path':
+            output.append(f"\n{key}: {value}")
+            # Intentar detectar tipo de exploit
+            ext = Path(value).suffix.lower()
+            lang_map = {
+                '.py': 'Python',
+                '.rb': 'Ruby (Metasploit)',
+                '.c': 'C',
+                '.cpp': 'C++',
+                '.sh': 'Shell Script',
+                '.pl': 'Perl',
+                '.php': 'PHP',
+                '.js': 'JavaScript',
+                '.exe': 'Windows Executable',
+            }
+            lang = lang_map.get(ext, 'Desconocido')
+            output.append(f"Lenguaje: {lang}")
+        else:
+            output.append(f"{key}: {value}")
+
+    if description_lines:
+        output.append(f"\nDescripción:\n" + "\n".join(description_lines))
+
+    output.append(f"\n{'━' * 60}")
+    output.append(f"Para copiar: searchsploit copy {exploit_id}")
+    output.append(f"Para ver archivo: cat $EXPLOITDB_PATH/{info.get('Path', '')}")
+
+    return "\n".join(output)
+
+
+def _copy_exploit(exploit_id: str, dest: str = ".") -> str:
+    """Copia un exploit al directorio especificado."""
+    dest_path = Path(dest).resolve()
+    dest_path.mkdir(parents=True, exist_ok=True)
+
+    cmd = f"searchsploit -m {shlex.quote(exploit_id)} {shlex.quote(str(dest_path))}"
+
+    retcode, stdout, stderr = _run_cmd(cmd)
+
+    if retcode != 0:
+        return f"Error copiando exploit: {stderr}"
+
+    # Buscar el archivo copiado
+    copied_files = list(dest_path.glob(f"*{exploit_id}*"))
+
+    output = [f"✓ Exploit {exploit_id} copiado a: {dest_path}"]
+
+    if copied_files:
+        for f in copied_files:
+            output.append(f"  Archivo: {f.name}")
+
+    return "\n".join(output)
+
+
+def _mirror_exploit(exploit_id: str, dest: str = ".") -> str:
+    """Copia exploit y archivos relacionados."""
+    dest_path = Path(dest).resolve()
+    dest_path.mkdir(parents=True, exist_ok=True)
+
+    # -m ya hace mirror, pero intentamos obtener más contexto
+    cmd = f"searchsploit -m {shlex.quote(exploit_id)} {shlex.quote(str(dest_path))}"
+
+    retcode, stdout, stderr = _run_cmd(cmd)
+
+    if retcode != 0:
+        return f"Error en mirror: {stderr}"
+
+    # Ver archivos creados
+    copied_files = list(dest_path.glob("*"))
+
+    output = [f"✓ Exploit {exploit_id} copiado con archivos a: {dest_path}"]
+
+    for f in sorted(copied_files):
+        size = f.stat().st_size if f.is_file() else ""
+        output.append(f"  {'📁' if f.is_dir() else '📄'} {f.name} {f'({size} bytes)' if size else ''}")
+
+    return "\n".join(output)
+
+
+def _nmap_search(xml_file: str) -> str:
+    """Busca exploits basado en un scan Nmap XML."""
+    xml_path = Path(xml_file)
+    if not xml_path.exists():
+        return f"Error: Archivo no encontrado: {xml_file}"
+
+    cmd = f"searchsploit --nmap {shlex.quote(str(xml_path))}"
+
+    retcode, stdout, stderr = _run_cmd(cmd, timeout=120)
+
+    if retcode != 0 and not stdout:
+        return f"Error en búsqueda Nmap: {stderr}"
+
+    return stdout if stdout.strip() else "No se encontraron exploits relevantes."
+
+
+def _update_db() -> str:
+    """Actualiza la base de datos de exploits."""
+    output = ["Actualizando base de datos de Exploit-DB...", "━" * 50]
+
+    cmd = "searchsploit -u"
+
+    retcode, stdout, stderr = _run_cmd(cmd, timeout=300)
+
+    if retcode != 0:
+        output.append(f"Error: {stderr}")
+    else:
+        output.append(stdout if stdout.strip() else "Base de datos actualizada.")
+
+    return "\n".join(output)
+
+
+def _analyze_exploit(exploit_id: str) -> str:
+    """Analiza un exploit y sugiere cómo usarlo."""
+    # Primero obtener info del exploit
+    cmd = f"searchsploit -p {shlex.quote(exploit_id)}"
+    retcode, stdout, stderr = _run_cmd(cmd)
+
+    if retcode != 0 or not stdout.strip():
+        return f"No se pudo obtener info del exploit {exploit_id}"
+
+    # Parsear información
+    info = {}
+    for line in stdout.split('\n'):
+        if ':' in line and not line.startswith(' '):
+            key, value = line.split(':', 1)
+            info[key.strip()] = value.strip()
+
+    path = info.get('Path', '')
+    title = info.get('Exploit Title', 'Desconocido')
+
+    ext = Path(path).suffix.lower() if path else ''
+
+    output = [
+        f"ANÁLISIS DE EXPLOIT",
+        f"{'━' * 60}",
+        f"ID: {exploit_id}",
+        f"Título: {title}",
+        f"Tipo: {ext}",
+        f"",
+    ]
+
+    # Sugerencias basadas en tipo de archivo
+    suggestions = {
+        '.py': [
+            "Python exploit detectado.",
+            "Pasos para ejecutar:",
+            "1. Copiar el exploit: searchsploit copy " + exploit_id,
+            "2. Revisar el código: cat <archivo>.py",
+            "3. Instalar dependencias si las hay",
+            "4. Ejecutar: python <archivo>.py <target> [opciones]",
+            "",
+            "Verificar variables de configuración:",
+            "  - IP/URL del objetivo",
+            "  - Puerto",
+            "  - Payload o shellcode",
+        ],
+        '.rb': [
+            "Módulo Metasploit detectado.",
+            "Pasos para usar:",
+            "1. Copiar a ~/.msf4/modules/exploits/",
+            "2. Iniciar msfconsole",
+            "3. Cargar: use exploit/<nombre>",
+            "4. Configurar: set RHOSTS <target>",
+            "5. Ejecutar: exploit",
+        ],
+        '.c': [
+            "Exploit en C detectado.",
+            "Pasos para compilar:",
+            "1. Copiar: searchsploit copy " + exploit_id,
+            "2. Compilar: gcc -o exploit <archivo>.c",
+            "3. Si da error, probar: gcc -m32 -o exploit <archivo>.c",
+            "4. Ejecutar: ./exploit <argumentos>",
+        ],
+        '.sh': [
+            "Shell script detectado.",
+            "Ejecutar directamente después de revisar:",
+            "1. Copiar: searchsploit copy " + exploit_id,
+            "2. Revisar: cat <archivo>.sh",
+            "3. Dar permisos: chmod +x <archivo>.sh",
+            "4. Ejecutar: ./<archivo>.sh",
+        ],
+    }
+
+    if ext in suggestions:
+        output.extend(suggestions[ext])
+    else:
+        output.extend([
+            "Tipo de exploit no reconocido automáticamente.",
+            "Revisar el archivo y seguir las instrucciones internas.",
+            f"Copiar con: searchsploit copy {exploit_id}",
+        ])
+
+    output.append("")
+    output.append(f"Archivo original: {path}")
+
+    return "\n".join(output)
+
+
+def run(args: str = "") -> str:
+    """Punto de entrada del plugin."""
+    if not args.strip():
+        return f"Uso: {USAGE}\n\n{AGENT_DOC}"
+
+    parts = args.strip().split(maxsplit=2)
+    cmd = parts[0].lower()
+    cmd_args = parts[1:] if len(parts) > 1 else []
+
+    # ── SEARCH ────────────────────────────────────────────────────────────
+    if cmd == "search":
+        if not cmd_args:
+            return "Uso: search <término> [--exact] [--title]"
+
+        term = " ".join(cmd_args)
+        exact = "--exact" in term or "-e" in term
+        title_only = "--title" in term or "-t" in term
+
+        # Limpiar flags del término
+        for flag in ["--exact", "-e", "--title", "-t"]:
+            term = term.replace(flag, "")
+        term = term.strip()
+
+        return _search(term, exact=exact, title_only=title_only)
+
+    # ── CVE ────────────────────────────────────────────────────────────────
+    if cmd == "cve":
+        if not cmd_args:
+            return "Uso: cve <CVE>\nEjemplo: cve 2021-44228 o cve CVE-2021-44228"
+
+        cve = cmd_args[0]
+        return _search_cve(cve)
+
+    # ── VIEW ───────────────────────────────────────────────────────────────
+    if cmd == "view":
+        if not cmd_args:
+            return "Uso: view <id>"
+
+        exploit_id = cmd_args[0]
+        return _view_exploit(exploit_id)
+
+    # ── COPY ───────────────────────────────────────────────────────────────
+    if cmd == "copy":
+        if not cmd_args:
+            return "Uso: copy <id> [destino]"
+
+        exploit_id = cmd_args[0]
+        dest = cmd_args[1] if len(cmd_args) > 1 else "."
+        return _copy_exploit(exploit_id, dest)
+
+    # ── MIRROR ─────────────────────────────────────────────────────────────
+    if cmd == "mirror":
+        if not cmd_args:
+            return "Uso: mirror <id> [destino]"
+
+        exploit_id = cmd_args[0]
+        dest = cmd_args[1] if len(cmd_args) > 1 else "."
+        return _mirror_exploit(exploit_id, dest)
+
+    # ── NMAP ───────────────────────────────────────────────────────────────
+    if cmd == "nmap":
+        if not cmd_args:
+            return "Uso: nmap <archivo.xml>"
+
+        xml_file = cmd_args[0]
+        return _nmap_search(xml_file)
+
+    # ── UPDATE ─────────────────────────────────────────────────────────────
+    if cmd == "update":
+        return _update_db()
+
+    # ── ANALYZE ────────────────────────────────────────────────────────────
+    if cmd == "analyze":
+        if not cmd_args:
+            return "Uso: analyze <id> — Analiza y sugiere cómo usar el exploit"
+
+        exploit_id = cmd_args[0]
+        return _analyze_exploit(exploit_id)
+
+    # ── INFO ───────────────────────────────────────────────────────────────
+    if cmd in ("info", "help"):
+        return f"""SearchSploit — Buscar exploits en Exploit-DB
+
+Comandos:
+  search <término>        Buscar exploits por término
+  cve <CVE>               Buscar por CVE (ej: 2021-44228)
+  view <id>               Ver detalles de un exploit
+  copy <id> [dest]        Copiar exploit al directorio
+  mirror <id> [dest]      Copiar exploit con archivos relacionados
+  nmap <archivo.xml>      Buscar exploits desde scan Nmap
+  analyze <id>            Analizar y sugerir uso del exploit
+  update                  Actualizar base de datos
+
+Ejemplos:
+  searchsploit search apache struts
+  searchsploit cve 2021-44228
+  searchsploit view 46570
+  searchsploit copy 46570 ./exploits/
+  searchsploit analyze 46570
+"""
+
+    return f"Comando desconocido: {cmd}\nUsa: searchsploit info"

hanus/plugins/strategist.py

@@ -0,0 +1,175 @@
+# plugins/strategist.py — Plugin Estratega IA
+"""
+Llama a un modelo de IA para generar un plan estructurado paso a paso
+antes de ejecutar tareas complejas.
+"""
+import json
+import os
+import sys
+import urllib.request
+from pathlib import Path
+
+NAME        = "strategist"
+DESCRIPTION = "Usa un modelo IA para generar un plan detallado antes de actuar"
+USAGE       = "<descripción de la tarea compleja>"
+AGENT_DOC   = """
+Úsalo cuando la tarea sea compleja o requiera planificación previa.
+El plugin retorna un plan JSON estructurado que el agente debe seguir.
+Ejemplo: <run_plugin name="strategist" args="Refactorizar el módulo de auth para OAuth2"/>
+"""
+
+
+def run(args: str = "") -> str:
+    if not args.strip():
+        return "Proporciona la tarea: <run_plugin name='strategist' args='descripción'/>"
+
+    # Intentar con Claude si hay API key
+    api_key = os.environ.get("ANTHROPIC_API_KEY", "")
+    if api_key:
+        result = _try_claude(args, api_key)
+        if result:
+            return result
+
+    # Intentar con Ollama local
+    result = _try_ollama(args)
+    if result:
+        return result
+
+    return _fallback_plan(args)
+
+
+def _try_claude(task: str, api_key: str) -> str:
+    """Llama a Claude para planificar."""
+    try:
+        payload = json.dumps({
+            "model": "claude-haiku-4-5",
+            "max_tokens": 1500,
+            "system": _SYSTEM,
+            "messages": [{"role": "user", "content": _build_prompt(task)}],
+        }).encode()
+        req = urllib.request.Request(
+            "https://api.anthropic.com/v1/messages",
+            data=payload,
+            headers={
+                "Content-Type": "application/json",
+                "x-api-key": api_key,
+                "anthropic-version": "2023-06-01",
+            },
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=30) as r:
+            data = json.loads(r.read())
+            text = data["content"][0]["text"]
+            try:
+                import re
+                m = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL)
+                if m:
+                    text = m.group(1)
+                plan_data = json.loads(text)
+                return _format_plan(task, plan_data)
+            except Exception:
+                return f"## 🧠 Plan Estratégico\n**Tarea:** {task}\n\n{text}"
+    except Exception:
+        return ""
+
+
+def _try_ollama(task: str) -> str:
+    """Intenta usar Ollama local."""
+    try:
+        import requests
+        ollama_url = os.environ.get("OLLAMA_URL", "http://localhost:11434")
+
+        # Verificar que Ollama está disponible
+        try:
+            requests.get(f"{ollama_url}/api/tags", timeout=2)
+        except Exception:
+            return ""
+
+        payload = {
+            "model": "llama3",
+            "prompt": _build_prompt(task),
+            "system": _SYSTEM,
+            "stream": False,
+        }
+
+        r = requests.post(f"{ollama_url}/api/generate", json=payload, timeout=60)
+        r.raise_for_status()
+        text = r.json().get("response", "")
+
+        if text:
+            try:
+                import re
+                m = re.search(r'```(?:json)?\s*(\{.*?\})\s*```', text, re.DOTALL)
+                if m:
+                    text = m.group(1)
+                plan_data = json.loads(text)
+                return _format_plan(task, plan_data)
+            except Exception:
+                return f"## 🧠 Plan Estratégico\n**Tarea:** {task}\n\n{text}"
+    except Exception:
+        pass
+
+    return ""
+
+
+def _build_prompt(task: str) -> str:
+    return (
+        f"Analiza esta tarea de programación y genera un plan detallado en JSON:\n\n"
+        f"TAREA: {task}\n\n"
+        f"Responde SOLO con JSON válido, sin texto adicional."
+    )
+
+
+def _format_plan(task: str, data: dict) -> str:
+    lines = [
+        "## 🧠 Plan Estratégico",
+        f"**Tarea:** {task}",
+        "",
+        f"**Análisis:** {data.get('analysis', 'N/A')}",
+        f"**Pasos estimados:** {data.get('estimated_steps', len(data.get('plan', [])))}",
+        "",
+        "### Pasos a seguir:",
+    ]
+    for step in data.get("plan", []):
+        n = step.get("step", "?")
+        act = step.get("action", "")
+        tools = ", ".join(step.get("tools", []))
+        why = step.get("rationale", "")
+        lines.append(f"\n**Paso {n}:** {act}")
+        if tools:
+            lines.append(f"  → Herramientas: `{tools}`")
+        if why:
+            lines.append(f"  → Razón: {why}")
+
+    risks = data.get("risks", [])
+    if risks:
+        lines.append("\n### ⚠️ Riesgos:")
+        for r in risks:
+            lines.append(f"  - {r}")
+
+    return "\n".join(lines)
+
+
+def _fallback_plan(task: str) -> str:
+    return (
+        f"## Plan básico para: {task}\n\n"
+        "**Paso 1:** Explorar estructura del proyecto  →  `glob_search`, `read_file`\n"
+        "**Paso 2:** Leer archivos relevantes          →  `read_file`, `grep_search`\n"
+        "**Paso 3:** Analizar el código actual         →  `read_file`\n"
+        "**Paso 4:** Implementar los cambios           →  `write_file`, `edit_file`\n"
+        "**Paso 5:** Verificar y ejecutar tests        →  `exec_cmd`\n\n"
+        "_Para planes más detallados, configura ANTHROPIC_API_KEY o usa Ollama local._"
+    )
+
+
+_SYSTEM = """Eres un experto en arquitectura de software. Analiza la tarea y responde ÚNICAMENTE con JSON:
+{
+  "analysis": "Breve análisis de la tarea",
+  "plan": [
+    {"step": 1, "action": "Acción concreta", "tools": ["read_file"], "rationale": "Por qué"},
+    {"step": 2, "action": "...", "tools": [...], "rationale": "..."}
+  ],
+  "risks": ["Riesgo 1"],
+  "estimated_steps": 5
+}
+Sé específico con rutas de archivos y comandos exactos si los conoces."""