Desenmascara lo oculto antes de que el mundo lo haga

Un marco de IA autónomo que encadena reconocimiento, explotación y post-explotación en un solo pipeline, y luego va más allá triando cada hallazgo, implementando correcciones de código y abriendo pull requests en tu repositorio. Desde el primer paquete hasta el parche fusionado, con supervisión humana en cada paso crítico.

AVISO LEGAL: Esta herramienta está destinada únicamente para pruebas de seguridad autorizadas, fines educativos e investigación. Nunca uses este sistema para escanear, sondear o atacar ningún sistema que no poseas o para el cual no tengas permiso explícito por escrito. El acceso no autorizado es ilegal y punible por ley. Al usar esta herramienta, aceptas la responsabilidad total de tus acciones. Leer el aviso completo

Tres agentes de IA realizan pruebas en paralelo: uno valida políticas de credenciales mediante Hydra, uno verifica una ruta de explotación de CVE a través de escalada de privilegios, uno mapea vulnerabilidades XSS en el frontend.

Pipeline de Reconocimiento Paralelo con Múltiples Herramientas Dinámico

RedAmon lanza múltiples herramientas de reconocimiento en paralelo, cada una alimentando los resultados a un grafo de conocimiento compartido en tiempo real. Las herramientas se inician, adaptan su alcance en función de los descubrimientos en vivo y se coordinan sin intervención manual. Toda la superficie de ataque — subdominios, puertos, endpoints, parámetros — se materializa en minutos, no en horas.

Reconocimiento como un Grafo de Conocimiento Vivo

Escáneres de estándar de la industria encadenados para que la salida de cada herramienta alimente la siguiente, luego fusionados en un único grafo de conocimiento Neo4j. Los hallazgos se deduplican, las relaciones son explícitas y el agente hereda una superficie de ataque estructurada y completamente conectada lista para consultar en lenguaje natural.

Ataque se encuentra con defensa. Un pipeline, visibilidad completa.

Reconocimiento ➜ Explotación ➜ Post-Explotación ➜ Triaje IA ➜ Agente CodeFix ➜ PR de GitHub

RedAmon no se detiene al encontrar vulnerabilidades, las corrige. El pipeline comienza con un motor de reconocimiento en 6 fases que mapea toda la superficie de ataque de tu objetivo, luego pasa el control a un agente autónomo de IA que valida la explotabilidad de CVEs, prueba políticas de credenciales y mapea rutas de movimiento lateral. Cada hallazgo se registra en un grafo de conocimiento Neo4j. Al finalizar la fase ofensiva, CypherFix toma el control: un agente de triaje de IA correlaciona cientos de hallazgos, los deduplica y los clasifica por explotabilidad. Luego, un agente de CodeFix clona tu repositorio, navega por el código con 11 herramientas conscientes del código, implementa correcciones específicas y abre un pull request en GitHub, listo para revisión y fusión.

Hoja de Ruta y Contribuciones de la Comunidad

Mantenemos un Tablero de Proyecto público con las próximas funciones abiertas a contribuciones de la comunidad. ¡Elige una tarea y envía un PR!

¿Quieres contribuir? Consulta CONTRIBUTING.md para saber cómo empezar.

Mantenedores

Samuele Giampieri: Creador, Mantenedor y Arquitecto de Plataforma IA Arquitecto de Plataforma IA y Líder Full-Stack con más de 15 años de experiencia como freelancer y más de 30 proyectos puestos en producción, incluyendo sistemas agénticos de IA a escala empresarial. Certificado en AWS (DevOps Engineer, ML Specialty) e Ingeniero de IA certificado por IBM. Diseña soluciones de ML de extremo a extremo que abarcan aprendizaje profundo, PNL, visión por computadora y sistemas de agentes de IA con LangChain/LangGraph. LinkedIn · GitHub · Devergo Labs

Ritesh Gohil: Mantenedor e Investigador Principal de Seguridad Ingeniero de Ciberseguridad en Workday con más de 7 años de experiencia en pruebas de penetración web, API, móvil, redes y nube. Publicó 11 CVE en MITRE, con reconocimientos de seguridad de Google (4×) y Apple (6×). Aseguró más de 200 aplicaciones web y móviles y contribuyó a Exploit Database, Google Hacking Database y la comunidad de AWS. Posee certificaciones AWS Security Specialty, eWPTXv2, eCPPTv2, CRTP y CEH, con experiencia en red teaming, seguridad en la nube, investigación de CVE y revisión de arquitectura de seguridad. LinkedIn · GitHub

Inicio Rápido

Requisitos Previos

• Docker y Docker Compose v2+
  • macOS: Docker Desktop, con la memoria asignada a al menos 4 GB (8 GB con --gvm) en Ajustes → Recursos. Clona dentro de ~/ para que la ruta esté dentro de la lista de intercambio de archivos predeterminada.
  • Windows: Docker Desktop con el backend WSL2, ejecuta desde el sistema de archivos de WSL2 (~/), no desde /mnt/c/.

Eso es todo. No necesitas Node.js, Python ni herramientas de seguridad en tu host.

Requisitos Mínimos del Sistema

Sin OpenVAS ejecuta 7 contenedores: webapp, postgres, neo4j, agent, kali-sandbox, recon-orchestrator y docker-broker (un proxy de socket Docker de filtrado por el que pasan los contenedores de escaneo generados por el orquestador de reconocimiento, de modo que solo pueden lanzar las imágenes de herramientas conocidas). Con OpenVAS añade 4 contenedores en tiempo de ejecución más (gvmd, ospd-openvas, gvm-postgres, gvm-redis) además de ~8 contenedores de inicialización de datos únicos para las fuentes de vulnerabilidades (~170K+ NVT). El primer lanzamiento tarda ~30 minutos en la sincronización de datos de GVM. Los contenedores de reconocimiento y escaneo dinámicos se generan bajo demanda durante las operaciones y requieren recursos adicionales.

Dimensionamiento de disco para un despliegue real. Las cifras anteriores son mínimos absolutos para construir y ejecutar la pila (huella fija de la plataforma: ~70 GB sin OpenVAS, ~95 GB con OpenVAS - medida por el tamaño real de la imagen en disco después de deduplicar las capas base compartidas de Kali). Para un servidor siempre encendido que ejecute compromisos reales, añade ~100 GB de espacio libre para datos operativos - el grafo de ataque Neo4j, artefactos/salidas de escaneo, Postgres y los registros de contenedores crecen con el uso. Eso significa 200 GB sin OpenVAS, 250 GB con OpenVAS, cada uno dejando más de 100 GB libres para operaciones. Consulta la guía de despliegue para el desglose completo.

1. Clonar e Instalar```bash

git clone https://github.com/samugit83/redamon.git cd redamon

Without GVM (lighter, faster startup):

./redamon.sh install

With GVM / OpenVAS (full stack, ~30 min first run):

./redamon.sh install --gvm

El script construye todas las imágenes e inicia los servicios.

### 2. Crear cuenta de administrador

Al final de la instalación (y en cada `./redamon.sh up` o `./redamon.sh update` si no existe un administrador), se le solicitará en la terminal:```
[WARN] No admin user found. Let's create one.

  Admin name: Your Name
  Admin email: [email protected]
  Admin password: ********
  Confirm password: ********

• Nombre del administrador -- nombre visible en la interfaz (p.ej. Admin, tu nombre, lo que quieras).
• Correo electrónico del administrador -- usado para iniciar sesión en http://localhost:3000/login.
• Contraseña del administrador -- mínimo 12 caracteres.

Después de la creación, abre http://localhost:3000 e inicia sesión con el correo electrónico y la contraseña que acabas de configurar.

¿No apareció el aviso? En un primer arranque pesado (especialmente --gvm, o una VM pequeña) la aplicación web puede tardar un poco en iniciarse, por lo que el aviso automático puede omitirse. Crea el administrador en cualquier momento con:

root@kitploit:~

./redamon.sh create-admin

Espera a que la aplicación web esté lista, luego solicita los mismos detalles. Es seguro volver a ejecutarlo: reutilizar el correo electrónico de un administrador existente restablece esa contraseña, un nuevo correo electrónico agrega otro administrador.

Qué puede hacer el administrador:

• Cambiar entre todos los usuarios mediante el menú desplegable de usuario en el encabezado (incluyendo usuarios sin contraseña).
• Crear nuevos usuarios (con o sin contraseña) y asignarles roles de admin o standard.
• Establecer o cambiar la contraseña de cualquier usuario.
• Eliminar usuarios (excepto a sí mismo).
• Acceder a la página de gestión de Usuarios desde la navegación del encabezado.

Usuarios estándar solo pueden iniciar sesión (si tienen una contraseña establecida por un administrador), cambiar su propia contraseña y usar la aplicación dentro de su propio ámbito. No pueden cambiar de usuario, crear usuarios ni acceder a la gestión de usuarios.

Si olvidas la contraseña del administrador, restablécela desde la terminal:```bash ./redamon.sh reset-password # reset an EXISTING user's password ./redamon.sh create-admin # create the first admin, or reset an admin by re-entering its email

Use `create-admin` cuando aún no exista un administrador (se inserta o actualiza según el correo electrónico); `reset-password` solo actualiza un usuario que ya existe.

### 3. Configurar

Abra **http://localhost:3000/settings** (icono de engranaje en el encabezado) para configurar todo. No se necesita un archivo `.env`.

- **Proveedores de LLM** -- agregue claves API para OpenAI, Anthropic, OpenRouter, AWS Bedrock o cualquier endpoint compatible con OpenAI (Ollama, vLLM, Groq, etc.). Cada proveedor se puede probar antes de guardar. El selector de modelos en la configuración del proyecto **obtiene dinámicamente** los modelos disponibles de los proveedores configurados.
- **Claves API** -- Tavily, Shodan, SerpAPI, NVD, Vulners, URLScan y claves de inteligencia de amenazas (Censys, FOFA, OTX, Netlas, VirusTotal, ZoomEye, CriminalIP) para habilitar capacidades extendidas del agente (búsqueda web, OSINT, consultas de CVE, inteligencia pasiva de amenazas). Las claves **Uncover multi-engine search** (Quake, Hunter, PublicWWW, HunterHow, Google, Onyphe, Driftnet) amplían el descubrimiento de objetivos en 13 motores de búsqueda; las claves compartidas (Shodan, Censys, FOFA, etc.) se reutilizan automáticamente. Admite **rotación de claves** -- configure múltiples claves por herramienta con rotación automática round-robin para evitar límites de tasa.
- **Túneles** -- configure ngrok o chisel para túneles de shell inversa. Los cambios se aplican inmediatamente sin reiniciar contenedores.

Todos los ajustes se almacenan por usuario en la base de datos. Consulte la página de la wiki **[AI Model Providers](https://github.com/samugit83/redamon/wiki/AI-Model-Providers)** para obtener instrucciones detalladas de configuración.

### 4. Abrir la aplicación web

Vaya a **http://localhost:3000** -- cree un proyecto, configure su objetivo y comience a escanear.

> Para obtener un recorrido detallado de cada función, consulte la **[Wiki](https://github.com/samugit83/redamon/wiki)**.
>
> ¿Tiene problemas? Consulte la guía de **[Solución de problemas](https://github.com/samugit83/redamon/blob/master/readmes/TROUBLESHOOTING.md)** o la página **[Wiki de solución de problemas](https://github.com/samugit83/redamon/wiki/Troubleshooting)**.

### Comandos de gestión

Toda la gestión del ciclo de vida se maneja con un solo script:

| Comando | Descripción |
|---------|-------------|
| `./redamon.sh install` | Compilar + iniciar ligero (sin GVM, sin Base de conocimiento, solo búsqueda web Tavily) |
| `./redamon.sh install --kbase` | Compilar + iniciar con la Base de conocimiento local (~4.4 GB más pesado) |
| `./redamon.sh install --gvm` | Compilar + iniciar con GVM/OpenVAS |

> Las banderas se pueden combinar: `./redamon.sh install --gvm --kbase`

| Comando | Descripción |
|---------|-------------|
| **`./redamon.sh update`** | **Obtener la última versión, reconstruir inteligentemente solo los servicios cambiados (conserva su elección de GVM/KB al momento de la instalación)** |
| `./redamon.sh up` | Iniciar servicios (detecta automáticamente el modo GVM y KB desde la instalación) |
| `./redamon.sh up dev` | Iniciar en modo de desarrollo con recarga en caliente (detecta automáticamente el modo GVM y KB) |
| `./redamon.sh down` | Detener servicios (conserva datos) |
| `./redamon.sh status` | Mostrar servicios en ejecución, versión, modo GVM, estado de KB |
| `./redamon.sh clean` | Eliminar contenedores + imágenes, conservar datos |
| `./redamon.sh create-admin` | Crear el inicio de sesión de administrador (o restablecerlo) -- úselo si no apareció un mensaje en la instalación |
| `./redamon.sh reset-password` | Restablecer la contraseña de un usuario existente desde la terminal |
| `./redamon.sh purge` | Eliminar todo, incluidos todos los datos |

### Actualizar a una nueva versión

Simplemente ejecute:```bash
./redamon.sh update

The script pulls the latest code from GitHub, detects which Dockerfiles and source files changed, rebuilds only the affected images, and restarts the updated services. Your databases, scan results, and reports are preserved -- volumes are never deleted.

Nota única cuando una versión añade un nuevo servicio en segundo plano. update re-ejecuta el script recién obtenido para que las nuevas reglas de construcción/inicio se apliquen automáticamente -- pero solo para la versión del script desde la que estás actualizando. Al actualizar desde una versión anterior a esta auto-reparación (es decir, tu primera actualización que la incluya), ejecuta ./redamon.sh up una vez justo después de update para que cualquier nuevo servicio central añadido se inicie:

root@kitploit:~

./redamon.sh update && ./redamon.sh up

up es idempotente -- inicia solo lo que falta y deja los contenedores en ejecución intactos. Después de este paso único, un simple ./redamon.sh update se encarga de todo por sí mismo.

La aplicación web también verifica automáticamente si hay actualizaciones y muestra una notificación en la interfaz de usuario cuando hay una nueva versión disponible.

Desplegar en un Servidor (Producción)

El inicio rápido anterior ejecuta RedAmon localmente en localhost. Para ejecutar una instancia compartida y accesible desde internet en un servidor Linux (EC2, DigitalOcean, Hetzner, o hardware físico), utiliza el despliegue de un solo host en deploy/single-host/. Este controla redamon.sh a través de SSH desde tu portátil y envuelve el stack en la capa de seguridad orientada a internet que RedAmon omite por defecto: nginx + TLS (Let's Encrypt), un cortafuegos de host, endurecimiento de SSH y fail2ban, con un único origen HTTPS público para que solo la página de inicio de sesión sea accesible y todo lo demás permanezca vinculado a loopback.```bash cd deploy/single-host cp .env.example .env # set HOST_IP, DOMAIN, SSH_KEY_PATH, OPERATOR_ALLOW_CIDRS, # LETSENCRYPT_EMAIL, ADMIN_* ... ./deploy.sh init # first build takes 30-60 min, then log in at https:///

Tutorial completo: [Wiki: Desplegando en un Servidor](https://github.com/samugit83/redamon/wiki/Deploying-to-a-Server). Referencia completa: [deploy/single-host/README.md](https://github.com/samugit83/redamon/blob/master/deploy/single-host/README.md).

### Modo de Desarrollo

Para contribuyentes y desarrollo activo con **Next.js fast refresh**:```bash
./redamon.sh up dev           # auto-detects GVM mode from install

Las imágenes de herramientas se construyen automáticamente en la primera ejecución si aún no existen. La anulación de desarrollo intercambia la imagen de producción de webapp por un contenedor de desarrollo con el código fuente montado como volumen. Cada guardado de archivo provoca una recarga instantánea en el navegador.

Cuándo reconstruir vs reiniciar

Reconstruir un solo servicio:```bash docker compose build # Rebuild one image docker compose up -d --no-deps # Restart only that service

**Comandos comunes de desarrollo:**```bash
docker compose ps                                 # Check service status
docker compose logs -f <service>                  # Follow logs for a service
docker compose down                               # Stop all (preserves volumes)
docker compose --profile tools down --rmi local   # Remove built images
docker compose --profile tools down --rmi local --volumes --remove-orphans  # Full cleanup

Recuperar espacio en disco:```bash docker system df # Show Docker disk usage (add -v for per-image breakdown) docker image prune -f # Remove dangling images (auto-run by ./redamon.sh update) docker builder prune -f # Clear build cache (NOT auto-cleaned, can grow to many GB over time) docker container prune -f # Remove stopped containers

> Para una referencia completa de desarrollo — reglas de recarga en caliente, comandos comunes, reglas importantes y pautas de codificación asistida por IA — consulte la **[Guía de Desarrollador](https://github.com/samugit83/redamon/blob/master/readmes/README.DEV.md)**.

---

### Base de Conocimiento (Búsqueda Web Mejorada con RAG)

La herramienta `web_search` del agente incluye una **Base de Conocimiento** local — un pipeline RAG que busca en conjuntos de datos de seguridad curados (GTFOBins, LOLBAS, OWASP WSTG, NVD CVEs, ExploitDB, plantillas de Nuclei y documentos de habilidades del agente) antes de recurrir a la búsqueda web de Tavily. Cuando la KB devuelve una coincidencia de alta confianza, se omite Tavily por completo para obtener resultados más rápidos y que funcionan sin conexión.

**Cómo funciona:** Cuando la KB está habilitada, `install` / `up` / `update` construye un índice KB ligero (~1200 fragmentos en 10-15 minutos en CPU). En el momento de la consulta, el agente ejecuta un pipeline de recuperación híbrido (búsqueda vectorial FAISS + texto completo Neo4j), reordena con un cross-encoder y verifica un umbral de confianza. Si la puntuación es lo suficientemente alta, los resultados provienen de la KB local. De lo contrario, recurre a Tavily o combina ambos.

**Comportamiento predeterminado:** La KB es **opt-in**. `./redamon.sh install` produce una instalación ligera (~4,4 GB más ligera, búsqueda web solo con Tavily). Para habilitar la KB local, pase `--kbase`:```bash
./redamon.sh install --kbase

En la primera instalación con --kbase, RedAmon detecta tu hardware (GPU / CPU / API) y ofrece un perfil de inicio rápido. La elección se guarda, por lo que los comandos update / up posteriores la respetan sin necesidad de volver a pasar la bandera.

Acelera la ingesta con embeddings de API: Por defecto, los embeddings se ejecutan localmente en CPU/GPU. En máquinas solo con CPU, conjuntos de datos grandes (ExploitDB, NVD) pueden tardar horas. Puedes delegar los embeddings a una API externa creando un archivo .env a partir de la plantilla:```bash cp .env.example .env

Luego configura la API de embeddings en `.env`:

| Variable | Por defecto | Descripción |
|----------|-------------|-------------|
| `KB_EMBEDDING_USE_API` | `false` | Establécelo en `true` para usar embeddings basados en API en lugar del modelo local |
| `KB_EMBEDDING_API_BASE_URL` | *(vacío = OpenAI)* | Cualquier endpoint compatible con OpenAI (Ollama, vLLM, LiteLLM, Together AI, Azure) |
| `KB_EMBEDDING_API_KEY` | *(vacío)* | Clave API para el proveedor de embeddings |
| `KB_EMBEDDING_API_MODEL` | `text-embedding-3-small` | Nombre del modelo (específico del proveedor) |
| `NVD_API_KEY` | *(vacío)* | Clave API gratuita de NVD para ingesta de CVE 10x más rápida |

Ejemplo con Ollama (gratuito, local, sin costo de clave API):```bash
KB_EMBEDDING_USE_API=true
KB_EMBEDDING_API_BASE_URL=http://host.docker.internal:11434/v1
KB_EMBEDDING_API_KEY=ollama
KB_EMBEDDING_API_MODEL=nomic-embed-text

Importante: La ingesta y la consulta deben usar el mismo modelo. Si cambias de modelo, reconstruye el índice: make -C knowledge_base kb-rebuild-lite MODE=docker

Gestionar la base de conocimiento:```bash ./redamon.sh kb build lite # Build with lite profile (~30-60s with API) ./redamon.sh kb build standard # Add NVD CVEs ./redamon.sh kb update nvd # Incremental NVD refresh ./redamon.sh kb stats # Show index statistics ./redamon.sh kb rebuild lite # Wipe and rebuild from scratch

> Para obtener la documentación técnica completa —canalización de consultas, fuentes de datos, perfiles de ingesta, puntuación, modelo de seguridad— consulte la **[Referencia técnica de la base de conocimiento](https://github.com/samugit83/redamon/blob/master/readmes/README.KBASE.md)** o el **[Wiki: Base de conocimiento y búsqueda web](https://github.com/samugit83/redamon/wiki/Knowledge-Base-Web-Search)**.

---

## Tabla de contenido

- [Documentación completa del Wiki](https://github.com/samugit83/redamon/wiki)
- [Descripción general](#overview)
- [Diseñado para empresas, seguro por diseño](#built-for-enterprise-secure-by-design)
- [Modelo de seguridad y amenazas](#security--threat-model)
- [Destacados de funciones](#feature-highlights)
- [Arquitectura del sistema](#system-architecture)
- [Componentes](#components)
- [Documentación](#documentation)
- [Solución de problemas](#troubleshooting)
- [RedAmon HackLab](#redamon-hacklab)
- [Demostraciones comunitarias](#community-showcase)
- [Aspectos legales](#legal)

---

## Descripción general

RedAmon es un framework de pruebas de penetración modular y contenerizado que encadena reconocimiento automatizado, explotación impulsada por IA e inteligencia basada en grafos en una única canalización de seguridad ofensiva de extremo a extremo. Cada componente se ejecuta dentro de Docker (sin herramientas instaladas en su host) y se comunica a través de API bien definidas para que cada capa pueda evolucionar de forma independiente.

La plataforma se basa en seis pilares:

| Pilar | Qué hace |
|-------|----------|
| **Canalización de reconocimiento** | Una canalización de escaneo **fan-out / fan-in paralelizada** que mapea toda la superficie de ataque del objetivo (comenzando desde un dominio **o direcciones IP / rangos CIDR**) desde el descubrimiento de subdominios (5 herramientas concurrentes) hasta el escaneo de puertos, detección de servicios de Nmap y scripts de vulnerabilidad NSE, sondas HTTP, enumeración de recursos y detección de vulnerabilidades. Los módulos independientes se ejecutan concurrentemente a través de `ThreadPoolExecutor`, las actualizaciones de la base de datos de grafos ocurren en un hilo en segundo plano, y los resultados se almacenan como un grafo enriquecido y consultable. Complementado por módulos independientes de escaneo de red GVM, búsqueda de secretos en GitHub y escaneo profundo de secretos TruffleHog. |
| **Orquestador de agente de IA** | Un agente autónomo basado en LangGraph que razona sobre el grafo, selecciona herramientas de seguridad a través de MCP, transita por fases de información / explotación / post-explotación, y puede ser dirigido en tiempo real mediante chat. |
| **Grafo de superficie de ataque** | Un grafo de conocimiento Neo4j con 17 tipos de nodos y más de 20 tipos de relaciones que sirve como la única fuente de verdad para cada hallazgo, y la fuente de datos principal que el agente de IA consulta antes de cada decisión. |
| **EvoGraph** | Un grafo de cadena de ataque persistente y evolutivo en Neo4j que rastrea cada paso, hallazgo, decisión y fallo a lo largo del ciclo de vida del ataque, conectando el grafo de reconocimiento y permitiendo la acumulación de inteligencia entre sesiones. |
| **CypherFix** | Canalización automatizada de remediación de vulnerabilidades: un agente de triaje de IA correlaciona y prioriza los hallazgos del grafo, luego un agente CodeFix clona el repositorio objetivo, implementa correcciones utilizando un bucle ReAct con 11 herramientas de código, y abre una solicitud de extracción de GitHub. |
| **Motor de configuración de proyectos** | Más de 500 parámetros por proyecto (expuestos a través de la interfaz web) que controlan el comportamiento de cada herramienta, desde conteos de hilos de Naabu hasta filtros de gravedad de Nuclei y puertas de aprobación de agentes. |

---

## Diseñado para empresas, seguro por diseño

RedAmon está diseñado para integrarse en una organización de seguridad real, no solo en el portátil de un investigador.

- **Seguro por diseño, modelado de amenazas STRIDE.** Toda la plataforma se evalúa de extremo a extremo bajo STRIDE y se endurece en oleadas verificadas de forma independiente: separación de privilegios a nivel de código, un broker Docker de filtrado frente al socket del host, autenticación con cierre por fallo, guardas de egreso SSRF, redacción de secretos, registros de auditoría solo de adición, y un mecanismo de protección no desactivable que bloquea objetivos gubernamentales, militares e intergubernamentales. Consulte [Postura de seguridad](https://github.com/samugit83/redamon/blob/master/readmes/README.SECURITY_POSTURE.md) y [Modelo de amenazas](https://github.com/samugit83/redamon/blob/master/readmes/README.TM.SYSTEM_OVERVIEW.md).
- **Completamente aislado y contenerizado.** Cada herramienta, escáner y agente se ejecuta en su propio contenedor sin ejecución a nivel de host. Los trabajos de escaneo se generan como contenedores hermanos efímeros con su propio sistema de archivos y espacio de nombres de red, y luego se eliminan al finalizar, manteniendo el host limpio y conteniendo el radio de explosión de cualquier exploit.
- **Gobernado y multiinquilino.** Tenencia multiusuario / multiproyecto con roles de administrador y estándar, alcance a nivel de base de datos de `user_id + project_id` en cada nodo, aplicación de reglas de compromiso, puertas de aprobación humano en el bucle, y más de 500 configuraciones por proyecto brindan a los equipos el control que requiere un compromiso empresarial.

**Implementar en un servidor con un solo comando.** Más allá de `localhost` local, RedAmon incluye una [implementación de un solo host](https://github.com/samugit83/redamon/blob/master/deploy/single-host) endurecida que crea una instancia compartida accesible por Internet y envuelve la pila en nginx + TLS (Let's Encrypt), un cortafuegos del host, endurecimiento SSH y fail2ban, exponiendo un único origen HTTPS público:```bash
cd deploy/single-host
cp .env.example .env      # set DOMAIN, HOST_IP, SSH_KEY_PATH, ADMIN_* ...
./deploy.sh init          # builds the full stack and brings it up over SSH

Full walkthrough: Wiki: Deploying to a Server.

Security & Threat Model

RedAmon es software ofensivo, por lo que lo mantenemos al estándar con el que prueba a otros. Está diseñado seguro por diseño y ha sido evaluado de extremo a extremo bajo la metodología STRIDE (Suplantación, Manipulación, Repudio, Divulgación de información, Denegación de servicio, Elevación de privilegios), con hallazgos corregidos en oleadas secuenciadas y verificadas de forma independiente.

Esto no es una afirmación de marketing. Se basa en un análisis publicado y basado en evidencia que puedes leer:

• Security Posture - el catálogo completo de controles de defensa en profundidad: cada capa implementada, mapeada al código.
• Threat Model - los activos, límites de confianza, flujos de datos, puntos de entrada y superficie de red sobre los que se construyó el análisis.

Aspectos destacados de lo implementado:

• Separación de privilegios a nivel de código. El trabajador orientado al objetivo es el componente menos confiable y no guarda secretos; un broker de docker filtrado se interpone entre el orquestador y el socket Docker del host (lista blanca de imágenes, deniega --privileged, binds de raíz del host, capacidades peligrosas).
• Dos posturas de despliegue, un modelo de confianza. Local (backends vinculados a loopback) y un despliegue endurecido para internet público que añade nginx + TLS, una puerta de operador, limitación de velocidad de inicio de sesión y un único origen público.
• Cerrado por defecto en caso de fallo. Los tokens de autenticación no establecidos rechazan en lugar de servir, las credenciales de base de datos predeterminadas son rechazadas y rotadas, los WebSockets requieren un ticket firmado más una verificación de mismo origen del lado del servidor, y cada solicitud está limitada a su propietario autenticado (control de acceso por usuario con 404 antienumeración).
• Defensa en profundidad. Guardias de salida SSRF, redacción de secretos en registros, pistas de auditoría de solo adición, endurecimiento contra escapes de contenedores, límites de descompresión y concurrencia, y fijación de cadena de suministro (pines sha256 + commit).
• Una barrera dura no desactivable bloquea objetivos gubernamentales, militares e intergubernamentales independientemente de la configuración.
• Corrección verificada y controlada por versiones. Las correcciones se envían en oleadas secuenciadas, cada una verificada de forma independiente con reproducción de exploit en vivo antes y después del parche. Consulta las entradas de seguridad en el Changelog.

¿Encontraste una vulnerabilidad? Consulta nuestra Política de Seguridad para divulgación privada.

Feature Highlights

Reconnaissance Pipeline

Un mapeador de superficie de ataque externa completamente automatizado y de extremo a extremo que se ejecuta dentro de un contenedor Kali Linux. Proporciónale una entrada (un dominio raíz, una lista de subdominios o rangos IP/CIDR) y el pipeline devuelve una imagen completa y estructurada del objetivo: cada subdominio, cada host activo, cada puerto abierto, cada servicio HTTP con su pila tecnológica, cada endpoint rastreado y parámetro descubierto, cada CVE al que el objetivo probablemente sea vulnerable, además de escáneres dedicados para API GraphQL, tomas de subdominios, hosts virtuales ocultos detrás de proxies inversos, envenenamiento y engaño de caché web, y una capa de Superficie de IA Adversaria que etiqueta tiempos de ejecución de IA / bases de datos vectoriales / frontends de LLM / proxies / servidores MCP / endpoints de chat, completación, incrustación, RAG y parámetros inyectables mediante encabezados, favicons, títulos, rutas y nombres de parámetros, luego los confirma activamente con un módulo dedicado de Reconocimiento de Superficie de IA (sondas benignas en forma de chat, handshake MCP + escaneo de envenenamiento de herramientas, lecturas de BD vectoriales — sin llamadas a LLM).

Todo funciona sobre una arquitectura fan-out / fan-in: cada fase lanza tantas herramientas en paralelo como el trabajo lo permita, luego converge antes de que comience la siguiente fase. Más de 40 herramientas de la industria se integran en un flujo de trabajo coordinado, el envenenamiento de DNS con comodín se filtra automáticamente con puredns, y el modo sigiloso mantiene todo el pipeline ejecutándose solo con fuentes pasivas cuando la sonda activa está prohibida. Los hallazgos se transmiten al grafo de conocimiento Neo4j en un hilo en segundo plano para que el escaneo nunca se bloquee en escrituras de base de datos, y el JSON sin procesar se conserva para su descarga. El desglose detallado herramienta por herramienta está en la matriz a continuación.

Wiki: Ejecutar Reconocimiento | Técnico: README.RECON.md

Matriz de Herramientas del Pipeline de Reconocimiento

_{*Amass puede ejecutarse en modo activo cuando está configurado. Knockpy realiza sondas DNS activas.}

Reconocimiento Parcial

Ejecuta cualquier herramienta individual del pipeline de forma independiente sin volver a ejecutar todo el escaneo. Hasta 12 reconocimientos parciales pueden ejecutarse en paralelo por proyecto, cada uno con registros independientes, controles de detención e insignias de estado visibles tanto en la barra de herramientas del Grafo como en el encabezado de Configuración del Proyecto. Cada sección de herramienta tiene un botón de reproducción que abre un modal donde puedes revisar los datos existentes del grafo, agregar objetivos personalizados (subdominios, IPs, puertos o URLs) y lanzar la herramienta de forma aislada. Los resultados se fusionan en el grafo Neo4j mediante operaciones MERGE -- los duplicados se actualizan, no se recrean. La herramienta se ejecuta con todas las configuraciones del proyecto (tiempos de espera, listas de palabras, claves API, proxy) aplicadas automáticamente. Todas las herramientas del pipeline soportan reconocimiento parcial.

Wiki: Flujo de Trabajo del Pipeline de Reconocimiento -- Reconocimiento Parcial

IA en el Pipeline

Puntos de decisión opcionales aumentados por LLM integrados en el pipeline de reconocimiento donde las búsquedas estáticas históricamente se desvían -- Nuclei poda su lista de etiquetas para que coincida con la pila tecnológica detectada, el clasificador de WAF captura Cloudflare/AWS WAF/Imperva sin encabezados, y muchos otros a través de FFuf, filtrado de falsos positivos de Nuclei y desambiguación de toma de subdominios. Cada gancho es un respaldo en cascada después de la ruta estática con un respaldo seguro determinista, por lo que una interrupción del LLM no puede romper un escaneo. Un interruptor maestro en la pestaña Objetivo los gobierna a todos.

Wiki: IA en el Pipeline

Guantelete de IA: Pruebas Ofensivas de IA/LLM

Donde el pipeline de reconocimiento encuentra la superficie de IA, el Guantelete de IA la ataca. Selecciona los endpoints de LLM descubiertos (o escribe una URL personalizada), elige una herramienta, confirma las Reglas de Compromiso y lanza: un contenedor de corta duración ejecuta el objetivo a través de cuatro herramientas de equipo rojo de la industria -- garak (escáner amplio de un solo disparo, 40 familias de sondas), PyRIT (jailbreaks acotados de múltiples turnos), Giskard (escaneo de seguridad asistido por LLM) y promptfoo (evaluación de equipo rojo con conjuntos de datos) -- midiendo una Tasa de Éxito de Ataque por ataque y escribiendo las debilidades confirmadas de nuevo en el grafo como hallazgos de Vulnerability mapeados a OWASP-LLM / MITRE-ATLAS con transcripciones de evidencia.

Es determinista (semillas, límites fijos, versiones de herramientas fijadas) y se ejecuta con egreso externo cero: cada llamada de juez/calificador/incrustación se fuerza a un modelo Ollama local, por lo que ningún payload o transcripción sale nunca de tu máquina. Desactivado por defecto y controlado por RoE, con progreso en vivo fase por fase, y los hallazgos aparecen en la tabla Vulnerabilidades del Guantelete de IA de la Zona Roja y en el informe de pentest.

Wiki: Guantelete de IA | Técnico: AI_GAUNTLET_TECH_DOC.md

Escáner de Vulnerabilidades GVM

GVM/OpenVAS realiza una evaluación profunda de vulnerabilidades a nivel de red con más de 170,000 NVTs, sondeando servicios en la capa de protocolo en busca de configuraciones incorrectas, software obsoleto, credenciales predeterminadas y CVEs conocidos. Complementa los hallazgos de Nuclei en la capa web. Siete perfiles de escaneo preconfigurados desde descubrimiento rápido de hosts (~2 min) hasta escaneo profundo exhaustivo (~8 horas). Los hallazgos se almacenan como nodos de Vulnerabilidad en Neo4j junto al grafo de reconocimiento.

Wiki: Escaneo de Vulnerabilidades GVM | Técnico: README.GVM.md

Orquestador de Agentes de IA

Un agente autónomo basado en LangGraph que implementa el patrón ReAct. Progresa a través de tres fases: Informativa (recopilación de inteligencia, consultas al grafo, Shodan, Google dorking), Explotación (Metasploit, pruebas de credenciales Hydra, simulación de ingeniería social) y Post-Explotación (enumeración, movimiento lateral). El agente ejecuta 14 herramientas de seguridad a través de servidores MCP dentro de un sandbox Kali, soporta ejecución paralela de herramientas mediante Wave Runner, y proporciona interacción de chat en tiempo real con guía, flujos de trabajo de detener/reanudar y aprobación. El modo Deep Think permite un análisis estratégico estructurado antes de actuar.

Wiki: Guía del Agente de IA | Técnico: README.AGENTIC_SYSTEM.md

Arsenal de Herramientas del Agente| Categoría | Herramienta | Descripción | Fases | Servidor MCP |

|:-----:|-------|-------------|:------:|:----------:| | Inteligencia | query_graph | Consultas de grafos Neo4j — fuente principal de verdad para datos de reconocimiento | Todas | -- | | | web_search | Búsqueda en internet vía Tavily para detalles de CVE, PoCs de exploits, avisos | Todas | -- | | | cve_intel | vulnx de ProjectDiscovery — inteligencia estructurada de CVE que agrega NVD + CISA KEV + EPSS + HackerOne + GitHub PoCs + disponibilidad de plantillas Nuclei. 69 campos filtrables por Lucene. Clave PDCP opcional (por usuario, modo anónimo = 10 req/min) | Todas | network_recon :8000 | | | tradecraft_lookup | Catálogo curado por el usuario de URLs de conocimiento de seguridad confiables (HackTricks, PayloadsAllTheThings, repositorios de PoCs de CVE, blogs de proveedores) — 6 tipos de recursos auto-detectados, selección de sección basada en sitemap, caché sqlite+disco | Exploit, Post | -- | | | shodan | OSINT de Shodan — detalles del host, DNS inverso, búsqueda de dispositivos | Info, Exploit | -- | | | google_dork | Dorking de Google vía SerpAPI — archivos expuestos, paneles de administración, listados de directorios | Info | -- | | Reconocimiento y OSINT | execute_subfinder | Enumeración pasiva de subdominios mediante OSINT (registros CT, conjuntos de datos DNS). Sin tráfico al objetivo | Info, Exploit | network_recon :8000 | | | execute_gau | Descubrimiento pasivo de URLs desde Wayback Machine, Common Crawl, AlienVault OTX, URLScan. Sin tráfico al objetivo | Info, Exploit | network_recon :8000 | | | execute_amass | Enumeración de subdominios y mapeo de red de OWASP Amass (pasivo + activo, inteligencia ASN) | Info, Exploit | network_recon :8000 | | Escaneo | execute_naabu | Escaneo rápido de puertos y verificación | Info, Exploit | network_recon :8000 | | | execute_nmap | Detección profunda de servicios (-sV), huella digital del SO, scripts NSE | Todas | nmap :8004 | | | execute_nuclei | Verificación y explotación de CVE con más de 9000 plantillas + subidas personalizadas | Info, Exploit | nuclei :8002 | | | execute_httpx | Sondeo y huella digital HTTP — códigos de estado, títulos, cabeceras del servidor, detección de tecnologías | Info, Exploit | network_recon :8000 | | | execute_wpscan | Escáner de vulnerabilidades de WordPress — detecta plugins, temas, usuarios y configuraciones erróneas vulnerables | Info, Exploit | network_recon :8000 | | Web y HTTP | execute_curl | Peticiones HTTP — accesibilidad, cabeceras, códigos de estado, banners | Todas | network_recon :8000 | | | execute_katana | Rastreo web y descubrimiento de endpoints con análisis de JS y enumeración de archivos conocidos | Info, Exploit | network_recon :8000 | | | execute_jsluice | Análisis estático de JavaScript para endpoints ocultos de API, rutas URL y secretos | Info, Exploit | network_recon :8000 | | | execute_arjun | Descubrimiento de parámetros HTTP mediante fuerza bruta de aproximadamente 25 000 nombres de parámetros comunes | Info, Exploit | network_recon :8000 | | | execute_ffuf | Fuzzing web para directorios ocultos, archivos, hosts virtuales y parámetros | Info, Exploit | network_recon :8000 | | | execute_playwright | Automatización de navegador Chromium sin cabeza — extracción de contenido renderizado por JS y scripting interactivo para SPAs, pruebas de formularios, verificación de XSS | Todas | playwright :8005 | | Explotación | metasploit_console | msfconsole persistente — ejecución de exploits, gestión de sesiones, post-explotación | Exploit, Post | metasploit :8003 | | | msf_restart | Reinicio completo de Metasploit — mata todas las sesiones, limpia el estado del módulo | Exploit, Post | metasploit :8003 | | | execute_hydra | THC Hydra por fuerza bruta — más de 50 protocolos (SSH, FTP, RDP, SMB, HTTP, MySQL, etc.) | Exploit, Post | network_recon :8000 | | Ejecución de código | kali_shell | Shell completa de Kali Linux — nikto, whatweb, testssl, commix, sstimap, tplmap, ysoserial, phpggc, dnsrecon, dnsx, subzy, enum4linux-ng, netexec, kerbrute, bloodhound-python, bhgraph, certipy-ad, bloodyAD, jwt_tool, graphql-cop, graphqlmap, gitleaks, semgrep, hashcat, john, cewl, paramspider, Node.js + npm, librerías Python (websockets, zeep, python3-saml, boto3, msal, azure-identity, google-auth, google-cloud-storage), kits de herramientas de post-explotación preinstalados en /opt/tools/{linux,windows}/ (linpeas, LinEnum, pspy64, deepce, winPEAS, PowerUp, PrivescCheck) y más de 70 herramientas CLI | Todas | network_recon :8000 | | | execute_code | Escribir y ejecutar archivos de código (Python, bash, Ruby, Perl, C, C++) — sin escapes de shell | Exploit, Post | network_recon :8000 | | Tráfico (TrafficMind) | proxy_search | Historial al estilo Burp sobre el corpus HTTP capturado — solo resúmenes, mismos filtros que la interfaz (host, método, estado, herramienta, origen, q subcadena de URL / bodyq subcadena del cuerpo, reflejado, solo5xx) | Todas | -- (en proceso) | | | proxy_get | Petición o respuesta completa (cabeceras + cuerpo) de una transacción capturada | Todas | -- (en proceso) | | | proxy_sitemap | Endpoints distintos observados (host + ruta + método) con conteos de aciertos y códigos de estado | Todas | -- (en proceso) | | | proxy_params | Parámetros de petición distintos con valores de muestra y una heurística de inyectabilidad (id secuencial / uuid / jwt / base64) | Todas | -- (en proceso) | | | proxy_grep | Búsqueda de subcadenas sin distinción de mayúsculas/minúsculas en los cuerpos de respuesta capturados, con un fragmento alrededor de la primera coincidencia | Todas | -- (en proceso) | | | proxy_diff | Diff estructural de dos respuestas (estado, longitud, conjunto de cabeceras, diff unificado del cuerpo) para detección de SQLi ciega booleana / IDOR / bypass de autenticación | Todas | -- (en proceso) | | | proxy_to_curl | Renderizar una petición capturada como un comando curl reproducible (solo lectura, no envía nada) | Todas | -- (en proceso) | | | proxy_query | Constructor de consultas analíticas restringidas sobre columnas/agregaciones permitidas (solo especificación JSON, sin SQL sin procesar) | Todas | -- (en proceso) | | | proxy_replay | PELIGROSO — reenviar una petición capturada con campos mutados (método / ruta / consulta / parámetros / cabeceras / cookie / cuerpo); host, esquema, puerto fijados al original. Intercambio de contexto de autenticación para IDOR / BOLA / escalada de privilegios. Se recaptura como transacción isReplay | Exploit, Post | network_recon :8000 | | | proxy_fuzz | PELIGROSO — estilo Burp Intruder: reproducir una petición capturada iterando un conjunto de payloads (limitado a 50) sobre un parámetro de consulta, devuelve un resumen de estado/longitud por payload | Exploit, Post | network_recon :8000 | | Sistema de archivos del espacio de trabajo | fs_read | Leer archivo del espacio de trabajo con números de línea, detecta automáticamente binarios, almacena instantánea para fs_diff vs_last_read | Todas | -- (en proceso) | | | fs_read_many | Lectura por lotes de múltiples archivos, limitada a max_total_bytes (por defecto 200 KB) | Todas | -- (en proceso) | | | fs_stat | Solo metadatos — tamaño, mtime, modo, tipo, SHA-256 opcional | Todas | -- (en proceso) | | | fs_write | Crear/sobrescribir/añadir atómicamente, crea automáticamente los directorios padre | Todas | -- (en proceso) | | | fs_edit | Reemplazo de cadena exacta con verificación de unicidad, registra entrada de deshacer | Todas | -- (en proceso) | | | fs_multi_edit | Múltiples ediciones ordenadas en una sola llamada, transacción todo-o-nada | Todas | -- (en proceso) | | | fs_undo_edit | Revertir el último fs_edit / fs_multi_edit, pila de deshacer por archivo limitada a 20 | Todas | -- (en proceso) | | | fs_delete | Eliminar archivo o directorio (se requiere indicador recursivo para directorios) | Todas | -- (en proceso) | | | fs_move | Mover o renombrar una ruta, crea automáticamente los directorios padre de destino | Todas | -- (en proceso) | | | fs_copy | Copiar archivo o árbol de directorios, permisos normalizados para que el usuario anfitrión pueda editar | Todas | -- (en proceso) | | | fs_mkdir | Crear directorio, idempotente | Todas | -- (en proceso) | | | fs_chmod | Cambiar bits de permiso (octal 0o755 o simbólico +x) | Todas | -- (en proceso) | | | fs_symlink_create | Crear enlace simbólico, rechaza endpoints que escaparían del espacio de trabajo | Todas | -- (en proceso) | | | fs_grep | Ripgrep sobre el espacio de trabajo con expresión regular, tiempo de espera de 30 s, límite de 1000 coincidencias, funciona en registros de trabajos en curso | Todas | -- (en proceso) | | | fs_glob | Búsqueda de patrón glob ordenado del más nuevo al más antiguo, límite de 500 resultados | Todas | -- (en proceso) | | | fs_find | Búsqueda de metadatos (filtros de nombre + mtime + tamaño + tipo), tiempo de espera de caminata de 30 s, límite de 5000 resultados | Todas | -- (en proceso) | | | fs_list | Listado de un solo directorio con tipo / tamaño / mtime, límite de 200 entradas | Todas | -- (en proceso) | | | fs_tree | Árbol ASCII con profundidad limitada, omite .git, node_modules, __pycache__ | Todas | -- (en proceso) | | | fs_symbols | Esquema AST de Tree-sitter (nombres de funciones / clases / métodos + rangos de líneas), 15 lenguajes (py, js, ts, tsx, jsx, java, go, rs, rb, php, c, cpp, cs, kt, swift, scala) | Todas | -- (en proceso) | | | fs_symlink_read | Resolver enlace simbólico a su destino sin seguirlo | Todas | -- (en proceso) | | | fs_hash | Hash SHA-256 o MD5 de un archivo, transmite en fragmentos de 64 KB | Todas | -- (en proceso) | | | fs_diff | Diff unificado entre dos archivos, o entre un archivo y su última instantánea de fs_read (detecta escrituras concurrentes en fireteam) | Todas | -- (en proceso) | | | fs_extract | Extracción segura de archivos tar / zip / gz, rechaza rutas de tipo zip-slip y tar-slip | Todas | -- (en proceso) | | | fs_archive | Agrupar rutas del espacio de trabajo en tar.gz o zip para descarga con un solo clic del operador | Todas | -- (en proceso) | | Trabajos en segundo plano | job_spawn | Desvincular llamada a herramienta como tarea en segundo plano de asyncio, la salida se redirige a jobs/<id>.log en tiempo real, comprobaciones de fase / RoE al generar | Todas | -- (en proceso) | | | job_status | Consulta de estado no bloqueante — estado actual, tamaño del registro, últimas 40 líneas de salida, sobrevive al reinicio del agente mediante <id>.meta.json | Todas | -- (en proceso) | | | job_wait | Bloquear hasta N segundos hasta que el trabajo termine, devuelve la misma estructura que job_status | Todas | -- (en proceso) | | | job_cancel | Cancelar un trabajo en ejecución, el estado cambia a cancelled, no operativo en trabajos terminales | Todas | -- (en proceso) | | | job_list | Listar trabajos en segundo plano del proyecto, filtrar por active=true / false u omitir para todos | Todas | -- (en proceso) |

_{Todas las herramientas MCP se ejecutan dentro de un contenedor sandbox de Kali Linux. Sistema de archivos del espacio de trabajo y las herramientas de Trabajos en segundo plano se ejecutan dentro del proceso del contenedor del agente y operan exclusivamente sobre el espacio de trabajo por proyecto en /workspace/<projectId>/ — la validación de rutas rechaza toda técnica de traversal (inyección de project-id, escape de symlink, zip-slip, tar-slip). Consulte la página wiki del Espacio de trabajo del agente para la referencia completa. Las herramientas marcadas como peligrosas requieren confirmación manual antes de ejecutarse. El modo sigiloso restringe las herramientas activas a operaciones solo pasivas o de objetivo único. Nota: WPScan está licenciado bajo la Licencia Pública de Fuente de WPScan (no MIT). Gratuito para evaluaciones de pentesting y uso personal; el uso comercial puede requerir una licencia separada de wpscan.com.}

Complementos de herramientas MCP (extendiendo el arsenal de herramientas del agente)

Más allá de los 5 servidores MCP integrados anteriores, puede conectar cualquier servidor Model-Context-Protocol al agente como un complemento de herramienta (Shodan, GitHub, Censys, Hugging Face, mitmproxy, sus propios MCP internos) sin editar código, reconstruir contenedores ni ejecutar migraciones. Abra Configuración global → Complementos de herramientas MCP.

Dos caminos: elija una de las 39 preselecciones de Adición rápida (OSINT, inteligencia de amenazas, nube, escáneres de aplicaciones web, informes, ingeniería inversa; categorías etiquetadas en cada tarjeta), o haga clic en Agregar MCP para una configuración manual. Tres transportes compatibles: stdio, sse, streamable_http. El botón naranja Descubrir y agregar nuevas herramientas ejecuta un list_tools() en vivo contra el borrador, devuelve resultados en menos de 30 segundos e importa automáticamente cada herramienta descubierta con su nombre, descripción y un args_format derivado de JSON-Schema (tipos, enumeraciones, valores por defecto, mínimo/máximo, descripciones por propiedad). Guardar → las herramientas aparecen automáticamente en la Matriz de herramientas de cada proyecto y en el prompt del sistema del agente en aproximadamente 1 segundo. Sin reinicio del agente, sin prisma db push.

Manual completo del operador (cada campo del formulario, las 39 preselecciones, el flujo de autenticación, el flujo de descubrimiento en vivo, reglas de validación, solución de problemas y el modelo de almacenamiento/seguridad): Página wiki de Complementos de herramientas MCP.

Espacio de trabajo del agente: sistema de archivos por proyecto, trabajos en segundo plano, descarga automática

Vea la demostración: RedAmon Agent Workspace: AI Runs 4 Parallel Pentests and Writes Its Own Report (YouTube)

Cada proyecto obtiene un directorio persistente /workspace/<projectId>/ que el agente, el sandbox de Kali y usted (a través del Cajón del sistema de archivos en la Zona Roja) ven al mismo tiempo. Se crean automáticamente cuatro carpetas con un propósito específico protegidas contra cambio de nombre/eliminación: notes/ para el trabajo preliminar del agente y borradores de informes, tool-outputs/ para salidas grandes descargadas automáticamente, jobs/ para registros de trabajos en segundo plano y uploads/ para archivos que usted suelta para que el agente lea. El agente conoce la disposición en cada paso de pensamiento a través de un WORKSPACE_LAYOUT_BLOCK, y cuando usted suelta archivos en uploads/, el bloque los muestra bajo una directiva CHECK THESE NOW para que el agente los lea antes de continuar con lo que estaba haciendo.

El agente obtiene 24 herramientas del sistema de archivos (fs_read, fs_write, fs_edit, fs_multi_edit, fs_undo_edit, fs_grep, fs_glob, fs_find, fs_diff, fs_symbols, fs_archive, fs_extract y más) más 5 herramientas de trabajos en segundo plano (job_spawn, job_status, job_wait, job_cancel, job_list). Los escaneos largos como nuclei o hydra se separan como tareas asyncio y transmiten salida a jobs/<id>.log, por lo que el agente puede fs_grep en busca de aciertos en pleno vuelo sin bloquear el siguiente paso de razonamiento. Las salidas de más de 20 KB se descargan automáticamente a tool-outputs/<utc-iso>-<tool>.txt y el LLM recibe un fragmento de inicio/fin más la ruta del archivo, por lo que un volcado DOM de Playwright de 5 MB nunca descarrila la ventana de contexto. El cajón expone todo esto con navegación de migas de pan, arrastrar y soltar, vista previa en línea, propiedades SHA-256, descarga tar.gz por carpeta y una pestaña de Trabajos con insignias de estado en vivo y cancelación.

La validación de rutas rechaza toda técnica de traversal (inyección de project-id, escape de symlink, zip-slip, tar-slip, bypass de carpetas protegidas mediante normalización) y se aplica del lado del servidor. Los trabajos sobreviven al reinicio del agente mediante metadatos en disco: los trabajos en ejecución huérfanos cambian a interrupted al arrancar para que la interfaz nunca muestre una fila girando para siempre.

Manual completo del operador (cada función del cajón, las 29 herramientas del espacio de trabajo, el mapa de políticas de descarga automática, las cuatro carpetas protegidas, patrones de coordinación del fireteam mediante fs_diff vs_last_read y el modelo de seguridad de validación de rutas): Página wiki del Espacio de trabajo del agente.

Fireteam: subagentes especialistas paralelos

El modo de ejecución más potente del agente. Cuando un objetivo se descompone en ángulos de investigación independientes (superficie de autenticación, mapa de rutas, política de cabeceras; o 5 CVEs candidatos a clasificar en paralelo), el agente raíz se expande en N subagentes especialistas que trabajan concurrentemente dentro del mismo backend, cada uno ejecutando su propio bucle ReAct de múltiples pasos con una misión enfocada. Esta es la implementación de RedAmon del patrón arquitectónico Scatter-Gather ReAct (SG-ReAct): un agente raíz que decide cuándo expandirse, un fireteam acotado de especialistas que trabajan en paralelo y un paso de recolección que fusiona sus hallazgos en una única cosmovisión consolidada.

Toda garantía de seguridad que se aplica al agente raíz también se aplica a cada miembro: barreras duras, barreras blandas, control de fases, Reglas de enfrentamiento y confirmaciones de herramientas peligrosas (manejadas por miembro, en paralelo; N miembros pueden estar esperando su aprobación en sus propios paneles simultáneamente sin serialización). La recursión está prohibida (un miembro no puede desplegar un fireteam) y cada oleada tiene un límite máximo de miembros, un presupuesto de iteraciones por miembro y un tiempo de espera de reloj de pared. El resultado es paralelismo de tiempo de pared sin caos de coordinación, terminación predecible y un rastro de auditoría donde cada acción es atribuible al especialista que la produjo.

Wiki: Fireteam (especialistas paralelos) | Técnico: README.AGENTIC_SYSTEM.md

Proveedores de modelos de IA

Compatible con 5 proveedores y más de 400 modelos: OpenAI (GPT-5.2, GPT-5, GPT-4.1), Anthropic (Claude Opus 4.6, Sonnet 4.5), OpenRouter (más de 300 modelos), AWS Bedrock y cualquier endpoint compatible con OpenAI (Ollama, vLLM, LM Studio, Groq, etc.). Los modelos se obtienen dinámicamente, sin listas codificadas.

La configuración del proveedor compatible con OpenAI incluye un control de esfuerzo de razonamiento. Actívelo para enviar reasoning_effort con low, medium, high o max; déjelo desactivado para no enviar nada y usar el valor predeterminado del modelo. Actívelo solo para modelos capaces de pensar: un modelo sin capacidad de pensar rechazará un nivel y el agente lo reintentará de forma transparente sin él. Los niveles de esfuerzo disponibles dependen del modelo. Los proveedores canónicos de OpenAI y los endpoints compatibles con OpenAI no relacionados mantienen su comportamiento existente.

Wiki: Proveedores de modelos de IA

Grafo de superficie de ataque

Un grafo de conocimiento Neo4j con 17 tipos de nodo y más de 20 tipos de relación, la única fuente de verdad para la superficie de ataque del objetivo. El agente lo consulta antes de cada decisión mediante traducción de lenguaje natural a Cypher.

Wiki: Grafo de superficie de ataque | Técnico: GRAPH.SCHEMA.md

EvoGraph: Evolución de la cadena de ataque

Un grafo evolutivo persistente que rastrea todo lo que hace el agente de IA: ejecuciones de herramientas, descubrimientos, fallos y decisiones estratégicas. El contexto de cadena estructurado reemplaza los trazos de ejecución planos, mejorando la eficiencia del agente en más del 25 %. La memoria entre sesiones significa que el agente nunca comienza desde cero.

Wiki: EvoGraph | Técnico: README.AGENTIC_SYSTEM.md

Cadenas de ataque paralelas multisistema

Inicie múltiples sesiones de agente concurrentes contra el mismo proyecto. Cada sesión crea su propia AttackChain en EvoGraph. Las nuevas sesiones cargan automáticamente hallazgos y lecciones de fallos de todas las sesiones anteriores, evitando trabajo redundante.

Wiki: Guía del agente de IA

TrafficMind: Captura de tráfico HTTP

El historial de proxy integrado y con alcance de compromiso de RedAmon: un proxy intermediario sin credenciales (impulsado por mitmproxy) se sitúa entre cada herramienta ofensiva y su objetivo, registra la petición/respuesta completa de cada transacción HTTP, la etiqueta con quién la produjo (proyecto / usuario / ejecución / herramienta mediante una etiqueta de contexto HMAC firmada) y la almacena en Postgres a través de un trabajador de ingesta de solo inserción y confianza. Piense en el historial HTTP de Burp Suite, excepto que se activa con un interruptor, atribuye cada petición a su fuente y puede ser consultado por el operador y el agente de IA.

La captura está desactivada por defecto y controlada en dos niveles (un interruptor maestro global que ejecuta el proxy, más un interruptor de enrutamiento por proyecto). Ocho herramientas de reconocimiento y ocho herramientas HTTP del agente (execute_curl, execute_httpx, execute_playwright, execute_nuclei, execute_katana, execute_ffuf, execute_arjun, execute_wpscan) están enrutadas, por lo que tanto el tráfico de la canalización como el del propio agente (rastreo, fuzzing, escaneo) se captura, es buscable y reproducible. El proxy no contiene secretos, un guardia de salida SSRF con un pin de IP de rebote de DNS evita que pivote hacia la infraestructura interna, las cabeceras sensibles se redactan y las señales pasivas (parámetros reflejados, cabeceras de seguridad faltantes, problemas de banderas de cookies) se computan gratuitamente en cada respuesta. Una vista TrafficMind en la navegación superior expone el corpus como una tabla paginada, filtrable, al estilo Burp, con un cajón de detalle de petición/respuesta, exportación CSV/JSON y limpieza de cuerpo con contador de referencias.El agente trabaja el corpus a través de diez herramientas proxy_*: ocho herramientas de análisis de solo lectura (proxy_search, proxy_get, proxy_sitemap, proxy_params, proxy_grep, proxy_diff, proxy_to_curl, proxy_query) y dos herramientas activas (proxy_replay, proxy_fuzz) que reenvían o fuzzan al estilo Intruder una solicitud capturada. Las diez están estrictamente limitadas al alcance del tenant; las herramientas activas están ancladas al host de origen, marcadas como peligrosas, controladas por fase y restringidas sigilosamente.

Wiki: TrafficMind | Técnico: README.TRAFFIC.md

Reverse Shells

Vista unificada de sesiones activas: meterpreter, reverse/bind shells y listeners. Terminal integrada con un Command Whisperer que traduce inglés simple a comandos de shell.

Wiki: Reverse Shells

RedAmon Terminal

Acceso interactivo completo a shell PTY al contenedor sandbox de Kali directamente desde la página de gráficos a través de xterm.js. Acceda a todas las herramientas de pentesting preinstaladas (Metasploit, Nmap, Nuclei, Hydra, sqlmap) sin salir del navegador. Incluye tema oscuro de terminal, indicador de estado de conexión, reconexión automática con retroceso exponencial, modo pantalla completa y keepalive del lado del navegador.

Wiki: The Graph Dashboard

CypherFix: Remedación Automatizada de Vulnerabilidades

Pipeline de dos agentes: un Agente de Triage ejecuta 9 consultas Cypher fijas y luego usa un LLM para correlacionar, deduplicar y priorizar hallazgos. Un Agente CodeFix clona el repositorio objetivo, explora la base de código con 11 herramientas, implementa correcciones y abre un PR en GitHub, replicando el diseño agéntico de Claude Code. Debido a que el repositorio clonado no es de confianza, sus comandos de compilación/prueba se ejecutan en un contenedor sandbox aislado y sin secretos (no en el agente), y el token de GitHub nunca ingresa en él.

Wiki: CypherFix | Técnico: README.CYPHERFIX_AGENTS.md

Agent Skills

Un Enrutador de Intenciones impulsado por LLM clasifica las solicitudes de usuario en habilidades de agente: CVE (MSF), SQL Injection, XSS, SSRF, RCE, Path Traversal / LFI / RFI, Credential Testing, Social Engineering, Availability Testing o habilidades personalizadas definidas por el usuario cargadas como archivos Markdown. Habilidades comunitarias listas para usar se incluyen para pruebas de API, XSS, SQLi, XXE, BFLA, SSTI, IDOR / BOLA, deserialización insegura, asignación masiva, toma de subdominios y cargas de archivos inseguras: descargue el archivo .md y cárguelo a través de Global Settings > Agent Skills para activarlo para su usuario. También puede contribuir con las suyas abriendo un PR.

Wiki: Agent Skills | Community Skills

Chat Skills

Inyección de referencia bajo demanda mediante el comando /skill en el chat del agente. Las Chat Skills son documentos de referencia táctica — guías de herramientas, guías de vulnerabilidades, notas específicas de frameworks — que se inyectan en el contexto del agente exactamente cuando se necesitan. Escriba /skill ssrf para cargar experiencia en SSRF, o haga clic en el botón selector de habilidades para obtener una lista navegable. 46 habilidades de referencia se incluyen con RedAmon que cubren vulnerabilidades (JWT, OAuth/OIDC, CSRF, condiciones de carrera, lógica de negocio, contaminación de prototipos, ReDoS, bypass de 2FA, inyección LDAP/XPath, envenenamiento de caché web, CORS, inyección de encabezado de host, clickjacking, CRLF, y más), herramientas (sqlmap, nuclei, ffuf, nmap, httpx, naabu, katana, subfinder, semgrep), protocolos (GraphQL, WebSocket, SOAP/WS-Security, SAML), tecnologías (Firebase, Supabase), frameworks (Next.js, FastAPI, NestJS), Active Directory (kill chain, Kerberoasting/ASREPRoast, AD-CS ESC1-15, BloodHound path-to-DA), nube (AWS, Azure, GCP) y post-explotación (escape de Docker, escalada de privilegios en Linux / Windows). A diferencia de las Agent Skills (que impulsan clasificación y flujos de trabajo conscientes de fases), las Chat Skills son contexto suplementario que persiste hasta que se cambian o eliminan.

Wiki: Chat Skills | Community Chat Skills

GitHub Secret Hunter

Escanea repositorios de GitHub, gists e historial de confirmaciones en busca de secretos expuestos usando más de 40 patrones regex y análisis de entropía de Shannon.

Wiki: GitHub Secret Hunting

TruffleHog Deep Secret Scanner

Escanea repositorios de GitHub en busca de credenciales filtradas usando más de 700 detectores con verificación automática de si los secretos descubiertos siguen activos. Impulsado por el motor TruffleHog (trufflesecurity/trufflehog), detecta claves de API, contraseñas, tokens, certificados y más a través del historial completo de confirmaciones. Los resultados se almacenan como nodos TrufflehogScan → TrufflehogRepository → TrufflehogFinding en el grafo de Neo4j. Tanto GitHub Hunt como TruffleHog son accesibles desde el modal "Other Scans" en la barra de herramientas del grafo.

Project Settings

Más de 500 parámetros configurables en 16 pestañas que controlan el comportamiento de cada herramienta, desde módulos de escaneo hasta compuertas de aprobación de agente. Gestionados a través de la interfaz de la aplicación web.

Wiki: Project Settings Reference

Reglas de Compromiso (RoE)

Cargue un documento de RoE (PDF, TXT, MD, DOCX) para configurar automáticamente los ajustes del proyecto y hacer cumplir las restricciones del compromiso. Aplicación tanto en el pipeline de reconocimiento (hosts excluidos, límites de velocidad, ventanas de tiempo) como en el agente de IA (inyección de prompts, límite de fase de severidad, restricciones de herramientas).

Wiki: Rules of Engagement

Insights Dashboard

Más de 30 gráficos interactivos en 4 secciones: cadenas de ataque y exploits, superficie de ataque, vulnerabilidades e inteligencia de CVE, y vista general del grafo. Todos los datos obtenidos en vivo desde Neo4j y PostgreSQL.

Wiki: Insights Dashboard

Target Guardrail

Guardarraíl basado en LLM que evita atacar dominios no autorizados: bloquea sitios gubernamentales, grandes empresas tecnológicas, instituciones financieras y plataformas de redes sociales. Opera tanto en la creación de proyectos como en la inicialización del agente. Los dominios gubernamentales, militares, educativos y de organizaciones internacionales (.gov, .mil, .edu, .int) están bloqueados permanentemente por un guardarraíl determinista duro que no se puede deshabilitar.

Wiki: Creating a Project

Tool Confirmation

Compuerta de humano en el bucle por herramienta para operaciones peligrosas. Cuando está habilitada, el agente se detiene antes de ejecutar herramientas de alto impacto (Nmap, Nuclei, Metasploit, Hydra, shell de Kali, ejecución de código) y presenta una solicitud en línea de Permitir / Denegar en la línea de tiempo del chat. Soporta modos de confirmación de herramienta única y de onda paralela (plan). Los usuarios pueden aprobar, rechazar o modificar los argumentos de la herramienta antes de que la ejecución continúe. Se desactiva mediante el interruptor Require Tool Confirmation en Project Settings.

Wiki: Pentest Agent (Tool Confirmation)

Pentest Reports

Informes HTML profesionales listos para el cliente con 11 secciones. Cuando se configura un modelo de IA, 6 secciones reciben narrativas generadas por LLM que incluyen resumen ejecutivo, análisis de riesgos y triaje de remediación priorizado. Ver informe de ejemplo.

Wiki: Pentest Reports

Exportación e Importación de Datos

Copia de seguridad y restauración completa del proyecto a través de la interfaz web: configuraciones, conversaciones, datos del grafo, resultados de reconocimiento/GVM/GitHub hunt como un archivo ZIP portátil.

Wiki: Data Export & Import

Arquitectura del Sistema```mermaid

flowchart TB subgraph User["👤 User Layer"] Browser[Web Browser] CLI[Terminal/CLI] end

subgraph Frontend["🖥️ Frontend Layer"]
    Webapp[Next.js Webapp<br/>:3000]
end

subgraph Backend["⚙️ Backend Layer"]
    Agent[AI Agent Orchestrator<br/>FastAPI + LangGraph<br/>:8090]
    ReconOrch[Recon Orchestrator<br/>FastAPI + Docker SDK<br/>:8010]
end

subgraph Tools["🔧 MCP Tools Layer"]
    NetworkRecon[Network Recon Server<br/>Curl + Naabu<br/>:8000]
    Nuclei[Nuclei Server<br/>:8002]
    Metasploit[Metasploit Server<br/>:8003]
    Nmap[Nmap Server<br/>:8004]
end

subgraph Scanning["🔍 Scanning Layer"]
    Recon[Recon Pipeline<br/>Docker Container]
    GVM[GVM/OpenVAS Scanner<br/>Network Vuln Assessment]
    GHHunt[GitHub Secret Hunter<br/>Credential Scanning]
    TruffleHog[TruffleHog Scanner<br/>700+ Secret Detectors]
end

subgraph Data["💾 Data Layer"]
    Neo4j[(Neo4j Graph DB<br/>:7474/:7687)]
    Postgres[(PostgreSQL<br/>Project Settings<br/>:5432)]
end

subgraph LLMProviders["🧠 LLM Providers"]
    OpenAI[OpenAI]
    Anthropic[Anthropic]
    LocalLLM[Local Models<br/>Ollama · vLLM · LM Studio]
    OpenRouter[OpenRouter<br/>300+ Models]
    Bedrock[AWS Bedrock]
end

subgraph External["🌐 External APIs"]
    GitHubAPI[GitHub API<br/>Repos & Code Search]
end

subgraph Targets["🎯 Target Layer"]
    Target[Target Systems]
    GuineaPigs[Guinea Pigs<br/>Test VMs]
end

Browser --> Webapp
CLI --> Recon
Webapp <-->|WebSocket| Agent
Webapp -->|REST + SSE| ReconOrch
Webapp --> Neo4j
Webapp --> Postgres
ReconOrch -->|Docker SDK| Recon
ReconOrch -->|Docker SDK| GVM
ReconOrch -->|Docker SDK| GHHunt
ReconOrch -->|Docker SDK| TruffleHog
Recon -->|Fetch Settings| Webapp
GHHunt -->|GitHub API| GitHubAPI
TruffleHog -->|GitHub API| GitHubAPI
TruffleHog --> Neo4j
Agent -->|API| OpenAI
Agent -->|API| Anthropic
Agent -->|API| LocalLLM
Agent -->|API| OpenRouter
Agent -->|API| Bedrock
Agent --> Neo4j
Agent -->|MCP Protocol| NetworkRecon
Agent -->|MCP Protocol| Nuclei
Agent -->|MCP Protocol| Metasploit
Agent -->|MCP Protocol| Nmap
Recon --> Neo4j
GVM -->|Reads Recon Output| Recon
GVM --> Neo4j
GVM --> Target
GVM --> GuineaPigs
NetworkRecon --> Target
Nuclei --> Target
Metasploit --> Target
Nmap --> Target
NetworkRecon --> GuineaPigs
Nuclei --> GuineaPigs
Metasploit --> GuineaPigs
Nmap --> GuineaPigs

> **Diagramas completos de arquitectura** (flujo de datos, contenedores Docker, pipeline de reconocimiento, flujo de trabajo del agente, integración MCP): **[ARCHITECTURE.md](https://github.com/samugit83/redamon/blob/master/readmes/ARCHITECTURE.md)**
>
> **Stack tecnológico** (más de 70 tecnologías en frontend, backend, IA, bases de datos, herramientas de seguridad): **[TECH_STACK.md](https://github.com/samugit83/redamon/blob/master/readmes/TECH_STACK.md)**

---

## Components

| Component | Description | Documentation |
|-----------|-------------|---------------|
| **Pipeline de Reconocimiento** | Pipeline paralelizado de abanico (fan-out/fan-in) para OSINT y escaneo de vulnerabilidades | [README.RECON.md](https://github.com/samugit83/redamon/blob/master/readmes/README.RECON.md) |
| **Orquestador de Reconocimiento** | Gestión del ciclo de vida de contenedores mediante Docker SDK | [README.RECON_ORCHESTRATOR.md](https://github.com/samugit83/redamon/blob/master/readmes/README.RECON_ORCHESTRATOR.md) |
| **Docker Socket Broker** | Proxy inverso de filtrado para el socket de Docker: los contenedores de escaneo generados llegan al daemon a través de él, por lo que solo pueden crear las imágenes de herramientas conocidas (en lista blanca, sin montajes del host / privilegiadas / imágenes arbitrarias) | n/a |
| **Base de Datos de Grafos** | Mapeo de superficie de ataque con Neo4j y soporte multiinquilino | [README.GRAPH_DB.md](https://github.com/samugit83/redamon/blob/master/readmes/README.GRAPH_DB.md) · [GRAPH.SCHEMA.md](https://github.com/samugit83/redamon/blob/master/readmes/GRAPH.SCHEMA.md) |
| **Servidores de Herramientas MCP** | Herramientas de seguridad mediante el Protocolo de Contexto de Modelo (sandbox Kali) | [README.MCP.md](https://github.com/samugit83/redamon/blob/master/readmes/README.MCP.md) |
| **Orquestador de Agente IA** | Agente autónomo basado en LangGraph con patrón ReAct | [README.AGENTIC_SYSTEM.md](https://github.com/samugit83/redamon/blob/master/readmes/README.AGENTIC_SYSTEM.md) |
| **Agentes CypherFix** | Triage automatizado + corrección de código + PR en GitHub | [README.CYPHERFIX_AGENTS.md](https://github.com/samugit83/redamon/blob/master/readmes/README.CYPHERFIX_AGENTS.md) |
| **Aplicación Web** | Panel en Next.js para visualización e interacción con IA | [README.WEBAPP.md](https://github.com/samugit83/redamon/blob/master/readmes/README.WEBAPP.md) |
| **Escáner GVM** | Escáner de vulnerabilidades de red Greenbone/OpenVAS (más de 170 mil NVTs) | [README.GVM.md](https://github.com/samugit83/redamon/blob/master/readmes/README.GVM.md) |
| **Escáner TruffleHog** | Escaneo profundo de secretos con más de 700 detectores y verificación de credenciales | n/a |
| **Base de Datos PostgreSQL** | Configuraciones de proyectos, cuentas de usuario, datos de configuración | [README.POSTGRES.md](https://github.com/samugit83/redamon/blob/master/readmes/README.POSTGRES.md) |
| **Entornos de Prueba** | Contenedores Docker intencionalmente vulnerables para pruebas seguras | [README.GPIGS.md](https://github.com/samugit83/redamon/blob/master/readmes/README.GPIGS.md) |

---

## Documentation

| Resource | Link |
|----------|------|
| **Wiki Completa** (guía de usuario) | **[github.com/samugit83/redamon/wiki](https://github.com/samugit83/redamon/wiki)** |
| Despliegue en Servidor (un solo host) | **[Wiki: Desplegando en un Servidor](https://github.com/samugit83/redamon/wiki/Deploying-to-a-Server)** · [deploy/single-host/README.md](https://github.com/samugit83/redamon/blob/master/deploy/single-host/README.md) |
| **Postura de Seguridad** (catálogo de defensa en profundidad) | **[readmes/README.SECURITY_POSTURE.md](https://github.com/samugit83/redamon/blob/master/readmes/README.SECURITY_POSTURE.md)** |
| Modelo de Amenazas (STRIDE) | [readmes/README.TM.SYSTEM_OVERVIEW.md](https://github.com/samugit83/redamon/blob/master/readmes/README.TM.SYSTEM_OVERVIEW.md) |
| Política de Seguridad | [SECURITY.md](https://github.com/samugit83/redamon/blob/master/SECURITY.md) |
| Desarrollo Asistido por IA | **[Wiki: Crea PRs Perfectos con IA](https://github.com/samugit83/redamon/wiki/AI-Assisted-Development)** |
| Guía para Desarrolladores | [readmes/README.DEV.md](https://github.com/samugit83/redamon/blob/master/readmes/README.DEV.md) |
| Diagramas de Arquitectura | [readmes/ARCHITECTURE.md](https://github.com/samugit83/redamon/blob/master/readmes/ARCHITECTURE.md) |
| Stack Tecnológico | [readmes/TECH_STACK.md](https://github.com/samugit83/redamon/blob/master/readmes/TECH_STACK.md) |
| Solución de Problemas | [readmes/TROUBLESHOOTING.md](https://github.com/samugit83/redamon/blob/master/readmes/TROUBLESHOOTING.md) |
| Registro de Cambios | [CHANGELOG.md](https://github.com/samugit83/redamon/blob/master/CHANGELOG.md) |
| Descargo de Responsabilidad Completo | [DISCLAIMER.md](https://github.com/samugit83/redamon/blob/master/DISCLAIMER.md) |
| Licencias de Terceros | [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/master/THIRD-PARTY-LICENSES.md) |
| Licencia | [LICENSE](https://github.com/samugit83/redamon/blob/master/LICENSE) |

---

## Solución de Problemas

RedAmon está completamente dockerizado y funciona en cualquier sistema operativo con Docker Compose v2+. Para soluciones específicas por SO (Linux, Windows, macOS), consulta la **[Guía de Solución de Problemas](https://github.com/samugit83/redamon/blob/master/readmes/TROUBLESHOOTING.md)** o la **[Wiki](https://github.com/samugit83/redamon/wiki/Troubleshooting)**.

---

## RedAmon HackLab

<table>
<tr>
<td width="280" align="center">
  <a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab">
    <img src="https://raw.githubusercontent.com/samugit83/redamon/HEAD/assets/hacklab.png" alt="RedAmon HackLab" width="260"/>
  </a>
</td>
<td>
  <h3>¿Quieres ver a RedAmon pensar como un pentester real?</h3>
  <p>Explora sesiones de ataque en vivo en tiempo real — cada paso, cada pivote, cada exploit — en 15 categorías de vulnerabilidades sobre un objetivo real. Registros completos de sesiones, tutoriales descifrados y grabaciones de video que muestran al agente comprometiendo autónomamente un servidor multiservicio desde cero.</p>
  <a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab"><b>Explora el HackLab &rarr;</b></a>
  &nbsp;&nbsp;|&nbsp;&nbsp;
  <a href="https://github.com/samugit83/redamon/wiki/RedAmon-HackLab#community-sessions"><b>Envía tu propia sesión &rarr;</b></a>
  <br/><sub>¿Tienes una sesión increíble de tu agente en tu propio objetivo? Compártela con la comunidad — registro de sesión + video de YouTube.</sub>
</td>
</tr>
</table>

---

## Vitrina de la Comunidad

Vídeos, análisis y experiencias del mundo real de profesionales de la seguridad que usan RedAmon en el campo. ¿Quieres aparecer? Consulta la ruta [Creador de Contenido](https://github.com/samugit83/redamon/blob/master/CONTRIBUTING.md#content-creator) en CONTRIBUTING.md.

### Vídeos

| Título | Enlace |
|-------|--------|
| RedAmon v2.2.0, Prueba de Ingeniería Social: Entrega de Payload a Acceso Shell | [Ver](https://youtu.be/kVjV9K_eks4) |
| Validación de CVE por Agente IA: Más Allá de las Herramientas Estándar | [Ver](https://youtu.be/rypmP1SJon8) |
| RedAmon 2.0, De 0 a 1000 Estrellas en GitHub en 10 Días: Ataques Paralelos Multi-Agente | [Ver](https://youtu.be/afViJUit0xE) |
| Construye un Agente Autónomo de Red Team desde Cero: Tutorial Completo de LangGraph + Metasploit + Neo4j | [Ver](https://youtu.be/mO5CCkYlY94) |

### Casos de Estudio Reales

| Quién | Qué | Enlace |
|-----|------|--------|
| Nipun Dinudaya | Desplegó RedAmon en el sitio web de una empresa e identificó una vulnerabilidad crítica de inyección SQL que podría haber causado una exposición significativa de datos | [Leer en LinkedIn](https://www.linkedin.com/posts/nipun-dinudaya-6159b32bb_redamon-cybersecurity-penetrationtesting-ugcPost-7431233870253166592-aLvb) |
| Venkata Bhargav CH S | Usó RedAmon durante una pasantía en Ascent e-Digit Solutions: reconocimiento práctico, análisis DNS y mapeo de superficie de ataque | [Leer en LinkedIn](https://www.linkedin.com/posts/venkata-bhargav-cybersecurity_cybersecurity-ethicalhacking-redteam-share-7434940660803182592-e9En) |

### Guías de la Comunidad

| Quién | Qué | Enlace |
|-----|------|--------|
| MrGood | Dominando Redamon: Una Guía Completa para la Instalación en Kali Linux, abordando desafíos específicos de Docker en Kali y postura de seguridad | [Leer en Medium](https://cyberaccoon.medium.com/mastering-redamon-a-comprehensive-guide-to-installation-on-kali-linux-ea544e6f5b9f) |
| Bogdan Caraman | Cómo Instalar RedAmon en Debian 13 (Trixie) con OpenRouter, guía paso a paso con configuración de Docker, IP estática y automatización con systemd | [Leer en Blog](https://blog.bogdancaraman.com/install-redamon-debian-13-openrouter/) |

---

## Contribuciones

¡Las contribuciones son bienvenidas! Por favor, lee [CONTRIBUTING.md](https://github.com/samugit83/redamon/blob/master/CONTRIBUTING.md) para obtener directrices sobre cómo empezar, convenciones de estilo de código y el proceso de solicitudes de extracción.

---

## Mantenedores

**Samuele Giampieri**: creador, mantenedor y arquitecto de plataforma IA · [LinkedIn](https://www.linkedin.com/in/samuele-giampieri-b1b67597/) · [GitHub](https://github.com/samugit83) · [Devergo Labs](https://www.devergolabs.com/)

**Ritesh Gohil**: mantenedor e investigador principal de seguridad · [LinkedIn](https://www.linkedin.com/in/riteshgohil25/) · [GitHub](https://github.com/L4stPL4Y3R)

---

## Contacto

Para preguntas, comentarios o consultas de colaboración: **[email protected]**

---

## Legal

> **Local por defecto; el despliegue en servidor tiene una ruta reforzada compatible.** De fábrica, RedAmon está diseñado para ejecutarse en una **máquina local** y no incluye controles de seguridad orientados a internet por sí mismo. Para ejecutarlo en un servidor público accesible desde internet, usa el **despliegue reforzado de un solo host** en [`deploy/single-host/`](https://github.com/samugit83/redamon/blob/master/deploy/single-host), que coloca todo el stack detrás de nginx + TLS, un cortafuegos de host, endurecimiento SSH y un único origen HTTPS público, con cada servicio interno vinculado a loopback. Ejecutar el stack **crudo** (sin ese despliegue) en una IP pública expondría servicios internos no autenticados, por lo que cualquier cosa fuera de una red local de confianza sin el despliegue reforzado es completamente bajo su propio riesgo.

Este proyecto se publica bajo la [Licencia MIT](https://github.com/samugit83/redamon/blob/master/LICENSE).

RedAmon integra varias herramientas de terceros bajo sus propias licencias (MIT, Apache-2.0, BSD, GPL-2.0/3.0, AGPL-3.0, LGPL y la Licencia Pública de Fuente de WPScan). El código fuente de todos los componentes con licencia AGPL está disponible en sus repositorios upstream. El inventario completo y las obligaciones de licencia están documentados en [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/master/THIRD-PARTY-LICENSES.md).

> **Nota sobre uso comercial**: La imagen sandbox de Kali incluye **WPScan**, que se rige por la Licencia Pública de Fuente de WPScan. WPScan restringe el uso comercial (SaaS, ofertas de productos de pago, servicios de valor añadido) sin una licencia separada del equipo de WPScan. Las pruebas de penetración y el uso personal están permitidos. Si tienes la intención de usar RedAmon en un producto o servicio comercial, revisa [THIRD-PARTY-LICENSES.md](https://github.com/samugit83/redamon/blob/master/THIRD-PARTY-LICENSES.md) antes de la distribución.

Consulta [DISCLAIMER.md](https://github.com/samugit83/redamon/blob/master/DISCLAIMER.md) para conocer los términos de uso completos, la política de uso aceptable y los requisitos de cumplimiento legal.

---

<p align="center">
  <strong>Usa responsablemente. Prueba éticamente. Defiende mejor.</strong>
</p>