Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
red-clippy — open-source pentest management built to be operated by an AI agent | Kitploit
Herramientas/GitHubGitHub/cspf-founder/red-clippy
Frameworks de Pruebas de PenetraciónReconocimientoEscáneres de VulnerabilidadesAnálisis de VulnerabilidadesExplotaciónRecopilación de InformaciónPruebas de PenetraciónRed TeamingSeguridad de IA
GitHubcspf-founder/red-clippy

red-clippy

open-source pentest management built to be operated by an AI agent

178hace 2 díasAún no revisado
Ver RepositorioSitio web

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

Red Clippy

Tus pruebas de agente. Red Clippy lleva el registro.

Gestión de pentesting de código abierto diseñada para ser operada por un agente de IA. Conéctalo a Claude Code mediante MCP y ejecutará el compromiso junto a ti: alcance y activos, observaciones de reconocimiento, cobertura de metodología y hallazgos con CVSS y evidencia.

Diseñado para testers que quieren la velocidad de un agente sin renunciar a la disciplina de un compromiso real. El trabajo no se repite, los hallazgos no se evaporan entre sesiones, y nada llega al informe que nunca fue probado.

Un compromiso en Red Clippy: progreso de cobertura, hallazgos por severidad, fases pendientes, hallazgos recientes y el alcance de la carta de compromiso

Documentación completa: https://cspf-founder.github.io/red-clippy/


Contenido

  • Por qué
  • Inicio rápido
  • Cómo se organizan los datos
  • Primera ejecución
  • Uso
  • Conexión de un agente de IA (MCP)
  • Características
  • Configuración
  • Referencia de CLI
  • Compilación desde el código fuente
  • Desarrollo
  • Contribuciones
  • Licencia

  • Por qué

    Los agentes de programación se han convertido en testers genuinamente útiles. Tienen un shell, ejecutan las mismas herramientas que tú y cubren terreno rápido. Apunta uno a un objetivo y encontrará cosas.

    Luego la ventana de contexto se llena y el compromiso desaparece. La siguiente sesión reescanea hosts que ya había limpiado, vuelve a probar lo que ya descartó y no puede decirte qué partes del alcance fueron tocadas alguna vez. En algún lugar del transcripto hay una inyección SQL confirmada que nadie anotó.

    Red Clippy soluciona eso dándole al agente dos cosas que no tiene por sí solo.

    Un lugar para poner el trabajo. Cada activo, observación, verificación y hallazgo aterriza en una base de datos a medida que se prueba, no en un búfer de scrollback. La cobertura se convierte en una consulta en lugar de un recuerdo: qué activos existen, qué verificaciones están despejadas en cada uno, qué ya se ha informado. La sesión de mañana retoma exactamente donde terminó la anterior.

    Reglas para trabajar. Un documento de Instrucciones de Red Team llega al agente en el handshake de MCP, antes de que haga cualquier cosa: verifica antes de informar, prueba cada afirmación, toma el acceso mínimo necesario para demostrar el impacto, deja los sistemas de terceros en paz. Anúlalo por organización y por compromiso, porque las reglas internas difieren entre equipos y clientes.

    Tú permaneces en el bucle todo el tiempo. Todo lo que el agente escribe es una fila ordinaria en la interfaz web que puedes revisar, corregir, reclasificar o descartar.

    [!CAUTION] Solo pruebas autorizadas. Red Clippy es para testers de penetración que trabajan bajo un compromiso. Prueba solo sistemas que poseas o para los que tengas permiso escrito explícito para evaluar. El marcado de alcance y las Instrucciones de Red Team existen para mantener a un agente dentro de las reglas de compromiso, pero son barreras de contención, no autorización. Un agente actúa bajo tu autoridad, y tú sigues siendo responsable de todo lo que hace.


    Inicio rápido

    Descarga un binario de la última versión y ejecútalo. Configura la base de datos y sirve el panel en 127.0.0.1:7337.

    Linux

    root@kitploit:~
    tar xzf red-clippy-*-x86_64-unknown-linux-musl.tar.gz
    cd red-clippy-*-x86_64-unknown-linux-musl
    ./red-clippy serve
    

    Windows

    Descomprime el archivo y, desde esa carpeta:

    root@kitploit:~
    .\red-clippy.exe serve
    

    Abre http://127.0.0.1:7337 y el asistente de configuración se encarga del resto.

    La base de datos se crea en el directorio donde ejecutas el binario. La evidencia subida también se almacena allí, en red-clippy-storage. Ambas rutas se pueden cambiar en el archivo de configuración; consulta Configuración.

    ¿Prefieres compilarlo tú mismo? Consulta Compilación desde el código fuente.


    Cómo se organizan los datos

    Red Clippy agrupa el trabajo en organizaciones. Una organización contiene tus pentests, y cada pentest contiene los activos, hallazgos y evidencia de ese compromiso. Si pruebas para una empresa, una sola organización es todo lo que necesitas. Si consultas para varios clientes, dale a cada cliente la suya: una organización no ve nada que pertenezca a otra, por lo que sus compromisos nunca se mezclan.

    Una organización tiene dos nombres. El nombre para mostrar ("Acme Corp") es lo que ves en el panel y se puede cambiar más tarde. El slug (acme) es un identificador corto en minúsculas utilizado en la carpeta de evidencia en disco (red-clippy-storage/org_acme/pentest_PT-2026-08-27/), por lo que queda fijo una vez establecido.

    Puedes pertenecer a varias organizaciones y cambiar entre ellas desde el menú de avatar. En cada una eres o un propietario, que puede agregar y eliminar personas y renombrar o eliminar la organización, o un miembro, que trabaja en los compromisos.


    Primera ejecución

    En el primer lanzamiento la base de datos está vacía, por lo que el navegador muestra un asistente de configuración en lugar de un formulario de inicio de sesión. Pide:

    • un slug y nombre para mostrar para tu primera organización
    • un nombre de usuario y, opcionalmente, un correo electrónico
    • una contraseña (mínimo 8 caracteres)

    La cuenta que crea es la propietaria de esa organización. El asistente solo aparece mientras la base de datos no tenga usuarios; una vez que existe la primera cuenta queda deshabilitado permanentemente, por lo que no se puede usar para crear cuentas adicionales más tarde.

    Después de la configuración, gestiona organizaciones y compañeros de equipo en la aplicación bajo menú de avatar > Organizaciones.

    Si nadie puede iniciar sesión, la CLI es el camino de regreso:

    root@kitploit:~
    red-clippy reset-password --username alice --password 'new-one'
    

    Uso

    El flujo previsto está impulsado por el agente. Tú configuras el compromiso y luego trabajas a través del objetivo con Claude Code mientras este lleva el registro.

    Tú configuras:

    1. Crea un pentest. Código, alcance, fechas. La lista de verificación de metodología se siembra automáticamente.
    2. Define el alcance. Agrega los dominios, hosts y rangos de IP que estás autorizado a probar, y marca cualquier cosa explícitamente fuera de alcance. Puedes escribirlos tú mismo o pegar la lista de alcance del cliente al agente y hacer que los ingrese por ti.
    3. Conecta el agente mediante MCP, anclado a este compromiso (ver más abajo).

    El agente entonces trabaja y registra a medida que avanza:

    • Ejecuta herramientas de reconocimiento y pruebas desde su propio shell, de la manera habitual.
    • Entrega la salida cruda del escáner con ingest_tool_output, o escribe activos y observaciones directamente.
    • Promueve unidades de alcance reales a activos, dejando el resto como observaciones.
    • Marca las verificaciones de metodología a medida que las despeja.
    • Archiva hallazgos con CVSS, PoC y evidencia adjunta.

    Tú supervisas:

    • Observa cómo aterriza en el navegador en tiempo real.
    • Corrige cualquier cosa: cada fila que escribió el agente es un registro ordinario que puedes editar, reclasificar o eliminar.
    • Revisa la vista de cobertura para ver qué sigue sin tocar.
    • Revisa en el panel entre compromisos, que muestra cada hallazgo en la organización junto con el pentest del que proviene.

    El agente es opcional. Trabaja a través de la misma API que el panel, por lo que cualquier cosa que registre también puedes ingresarla, corregirla o eliminarla tú mismo en el navegador. Ejecuta un compromiso completamente a mano, completamente a través del agente, o alterna entre ambos a medida que avanzas.


    Conexión de un agente de IA (MCP)

    Esta es la forma principal en que se pretende usar Red Clippy.

    red-clippy mcp cubre toda la aplicación: alcance y activos, observaciones, cobertura de metodología, hallazgos, evidencia, el grafo de ataque y la ingesta de salida de herramientas. Un agente conectado trabaja el compromiso en lugar de solo responder preguntas sobre él.

    Al conectarse, el servidor entrega al cliente el documento de Instrucciones de Red Team, la doctrina operativa sobre cómo comportarse durante las pruebas, en el handshake de MCP, para que esté en el contexto del agente antes de la primera llamada a herramienta. Se resuelve de lo más específico a lo más general: desde una anulación por compromiso, a un valor predeterminado de organización, hasta el documento integrado. Edita el valor predeterminado de la organización en Configuración > Instrucciones de Red Team, o establece una anulación por compromiso desde la página de configuración del pentest. get_instructions lo vuelve a leer bajo demanda.

    Crear una clave de API

    Emite una en Configuración > Claves de API. La sección Conectar MCP debajo te da entonces configuraciones listas para pegar para cada cliente, con esa clave, la URL de este servidor y la ruta del propio binario ya completadas. No hay nada que sustituir a mano.

    Para crear la clave desde la CLI en su lugar y pegarla tú mismo en los fragmentos:

    root@kitploit:~
    red-clippy create-api-key --username alice --org acme --name laptop
    # -> rcl_<prefix>_<secret>   (se muestra una vez, guárdala ahora)
    

    Claude Code

    root@kitploit:~
    claude mcp add red-clippy \
      --env RED_CLIPPY_URL=http://127.0.0.1:7337 \
      --env RED_CLIPPY_API_KEY=rcl_xxxx_yyyy \
      -- /path/to/red-clippy mcp
    

    El nombre después de add es solo una etiqueta que muestra Claude Code. El comando después de -- es lo que realmente lanza, así que usa la ruta completa del binario: Claude Code no encontrará necesariamente red-clippy en su PATH. Si copias el comando desde Conectar MCP en el panel, la ruta correcta ya está completada.

    z.ai GLM

    z.ai sirve un endpoint compatible con Anthropic, por lo que Claude Code puede impulsar Red Clippy con GLM en lugar de un modelo de Anthropic.

    Agrega esto a la configuración de Claude Code: .claude/settings.local.json dentro de tu carpeta de trabajo para limitarlo a un compromiso, o ~/.claude/settings.json para aplicarlo en todas partes.

    root@kitploit:~
    {
      "env": {
        "ANTHROPIC_BASE_URL": "https://api.z.ai/api/anthropic",
        "ANTHROPIC_AUTH_TOKEN": "your-z-ai-api-key",
        "ANTHROPIC_API_KEY": "",
        "API_TIMEOUT_MS": "3000000",
        "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5.3",
        "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-5.3",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-5.3",
        "ANTHROPIC_SMALL_FAST_MODEL": "glm-5.3",
        "CLAUDE_CODE_SUBAGENT_MODEL": "glm-5.3"
      }
    }
    

    Dos cosas para sustituir:

    • your-z-ai-api-key con tu propia clave. Prefiere el .claude/settings.local.json local al proyecto, que Claude Code mantiene fuera de git, para que la clave no termine confirmada.
    • glm-5.3 con el modelo que z.ai ofrezca actualmente. Los nombres de los modelos cambian, así que consulta la guía de Claude Code de z.ai para el actual y establece cada entrada con él.

    Luego agrega el servidor MCP exactamente como arriba. Red Clippy no se ve afectado por la elección del modelo: MCP se ejecuta del lado del cliente, por lo que las herramientas se comportan de manera idéntica sea cual sea el modelo detrás del agente.

    OpenAI Codex CLI

    Según la configuración de Codex CLI, en ~/.codex/config.toml:

    root@kitploit:~
    [mcp_servers.red-clippy]
    command = "/path/to/red-clippy"
    args = ["mcp"]
    env = { RED_CLIPPY_URL = "http://127.0.0.1:7337", RED_CLIPPY_API_KEY = "rcl_xxxx_yyyy" }
    

    Cualquier otro cliente MCP

    red-clippy mcp es un servidor stdio JSON-RPC 2.0 simple. Necesita dos cosas en su entorno y acepta un anclaje de compromiso opcional:

    root@kitploit:~
    RED_CLIPPY_URL=http://127.0.0.1:7337 \
    RED_CLIPPY_API_KEY=rcl_xxxx_yyyy \
    /path/to/red-clippy mcp --pentest PT-2026-Q2-ACME
    

    --pentest vincula la sesión a un compromiso para que el agente no tenga que nombrarlo en cada llamada. Ejecuta una entrada MCP por compromiso activo y cambia de compromiso cambiando de servidor.

    Una vez conectado, puedes simplemente pedir: "agrega un hallazgo a PT-2026-Q2-ACME: XSS reflejado en /search, severidad alta, aquí está el PoC".

    [!NOTE] Tu agente y red-clippy serve se ejecutan en la misma máquina, por eso RED_CLIPPY_URL apunta a 127.0.0.1.


    Características

    Una superficie de herramientas MCP completa. Paridad casi total con la interfaz web, no un subconjunto simbólico. Un agente puede crear y delimitar activos, adjuntar observaciones, marcar verificaciones de metodología, archivar y actualizar hallazgos, subir evidencia, construir bordes de grafo y buscar en toda la organización.

    Un alcance que se mantiene limpio. Los activos son las unidades que realmente pruebas: dominios, hosts, URLs, APIs, paquetes móviles, rangos de IP. Cada uno lleva su propia lista de verificación, marcado de alcanzabilidad y bandera de dentro/fuera de alcance. El ruido de reconocimiento (rutas descubiertas, huellas tecnológicas, certificados, URLs de wayback) se adjunta a un activo como una observación en lugar de entrar en la lista de alcance, y se promueve a activo solo cuando lo amerita. Sin esa división, una sola ejecución de descubrimiento de contenido deja la lista de activos inutilizable.

    Hallazgos hasta el informe. Severidad, CVSS 3.1 con una calculadora integrada en el formulario, CWE/CVE, PoC, remediación y evidencia de archivos. Un panel entre compromisos lista cada hallazgo en la organización contra su pentest de origen, que es la vista que un retest necesita.

    Cobertura que puedes consultar. 135 verificaciones integradas mapeadas a OWASP WSTG, más verificaciones de reconocimiento, red, nube y OSINT. Los resúmenes informan qué se ha probado por activo y por compromiso, para que el terreno despejado no se vuelva a probar.

    El espacio de trabajo de metodología para un activo: verificaciones agrupadas por categoría a la izquierda, la verificación seleccionada con sus referencias, estado y caja de evidencia a la derecha

    Doctrina operativa. El documento de Instrucciones de Red Team, servido mediante MCP y resuelto por compromiso, luego por organización y luego con el valor predeterminado integrado.

    Ingesta de salida de herramientas. La salida cruda del escáner se envía en una sola llamada, que es como un agente mueve los resultados fuera de su propio shell y hacia el registro. Analizadores para nmap, burp, nessus, openvas, masscan, naabu y subfinder, con detección automática de formato. Hallazgos, reconocimiento y salida cruda aterrizan juntos en una sola transacción.

    Un grafo de ataque. Vincula dos nodos cualesquiera con una relación de forma libre, luego recorre vecinos o calcula las rutas de ataque más cortas entre ellos.

    Multiinquilino. Cada registro pertenece a una organización. Un usuario puede pertenecer a muchas y cambiar sin cerrar sesión, para que los datos del cliente permanezcan separados.

    API REST. Claves bearer con alcance de organización, misma superficie que todo lo anterior.

    Opcional: un ejecutor de escaneos integrado. Una conveniencia para impulsar subfinder, nmap, masscan y naabu desde la página de Escaneo, con cobertura reanudable por objetivo. Existe para uso manual del operador y no forma parte del flujo normal impulsado por agente, donde el agente ejecuta sus propias herramientas e ingiere la salida.

    La documentación cubre todo esto pantalla por pantalla, con la referencia de herramientas MCP, la API REST y el modelo de datos. Este README cubre la puesta en marcha.


    Configuración

    La configuración proviene de un archivo TOML. red-clippy serve lee ./red-clippy.toml por defecto. Copia el ejemplo y edítalo:

    root@kitploit:~
    cp red-clippy.toml.example red-clippy.toml
    
    root@kitploit:~
    bind             = "127.0.0.1:7337"
    database_url     = "sqlite://red-clippy.db?mode=rwc"
    storage_root     = "./red-clippy-storage"   # la evidencia subida vive aquí
    max_upload_bytes = 26_214_400               # 25 MiB
    

    Cada campo también se puede establecer mediante bandera de CLI o variable de entorno. La precedencia es bandera de CLI > variable de entorno > TOML > valor predeterminado integrado, por campo.

    ConfiguraciónBandera de CLIVariable de entorno
    bind--bindRED_CLIPPY_BIND
    database_url--database-urlRED_CLIPPY_DATABASE_URL
    storage_root--storage-rootRED_CLIPPY_STORAGE_ROOT
    max_upload_bytes--max-upload-bytesRED_CLIPPY_MAX_UPLOAD_BYTES
    frontend_dist--
    local_open--
    ruta del archivo de configuración-c, --configRED_CLIPPY_CONFIG

    Dos configuraciones son solo de archivo:

    • frontend_dist anula la SPA compilada. Los binarios de lanzamiento la incrustan, por lo que normalmente no está establecida; apúntala a un directorio para servir un bundle parcheado sin recompilar.
    • local_open permite que el botón "revelar en el administrador de archivos" de la página de Archivos ejecute xdg-open / open / explorer.exe en la máquina que ejecuta el servidor. Viene desactivada. Actívala solo cuando el servidor sea tu propio escritorio en una sesión gráfica con sesión iniciada, nunca bajo systemd ni al servir de forma remota.

    Una clave que no reconoce detiene el inicio con un error en lugar de ser ignorada, para que un error tipográfico no te deje silenciosamente en un valor predeterminado.

    El filtrado de registros usa RUST_LOG (predeterminado info,sqlx=warn).

    Ejecuta red-clippy serve --help para la lista completa.

    [!WARNING] Ejecútalo localmente. Red Clippy se vincula a 127.0.0.1 y está pensado para ejecutarse en tu propia máquina, junto al agente que lo impulsa. No está diseñado para ser expuesto a una red o a internet.


    Referencia de CLI

    root@kitploit:~
    red-clippy serve             Ejecuta la interfaz web y la API REST
    red-clippy mcp               Ejecuta el servidor stdio MCP
    red-clippy init-db           Aplica migraciones
    red-clippy create-org        Crea una organización
    red-clippy create-user       Crea un usuario
    red-clippy add-member        Agrega un usuario a una organización
    red-clippy reset-password    Restablecimiento de contraseña de emergencia
    red-clippy create-api-key    Emite una clave de API
    

    Agrega --help a cualquier subcomando para sus banderas.

    La API REST vive bajo /api/v1 y autentica con Authorization: Bearer rcl_<prefix>_<secret>. Las claves tienen alcance de organización, por lo que ningún endpoint toma una organización en su URL. La página Ayuda dentro de la aplicación documenta los endpoints.


    Compilación desde el código fuente

    Versión
    Rustestable (1.85+), edición 2024
    Node.js20.19+ o 22.13+ (para compilar la interfaz web)

    Linux y macOS

    root@kitploit:~
    git clone https://github.com/CSPF-Founder/red-clippy.git
    cd red-clippy
    make all
    ./target/release/red-clippy serve
    

    make all compila primero la interfaz web y luego compila el binario con ese bundle incrustado.

    [!NOTE] Orden de compilación. El bundle de React se incrusta en tiempo de compilación. Ejecutar cargo build --release por sí solo funciona, pero si la interfaz nunca se ha compilado, el binario incluye una página de marcador de posición (cargo imprime una advertencia). Ejecuta make frontend primero, o simplemente usa make all.

    Windows

    Compila de forma nativa con rustup, las herramientas de compilación MSVC y Node instalados:

    root@kitploit:~
    npm --prefix frontend ci
    npm --prefix frontend run build
    cargo build --release
    .\target\release\red-clippy.exe serve
    

    O compila de forma cruzada desde Linux usando el toolchain mingw-w64 (apt install gcc-mingw-w64-x86-64):

    root@kitploit:~
    rustup target add x86_64-pc-windows-gnu
    make frontend
    cargo build --release --target x86_64-pc-windows-gnu
    # -> target/x86_64-pc-windows-gnu/release/red-clippy.exe
    

    Copia ese único .exe al host de Windows y ejecútalo. Nada más que instalar.


    Desarrollo

    root@kitploit:~
    make help              # lista cada objetivo
    make dev               # servidor de desarrollo Vite, proxya /api a un backend en ejecución
    make backend-dev       # cargo build (debug)
    make test              # suite de pruebas de Rust
    make clippy            # lint con advertencias como errores
    make install-hooks     # habilita la compuerta de clippy pre-commit (una vez por clon)
    

    Las compilaciones de depuración leen frontend/dist desde el disco en tiempo de ejecución en lugar de incrustarlo, para que puedas reconstruir la interfaz sin recompilar Rust.

    Antes de abrir una solicitud de extracción, ejecuta lo que ejecuta CI: cargo fmt --all --check, make clippy, make test, make lint y make frontend. make install-hooks conecta las compuertas de formato y lint en un hook pre-commit. Consulta CONTRIBUTING.md para la versión más completa, incluido cómo agregar un analizador.

    Publicar una versión

    Incrementa version en Cargo.toml y luego empuja una etiqueta que coincida:

    root@kitploit:~
    git tag -a v0.2.0 -m "v0.2.0"
    git push origin v0.2.0
    

    CI compila un binario Linux estático y un ejecutable de Windows, y luego publica ambos como una versión de GitHub con sumas de verificación. La etiqueta debe coincidir con la versión del crate o la compilación falla. Para ensayar sin publicar, ejecuta el flujo de trabajo Release manualmente desde la pestaña Actions: compila y sube los archivos como artefactos del flujo de trabajo y omite el paso de publicación.


    Contribuciones

    Informes de errores, analizadores para nuevas herramientas y cobertura MCP son bienvenidos; consulta CONTRIBUTING.md.

    ¿Encontraste un problema de seguridad? Infórmalo de forma privada mediante SECURITY.md en lugar de abrir un issue.


    Licencia

    Copyright (C) 2026 Cyber Security & Privacy Foundation

    Publicado bajo la GNU General Public License v3.0. Este programa viene con ABSOLUTAMENTE SIN GARANTÍA; consulta la licencia para más detalles.

    Descargar herramienta