Unmask the hidden before the world does.
An autonomous AI framework that chains reconnaissance, exploitation, and post-exploitation into a single pipeline, then goes further by triaging every finding, implementing code fixes, and opening pull requests on your repository. From first packet to merged patch, no human intervention required.
Three AI agents attack simultaneously — one brute-forces SSH credentials with Hydra, one chains a CVE to escalate to root and defaces the homepage, one hunts down every XSS vulnerability on the frontend.
进攻与防御相遇，一条流水线，零交接。
侦察 ➜ 利用 ➜ 后渗透 ➜ AI 分诊 ➜ 代码修复智能体 ➜ GitHub PR
RedAmon 不仅仅止步于发现漏洞，它还能修复漏洞。该流水线始于一个 6 阶段侦察引擎，可映射目标完整的攻击面，随后将控制权移交给自主 AI 智能体，该智能体利用 CVE 漏洞、暴力破解凭据并在网络中横向移动。每一项发现都被记录在 Neo4j 知识图谱中。当进攻阶段完成后，CypherFix 接管工作：一个 AI 分诊智能体关联数百项发现，对其进行去重，并按可利用性排序。随后，代码修复智能体克隆您的仓库，使用 11 种代码感知工具导航代码库，实施针对性修复，并打开一个 GitHub 拉取请求，随时可供审查和合并。
## 快速开始
### 前置条件
- [Docker](https://docs.docker.com/get-docker/) 和 Docker Compose v2+
仅此而已。您的主机上不需要安装 Node.js、Python 或安全工具。
#### 最低系统要求
| 资源 | 不含 OpenVAS | 含 OpenVAS (完整栈) |
|----------|----------------|--------------------------|
| **CPU** | 2 核 | 4 核 |
| **内存** | 4 GB | 8 GB (推荐 16 GB) |
| **磁盘** | 20 GB 可用空间 | 50 GB 可用空间 |
### 1. 克隆与配置
```
git clone https://github.com/samugit83/redamon.git
cd redamon
cp .env.example .env
```
编辑 `.env` 并添加至少一个 AI 提供商密钥：
```
ANTHROPIC_API_KEY=sk-ant-... # recommended
# 或
OPENAI_API_KEY=sk-proj-...
```
从 [Anthropic Console](https://console.anthropic.com/) 或 [OpenAI Platform](https://platform.openai.com/api-keys) 获取您的密钥。
**其他 AI 提供商**（可选 —— 添加这些以解锁更多模型）：
```
OPENAI_COMPAT_BASE_URL=http://host.docker.internal:11434/v1 # Ollama on the same machine (see below for remote servers)
OPENAI_COMPAT_API_KEY= # optional (fallback token "ollama" is used if empty)
OPENROUTER_API_KEY=sk-or-... # OpenRouter — access 300+ models (Llama, Gemini, Mistral, etc.) via openrouter.ai
AWS_ACCESS_KEY_ID=AKIA... # AWS Bedrock — access foundation models (Claude, Titan, Llama, etc.)
AWS_SECRET_ACCESS_KEY=... # AWS Bedrock secret key
AWS_DEFAULT_REGION=us-east-1 # AWS Bedrock region (default: us-east-1)
```
项目设置中的模型选择器会从每个配置了 API 密钥的提供商处**动态获取**可用模型。仅显示具有有效密钥的提供商。
**可选密钥**（添加这些以获得额外功能）：
```
TAVILY_API_KEY=tvly-... # Web search for the AI agent — get one at tavily.com
NVD_API_KEY=... # NIST NVD API — higher rate limits for CVE lookups — nist.gov/developers
NGROK_AUTHTOKEN=... # ngrok TCP tunnel for reverse shells — get one at dashboard.ngrok.com
```
### 2. 构建与启动
**不含 GVM（更轻量，启动更快）：**
```
docker compose --profile tools build # Build all images
docker compose up -d postgres neo4j recon-orchestrator kali-sandbox agent webapp # Start core services only
```
**完整版，含 GVM：**
```
docker compose --profile tools build # Build all images (recon + vuln-scanner + services)
docker compose up -d # Start all services (first GVM run takes ~30 min for feed sync)
# Total image size: ~15 GB
```
### 3. 打开 Web 应用
访问 **http://localhost:3000** —— 创建项目，配置目标，然后开始扫描。
### 常用命令
```
docker compose up -d # Start all services (including GVM)
docker compose down # Stop all services (keeps data)
docker compose ps # Check service status
docker compose logs -f # Follow all logs
docker compose logs -f webapp # Webapp (Next.js)
docker compose logs -f agent # AI agent orchestrator
docker compose logs -f recon-orchestrator # Recon orchestrator
docker compose logs -f kali-sandbox # MCP tool servers
docker compose logs -f gvmd # GVM vulnerability scanner daemon
docker compose logs -f neo4j # Neo4j graph database
docker compose logs -f postgres # PostgreSQL database
# 停止服务但不删除卷（保留所有数据，快速重启）
docker compose down
# 停止并删除本地构建的镜像（下次启动时强制重新构建）
docker compose --profile tools down --rmi local
# 完全清理：删除所有容器、镜像和卷（销毁所有数据！）
docker compose --profile tools down --rmi local --volumes --remove-orphans
```
### 开发模式
用于带有 **Next.js 快速刷新**的主动开发（无需在每次更改时重新构建）：
```
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d
```
**不含 GVM（更轻量，启动更快）：**
```
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d postgres neo4j recon-orchestrator kali-sandbox agent webapp
```
第一条命令启动**所有**服务，包括 GVM/OpenVAS（首次运行需要约 30 分钟的源同步）。第二条命令仅启动核心服务，完全跳过 GVM —— 当您不需要网络级漏洞扫描并希望获得更快、更轻量的技术栈时非常有用。
两条命令都会将生产环境 Web 应用镜像替换为挂载了源代码卷的开发容器。每次文件保存都会触发浏览器中的即时热重载。
**代码更改后刷新 Python 服务：**
Python 服务（`agent`、`recon-orchestrator`、`kali-sandbox`）的源代码已经挂载为卷，因此文件是实时同步的。但是，正在运行的 Python 进程不会获取更改，直到您重启容器：
```
# 重启单个服务（即时应用代码更改）
docker compose restart agent # AI agent orchestrator
docker compose restart recon-orchestrator # Recon orchestrator
docker compose restart kali-sandbox # MCP tool servers
```
无需重新构建 —— 只需重启。
## 目录
- [Overview](#overview)
- [Reconnaissance Pipeline](#reconnaissance-pipeline)
- [AI Agent Orchestrator](#ai-agent-orchestrator)
- [AI Model Providers](#ai-model-providers)
- [Local Models & OpenAI-Compatible Providers](#openai-compatible-provider)
- [GitHub Secret Hunter](#github-secret-hunter)
- [GVM Vulnerability Scanner](#gvm-vulnerability-scanner-optional)
- [Attack Surface Graph](#attack-surface-graph)
- [EvoGraph — Attack Chain Evolution](#evograph--attack-chain-evolution)
- [Multi-Session Parallel Attack Chains](#multi-session-parallel-attack-chains)
- [CypherFix — Automated Vulnerability Remediation](#cypherfix--automated-vulnerability-remediation)
- [Project Settings](#project-settings)
- [System Architecture](#system-architecture)
- [High-Level Architecture](#high-level-architecture)
- [Data Flow Pipeline](#data-flow-pipeline)
- [Docker Container Architecture](#docker-container-architecture)
- [Exposed Services & Ports](#exposed-services--ports)
- [Components](#components)
- [Reconnaissance Pipeline](#1-reconnaissance-pipeline)
- [Graph Database](#2-graph-database)
- [MCP Tool Servers](#3-mcp-tool-servers)
- [AI Agent Orchestrator](#4-ai-agent-orchestrator)
- [Web Application](#5-web-application)
- [GVM Scanner](#6-gvm-scanner)
- [GitHub Secret Hunter](#7-github-secret-hunter)
- [Test Environments](#8-test-environments)
- [Technology Stack](#technology-stack)
- [Frontend](#frontend)
- [Backend & API](#backend--api)
- [AI & LLM](#ai--llm)
- [Databases](#databases)
- [Security & Penetration Testing Tools](#security--penetration-testing-tools)
- [Vulnerability Assessment](#vulnerability-assessment)
- [Data Sources & Threat Intelligence](#data-sources--threat-intelligence)
- [Infrastructure & DevOps](#infrastructure--devops)
- [Protocols & Communication](#protocols--communication)
- [Development Mode](#development-mode)
- [Documentation](#documentation)
- [Data Export & Import](#data-export--import)
- [Updating to a New Version](#updating-to-a-new-version)
- [Legal](#legal)
## 概述
RedAmon 是一个模块化、容器化的渗透测试框架，将自动化侦察、AI 驱动的利用和图驱动的智能串联成一个单一的端到端进攻安全流水线。每个组件都在 Docker 内运行 —— 您的主机上无需安装任何工具 —— 并通过定义良好的 API 进行通信，因此每一层都可以独立演进。
该平台围绕六大支柱构建：
| 支柱 | 功能 |
|--------|-------------|
| **侦察流水线** | 六个顺序扫描阶段，映射目标完整的攻击面 —— 从子域名发现到漏洞检测 —— 并将结果存储为丰富的、可查询的图谱。辅以独立的 GVM 网络扫描和 GitHub 机密搜寻模块。 |
| **AI 智能体编排器** | 基于 LangGraph 的自主智能体，对图谱进行推理，通过 MCP 选择安全工具，在信息收集 / 利用 / 后渗透阶段之间转换，并可通过聊天实时引导。 |
| **攻击面图谱** | 包含 17 种节点类型和 20+ 种关系类型的 Neo4j 知识图谱，作为每项发现的唯一事实来源 —— 也是 AI 智能体在每次决策前查询的主要数据源。 |
| **EvoGraph** | Neo4j 中持久的、演进式攻击链图谱，跟踪攻击生命周期中的每一步、发现、决策和失败 —— 连接侦察图谱并实现跨会话智能积累。 |
| **CypherFix** | 自动化漏洞修复流水线 —— AI 分诊智能体关联并优先处理图谱中的发现，然后代码修复智能体克隆目标仓库，使用带有 11 种代码工具的 ReAct 循环实施修复，并打开 GitHub 拉取请求。 |
| **项目设置引擎** | 180+ 个项目级参数 —— 通过 Web 应用 UI 暴露 —— 控制每个工具的行为，从 Naabu 线程数到 Nuclei 严重性过滤器再到智能体审批关卡。 |
### 侦察流水线
侦察流水线是一个完全自动化的六阶段扫描引擎，运行在 Kali Linux 容器内。给定一个根域名（或特定的子域名列表），它逐步构建目标外部攻击面的完整图景。每个阶段将其输出馈送到下一个阶段，最终结果既是结构化的 JSON 文件，也是填充好的 Neo4j 图谱。
#### 阶段 1 —— 域名发现
流水线首先使用三种互补技术映射目标的子域名景观：
- **证书透明度** 通过 crt.sh —— 查询公共 CT 日志以查找为根域名颁发的每个证书，从 Subject 和 SAN 字段中提取子域名。
- **HackerTarget API** —— 被动查询，返回已知子域名而不向目标发送任何流量。
- **Knockpy**（可选暴力破解）—— 主动子域名暴力破解器，针对目标 DNS 测试数千个常见前缀。由 `useBruteforceForSubdomains` 开关控制。
- **WHOIS 查询** —— 检索注册商、注册人、创建/到期日期、名称服务器和联系信息，具有自动重试逻辑和指数退避。
- **DNS 解析** —— 将每个发现的子域名解析为其 A、AAAA、MX、NS、TXT、CNAME 和 SOA 记录，构建 IP 地址和邮件基础设施的映射。
当提供特定的 `subdomainList`（例如 `www.`、`api.`、`mail.`）时，流水线跳过主动发现，仅解析指定的子域名 —— 适用于针对性评估。
#### 阶段 2 —— 端口扫描
所有已解析的 IP 地址被输入到 **Naabu**，一个快速的 SYN/CONNECT 端口扫描器。主要功能：
- **SYN 扫描**（默认），如果原始套接字不可用则自动回退到 CONNECT 模式。
- Top-N 端口选择（100、1000 或自定义端口范围）。
- **CDN/WAF 检测** —— 识别 Cloudflare、Akamai、AWS CloudFront 和其他 CDN 提供商，可选择将其从深度扫描中排除。
- **被动模式** —— 查询 Shodan 的 InternetDB 而不是发送数据包，实现零接触侦察。
- **IANA 服务查询** —— 使用 15,000 条目的 IANA 注册表将端口号映射到服务名称。
#### 阶段 3 —— HTTP 探测与技术检测
每个主机+端口组合都通过 **httpx** 使用 HTTP/HTTPS 进行探测，以确定哪些服务存活以及它们运行什么：
- **响应元数据** —— 状态码、内容类型、页面标题、服务器头、响应时间、字数/行数。
- **TLS 检查** —— 证书主题、颁发者、到期时间、密码套件、JARM 指纹。
- **技术指纹识别** —— 双引擎方法：
- httpx 的内置检测识别主要框架和服务器。
- **Wappalyzer**（6,000+ 指纹，从 npm 自动更新）对响应 HTML 进行第二遍扫描，捕获 httpx 遗漏的 CMS 插件、JavaScript 库和分析工具。合并是完全自动的，具有可配置的最小置信度阈值。
- **Banner 抓取** —— 对于非 HTTP 端口（SSH、FTP、SMTP、MySQL、Redis 等），原始套接字连接使用特定协议的探测字符串提取服务 banner 和版本字符串。
#### 阶段 4 —— 资源枚举
三个工具**并行**运行（通过 ThreadPoolExecutor）以发现实时 URL 上的每个可访问端点：
- **Katana** —— 主动网络爬虫，可配置深度跟踪链接，可选择渲染 JavaScript 以发现动态路由。提取表单、输入字段和查询参数。
- **GAU** (GetAllUrls) —— 被动发现工具，查询 Wayback Machine、Common Crawl、AlienVault OTX 和 URLScan.io 获取历史 URL。结果用 httpx 验证以过滤死链接，并通过 OPTIONS 探测检测 HTTP 方法。
- **Kiterunner** —— API 专用暴力破解器，针对每个基础 URL 测试常见 API 路由（REST、GraphQL）的字典，检测允许的 HTTP 方法（GET、POST、PUT、DELETE、PATCH）。
结果被合并、去重并按基础 URL 组织。每个端点被分类到类别（auth、file_access、api、dynamic、static、admin），其参数被类型化（id、file、search、auth_param）。
#### 阶段 5 —— 漏洞扫描
发现的端点 —— 特别是带有查询参数的端点 —— 被输入到 **Nuclei**，一个基于模板的漏洞扫描器，拥有 8,000+ 社区模板：
- **DAST 模式**（主动模糊测试）—— 将 XSS、SQLi、RCE、LFI、SSRF 和 SSTI 载荷注入每个发现的参数。这能捕获仅签名扫描遗漏的漏洞。
- **严重性过滤** —— 扫描关键、高危、中危和/或低危发现。
- **Interactsh 集成** —— 通过回调服务器进行带外检测，用于盲漏洞（SSRF、XXE、盲 SQLi）。
- **CVE 丰富** —— 每项发现都与 NVD（或 Vulners）API 交叉引用，获取 CVSS 分数、描述和参考。
- **30+ 自定义安全检查** —— 直接 IP 访问、缺失的安全头（CSP、HSTS、Referrer-Policy、Permissions-Policy、COOP、CORP、COEP）、TLS 证书过期、DNS 安全（SPF、DMARC、DNSSEC、区域传送）、开放服务（无认证的 Redis、暴露的 Kubernetes API、SMTP 开放中继）、不安全的表单操作和缺失的速率限制。
#### 阶段 6 —— MITRE 丰富
- **MITRE CWE/CAPEC 映射** —— 阶段 5 中发现的每个 CVE 自动丰富其对应的 CWE 弱点和 CAPEC 攻击模式，使用来自 CVE2CAPEC 仓库的自动更新数据库（24 小时缓存 TTL）。
#### 输出
所有结果合并到单个 JSON 文件（`recon/output/recon_{PROJECT_ID}.json`）中，并同时导入到 Neo4j 图数据库，创建目标攻击面的完全连接的知识图谱。
#### 运行侦察
1. 创建带有目标域名和设置的项目
2. 导航到图谱页面
3. 点击 "Start Recon" 按钮
4 在抽屉中查看实时日志
### GVM 漏洞扫描器（可选）
侦察完成后，您可以选择运行 **GVM/OpenVAS 网络级漏洞扫描**，以补充 Nuclei 的 Web 层发现。
#### 什么是 GVM/OpenVAS？
**Greenbone 漏洞管理 (GVM)** —— 前身为 OpenVAS —— 是世界上最大的开源网络漏洞扫描器。虽然 Nuclei 专注于通过 HTTP 模板进行 Web 应用程序测试，但 GVM 在根本不同的层面上运行：它直接在**协议层**探测服务，测试错误配置、过时软件、默认凭据以及每个开放端口上的已知 CVE。
GVM 生态系统由多个协同工作的组件组成：
- **OpenVAS 扫描器 (ospd-openvas)** —— 执行网络漏洞测试 (NVT) 的扫描引擎，针对目标执行实际的协议级探测（SSH 版本检查、SMB 枚举、TLS 密码分析、banner 指纹识别）。
- **GVM 守护进程 (gvmd)** —— 中央管理服务，编排扫描、管理扫描配置、存储结果并暴露 GMP（Greenbone 管理协议）API。
- **漏洞源** —— 持续更新的 **170,000+ NVT** 数据库，涵盖操作系统、网络服务、数据库、嵌入式设备、工业控制系统等 —— 可用的最大开源漏洞测试源。
- **PostgreSQL + Redis** —— 扫描结果、NVT 元数据和进程间通信的后端存储。
GVM 特别强大之处在于其**测试深度**。与将 HTTP 响应与模式匹配的基于签名的扫描器不同，GVM 主动协商协议、认证服务、根据漏洞数据库检查软件版本、测试默认凭据，并探测在 HTTP 层不可见的错误配置 —— 如弱 SSH 密码、无认证的暴露数据库端口、SNMP 社区字符串猜测和 SMB 漏洞。
#### 扫描配置文件与时间估算
GVM 包含七个预配置的扫描配置文件，每个都在彻底性与速度之间进行权衡。以下时间是每个目标的估算：
| 扫描配置文件 | NVT 数量 | 持续时间 | 描述 |
|---|---|---|---|
| **Host Discovery** | ~100 | 2-5 分钟 | 基本主机检测 —— 目标是否存活？ |
| **Discovery** | ~500 | 5-10 分钟 | 网络发现 —— 开放端口、运行服务、操作系统指纹 |
| **System Discovery** | ~2,000 | 10-20 分钟 | 详细的操作系统和服务枚举，用于资产清单 |
| **Full and fast** | ~50,000 | 30-60 分钟 | 使用端口扫描结果选择相关 NVT 的综合漏洞扫描 —— **推荐的默认选项** |
| **Full and fast ultimate** | ~70,000 | 1-2 小时 | 与上述相同，但包含可能导致服务或主机崩溃的危险 NVT |
| **Full and very deep** | ~50,000 | 2-4 小时 | 忽略先前收集的端口/服务数据并无条件运行所有 NVT —— 等待每个测试的超时，速度明显较慢 |
| **Full and very deep ultimate** | ~70,000 | 4-8 小时 | 最彻底且最慢的选项 —— 运行所有 NVT 包括危险项，忽略先前扫描数据，等待所有超时 |
"fast" 和 "very deep" 配置文件之间的关键区别在于它们如何使用先前信息：**fast** 配置文件利用端口扫描结果跳过不相关的 NVT（例如，在没有端口 22 的主机上跳过 SSH 检查），而 **very deep** 配置文件忽略所有先前数据并无条件执行每个 NVT，等待无响应服务的超时。"ultimate" 变体添加可能导致目标拒绝服务条件的 NVT —— 仅在受控实验室环境中使用。
#### 与 RedAmon 集成
GVM 发现作为 Vulnerability 节点（`source="gvm"`）存储在 Neo4j 中，通过 `HAS_VULNERABILITY` 关系链接到 IP 和 Subdomain 节点，以及关联的 CVE 节点。这意味着 AI 智能体可以在单一统一图谱中推理 Web 层漏洞（来自 Nuclei）和网络层漏洞（来自 GVM）。
#### 运行 GVM 扫描
1. GVM 随 `docker compose up -d` 自动启动（首次运行需要约 30 分钟进行源同步）
2. 导航到图谱页面
3. 点击 "GVM Scan" 按钮（仅当项目存在侦察数据时启用）
4. 在 GVM 日志抽屉中查看实时日志
5. 完成后下载 GVM 结果 JSON
### AI 智能体编排器
AI 智能体是一个**基于 LangGraph 的自主系统**，实现了 ReAct（推理 + 行动）模式。它在循环中运行 —— 对当前状态进行推理、选择并执行工具、分析结果、重复 —— 直到目标完成或用户停止它。
#### 三个执行阶段
智能体通过三个不同的操作阶段进行，每个阶段有不同的工具访问权限和目标：
**信息收集阶段** —— 默认起始阶段。智能体通过查询 Neo4j 图谱、运行 CVE 详情的网络搜索、使用 curl 执行 HTTP 请求以及使用 Naabu 扫描端口来收集情报。没有进攻性工具可用。智能体分析攻击面，识别高价值目标，并构建可利用内容的心智模型。
**利用阶段** —— 当智能体识别出可行的攻击路径时，它请求阶段转换。这需要**用户批准**（可配置）。一旦批准，智能体通过 MCP 获得对 Metasploit 控制台的访问权限并可以执行利用。支持四种攻击路径类型：
- **CVE 利用** —— 智能体搜索匹配的 Metasploit 模块，配置载荷（反向 shell 或绑定 shell），设置目标参数，并触发利用。对于有状态模式，它建立 Meterpreter 会话；对于无状态模式，它执行一次性命令。当启用 **ngrok TCP 隧道**时，LHOST 和 LPORT 从 ngrok 公共 URL 自动检测，允许反向 shell 跨 NAT 和云环境工作，无需手动端口转发。
- **Hydra 暴力破解** —— 智能体使用 THC Hydra 对 SSH、FTP、RDP、SMB、MySQL、HTTP 表单等 50 多种协议的服务进行凭据暴力破解。Hydra 设置（线程、超时、额外检查）可按项目完全配置。发现凭据后，智能体通过 `sshpass`、数据库客户端或 Metasploit psexec 建立访问。
- **钓鱼 / 社会工程** —— 智能体生成恶意载荷（msfvenom 可执行文件、Office 宏文档、PDF、Web 交付单行命令、HTA 服务器）并通过电子邮件（Python smtplib，可配置 SMTP 设置）、聊天下载（`docker cp`）或 Web 链接交付。6 步工作流引导智能体完成目标平台选择、处理程序设置、载荷生成、验证、交付和会话回调。SMTP 设置在项目设置中的攻击路径选项卡中配置。
- **未分类回退** —— 用于不匹配 CVE 利用、暴力破解或钓鱼的技术（例如，SQL 注入、XSS、SSRF、文件上传）。智能体动态分类攻击类型并通用使用可用工具，无需强制工作流。这些在分类中显示为灰色徽章和 `-unclassified` 后缀。
当利用成功时，智能体在 [EvoGraph](#evograph--attack-chain-evolution) 中记录 **ChainFinding(exploit_success)** —— 记录攻击类型、目标 IP、端口、CVE ID、Metasploit 模块、载荷、会话 ID 和发现的凭据。此发现链接到产生它的攻击链步骤，并桥接到侦察图谱中的目标 IP 和被利用的 CVE，使每次成功的入侵成为知识图谱中永久的、可查询的、跨会话可访问的部分。
**后渗透阶段** —— 成功利用后，智能体可以选择转换到后渗透（如果启用）。在有状态模式（Meterpreter）下，它运行交互式命令 —— 枚举、横向移动、数据渗出。在无状态模式下，它使用不同的命令载荷重新运行利用。此阶段也需要用户批准。
#### 基于聊天的图谱交互
用户通过 Web 应用中的实时 **WebSocket 聊天界面**与智能体交互。您可以提出自然语言问题，智能体会自动将其转换为针对 Neo4j 图谱的 Cypher 查询：
- *"192.168.1.100 上存在哪些漏洞？"* —— 智能体生成 Cypher 查询，注入租户过滤器（这样您只能看到您项目的数据），执行它，并以自然语言返回结果。
- *"哪些技术有关键 CVE？"* —— 遍历 Technology → CVE 关系链。
- *"显示 example.com 子域名上的所有开放端口"* —— 遍历 Subdomain → IP → Port 路径。
- *"查找所有具有可注入参数的端点"* —— 查询被 Nuclei 标记为可注入的 Parameter 节点。
文本到 Cypher 系统包含 25+ 示例模式，处理 Vulnerability 节点（扫描器发现，小写严重性）和 CVE 节点（NVD 条目，大写严重性）之间的关键区别，并在查询失败时自动重试并带有错误上下文（最多 3 次尝试）。
#### 实时控制
智能体作为后台任务运行，保持 WebSocket 连接空闲以接收控制消息：
- **指导** —— 在智能体工作时发送引导消息（例如，*"专注于 SSH 漏洞，忽略 Web 应用"*）。这些在下一次推理步骤之前注入到系统提示中。
- **停止** —— 随时暂停执行。智能体的状态通过 LangGraph 的 MemorySaver 检查点保存。
- **恢复** —— 从上次检查点继续，保留完整上下文。
- **批准工作流** —— 转换到利用或后渗透阶段会暂停智能体并呈现结构化请求（原因、计划行动、风险）供用户批准、修改或中止。
#### MCP 工具集成
智能体通过**模型上下文协议**执行安全工具，每个工具在 Kali 沙箱容器内的专用服务器中运行：
| 工具 | 用途 | 可用阶段 |
|------|---------|-------------|
| **query_graph** | 用于目标情报的 Neo4j Cypher 查询 | 所有阶段 |
| **web_search** | 基于 Tavily 的 CVE/利用研究 | 所有阶段 |
| **execute_curl** | HTTP 请求、API 探测、头检查 | 所有阶段 |
| **execute_naabu** | 快速端口扫描和服务检测 | 所有阶段 |
| **execute_nmap** | 深度服务分析、OS 指纹识别、NSE 脚本 | 所有阶段 |
| **execute_nuclei** | 使用 9,000+ 模板的漏洞扫描 | 所有阶段 |
| **kali_shell** | 直接 Kali Linux shell 命令（任意命令执行） | 所有阶段 |
| **execute_code** | 在 Kali 沙箱上运行自定义 Python/Bash 利用脚本 | 利用和后渗透 |
| **execute_hydra** | THC Hydra 暴力破解密码破解（50+ 协议） | 利用和后渗透 |
| **metasploit_console** | 利用执行、载荷交付、会话 | 利用和后渗透 |
| **msf_restart** | 当 Metasploit RPC 守护进程无响应时重启 | 利用和后渗透 |
对于长时间运行的操作（例如，使用大型字典的 Hydra 暴力破解、Metasploit 利用），智能体每 5 秒向 WebSocket 流式传输进度更新，因此您可以实时看到输出。
#### Kali 沙箱工具
除了上面列出的 MCP 工具外，`kali_shell` 和 `execute_code` 工具使智能体能够访问沙箱容器中安装的**完整 Kali Linux 工具集**。智能体可以通过 shell 命令直接调用其中任何一个，或即时编译和运行自定义利用脚本。
**利用与进攻**
| 工具 | 描述 |
|------|-------------|
| **Metasploit Framework** | 完整的利用框架 —— exploits、payloads、encoders、auxiliaries、Meterpreter 会话 |
| **SQLMap** | 自动 SQL 注入检测和利用 |
| **ExploitDB** | Exploit Database 的本地副本 —— 离线 CVE 利用搜索 |
| **John the Ripper** | 密码破解器 —— 字典、暴力破解和基于规则的攻击 |
**网络与侦察**
| 工具 | 描述 |
|------|-------------|
| **Nmap** | 网络映射器 —— 端口扫描、服务检测、OS 指纹识别、NSE 脚本 |
| **Naabu** | 来自 ProjectDiscovery 的快速 SYN/CONNECT 端口扫描器 |
| **Nuclei** | 基于 9,000+ 社区模板的漏洞扫描器 |
| **curl** | HTTP/HTTPS 客户端 —— API 探测、头检查、文件上传/下载 |
| **wget** | 文件下载工具 |
| **Netcat (nc)** | TCP/UDP 瑞士军刀 —— 反向 shell、端口监听器、数据传输 |
| **Socat** | 高级套接字中继 —— 双向数据流、端口转发、SSL 隧道 |
| **dig / nslookup / host** | DNS侦察 —— 记录查询、区域传送、反向 DNS |
| **SMBClient** | SMB/CIFS 协议客户端 —— 共享枚举、文件访问、认证测试 |
**编程与脚本**
| 工具 | 描述 |
|------|-------------|
| **Python 3** | 完整的 Python 解释器 —— 编写和运行自定义利用脚本、解析器、自动化 |
| **Perl** | Perl 解释器 —— 遗留利用脚本和文本处理 |
| **GCC / G++** | C/C++ 编译器 —— 即时编译自定义利用、shellcode 和二进制工具 |
| **Make** | 多文件利用项目的构建自动化 |
| **Go 1.25** | Go 编译器 —— 从源代码构建基于 Go 的安全工具 |
| **Git** | 在运行时克隆利用仓库和安全工具 |
**实用工具**
| 工具 | 描述 |
|------|-------------|
| **jq** | JSON 处理器 —— 解析 API 响应、过滤扫描结果 |
| **rlwrap** | Readline 包装器 —— 增强的交互式 shell 会话 |
| **net-tools** | 网络实用工具 —— `netstat`、`ifconfig`、路由表 |
| **iputils-ping** | 用于主机发现的 ICMP ping |
#### 攻击路径路由
智能体使用 **LLM 驱动的意图路由器**将每个用户请求分类到适当的攻击路径类别。路由器不是遵循单一、固定的利用工作流，而是分析用户目标、来自 Neo4j 图谱的可用目标情报以及当前操作阶段，以选择正确的攻击链 —— 每个都有其自己的 Metasploit 工作流、工具序列和后渗透行为。
该架构支持 **10 种攻击路径类别**（CVE 利用、暴力破解、社会工程、DoS、模糊测试、凭据捕获、无线攻击、Web 应用攻击、客户端利用和本地权限提升），并有实现路线图逐步启用每一种。攻击路径也可以**相互链接** —— 例如，凭据捕获可以将捕获的用户名馈送到暴力破解攻击中，或者模糊测试发现可以链接到 CVE 研究和利用。
**当前实现的攻击路径：**
| # | 攻击路径 | 描述 | 模块类型 | 后渗透 |
|---|-------------|-------------|-------------|-------------------|
| 1 | **基于 CVE 的利用** | 利用由 CVE 标识符识别的已知漏洞。智能体搜索匹配的 Metasploit 利用模块，配置目标参数和载荷（反向/绑定 shell），并触发利用。支持有状态（Meterpreter 会话）和无状态（一次性命令）后渗透。 | `exploit/*` | 是 |
| 2 | **Hydra 暴力破解** | 针对 50+ 认证协议（SSH、FTP、RDP、SMB、MySQL、HTTP 表单等）的密码猜测攻击。智能体使用 THC Hydra（`execute_hydra`），具有可配置的线程、超时和重试策略。发现凭据后，智能体通过 `sshpass`（SSH）、数据库客户端或 Metasploit psexec（SMB）建立访问。 | `execute_hydra` | 有时（SSH、SMB） |
| 3 | **钓鱼 / 社会工程** | 生成恶意载荷、武器化文档（Office 宏、PDF、RTF、LNK）、Web 交付单行命令和 HTA 服务器。通过电子邮件、聊天下载或 Web 链接交付。6 步引导工作流，包含处理程序设置和会话回调。 | `msfvenom`、`fileformat/*`、`web_delivery` | 是 |
| 4 | **未分类回退** | 用于不匹配 CVE、暴力破解或钓鱼的技术的动态分类（例如，`sql_injection-unclassified`、`ssrf-unclassified`）。智能体通用使用所有可用工具，无需强制工作流。 | 任何可用 | 取决于技术 |
有关所有 10 种攻击路径类别、意图路由器架构、链特定工作流和实现路线图的完整详细信息，请参阅 **[Attack Paths Documentation](agentic/readmes/README.ATTACK_PATHS.md)**。
### AI 模型提供商
RedAmon 开箱即支持**五种 AI 提供商**，通过单一统一界面让您访问 **400+ 语言模型**。项目设置中的模型选择器从每个配置的提供商**动态获取**可用模型 —— 无硬编码列表，无需手动更新。当提供商发布新模型时，它会自动出现。
| 提供商 | 模型 | 定价 | 需要 API 密钥 |
|----------|--------|---------|-----------------|
| **OpenAI**（直接） | ~30 种聊天模型 —— GPT-5.2、GPT-5、GPT-4.1、o3、o4-mini 等 | 通过 OpenAI 按令牌付费 | `OPENAI_API_KEY` |
| **Anthropic**（直接） | ~15 种模型 —— Claude Opus 4.6、Sonnet 4.6/4.5、Haiku 4.5 | 通过 Anthropic 按令牌付费 | `ANTHROPIC_API_KEY` |
| **OpenAI 兼容** | 任何自托管或第三方 OpenAI 兼容 API（例如 Ollama、本地网关、代理）。模型列表直接来自您的后端；手动选择支持聊天的模型 | 取决于您的后端 | `OPENAI_COMPAT_BASE_URL`（`OPENAI_COMPAT_API_KEY` 可选） |
| **OpenRouter** | **300+ 模型** —— Llama 4、Gemini 3、Mistral、Qwen、DeepSeek、Command R+ 以及来自 50+ 提供商的数百种其他模型，通过单一 API 路由 | 每个模型不同（部分免费） | `OPENROUTER_API_KEY` |
| **AWS Bedrock** | ~60 种基础模型 —— Claude、Titan、Llama、Cohere Command、Mistral、AI21 Jamba 等 | 通过 AWS 按令牌付费 | `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` |
#### 工作原理
1. **提供商检测** —— 启动时，智能体检查环境中设置了哪些提供商凭据/URL。仅查询已配置的提供商。
2. **动态模型获取** —— 智能体的 `/models` 端点并行从所有配置的提供商获取可用模型（OpenAI API、Anthropic API、OpenAI 兼容 `/models`、OpenRouter API、AWS Bedrock `ListFoundationModels`）。结果缓存 1 小时。
3. **可搜索模型选择器** —— 项目设置 UI 呈现按提供商分组的可搜索下拉列表。每个模型显示其名称、上下文窗口大小和定价信息。输入即可跨所有提供商即时过滤。
4. **提供商前缀约定** —— 模型以提供商前缀存储（`openai_compat/`、`openrouter/`、`bedrock/`），以便智能体在运行时知道使用哪个 SDK。OpenAI 和 Anthropic 模型通过名称模式检测（无需前缀）。现有项目继续工作不变。
#### 提供商设置
```
# .env — 添加您想使用的提供商的密钥
# 直连提供商（延迟最低，直接 API 连接）
OPENAI_API_KEY=sk-proj-... # OpenAI — platform.openai.com/api-keys
ANTHROPIC_API_KEY=sk-ant-... # Anthropic — console.anthropic.com
# OpenAI 兼容提供商（自托管或第三方）
OPENAI_COMPAT_BASE_URL=http://host.docker.internal:11434/v1 # Ollama on same machine (use IP for remote, e.g. http://192.168.1.50:11434/v1)
OPENAI_COMPAT_API_KEY= # Optional; fallback token "ollama" is used if empty
# 网关提供商（通过一个密钥访问多种模型）
OPENROUTER_API_KEY=sk-or-... # OpenRouter — openrouter.ai/settings/keys
# AWS Bedrock（使用标准 AWS 凭证链）
AWS_ACCESS_KEY_ID=AKIA... # IAM user with bedrock:InvokeModel permission
AWS_SECRET_ACCESS_KEY=... # IAM secret key
AWS_DEFAULT_REGION=us-east-1 # Recommended: us-east-1 (N. Virginia) has the widest model availability
```
#### OpenAI 兼容提供商
任何暴露标准 `/v1/chat/completions` 和 `/v1/models` 端点的后端都可以开箱即用地与 RedAmon 配合使用。在 `.env` 中设置 `OPENAI_COMPAT_BASE_URL`，匹配的模型会自动出现在项目设置下拉列表中。
智能体容器已包含 `host.docker.internal` 解析，因此从 Docker 可以访问您主机上运行的本地服务器。
**Ollama 与 RedAmon 在同一台机器上（本地）：**
```
OPENAI_COMPAT_BASE_URL=http://host.docker.internal:11434/v1
```
**Ollama 在不同机器上（远程服务器）：**
```
OPENAI_COMPAT_BASE_URL=http://192.168.1.50:11434/v1 # replace with your Ollama server's IP or hostname
```
使用远程机器的 IP 地址（或主机名）代替 `host.docker.internal`。确保端口 `11434` 可从运行 RedAmon 的机器访问（没有防火墙阻止它）。
**自托管 / 本地（免费）：**
| 提供商 | 描述 | 示例 `OPENAI_COMPAT_BASE_URL` |
|----------|-------------|----------------------------------|
| [Ollama](https://ollama.com/) | 运行本地 LLM 的最简单方式 —— 单命令设置 | `http://host.docker.internal:11434/v1` |
| [vLLM](https://github.com/vllm-project/vllm) | 高性能 GPU 推理服务器 | `http://host.docker.internal:8000/v1` |
| [LM Studio](https://lmstudio.ai/) | 带内置本地服务器的桌面应用 | `http://host.docker.internal:1234/v1` |
| [LocalAI](https://localai.io/) | 开源 OpenAI 替代品，在 CPU 上运行 | `http://host.docker.internal:8080/v1` |
| [Jan](https://jan.ai/) | 类 ChatGPT UI 和本地服务器模式的桌面应用 | `http://host.docker.internal:1337/v1` |
| [llama.cpp server](https://github.com/ggerganov/llama.cpp) | 轻量级 C++ 推理 | `http://host.docker.internal:8080/v1` |
| [OpenLLM](https://github.com/bentoml/OpenLLM) | 用一条命令运行任何开源 LLM | `http://host.docker.internal:3000/v1` |
| [text-generation-webui](https://github.com/oobabooga/text-generation-webui) | 带 OpenAI 兼容 API 扩展的 Gradio UI | `http://host.docker.internal:5000/v1` |
**网关 / 代理（在一个端点后聚合多个提供商）：**
| 提供商 | 描述 |
|----------|-------------|
| [LiteLLM](https://github.com/BerriAI/litellm) | OpenAI 格式的 100+ LLM 代理 —— 可通过 Docker 自托管 |
**具有 OpenAI 兼容 API 的云提供商：**
| 提供商 | 描述 |
|----------|-------------|
| [Together AI](https://together.ai/) | 200+ 开源模型，无服务器 |
| [Groq](https://groq.com/) | Llama、Mixtral、Gemma 的超快推理 |
| [Fireworks AI](https://fireworks.ai/) | 快速开源模型托管 |
| [Deepinfra](https://deepinfra.com/) | 按令牌付费的开源模型 |
| [Mistral AI](https://mistral.ai/) | 通过 OpenAI 兼容端点的 Mistral / Mixtral 模型 |
| [Perplexity](https://www.perplexity.ai/) | 通过 OpenAI 兼容 API 的 Sonar 模型 |
### 攻击面图谱
Neo4j 图数据库是 RedAmon 中每项发现的**唯一事实来源**。它将目标攻击面的完整拓扑存储为互连的知识图谱，支持 Web 应用中的可视探索和 AI 智能体的智能查询。
#### 节点类型
图谱包含组织为四个类别的 **17 种侦察节点类型**，以及 **5 种 EvoGraph 攻击链节点类型**（见下文 [EvoGraph](#evograph--attack-chain-evolution)）：
**基础设施节点** —— 表示网络拓扑：
| 节点 | 关键属性 | 描述 |
|------|---------------|-------------|
| **Domain** | name, registrar, creation_date, expiration_date, WHOIS data | 具有完整 WHOIS 信息的根域名 |
| **Subdomain** | name, has_dns_records | 发现的主机名 |
| **IP** | address, version, is_cdn, cdn_name, asn | 带有 CDN/ASN 元数据的已解析 IP 地址 |
| **Port** | number, protocol, state | IP 上的开放端口 |
| **Service** | name, product, version, banner | 带有版本信息的运行服务 |
**Web 应用节点** —— 表示应用层：
| 节点 | 关键属性 | 描述 |
|------|---------------|-------------|
| **BaseURL** | url, status_code, title, server, response_time_ms, resolved_ip | 带有完整响应元数据的实时 HTTP 端点 |
| **Endpoint** | path, method, has_parameters, is_form, source | 带有 HTTP 方法的已发现 URL 路径 |
| **Parameter** | name, position (query/body/header/path), is_injectable | 输入参数，当漏洞影响它时标记 |
**技术与安全节点** —— 表示检测到的软件和安全态势：
| 节点 | 关键属性 | 描述 |
|------|---------------|-------------|
| **Technology** | name, version, categories, confidence, detected_by, known_cve_count | 检测到的框架、库或服务器 |
| **Header** | name, value, is_security_header | HTTP 响应头 |
| **Certificate** | subject_cn, issuer, not_after, san, tls_version | TLS 证书详情 |
| **DNSRecord** | type (A/AAAA/MX/NS/TXT/SOA), value, ttl | 子域名的 DNS 记录 |
**漏洞与利用节点** —— 表示安全发现和成功攻击：
| 节点 | 关键属性 | 描述 |
|------|---------------|-------------|
| **Vulnerability** | id, name, severity (lowercase), source (nuclei/gvm/security_check), category, curl_command | 带有证据的扫描器发现 |
| **CVE** | id, cvss, severity (uppercase), description, published | 来自 NVD 的已知漏洞 |
| **MitreData** | cve_id, cwe_id, cwe_name, abstraction | CWE 弱点映射 |
| **Capec** | capec_id, name, likelihood, severity, execution_flow | 常见攻击模式 |
| **ChainFinding** | finding_type, severity, title, evidence, confidence | EvoGraph：智能体发现（取代旧版 Exploit 节点）—— 见 [EvoGraph](#evograph--attack-chain-evolution) |
#### 关系链
图谱通过镜像现实世界基础设施的有向关系链连接这些节点：
```
flowchart TB
Domain -->|HAS_SUBDOMAIN| Subdomain
Subdomain -->|RESOLVES_TO| IP
IP -->|HAS_PORT| Port
Port -->|RUNS_SERVICE| Service
Service -->|POWERED_BY| BaseURL
Port -->|SERVES_URL| BaseURL
BaseURL -->|HAS_ENDPOINT| Endpoint
BaseURL -->|USES_TECHNOLOGY| Technology
BaseURL -->|HAS_HEADER| Header
Endpoint -->|HAS_PARAMETER| Parameter
Technology -->|HAS_KNOWN_CVE| CVE
CVE -->|HAS_CWE| MitreData
MitreData -->|HAS_CAPEC| Capec
Vulnerability -->|FOUND_AT| Endpoint
Vulnerability -->|AFFECTS_PARAMETER| Parameter
AttackChain -->|HAS_STEP| ChainStep
ChainStep -->|PRODUCED| ChainFinding
AttackChain -.->|CHAIN_TARGETS| IP
ChainStep -.->|STEP_TARGETED| IP
ChainStep -.->|STEP_EXPLOITED| CVE
ChainFinding -.->|FOUND_ON| IP
ChainFinding -.->|FINDING_RELATES_CVE| CVE
style Domain fill:#2d2d2d,color:#fff
style Subdomain fill:#2d2d2d,color:#fff
style IP fill:#2d2d2d,color:#fff
style Port fill:#2d2d2d,color:#fff
style Service fill:#2d2d2d,color:#fff
style BaseURL fill:#3a3a3a,color:#fff
style Endpoint fill:#3a3a3a,color:#fff
style Parameter fill:#3a3a3a,color:#fff
style Technology fill:#474747,color:#fff
style Header fill:#474747,color:#fff
style CVE fill:#545454,color:#fff
style Vulnerability fill:#545454,color:#fff
style MitreData fill:#616161,color:#fff
style Capec fill:#616161,color:#fff
style AttackChain fill:#6e6e6e,color:#fff
style ChainStep fill:#6e6e6e,color:#fff
style ChainFinding fill:#6e6e6e,color:#fff
```
漏洞根据其来源以不同方式连接：
- **Nuclei 发现**（Web 应用）→ 通过 `FOUND_AT` 链接到特定 Endpoint，通过 `AFFECTS_PARAMETER` 链接到易受攻击的 Parameter。
- **GVM 发现**（网络层）→ 通过 `HAS_VULNERABILITY` 直接链接到 IP 和 Subdomain 节点，以及关联的 CVE 节点。
- **安全检查**（DNS/邮件/头）→ 通过 `HAS_VULNERABILITY` 链接到 Subdomain 或 Domain。
#### 智能体如何使用图谱
在智能体采取任何进攻行动之前，它查询图谱以构建态势感知。这是核心情报循环：
1. **攻击面映射** —— 智能体查询 Domain → Subdomain → IP → Port → Service 链以了解暴露内容。
2. **技术-CVE 关联** —— 遍历 Technology → CVE 关系以查找哪些检测到的软件版本有已知漏洞，按 CVSS 分数优先排序。
3. **可注入参数发现** —— 查询被 Nuclei 标记为 `is_injectable: true` 的 Parameter 节点以识别确认的注入点。
4. **利用可行性评估** —— 交叉引用开放端口、运行服务和已知 CVE 以确定哪些 Metasploit 模块可能成功。
5. **后渗透上下文** —— 成功利用后，智能体在 [EvoGraph](#evograph--attack-chain-evolution) 中创建 `ChainFinding(exploit_success)`，桥接到侦察图谱中的目标 IP 和 CVE，以便后续会话可以引用已被入侵的内容。
所有查询都通过基于正则的租户过滤器注入自动限定到当前用户和项目 —— 智能体从不自己生成租户过滤器，防止意外的跨项目数据访问。
### EvoGraph —— 攻击链演进
与侦察图谱并行运行，**EvoGraph**（演进式攻击链图谱）是一个持久的、演进式图谱，跟踪 AI 智能体在利用会话期间所做的一切。侦察图谱捕获*存在什么*，而 EvoGraph 捕获*尝试了什么、发现了什么、失败了什么以及做出了什么决策* —— 跨越整个攻击生命周期。
EvoGraph 不仅仅是一种日志机制 —— 它是使 RedAmon 的智能体从根本上区别于无状态 LLM 工具的**核心智能层**。通过将攻击链数据构建为图谱并以语义组织格式注入智能体的 ReAct 提示，EvoGraph 将原始执行历史转化为可操作的操作记忆。
#### ReAct 提示中的结构化链上下文
传统智能体系统向 LLM 馈送每个工具调用和输出的扁平、按时间顺序排列的列表 —— 一种嘈杂、令牌密集的格式，关键情报（发现的凭据、确认的 CVE、失败利用的教训）被埋没在数十个外观相同的步骤条目中。**EvoGraph 用直接注入 ReAct 推理循环的结构化、语义分区上下文取而代之**：
| 部分 | LLM 看到的内容 | 为什么重要 |
|---------|-------------------|----------------|
| **发现** | 按严重性排序的所有发现 —— 关键优先（凭据、利用成功、确认的漏洞） | 智能体立即知道已达成什么并可以在此基础上构建 |
| **失败尝试** | 每次失败及其具体教训（"rockyou-top1000 对 SSH 不足"、"端口 80 被过滤，使用 443"） | 智能体避免重复错误 —— 不在已知死胡同上浪费周期 |
| **决策** | 阶段转换和策略变更及其理由 | 智能体理解会话的战略弧线 |
| **最近步骤** | 仅最后 5 次工具执行的紧凑形式 | 保持即时战术感知而不淹没上下文 |
这种结构化注入**将智能体效率提高 25% 以上**，相比扁平执行跟踪。改进来自两个复合效应：LLM 花费更少的推理令牌解析无关上下文（更少噪音 → 更快收敛），并且它做出更好的战术决策，因为关键情报被浮现在其上下文窗口顶部，而不是埋在数百行深处。智能体更快找到正确的利用路径，避免冗余工作，并产生更集中的工具调用 —— 更少浪费的迭代，每会话更多可操作的步骤。
#### 五种节点类型
| 节点 | 用途 |
|------|---------|
| **AttackChain** | 攻击链的根 —— 与聊天会话 1:1 映射（目标、目标、状态、结果） |
| **ChainStep** | 每次工具执行 —— 工具名称、参数、输出分析、成功/失败 |
| **ChainFinding** | 步骤期间发现的情报 —— 确认的漏洞、发现的凭据、利用成功 |
| **ChainDecision** | 战略决策点 —— 阶段转换、策略变更、用户批准/拒绝 |
| **ChainFailure** | 尝试内容及其失败原因的结构化记录，附带经验教训 |
#### 桥接关系
EvoGraph 节点通过类型化桥接关系连接回侦察图谱：
- **CHAIN_TARGETS** —— 将 AttackChain 链接到其在侦察图谱中的目标 IP、Subdomain、Port 或 CVE
- **STEP_TARGETED / STEP_EXPLOITED** —— 将单个步骤链接到其作用的基础设施或其利用的 CVE
- **FOUND_ON / FINDING_RELATES_CVE** —— 将发现链接到其被发现的位置以及相关的 CVE
这种统一意味着单个 Neo4j 查询可以从侦察图谱节点（例如，IP 地址）遍历到针对它的所有攻击链、发现的每项发现以及遇到的每次失败。
#### 持久跨会话记忆
每个攻击链 —— 及其所有步骤、发现、决策和失败 —— 都**永久持久化在 Neo4j 中**。这不是短暂的会话状态：它是整个项目的不断增长的累积知识库。当新会话开始时，智能体自动加载所有先前链的摘要 —— 高严重性发现、失败教训、成功利用、战略结果 —— 并将其注入其初始系统提示。
这意味着智能体**从不从零开始**。会话 B 知道会话 A 已经尝试过小型字典的 SSH 暴力破解并失败了，端口 80 被过滤，以及在 FTP 服务上发现了凭据。它在此累积情报基础上构建，跳过已知死胡同并利用先前发现。跨多个会话，EvoGraph 将智能体从无状态工具执行器转变为**知识积累的进攻系统**，每个会话都使下一个更智能。
#### 双记忆架构
EvoGraph 使用双记录模式 —— 每个事件都写入**内存列表**（通过 `format_chain_context()` 实现即时 LLM 上下文）和 **Neo4j**（通过 `query_prior_chains()` 实现持久跨会话查询）。内存工作记忆从不依赖图谱可用性，确保零延迟智能体推理。
### 多会话并行攻击链
RedAmon 支持针对同一项目启动**多个并发智能体会话**。每个会话在 EvoGraph 中创建自己独立的 **AttackChain**，所有链与 PostgreSQL 中的完整对话历史一起永久持久化在 Neo4j 中。
这意味着您可以：
- **运行并行攻击策略** —— 启动一个针对 SSH 暴力破解的会话，同时另一个探索 Web 应用 CVE，每个独立操作，有自己的步骤、发现和决策链。
- **恢复任何会话** —— 每个会话出现在 AI 抽屉的会话列表中。选择会话恢复其完整对话和链上下文，因此您可以准确地从中断处继续。
- **积累跨会话情报** —— 当新会话开始时，智能体自动加载项目中*所有*先前会话的发现和失败教训。会话 B 知道会话 A 已经尝试过什么、什么有效、什么失败 —— 避免冗余工作并在先前发现基础上构建。
- **持久跟踪一切** —— 所有攻击链、工具执行、发现和决策永久存储在 Neo4j 中。关闭浏览器或重启容器时不会丢失任何内容。完整攻击历史始终可在图谱仪表板上查询和可视化。
每个会话的攻击链在 [graph dashboard](#attack-surface-graph) 上以独特颜色可视化 —— 非活动链以灰色渲染，活动会话的链以橙色脉动，每会话可见性可从底部栏控件切换。
### CypherFix —— 自动化漏洞修复
CypherFix 在**发现漏洞**和**修复漏洞**之间形成闭环。侦察、利用和渗透测试在攻击面图谱中填充数百项发现后，CypherFix 接管 —— 分诊、优先排序并自动生成代码修复。
流水线由两个 AI 智能体组成：
#### 分诊智能体 —— 分析与优先排序
分诊智能体使用**混合架构**：它首先针对 Neo4j 图谱运行 9 个硬编码 Cypher 查询以确定性地收集所有漏洞数据（DAST 发现、CVE 链、机密、利用、攻击链结果、证书、安全检查），然后将原始数据交给 LLM 进行关联、去重和优先排序。
LLM 应用加权评分算法，其中攻击链利用成功（1200 分）、确认的利用（1000 分）和 CISA KEV 条目（800 分）排名最高 —— 确保已证明可利用的漏洞首先被修复。输出是保存到数据库的**修复条目**优先列表，每个都有严重性、CVE/CWE/CAPEC 参考、受影响资产、证据和 AI 建议的解决方案。
在分析阶段，LLM 可以选择调用工具以丰富其理解：
- **`query_graph`** —— 运行后续 Cypher 查询以获取额外上下文
- **`web_search`** —— 检查 CISA KEV 目录、利用数据库或 CVE 详情
#### CodeFix 智能体 —— 修复与交付
CodeFix 智能体获取单个修复条目并自主实施修复。它复制 **Claude Code 的精确智能体设计** —— 一个纯 ReAct while 循环，LLM 是唯一控制器：
1. **克隆**目标仓库并创建修复分支（`cypherfix/{remediation_id}`）
2. **探索**代码库使用 11 种工具：`github_read`、`github_grep`、`github_glob`、`github_symbols`、`github_find_definition`、`github_find_references`、`github_repo_map`、`github_edit`、`github_write`、`github_bash`、`github_list_dir`
3. **实施**修复 —— LLM 读取文件、搜索模式、导航 AST 并进行针对性编辑。每次编辑生成一个**差异块**流式传输到前端供用户审查（接受/拒绝）
4. **验证** —— 智能体可以使用完整运行时环境运行测试、代码检查器和构建
5. **交付** —— 提交所有接受的更改，推送到 GitHub，并打开拉取请求
```
flowchart LR
subgraph Triage["Triage Agent"]
NEO4J[(Neo4j\nAttack Surface)] --> COLLECT[9 Cypher\nQueries]
COLLECT --> LLM_T[LLM Analysis\nCorrelate + Prioritize]
LLM_T --> REMS[Remediation\nEntries]
end
subgraph CodeFix["CodeFix Agent"]
REMS --> CLONE[Clone Repo\nCreate Branch]
CLONE --> REACT[ReAct Loop\n11 Code Tools]
REACT --> DIFF[Diff Blocks\nUser Review]
DIFF --> PR[Commit + Push\nGitHub PR]
end
```
#### 关键设计决策
- **确定性收集 + LLM 分析** —— 分诊智能体始终收集相同数据（可重现）；仅分析变化
- **无硬编码状态机** —— CodeFix 智能体的 LLM 决定工具顺序、重试和何时停止
- **用户批准关卡** —— 每次代码编辑都可以要求用户接受后智能体才能继续
- **可安全重新运行** —— 分支使用完整修复 ID；重新运行时 PR 被更新（不重复）
- **多提供商 LLM** —— 两个智能体都支持 OpenAI、Anthropic、Bedrock、OpenRouter 和自定义 OpenAI 兼容端点
### 项目设置
RedAmon 中的每个项目都有跨 11 个设置类别的 **180+ 个可配置参数**，控制每个侦察模块和 AI 智能体的行为。这些设置通过 Web 应用的项目表单 UI 管理，通过 Prisma ORM 存储在 PostgreSQL 中，并在运行时被侦察容器和智能体获取。
| 类别 | 关键设置 |
|----------|-------------|
| **目标与模块** | 目标域名、子域名列表、隐身模式、扫描模块开关、Tor 路由 |
| **端口扫描** | Naabu 扫描类型、Top-N 端口、速率限制、CDN 排除、被动模式 |
| **HTTP 探测** | httpx 25+ 探测开关、TLS 检查、重定向跟随 |
| **资源枚举** | Katana 深度/最大 URL、GAU 被动发现、Kiterunner API 暴力破解 |
| **漏洞扫描** | Nuclei 严重性过滤器、DAST 模式、模板管理、Interactsh |
| **CVE 与 MITRE** | 来自 NVD/Vulners 的 CVE 丰富、CWE/CAPEC 映射 |
| **安全检查** | 25+ 单项检查：头、TLS、DNS、暴露服务 |
| **GVM 扫描** | 扫描配置文件、目标策略、超时 |
| **集成** | 带有 40+ 正则模式的 GitHub 机密搜寻 |
| **智能体行为** | LLM 模型（400+）、阶段、载荷、ngrok TCP 隧道、批准关卡、限制 |
| **攻击路径** | Hydra 暴力破解、钓鱼 SMTP 配置、工具阶段限制矩阵 |
## 系统架构
### 高层架构
```
flowchart TB
subgraph User["👤 User Layer"]
Browser[Web Browser]
CLI[Terminal/CLI]
end
subgraph Frontend["🖥️ Frontend Layer"]
Webapp[Next.js Webapp
:3000]
end
subgraph Backend["⚙️ Backend Layer"]
Agent[AI Agent Orchestrator
FastAPI + LangGraph
:8090]
ReconOrch[Recon Orchestrator
FastAPI + Docker SDK
:8010]
end
subgraph Tools["🔧 MCP Tools Layer"]
NetworkRecon[Network Recon Server
Curl + Naabu
:8000]
Nuclei[Nuclei Server
:8002]
Metasploit[Metasploit Server
:8003]
Nmap[Nmap Server
:8004]
end
subgraph Scanning["🔍 Scanning Layer"]
Recon[Recon Pipeline
Docker Container]
GVM[GVM/OpenVAS Scanner
Network Vuln Assessment]
GHHunt[GitHub Secret Hunter
Credential Scanning]
end
subgraph Data["💾 Data Layer"]
Neo4j[(Neo4j Graph DB
:7474/:7687)]
Postgres[(PostgreSQL
Project Settings
:5432)]
end
subgraph LLMProviders["🧠 LLM Providers"]
OpenAI[OpenAI]
Anthropic[Anthropic]
LocalLLM[Local Models
Ollama · vLLM · LM Studio]
OpenRouter[OpenRouter
300+ Models]
Bedrock[AWS Bedrock]
end
subgraph External["🌐 External APIs"]
GitHubAPI[GitHub API
Repos & Code Search]
end
subgraph Targets["🎯 Target Layer"]
Target[Target Systems]
GuineaPigs[Guinea Pigs
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
Recon -->|Fetch Settings| Webapp
GHHunt -->|GitHub API| GitHubAPI
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
```
### 数据流流水线
```
flowchart TB
subgraph Phase1["Phase 1: Reconnaissance"]
Domain[🌐 Domain] --> Subdomains[📋 Subdomains
crt.sh, HackerTarget, Knockpy]
Subdomains --> DNS[🔍 DNS Resolution]
DNS --> Ports[🔌 Port Scan
Naabu]
Ports --> HTTP[🌍 HTTP Probe
Httpx]
HTTP --> Tech[🔧 Tech Detection
Wappalyzer]
Tech --> Vulns[⚠️ Vuln Scan
Nuclei]
end
subgraph Phase2["Phase 2: Data Storage"]
Vulns --> JSON[(JSON Output)]
JSON --> Graph[(Neo4j Graph)]
end
subgraph Phase2b["Phase 2b: Network Vuln Scan (Optional)"]
JSON -->|IPs + Hostnames| GVM[🛡️ GVM/OpenVAS
170k+ NVTs]
GVM --> GVMResults[(GVM JSON Output)]
GVMResults --> Graph
end
subgraph Phase2c["Phase 2c: GitHub Secret Hunt (Optional)"]
JSON -->|Target Domain| GHHunt[🔑 GitHub Secret Hunter
40+ Patterns + Entropy]
GHHunt --> GHResults[(GitHub Hunt JSON Output)]
GHResults --> Graph
end
subgraph Phase3["Phase 3: AI Analysis"]
Graph --> Agent[🤖 AI Agent]
Agent --> Query[Natural Language
→ Cypher Query]
Query --> Graph
end
subgraph Phase4["Phase 4: Exploitation"]
Agent --> MCP[MCP Tools]
MCP --> NetworkRecon2[Curl + Naabu
HTTP & Port Scan]
MCP --> Nuclei2[Nuclei
Vuln Verify]
MCP --> Nmap2[Nmap
Service Detection]
MCP --> MSF[Metasploit
Exploit]
MSF --> Shell[🐚 Shell/Meterpreter]
end
subgraph Phase5["Phase 5: Post-Exploitation"]
Shell --> Enum[Enumeration]
Enum --> Pivot[Lateral Movement]
Pivot --> Exfil[Data Exfiltration]
end
```
### Docker 器架构
```
flowchart TB
subgraph Host["🖥️ Host Machine"]
subgraph Containers["Docker Containers"]
subgraph ReconOrchContainer["recon-orchestrator"]
OrchAPI[FastAPI :8010]
DockerSDK[Docker SDK]
SSEStream[SSE Log Streaming]
end
subgraph ReconContainer["recon-container"]
ReconPy[Python Scripts]
Naabu1[Naabu]
Httpx[Httpx]
Knockpy[Knockpy]
end
subgraph MCPContainer["kali-mcp-sandbox"]
MCPServers[MCP Servers]
NetworkReconTool[Network Recon :8000
Curl + Naabu]
NucleiTool[Nuclei :8002]
MSFTool[Metasploit :8003]
NmapTool[Nmap :8004]
end
subgraph AgenticContainer["agentic-container"]
FastAPI[FastAPI :8090]
LangGraph[LangGraph Engine]
LLMProvider[LLM Provider
OpenAI · Anthropic · Local · OpenRouter · Bedrock]
end
subgraph Neo4jContainer["neo4j-container"]
Neo4jDB[(Neo4j :7687)]
Browser[Browser :7474]
end
subgraph PostgresContainer["postgres-container"]
PostgresDB[(PostgreSQL :5432)]
Prisma[Prisma ORM]
end
subgraph WebappContainer["webapp-container"]
NextJS[Next.js :3000]
PrismaClient[Prisma Client]
end
subgraph GVMStack["GVM Stack (Network Vuln Scanner)"]
GVMd[gvmd
GVM Daemon]
OSPD[ospd-openvas
Scanner Engine]
RedisGVM[redis-gvm
Cache/Queue]
PgGVM[pg-gvm
GVM Database]
GVMData[Data Containers
VT + SCAP + CERT + Notus]
end
subgraph GVMScanContainer["gvm-scanner-container"]
GVMScanPy[Python Scripts]
GVMClient[python-gvm Client]
end
subgraph GHHuntContainer["github-secret-hunter-container"]
GHHuntPy[Python Scripts]
PyGithub[PyGithub Client]
end
subgraph GuineaContainer["guinea-pigs"]
Apache1[Apache 2.4.25
CVE-2017-3167]
Apache2[Apache 2.4.49
CVE-2021-41773]
end
end
Volumes["📁 Shared Volumes"]
ReconOrchContainer -->|Manages| ReconContainer
ReconOrchContainer -->|Manages| GVMScanContainer
ReconOrchContainer -->|Manages| GHHuntContainer
GVMScanContainer -->|Unix Socket| GVMd
GVMd --> OSPD
GVMd --> PgGVM
OSPD --> RedisGVM
GVMData -->|Feed Sync| GVMd
ReconContainer --> Volumes
GVMScanContainer -->|Reads Recon Output| Volumes
Volumes --> Neo4jContainer
GVMScanContainer --> Neo4jContainer
WebappContainer --> PostgresContainer
ReconContainer -->|Fetch Settings| WebappContainer
end
```
### 暴露的服务与端口
| 服务 | URL | 描述 |
|---------|-----|-------------|
| **Webapp** | http://localhost:3000 | 主 UI —— 创建项目、配置目标、启动扫描 |
| PostgreSQL | localhost:5432 | 主数据库 |
| Neo4j Browser | http://localhost:7474 | 用于攻击面可视化的图谱数据库 UI |
| Neo4j Bolt | localhost:7687 | Neo4j 驱动协议（智能体使用） |
| Recon Orchestrator | http://localhost:8010 | 管理侦察流水线容器 |
| Agent API | http://localhost:8090 | AI 智能体 WebSocket + REST API |
| MCP Network Recon | http://localhost:8000 | curl + naabu（HTTP 探测、端口扫描） |
| MCP Nuclei | http://localhost:8002 | Nuclei 漏洞扫描器 |
| MCP Metasploit | http://localhost:8003 | Metasploit Framework RPC |
| MCP Nmap | http://localhost:8004 | Nmap 网络扫描器 |
| Metasploit Progress | http://localhost:8013 | 长时间运行利用的实时进度流 |
| Metasploit Listener | localhost:4444 | 反向 shell 监听器 |
### 侦察流水线详情
```
flowchart TB
subgraph Input["📥 Input Configuration"]
Params[project_settings.py
Webapp API → PostgreSQL
TARGET_DOMAIN, SCAN_MODULES]
Env[.env
API Keys
Neo4j Credentials]
end
subgraph Container["🐳 recon-container (Kali Linux)"]
Main[main.py
Pipeline Orchestrator]
subgraph Module1["1️⃣ domain_discovery"]
WHOIS[whois_recon.py
WHOIS Lookup]
CRT[crt.sh API
Certificate Transparency]
HT[HackerTarget API
Subdomain Search]
Knock[Knockpy
Active Bruteforce]
DNS[DNS Resolution
A, AAAA, MX, NS, TXT]
end
subgraph Module2["2️⃣ port_scan"]
Naabu[Naabu
SYN/CONNECT Scan
Top 100-1000 Ports]
Shodan[Shodan InternetDB
Passive Mode]
end
subgraph Module3["3️⃣ http_probe"]
Httpx[Httpx
HTTP/HTTPS Probe]
Tech[Wappalyzer Rules
Technology Detection]
Headers[Header Analysis
Security Headers]
Certs[TLS Certificate
Extraction]
end
subgraph Module4["4️⃣ resource_enum"]
Katana[Katana
Web Crawler]
Forms[Form Parser
Input Discovery]
Endpoints[Endpoint
Classification]
end
subgraph Module5["5️⃣ vuln_scan"]
Nuclei[Nuclei
9000+ Templates]
MITRE[add_mitre.py
CWE/CAPEC Enrichment]
end
end
subgraph Output["📤 Output"]
JSON[(recon/output/
recon_domain.json)]
Graph[(Neo4j Graph
via neo4j_client.py)]
end
Params --> Main
Env --> Main
Main --> WHOIS
WHOIS --> CRT
CRT --> HT
HT --> Knock
Knock --> DNS
DNS --> Naabu
Naabu -.-> Shodan
Naabu --> Httpx
Httpx --> Tech
Tech --> Headers
Headers --> Certs
Certs --> Katana
Katana --> Forms
Forms --> Endpoints
Endpoints --> Nuclei
Nuclei --> MITRE
MITRE --> JSON
JSON --> Graph
```
### 侦察模块数据流
```
sequenceDiagram
participant User
participant Main as main.py
participant DD as domain_discovery
participant PS as port_scan
participant HP as http_probe
participant RE as resource_enum
participant VS as vuln_scan
participant JSON as JSON Output
participant Neo4j as Neo4j Graph
participant GVM as GVM Scanner
User->>Main: python main.py
Main->>Main: Load project settings (API or defaults)
rect rgb(35, 35, 35)
Note over DD: Phase 1: Domain Discovery
Main->>DD: discover_subdomains(domain)
DD->>DD: WHOIS lookup
DD->>DD: crt.sh query
DD->>DD: HackerTarget API
DD->>DD: Knockpy bruteforce
DD->>DD: DNS resolution (all records)
DD-->>Main: subdomains + IPs
end
rect rgb(45, 45, 45)
Note over PS: Phase 2: Port Scanning
Main->>PS: run_port_scan(targets)
PS->>PS: Naabu SYN scan
PS->>PS: Service detection
PS->>PS: CDN/WAF detection
PS-->>Main: open ports + services
end
rect rgb(55, 55, 55)
Note over HP: Phase 3: HTTP Probing
Main->>HP: run_http_probe(targets)
HP->>HP: HTTP/HTTPS requests
HP->>HP: Follow redirects
HP->>HP: Technology fingerprint
HP->>HP: Extract headers + certs
HP-->>Main: live URLs + tech stack
end
rect rgb(40, 40, 40)
Note over RE: Phase 4: Resource Enumeration
Main->>RE: run_resource_enum(urls)
RE->>RE: Katana crawl
RE->>RE: Parse forms + inputs
RE->>RE: Classify endpoints
RE-->>Main: endpoints + parameters
end
rect rgb(50, 50, 50)
Note over VS: Phase 5: Vulnerability Scan
Main->>VS: run_vuln_scan(targets)
VS->>VS: Nuclei templates
VS->>VS: CVE detection
VS->>VS: MITRE CWE/CAPEC mapping
VS-->>Main: vulnerabilities + CVEs
end
Main->>JSON: Save recon_domain.json
Main->>Neo4j: Update graph database
Neo4j-->>User: Graph ready for visualization
rect rgb(60, 60, 60)
Note over GVM: Phase 6 (Optional): Network Vuln Scan
User->>GVM: Trigger GVM scan from UI
GVM->>JSON: Read recon output (IPs + hostnames)
GVM->>GVM: Create scan targets
GVM->>GVM: Run 170k+ NVTs per target
GVM->>GVM: Parse results + CVE extraction
GVM->>Neo4j: Store Vulnerability + CVE nodes
Neo4j-->>User: Network vulns added to graph
end
rect rgb(48, 48, 48)
Note over GVM: Phase 7 (Optional): GitHub Secret Hunt
User->>GVM: Trigger GitHub Hunt from UI
GVM->>GVM: Load project settings (token, org, options)
GVM->>GVM: Enumerate repositories + gists
GVM->>GVM: Scan contents with 40+ patterns + entropy
GVM->>GVM: Scan commit history (if enabled)
GVM->>Neo4j: Store findings in graph
Neo4j-->>User: Leaked secrets added to graph
end
```
### 智能体工作流（ReAct 模式）
```
stateDiagram-v2
[*] --> Idle: Start
Idle --> Reasoning: User Message
Reasoning --> ToolSelection: Analyze Task
ToolSelection --> AwaitApproval: Dangerous Tool?
ToolSelection --> ToolExecution: Safe Tool
AwaitApproval --> ToolExecution: User Approves
AwaitApproval --> Reasoning: User Rejects
ToolExecution --> Observation: Execute MCP Tool
Observation --> Reasoning: Analyze Results
Reasoning --> Response: Task Complete
Response --> Idle: Send to User
Reasoning --> AskQuestion: Need Clarification?
AskQuestion --> Reasoning: User Response
state "User Guidance" as Guidance
Reasoning --> Guidance: User sends guidance
Guidance --> Reasoning: Injected in next think step
state "Stopped" as Stopped
Reasoning --> Stopped: User clicks Stop
ToolExecution --> Stopped: User clicks Stop
Stopped --> Reasoning: User clicks Resume
```
### MCP 工具集成
```
sequenceDiagram
participant User
participant Agent as AI Agent
participant MCP as MCP Manager
participant Tool as Tool Server
participant Target
User->>Agent: "Scan ports on 10.0.0.5"
Agent->>Agent: Reasoning (ReAct)
Agent->>MCP: Request execute_naabu tool
MCP->>Tool: JSON-RPC over SSE (:8000)
Tool->>Target: SYN Packets
Target-->>Tool: Open Ports
Tool-->>MCP: JSON Results
MCP-->>Agent: Parsed Output
Agent->>Agent: Analyze Results
Agent-->>User: "Found ports 22, 80, 443..."
```
## 组件
### 1. 侦察流水线
从单个域名开始的自动化 OSINT 和漏洞扫描。
| 工具 | 用途 |
|------|---------|
| crt.sh | 证书透明度子域名发现 |
| HackerTarget | 基于 API 的子域名枚举 |
| Knockpy | 主动子域名暴力破解 |
| Naabu | 快速端口扫描 |
| Httpx | HTTP 探测和技术检测 |
| Nuclei | 基于模板的漏洞扫描 |
📖 **[Read Recon Documentation](recon/README.RECON.md)**
### 2. 图数据库
Neo4j 驱动的攻击面映射，支持多租户。
```
Domain → Subdomain → IP → Port → Service → Technology → Vulnerability → CVE
```
- **浏览器 UI**: http://localhost:7474
- **Bolt 协议**: bolt://localhost:7687
📖 **[Read Graph DB Documentation](graph_db/readmes/README.GRAPH_DB.md)**
📖 **[View Graph Schema](graph_db/readmes/GRAPH.SCHEMA.md)**
### 3. MCP 工具服务器
通过模型上下文协议暴露的安全工具，用于 AI 智能体集成。
| 服务器 | 端口 | 工具 | 能力 |
|--------|------|-------|------------|
| network_recon | 8000 | Curl, Naabu | HTTP 请求、头检查、快速端口扫描 |
| nuclei | 8002 | Nuclei | 9,000+ 漏洞模板 |
| metasploit | 8003 | Metasploit | 利用、后渗透、会话 |
| nmap | 8004 | Nmap | 服务检测、OS 指纹识别、NSE 脚本 |
📖 **[Read MCP Documentation](mcp/README.MCP.md)**
### 4. AI 智能体编排器
基于 LangGraph 的自主智能体，采用 ReAct 模式。
- **WebSocket 流式传输**：实时更新到前端
- **阶段感知执行**：危险操作需人工批准
- **记忆持久化**：通过 MemorySaver 保存对话历史
- **多目标支持**：复杂攻击链规划
- **实时指导**：在智能体工作时发送引导消息
- **停止与恢复**：中断执行并从上次检查点恢复
📖 **[Read Agentic Documentation](agentic/readmes/README.PENTEST_AGENT.md)**
📖 **[Attack Paths Architecture](agentic/readmes/README.ATTACK_PATHS.md)**
### 5. Web 应用程序
用于可视化和 AI 交互的 Next.js 仪表板。
- **图谱可视化**：交互式 Neo4j 图谱浏览器
- **AI 聊天界面**：基于 WebSocket 的智能体通信
- **节点检查器**：资产和关系的详细视图
- **批准工作流**：确认危险工具执行
📖 **[Read Webapp Documentation](webapp/README.WEBAPP.md)**
### 6. GVM 扫描器
Greenbone 漏洞管理 (GVM)，前身为 OpenVAS，是企业级网络漏洞扫描器。与 Nuclei（专注于通过 HTTP 模板进行 Web 应用测试）不同，GVM 通过直接在协议层探测服务来执行深度网络级漏洞评估 —— 测试错误配置、过时软件、默认凭据以及每个开放端口上的已知 CVE。
- **170,000+ 网络漏洞测试 (NVT)** —— 最大的开源漏洞测试源，涵盖操作系统、网络服务、数据库和嵌入式设备。
- **CVSS 评分和 CVE 映射** —— 每项发现都包含 CVSS 分数、CVE 参考和修复指导。
- **侦察输出集成** —— 消耗侦察流水线发现的 IP 地址和主机名，消除冗余主机发现的需要。
- **图谱数据库链接** —— GVM 发现作为 Vulnerability 节点（source="gvm"）存储在 Neo4j 中，通过 `HAS_VULNERABILITY` 关系链接到 IP 和 Subdomain 节点，以及关联的 CVE 节点 —— 补充 Nuclei 的 Web 层发现。
- **Web 应用集成** —— 通过图谱页面上的专用 "GVM Scan" 按钮触发（需要先前的侦察数据）。日志实时流式传输到带有 4 阶段进度跟踪的日志抽屉，结果可下载为 JSON。
📖 **[Read GVM Documentation](gvm_scan/README.GVM.md)**
### 7. GitHub 机密搜寻器
独立模块，扫描 GitHub 仓库、Gist 和提交历史，查找与您目标相关的暴露机密和凭据。独立于侦察流水线运行 —— 在侦察完成后从图谱页面触发。
- **40+ 机密检测模式** —— 基于 regex 的匹配，用于 AWS 密钥、Google Cloud 凭据、数据库连接字符串、JWT 令牌、私钥、Slack/Discord/Stripe 令牌、SSH 密钥等。
- **Shannon 熵分析** —— 检测可能是机密的高熵字符串，即使没有 regex 模式匹配，减少假阴性。
- **提交历史扫描** —— 检查 git diff 以查找已提交并后来删除但仍保留在版本历史中的机密。
- **组织和成员扫描** —— 枚举目标组织下的仓库，并可选扩展到单个组织成员的仓库。
- **Gist 扫描** —— 搜索公共和私有 Gist 中的泄露凭据。
- **图谱数据库链接** —— 发现存储在 Neo4j 中并链接到目标的攻击面图谱。
- **Web 应用集成** —— 通过图谱页面上的专用 "GitHub Hunt" 按钮触发（需要先前的侦察数据）。日志实时流式传输到带有 3 阶段进度跟踪的日志抽屉，结果可下载为 JSON。
#### 运行 GitHub 机密搜寻
1. 在项目设置中配置 **GitHub 个人访问令牌**和**目标组织**（见 [GitHub Secret Hunting parameters](#github-secret-hunting) 获取分步令牌设置）
2. 导航到图谱页面
3. 点击 **GitHub Hunt** 按钮（仅当项目存在侦察数据时启用）
4. 在 GitHub Hunt 日志抽屉中查看实时日志（3 阶段进度：加载设置、扫描仓库、完成）
5. 完成后下载结果 JSON
### 8. 测试环境
用于安全、隔离测试的故意易受攻击的 Docker 容器。这些环境让您验证完整的 RedAmon 流水线 —— 从侦察到利用 —— 而不触及任何外部系统。
| 环境 | 漏洞 | 描述 |
|-------------|--------------|-------------|
| Apache 2.4.25 | CVE-2017-3167 | `mod_auth_digest` 中的认证绕过，允许未经授权访问受保护资源 |
| Apache 2.4.49 | CVE-2021-41773 (路径遍历 + RCE) | 路径规范化缺陷，可通过 `mod_cgi` 实现目录遍历和远程代码执行 |
这些容器设计为与主栈一起部署，以便 AI 智能体可以在受控实验室环境中发现、扫描和利用它们。
📖 **[Read Guinea Pigs Documentation](guinea_pigs/README.GPIGS.md)**
## 技术栈
### 前端
| 技术 | 角色 |
|-----------|------|
| **Next.js** (v16) | 全栈 React 框架 —— 服务端渲染、API 路由和项目 Web 应用 |
| **React** (v19) | 为所有交互视图提供支持的基于组件的 UI 库 |
| **TypeScript** | 整个前端代码库的静态类型 |
| **TanStack React Query** | 服务器状态管理、缓存和数据同步 |
| **React Force Graph (2D & 3D)** | 交互式攻击面图谱可视化 |
| **Three.js** | 3D 图谱视图背后的 3D 渲染引擎 |
| **D3 Force** | 用于图谱定位的力导向布局算法 |
| **React Markdown** | 以 markdown 格式渲染智能体聊天响应 |
| **React Syntax Highlighter** | 智能体输出中的代码块高亮 |
| **Lucide React** | 整个 UI 中使用的图标系统 |
### 后端与 API
| 技术 | 角色 |
|-----------|------|
| **FastAPI** | 用于侦察编排器和智能体 API 的异步 Python Web 框架 |
| **Uvicorn** | 运行两个 FastAPI 服务的 ASGI 服务器 |
| **Pydantic** | 所有 Python 服务的数据验证和设置管理 |
| **Docker SDK for Python** | 编程式容器生命周期管理 —— 侦察编排器使用它生成和控制侦察、GVM 和 GitHub 搜寻容器 |
| **SSE (Server-Sent Events)** | 从侦察流水线和 GVM 扫描到 Web 应用的实时日志流 |
| **WebSocket** | 智能体和 Web 应用聊天之间的双向实时通信 |
### AI 与 LLM
| 技术 | 角色 |
|-----------|------|
| **LangChain** | LLM 应用框架 —— 提示管理、工具绑定、链组合 |
| **LangGraph** | 实现 ReAct（推理 + 行动）智能体循环的状态机引擎 |
| **OpenAI**（直接） | 支持的 LLM 系列 —— GPT-5.2、GPT-5、GPT-4.1。需要 `OPENAI_API_KEY` |
| **Anthropic**（直接） | 支持的 LLM 系列 —— Claude Opus 4.6、Sonnet 4.5、Haiku 4.5。需要 `ANTHROPIC_API_KEY` |
| **OpenAI 兼容** | 任何 OpenAI 兼容端点（例如 Ollama）。需要 `OPENAI_COMPAT_BASE_URL`；可选 `OPENAI_COMPAT_API_KEY` |
| **OpenRouter** | 多模型网关 —— 通过单一 API 密钥访问 300+ 模型（Llama 4、Gemini 3、Mistral、Qwen 等）。使用 OpenAI 兼容端点。需要 `OPENROUTER_API_KEY` |
| **AWS Bedrock** | 托管 AWS 服务 —— 通过 `langchain-aws` 访问基础模型（Claude、Titan、Llama、Cohere 等）。需要 `AWS_ACCESS_KEY_ID` + `AWS_SECRET_ACCESS_KEY` |
| **Tavily** | AI 驱动的网络搜索，智能体用于 CVE 研究和利用情报 |
| **模型上下文协议 (MCP)** | 工具集成的标准化协议 —— 智能体通过 MCP 服务器调用安全工具 |
| **LangChain AWS** | AWS Bedrock 集成 —— 用于 Bedrock 基础模型的 `ChatBedrockConverse` |
| **LangChain MCP 适配器** | 桥接 LangChain 工具接口与 MCP 服务器端点 |
| **文本到 Cypher** | LLM 驱动的自然语言到 Neo4j Cypher 查询转换 |
### 数据库
| 技术 | 角色 |
|-----------|------|
| **Neo4j**（社区版） | 图数据库 —— 将整个攻击面存储为具有 17 种节点类型和 20+ 种关系类型的互连知识图谱 |
| **APOC** | Neo4j 插件，为图谱操作提供高级过程和函数 |
| **PostgreSQL** (v16) | 关系数据库 —— 存储项目设置、用户账户和配置数据 |
| **Prisma** | PostgreSQL 的 TypeScript ORM —— 模式管理、迁移和类型安全查询 |
| **Redis** | GVM 漏洞扫描栈中使用的内存缓存和消息队列 |
### 安全与渗透测试工具
| 工具 | 类别 | 角色 |
|------|----------|------|
| **Kali Linux** | 基础平台 | 渗透测试发行版，用作侦察和 MCP 工具容器的基础 Docker 镜像 |
| **Metasploit Framework** | 利用 | 利用执行、载荷交付、Meterpreter 会话、辅助扫描器和后渗透 |
| **Naabu** | 端口扫描 | 来自 ProjectDiscovery 的快速 SYN/CONNECT 端口扫描器 |
| **Nmap** | 网络扫描 | 用于深度服务检测、OS 指纹识别和 NSE 漏洞脚本的网络映射器 —— 作为专用 MCP 服务器暴露 |
| **Nuclei** | 漏洞扫描 | 带有 9,+ 社区模板的基于模板的扫描器 —— DAST 模糊测试、CVE 检测、错误配置检查 |
| **Httpx** | HTTP 探测 | HTTP/HTTPS 探测、技术检测、TLS 检查和响应元数据提取 |
| **Katana** | Web 爬虫 | 带 JavaScript 渲染的主动网络爬虫 —— 发现 URL、端点、表单和参数 |
| **GAU** (GetAllUrls) | 被动侦察 | 来自 Wayback Machine、Common Crawl、AlienVault OTX 和 URLScan.io 的被动 URL 发现 |
| **Kiterunner** | API 发现 | 使用真实世界 Swagger/OpenAPI 衍生字典的 API 端点暴力破解器 |
| **Knockpy** | 子域名发现 | 主动子域名暴力破解工具 |
| **Wappalyzer** | 指纹识别 | 带有 6,000+ 检测规则的技术指纹识别引擎 |
| **Interactsh** | 带外检测 | 用于检测盲漏洞（SSRF、XXE、盲 SQLi）的回调服务器 |
| **Tor / Proxychains4** | 匿名性 | 用于隐秘侦察的匿名流量路由 |
### 漏洞评估
| 技术 | 角色 |
|-----------|------|
| **GVM / OpenVAS** (Greenbone) | 带有 170,000+ 网络漏洞测试 (NVT) 的网络级漏洞扫描器 |
| **ospd-openvas** | OpenVAS 扫描器引擎 —— 针对目标服务执行协议级探测 |
| **gvmd** | GVM 守护进程 —— 编排扫描、管理配置并暴露 GMP API |
| **GitHub 机密搜寻器** | 使用 40+ regex 模式和 Shannon 熵分析检测 GitHub 仓库中泄露凭据的自定义扫描器 |
### 数据源与威胁情报
| 来源 | 角色 |
|--------|------|
| **NVD**（国家漏洞数据库） | CVE 查询、CVSS 分数和漏洞描述 |
| **MITRE CWE / CAPEC** | 发现的 CVE 的弱点分类和常见攻击模式映射 |
| **Shodan InternetDB** | 无需向目标发送数据包的被动端口和服务数据 |
| **crt.sh** | 用于子域名发现的证书透明度日志查询 |
| **Wayback Machine** | 用于被动端点发现的历史 URL 存档 |
| **Common Crawl** | 用于被动 URL 收集的 Web 存档数据 |
| **AlienVault OTX** | 用于 URL 和指标丰富的开放威胁情报源 |
| **URLScan.io** | URL 扫描和分析数据 |
| **HackerTarget** | 被动子域名枚举 API |
| **Vulners** | 用于 CVE 丰富的替代漏洞数据库 |
| **GitHub API** | 通过 PyGithub 进行机密扫描的仓库和代码搜索 |
### 基础设施与 DevOps
| 技术 | 角色 |
|-----------|------|
| **Docker** | 容器运行时 —— 每个组件都容器化运行，零主机依赖 |
| **Docker Compose** (v2) | 多容器编排 —— 定义和管理整个 12+ 容器栈 |
| **Docker-in-Docker (DinD)** | 允许侦察编排器生成临时扫描容器的架构模式 |
| **Python** (3.11) | 所有后端服务的核心语言 —— 侦察流水线、智能体、编排器、GVM 扫描器、GitHub 搜寻器 |
| **Node.js** (v22) | Next.js Web 应用的 JavaScript 运行时 |
| **Go** (1.25) | 从源代码编译 ProjectDiscovery 工具的构建环境 |
| **Bash / Shell** | 容器入口点脚本、工具编排和自动化 |
### 协议与通信
| 协议 | 角色 |
|----------|------|
| **MCP (模型上下文协议)** | 标准化工具集成 —— 四个 MCP 服务器（网络侦察、Nuclei、Metasploit、Nmap）运行在 Kali 沙箱内 |
| **SSE (Server-Sent Events)** | 用于侦察日志、GVM 扫描进度和 GitHub 搜寻输出的单向实时流 |
| **WebSocket** | 用于代理聊天界面的双向实时通信 |
| **Bolt** (Neo4j) | 用于高性能 Neo4j 图数据库查询的二进制协议 |
| **GMP** (Greenbone Management Protocol) | 用于与 GVM 守护进程通信的基于 XML 的协议 |
| **REST / HTTP** | 所有容器之间的服务间 API 通信 |
## 文档
| 组件 | 文档 |
|-----------|---------------|
| 侦察 | [recon/README.RECON.md](recon/README.RECON.md) |
| 侦察编排器 | [recon_orchestrator/README.md](recon_orchestrator/README.md) |
| 图数据库 | [graph_db/readmes/README.GRAPH_DB.md](graph_db/readmes/README.GRAPH_DB.md) |
| 图模式 | [graph_db/readmes/GRAPH.SCHEMA.md](graph_db/readmes/GRAPH.SCHEMA.md) |
| PostgreSQL 数据库 | [postgres_db/README.md](postgres_db/README.md) |
| MCP 服务器 | [mcp/README.MCP.md](mcp/README.MCP.md) |
| AI 代理 | [agentic/readmes/README.PENTEST_AGENT.md](agentic/readmes/README.PENTEST_AGENT.md) |
| 攻击路径 | [agentic/readmes/README.ATTACK_PATHS.md](agentic/readmes/README.ATTACK_PATHS.md) |
| CypherFix 代理 | [agentic/readmes/README.CYPHERFIX_AGENTS.md](agentic/readmes/README.CYPHERFIX_AGENTS.md) |
| Web 应用 | [webapp/README.WEBAPP.md](webapp/README.WEBAPP.md) |
| GVM 扫描器 | [gvm_scan/README.GVM.md](gvm_scan/README.GVM.md) |
| GitHub 机密搜寻 | [github_secret_hunt/README.md](github_secret_hunt/README.md) |
| 测试环境 | [guinea_pigs/README.GPIGS.md](guinea_pigs/README.GPIGS.md) |
| 更新日志 | [CHANGELOG.md](CHANGELOG.md) |
| 完整免责声明 | [DISCLAIMER.md](DISCLAIMER.md) |
| 许可证 | [LICENSE](LICENSE) |
| **Wiki** | **[Full User Guide & Documentation](https://github.com/samugit83/redamon/wiki)** |
## 数据导出与导入
RedAmon 支持通过 Web 界面进行完整的项目备份和恢复。每次导出都会生成一个包含所有项目数据的可移植 ZIP 归档文件，该文件可在任何 RedAmon 实例中导入。
### 导出内容
| 数据 | 来源 | 描述 |
|------|--------|-------------|
| **项目设置** | PostgreSQL | 所有 300 多个配置字段（扫描模块、工具参数、代理行为、攻击路径） |
| **代理对话** | PostgreSQL | 与 AI 代理的完整聊天记录，包括工具调用和响应 |
| **攻击面图** | Neo4j | 所有节点（域名、子域名、IP、端口、服务、URL、漏洞、CVE 等）及其关系 |
| **侦察输出** | 文件系统 | 来自侦察管道的原始 JSON 输出 |
| **GVM 结果** | 文件系统 | 来自 OpenVAS/GVM 漏洞扫描的原始 JSON 输出 |
| **GitHub 搜寻结果** | 文件系统 | 来自 GitHub 机密扫描的原始 JSON 输出 |
### 导出项目
1. 导航至 **项目** 并选择一个项目
2. 打开 **项目设置**（齿轮图标）
3. 点击标题栏中的 **导出** 按钮
4. ZIP 文件将自动下载
### 导入项目
1. 导航至 **项目**
2. 选择将拥有导入项目的 **用户**
3. 点击 **导入项目** 按钮
4. 选择一个之前导出的 ZIP 文件
5. 项目将在所选用户下创建，并恢复所有数据
## 更新至新版本
将 RedAmon 更新至新版本时，所有 Docker 镜像和卷都会从头重新构建。请按照以下步骤在更新过程中保留您的数据。
### 分步更新流程
**1. 导出所有项目**
更新前，请前往 Web 界面导出您想保留的每个项目：
- 打开每个项目的 **设置** 页面
- 点击 **导出** 以下载备份 ZIP 文件
- 将所有 ZIP 文件保存在项目目录之外的安全位置
**2. 停止所有容器**
```
docker compose down
```
**3. 拉取最新版本**
```
git pull origin master
```
**4. 移除旧镜像、容器和卷**
```
docker compose down --rmi all --volumes
```
这将移除所有容器、镜像和数据卷，以便进行全新的构建。
**5. 从头重新构建所有内容**
构建核心服务和按需工具镜像（侦察扫描器、漏洞扫描器、GitHub 机密搜寻器）：
```
docker compose build --no-cache
docker compose --profile tools build --no-cache
```
**6. 启动新版本**
**完整堆栈**（包含 GVM/OpenVAS 漏洞扫描器）：
```
docker compose up -d
```
**仅核心服务**（不包含 GVM —— 启动更快，资源占用更低）：
```
docker compose up -d postgres neo4j recon-orchestrator kali-sandbox agent webapp
```
**7. 等待初始化**
等待所有服务变为健康状态。如果使用包含 GVM 的完整堆栈，首次启动需要约 30 分钟进行漏洞源同步。
```
docker compose ps # check service status
```
**8. 导入您的项目**
一旦所有服务运行：
1. 打开位于 `http://localhost:3000` 的 Web 界面
2. 创建或选择一个用户
3. 点击 **导入项目** 并上传每个导出的 ZIP 文件
4. 验证您的项目、图数据和对话是否已恢复
## 贡献
欢迎贡献！请阅读 [CONTRIBUTING.md](CONTRIBUTING.md) 了解如何开始、代码风格规范和拉取请求流程的指南。
## 维护者
**Samuele Giampieri** —— 创始人兼首席维护者。
- [LinkedIn](https://www.linkedin.com/in/samuele-giampieri-b1b67597/)
- [Devergo Labs](https://www.devergolabs.com/)
- [GitHub](https://github.com/samugit83)
## 法律声明
本项目基于 [MIT License](LICENSE) 发布。
请参阅 [DISCLAIMER.md](DISCLAIMER.md) 了解完整的使用条款、可接受使用策略和法律合规要求。
负责任地使用。合乎道德地测试。更好地防御。