abhikdps/universal-adversarial-mesh
GitHub: abhikdps/universal-adversarial-mesh
UAM 是一个可扩展的多智能体编排框架，能持续自主进行红蓝对抗，跨基础设施、应用和平台审计、利用及修复漏洞。
Stars: 0 | Forks: 0
# 通用对抗性网格（UAM）
一个可扩展的多智能体编排框架，作为持续自主运行的红蓝对抗团队。UAM 与目标无关——它可以通过可插拔的模块架构审计、利用并修复跨基础设施、应用程序和平台的漏洞。
```
╔═══════════════════════════════════════════════════════════╗
║ Universal Adversarial Mesh (UAM) ║
║ Autonomous Red/Blue Team Orchestration Framework ║
╚═══════════════════════════════════════════════════════════╝
```
## 工作原理
UAM 通过九个阶段运行完整的对抗循环：
```
Recon Chain Exploit Post- Multi- Detect Evaluate Remediate Validate
Exploit Stage
┌──────┐ ┌──────┐ ┌──────┐ ┌───────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐ ┌───────┐
│Scan │─▶│Decide│──▶│Attack│─▶│Pivot │─▶│Chain │──▶│Sense │──▶│Score │─▶│Patch │──▶│Re-run │
│Target│ │Order │ │Target│ │Persist│ │Follow│ │Threat│ │Result│ │Target│ │Exploit│
└──────┘ └──────┘ └──────┘ │Exfil │ │ Up │ └──────┘ └──────┘ └──────┘ └───────┘
Red Chain Red └───────┘ └──────┘ Blue Judge Blue Closed
Team Engine Team Red Chain Team Engine Team Loop
Team Engine
```
1. **侦察** -- 扫描目标以发现攻击面（开放端口、SUID 二进制文件、API 端点、云元数据、CI/CD 服务、OSINT、指纹识别）
2. **链式攻击** -- 攻击链引擎根据侦察结果决定运行哪些利用以及执行顺序
3. **利用** -- 发起与目标类型匹配的攻击（文件读取、SQL 注入、路径遍历、凭据填充、流水线投毒、API 模糊测试、协议攻击）
4. **后渗透** -- 执行后渗透技术：横向移动、持久化机制、数据泄露
5. **多阶段链式攻击** -- 分析利用结果并链接后续攻击（例如 SSH 密钥收集 → 横向移动，影子读取 → 凭据破解）
6. **检测** -- 传感器实时捕获攻击（用于系统调用的 eBPF、用于 HTTP 异常的 OTel 追踪收集器、平台审计日志监控器、后渗透行为传感器）
7. **评估** -- 策略引擎对结果进行评分，并可终止恶意进程
8. **修复** -- 合成针对目标特定的补丁（AppArmor 配置文件、WAF 规则、Seccomp 配置文件、Terraform 片段、K8s NetworkPolicy）
9. **验证** -- 重新运行原始利用攻击已修补的目标，以确认修复是否有效
所有组件通过 NATS JetStream 异步通信。每个事件——攻击、遥测、修复——都作为结构化 JSON 流经消息代理。
## 架构
```
┌──────────────────────────────────────────────────────────────────────┐
│ Control Plane │
│ ┌───────────────┐ ┌──────────────┐ ┌───────────────────────────┐ │
│ │ Orchestrator │ │ Event Router │ │ Evaluation Engine │ │
│ │ (Game Session)│ │ (NATS) │ │ (Scoring + Chaining) │ │
│ └──────┬────────┘ └──────┬───────┘ └───────────┬───────────────┘ │
│ │ │ │ │
│ ┌──────┴────────┐ ┌─────┴──────┐ ┌─────────────┴───────────┐ │
│ │Patch Validator│ │ Dashboard │ │ gRPC Plugin Server │ │
│ │(Closed Loop) │ │ (SSE/HTTP) │ │ (Out-of-process Extn) │ │
│ └───────────────┘ └────────────┘ └─────────────────────────┘ │
│ │
├──────────────────── Message Broker (NATS) ───────────────────────────┤
│ │ ┌────────┴────────┐ │ │
│ ▼ ▼ ▼ ▼ │
│ ┌──────────────────────────────────┐ ┌──────────────────────────┐ │
│ │ Red Team Mesh │ │ Blue Team Mesh │ │
│ │ ┌───────┐ ┌────────┐ ┌───────┐ │ │ ┌──────┐ ┌─────┐ ┌─────┐ │ │
│ │ │ Recon │ │Exploit │ │ Post │ │ │ │ eBPF │ │ OTel│ │Polic│ │ │
│ │ │Modules│ │Modules │ │Exploit│ │ │ │Senso.│ │Coll.│ │Engi.│ │ │
│ │ │OSINT │ │Go + Py │ │Lat.Mv │ │ │ │(C/Go)│ │ │ │ │ │ │
│ │ │Finger.│ │Nuclei │ │Persis │ │ │ │PostEx│ │ │ │ │ │ │
│ │ └───────┘ └────────┘ │Exfilt │ │ │ │Sensor│ │ │ │ │ │ │
│ │ └───────┘ │ │ └──────┘ └─────┘ └─────┘ │ │
│ └──────────────────────────────────┘ └──────────────────────────┘ │
│ │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ Remediation Synthesizer │ │
│ │ AppArmor │ WAF │ Seccomp │ Terraform │ K8s │ sshd │ iptables │ │
│ └───────────────────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────────────────────┘
```
## 快速开始
### 前置条件
- **Go 1.25+**
- **Podman**（首选）或 **Docker** -- 运行时将自动检测
- **podman-compose** 或 **docker-compose**（用于演示目标）
- **Python 3**（可选 -- 启用 Python 利用模块）
- **kubectl**（可选 -- 启用 Kubernetes 目标模块）
- **aws** CLI（可选 -- 启用 AWS 目标模块）
- **nmap**（可选 -- 启用网络端口扫描）
- **nikto**、**sqlmap**（可选 -- 深度 Web 应用扫描）
- **ssh-audit**（可选 -- SSH 密码/算法分析）
- **nuclei**（可选 -- 用于 Web 应用目标的 Nuclei 漏洞扫描器）
- **theHarvester**、**amass**（可选 -- OSINT 侦察）
- **protoc** + **protoc-gen-go** + **protoc-gen-go-grpc**（可选 -- 仅在编辑 `uam.proto` 后重新生成 proto 桩时需要）
### 运行完整循环
```
# 40. Generate
git clone https://github.com/abhikdps/universal-adversarial-mesh.git
cd universal-adversarial-mesh
# 41. encryption_key: "" # optional: set via UAM_ENCRYPTION_KEY env var instead
./scripts/run.sh
# 42. Run all unit tests
# 43. Run with verbose output and race detection
```
### 使用 CLI
UAM 支持两种 CLI 风格：`run` 子命令（推荐）和旧版标志。
```
# 44. Run a specific package
go build -o bin/uam ./cmd/uam
# 45. Run with coverage
./bin/uam help
./bin/uam run --help
./bin/uam target --help
# 46. CI/CD
./bin/uam run --all --config configs/default.yaml
# I need to translate each line to Simplified Chinese while keeping English terms intact. Let me go through each one.
./bin/uam run --targets ssh,network --config configs/default.yaml
# 1. Clone -> 克隆
./bin/uam run --dashboard 8080 --config configs/default.yaml
# 2. Start infrastructure + dashboard (builds containers, starts NATS) -> 启动基础设施 + 仪表板（构建容器，启动 NATS） – Keep NATS in English.
./bin/uam run --targets ssh --mode red
# 3. The dashboard opens at http://localhost:8080 -> 仪表板在 http://localhost:8080 打开 – URL stays in English.
./bin/uam run --session
# 4. Trigger sessions against any target from the UI -> 从 UI 触发对任何目标的会话 – UI is a common abbreviation, keep it in English.
./bin/uam run --all --mode both --validate --dashboard 8080 --config configs/default.yaml
```
### 目标管理
管理存储在 `~/.uam/targets.yaml` 中的持久化目标：
```
# 5. Build UAM -> 构建 UAM – UAM might be a tool or framework, keep in English.
./bin/uam target add --name "My SSH Server" --type ssh --endpoint localhost \
--metadata "ssh_user=admin,ssh_port=22"
# 6. Show help -> 显示帮助
./bin/uam target list
# 7. Run all targets from config -> 从配置运行所有目标
./bin/uam target remove target-ssh-my-ssh-server
```
来自 `~/.uam/targets.yaml` 的目标与 YAML 配置文件中定义的目标合并。带有 `container_label` 元数据字段的容器目标将根据正在运行的容器自动发现其端点。
### 手动运行（演示目标）
```
# 8. Run specific targets -> 运行特定目标
podman-compose -f deployments/docker-compose.yml up -d
# 9. Dashboard-only mode (no sessions on startup, trigger from UI) -> 仅仪表板模式（启动时不运行会话，从 UI 触发）
go build -o bin/uam ./cmd/uam
# 10. Red team only -> 仅红队
./bin/uam run --all --config configs/default.yaml --concurrent --validate --dashboard 8080
# 11. Remediate a previous red team session -> 修复先前的红队会话
podman-compose -f deployments/docker-compose.yml down -v
```
### 真实世界目标
```
# 12. Full pipeline with dashboard -> 带仪表板的完整流水线
./bin/uam run --targets kubernetes --validate --dashboard 8080
# 13. Add a target -> 添加目标
./bin/uam run --targets app --config targets.yaml --dry-run
# 14. List all targets -> 列出所有目标
./bin/uam run --targets ssh --config targets.yaml --validate
# 15. Remove a target -> 移除目标
./bin/uam run --targets aws --validate
# 16. 1. Start infrastructure -> 1. 启动基础设施
./bin/uam run --all --config targets.yaml --concurrent --validate
```
### CLI 参考
#### `uam run` 标志
| 标志 | 默认值 | 描述 |
| ------ | --------- | ------------- |
| `--targets` | | 要运行的目标 ID、名称或类型的逗号分隔列表 |
| `--all` | `false` | 运行所有用户定义的目标 |
| `--config` | | YAML 配置文件路径 |
| `--session` | | 要修复的源会话 ID（隐含 `--mode blue`） |
| `--mode` | `both` | 运行模式：`red`、`blue` 或 `both` |
| `--dashboard` | `0` | 仪表盘端口（0 = 禁用） |
| `--concurrent` | `false` | 并发运行会话 |
| `--validate` | `false` | 修补后重新运行利用以验证修复 |
| `--dry-run` | `false` | 记录操作但不执行破坏性利用 |
| `--watch` | | 监视模式间隔（例如 `5m`、`1h`） |
| `--watch-targets` | | 要监视的目标 ID 或类型的逗号分隔列表 |
| `--output` | | 输出目录（覆盖配置） |
| `--json-log` | `false` | 使用 JSON 结构化日志 |
| `--log-level` | `info` | 日志级别：`debug`、`info`、`warn`、`error` |
| `--plugins-dir` | | 包含远程插件 `.plugin` 描述符文件的目录 |
#### 旧版标志（无子命令）
| 标志 | 默认值 | 描述 |
| ------ | --------- | ------------- |
| `-target` | `all` | 目标类型过滤器：`infra`、`app`、`platform`、`kubernetes`、`ssh`、`aws`、`container`、`network` 或 `all` |
| `-nats` | `nats://localhost:4222` | NATS 服务器 URL |
| `-output` | `./output` | 存放会话结果 JSON 文件的目录 |
| `-config` | | YAML 配置文件路径 |
| `-concurrent` | `false` | 并发运行会话 |
| `-validate` | `false` | 修补后重新运行利用以验证修复 |
| `-dry-run` | `false` | 记录操作但不执行破坏性利用 |
| `-json-log` | `false` | 使用 JSON 结构化日志（slog） |
| `-dashboard` | `0` | 仪表盘端口（0 = 禁用） |
| `-mode` | `both` | 运行模式：`red`（仅攻击）、`blue`（仅修复）或 `both` |
| `-watch` | | 监视模式间隔（例如 `5m`、`1h`）。按此计划重新运行会话 |
| `-watch-targets` | | 要监视的目标 ID 或类型的逗号分隔列表 |
| `-log-level` | `info` | 日志级别：`debug`、`info`、`warn`、`error` |
| `-plugins-dir` | | 包含远程插件 `.plugin` 描述符文件的目录 |
## 功能
### 攻击链
攻击链引擎使用侦察结果来智能选择和排序利用：
- **基础设施**：可读的 `/etc/shadow` 触发文件读取利用；SUID 二进制文件触发权限提升；root 上下文提升所有优先级
- **应用程序**：SQL 错误消息触发 SQL 注入利用；搜索端点触发 Go 和 Python 模糊测试器；登录端点触发凭据填充；反射输入触发 XSS；暴露的 .env/.git 触发路径遍历
- **平台**：Jenkins/GitLab 端点触发流水线投毒；云元数据端点触发 SSRF；身份验证端点触发凭据填充
- **Kubernetes**：cluster-admin 绑定触发 RBAC 提升；特权 Pod 触发容器逃逸；缺失的网络策略触发横向移动
- **SSH**：sudo NOPASSWD 触发权限提升；弱密码和 PermitRootLogin 触发加固检查
- **AWS**：权限过宽的 IAM 触发提升；公开的 S3 存储桶触发数据泄露；IMDSv1 触发凭据收集
- **容器**：Docker 套接字挂载触发逃逸；全部 capabilities 触发特权突破；禁用 seccomp 触发攻击面扩大
- **网络**：Redis/MongoDB/MySQL 触发默认凭据探测；开放端口触发服务版本检查
#### 多阶段链式攻击
初始利用阶段后，第二次链式传递会分析成功的攻击结果以链接后续利用：
- **SSH 密钥收集** → 跨主机密钥重用的横向移动
- **影子文件读取** → 用于哈希破解的凭据攻击
- **容器逃逸** → 容器间横向移动的支点
- **SSRF 成功** → 对发现的内部端点进行高级 Web 应用攻击
- **默认凭据成功** → 凭据重用的横向移动
- **DNS 泄露** → 扩展的泄露通道测试
多阶段链式攻击被限制为单次额外传递，以防止链式失控。已执行的利用会被去重。
### 后渗透
后渗透模块在成功利用后执行，以展示真实世界影响：
| 模块 | 技术 |
| -------- | ------------ |
| **横向移动** | SSH 密钥重用、凭据支点、容器间移动、网络服务跳跃 |
| **持久化** | Cron 作业植入、SSH authorized_keys 注入、systemd 服务创建、shell 配置文件后门 |
| **泄露** | DNS 隧道、HTTP(S) 暂存、文件归档、云存储上传模拟 |
后渗透结果会反馈到多阶段链式攻击引擎，并由后渗透行为传感器监控。
### 运行模式
UAM 通过 `--mode` 支持三种运行模式，与 `--dry-run` 正交：
| 模式 | 红队 | 蓝队 | 用例 |
| ------ | ---------- | ----------- | ---------- |
| `both`（默认） | 侦察 + 利用 | 传感器 + 修复 + 验证 | 完整对抗循环 |
| `red` | 侦察 + 利用 | 跳过 | 仅攻击评估 |
| `blue` | 跳过 | 侦察 + 从发现结果修复 | 扫描并修复，无主动攻击 |
```
# 17. 2. Build UAM -> 2. 构建 UAM
./bin/uam run --targets ssh --mode red
# 18. 3. Run with all features -> 3. 使用所有功能运行
./bin/uam run --targets network --mode blue
# 19. 4. Cleanup -> 4. 清理
./bin/uam run --targets kubernetes --mode red --dry-run
# 20. Kubernetes cluster (uses current kubectl context) -> Kubernetes 集群（使用当前 kubectl 上下文） – Keep Kubernetes and kubectl in English.
./bin/uam run --all --mode both --validate --dashboard 8080
```
在仅蓝队模式下，侦察发现结果被转换为合成攻击事件，以便修复引擎无需运行主动利用即可生成补丁。
在仅红队模式下，由于没有蓝队传感器运行，仪表盘中的检测率、修复率和总体分数显示为“N/A”。
### 从先前会话修复
针对先前红队会话的真实攻击发现结果运行蓝队修复，而不是来自侦察的合成发现：
```
# 21. Web application (safe dry-run first) -> Web 应用程序（先进行安全干运行）
./bin/uam run --targets ssh --mode red --config configs/default.yaml
# 22. SSH host -> SSH 主机
# 23. AWS account -> AWS 账户
./bin/uam run --session
```
这也可以从仪表盘 UI 触发：完成的仅红队会话会显示“运行蓝队”按钮，该按钮使用原始攻击事件启动修复会话。
修复会话通过 `parent_session_id` 链接到其源会话，并在侧边栏中显示为单独的蓝队模式会话。
### 并发会话
使用 `--concurrent` 并行运行多个目标会话。每个会话独立运行，拥有自己的事件流、评分和修复。
### 补丁验证（闭环）
使用 `--validate`，UAM 会将生成的补丁应用到目标，并重新运行原始利用以确认漏洞已修复。验证结果（PASSED/FAILED）记录在会话输出中。
### 实时仪表盘
使用 `--dashboard 8080` 启用。嵌入式 HTTP 服务器提供：
- 通过服务器发送事件（SSE）的实时事件时间线，30 秒心跳和 5 分钟空闲超时
- 带有圆形进度环的会话分数（检测率、修复率、总体分数）
- 带有模式徽章（RED/BLUE/BOTH）和运行状态的会话侧边栏
- “运行蓝队”按钮，用于修复已完成的红队会话
- 用于针对单个目标启动会话的目标卡片
- 用于在运行时更改运行模式、并发性和验证的配置面板
- 侦察/利用失败时在时间线中显示错误事件
- 可调整大小的侧边栏，用于查看长会话名称
- 位于 `GET /api/v1/plugins` 的插件注册表查看器（列出所有注册的本地和远程插件）
- 位于 `GET /healthz` 的健康检查端点（无需身份验证）
- 位于 `GET /metrics` 的 Prometheus 指标
- `/api/v1/` 下的版本化 API，从 `/api/` 重定向以保持向后兼容
- 暗色主题单页应用程序
**仅仪表盘模式**：启动时无需运行任何会话即可启动仪表盘。目标从配置加载并显示为卡片——从 UI 按需触发会话。
```
./bin/uam run --dashboard 8080 --config configs/default.yaml
```
### 试运行模式
使用 `--dry-run` 运行以在不执行破坏性利用的情况下进行审计。实现 `DryRunnable` 接口的模块将记录它们 *会* 做什么，而不是执行。无论是否为试运行模式，侦察始终是只读的。
```
./bin/uam run --targets kubernetes --dry-run --validate --dashboard 8080
```
### 监视模式（持续监控）
使用 `--watch` 运行，将 UAM 转变为按计划重新运行会话的长期服务。仪表盘在监视模式下自动启用，并显示到下次运行的实时倒计时。
```
# 24. All targets from config file -> 从配置文件中的所有目标
./bin/uam run --all --watch 5m --concurrent
# 25. Red team only -- attack and report -> 仅红队 -- 攻击并报告
./bin/uam run --targets network --watch 1h --mode blue
# 26. Blue team only -- scan for vulnerabilities and generate patches -> 仅蓝队 -- 扫描漏洞并生成补丁
./bin/uam run --targets ssh --watch 30s --mode red
```
可与所有其他标志（`--mode`、`--dry-run`、`--concurrent`、`--validate`）组合使用。每次运行都会产生具有唯一 ID 的独立会话，所有会话在仪表盘侧边栏中可见。按 Ctrl+C 可干净关闭。
### 输入验证
所有目标端点在使用前都会根据目标类型进行验证：
| 目标类型 | 验证规则 |
| ------------- | ------------------ |
| SSH | 拒绝 shell 元字符（`` ; & \| $ ` ``），验证主机格式 |
| 网络 | 接受 CIDR 表示法、`host:port` 或裸 IP/主机名 |
| 容器 | 仅允许字母数字、连字符、下划线、点 |
| 应用程序/平台 | 需要 `http://` 或 `https://` 协议 |
| Kubernetes | 仅允许 Kubernetes 安全字符 |
无效端点在配置加载时和通过 `target add` CLI 在运行任何会话之前会被拒绝。
### 可观测性
**关联 ID** -- 会话中的每个事件（攻击、遥测、修复）共享一个 `correlation_id`，从而实现从利用到检测再到补丁的整个分布式事件流的端到端追踪。
**Prometheus 指标** -- 可在 `GET /metrics` 获取，采用 Prometheus 文本格式：
| 指标 | 类型 | 描述 |
| -------- | ------ | ------------- |
| `uam_sessions_total` | 计数器 | 启动的总会话数 |
| `uam_attacks_total` | 计数器 | 发起的总攻击数 |
| `uam_attacks_succeeded` | 计数器 | 成功攻击数 |
| `uam_remediations_total` | 计数器 | 生成的总修复数 |
| `uam_remediations_applied` | 计数器 | 应用的修复数 |
| `uam_session_duration_seconds` | 直方图 | 会话持续时间（桶：1 秒到 10 分钟） |
**结构化日志** -- 通过 `--log-level`（debug、info、warn、error）可配置的日志级别，支持 JSON 或文本输出。所有日志条目都包含结构化字段（组件、会话 ID、模块名称）。
**结构化错误** -- 错误携带操作上下文（`UAMError`，包含 `Op`、`SessionID`、`Module` 字段），并包装哨兵错误（`ErrSessionTimeout`、`ErrBrokerDisconnected`、`ErrInvalidTarget`）以进行程序化处理。
### 会话持久化
UAM 支持两种持久化后端，当两者都配置时可同时使用：
| 后端 | 何时使用 | 存储内容 |
| --------- | ----------- | ---------------- |
| **文件（默认）** | 始终 | `./output/` 中的 JSON 文件（可选加密） |
| **PostgreSQL（可选）** | 当设置 `database.dsn` 或 `UAM_DATABASE_DSN` 时 | 规范化表，使用 JSONB 存储目标、分数和事件负载 |
**设置：**
```
# 27. Passive recon only (red + dry-run) -> 仅被动侦察（红队 + 干运行）
createdb uam
# 28. Full pipeline (default) -> 完整流水线（默认）
export UAM_DATABASE_DSN="postgres://user:pass@localhost:5432/uam?sslmode=disable"
# 29. First, run red team -> 首先，运行红队
./bin/uam run --all --config configs/default.yaml
```
当配置了 Postgres 时，会话同时写入数据库（用于查询）和文件（用于导出/共享）。如果启动时无法连接到 Postgres，UAM 将回退到仅文件模式并发出警告。运行时使用内存缓存进行热读取——数据库用于跨重启的持久化。
```
# 30. Note the session ID from the output -> 注意输出中的会话 ID
psql uam -c "SELECT id, state, target->>'name', started_at FROM sessions ORDER BY started_at DESC"
```
### 可靠性
- **会话超时** -- 可配置的每会话超时（默认 5 分钟，通过配置中的 `session_timeout` 设置）。超时时通过上下文优雅地取消会话。
- **原子文件写入** -- 会话数据写入临时文件，然后原子重命名为最终路径，以防止崩溃或断电时数据损坏。
- **文件权限** -- 会话输出文件以 `0600` 权限创建（仅所有者可读/写）。
### 基于角色的访问控制（RBAC）
仪表盘 API 支持具有三种角色的多密钥 RBAC：
| 角色 | 读取（会话、事件、目标、配置） | 操作（启动会话、修复、应用补丁） | 管理员（修改配置、管理目标、控制监视） |
| ---------- | ---- | ------- | ----- |
| **viewer** | 是 | 否 | 否 |
| **operator** | 是 | 是 | 否 |
| **admin** | 是 | 是 | 是 |
公共端点（`/`、`/healthz`、`/metrics`）完全绕过身份验证。
**配置：**
```
dashboard:
enabled: true
port: 8080
rbac:
keys:
- name: "admin-key"
key: "your-admin-secret"
role: "admin"
- name: "ops-key"
key: "your-ops-secret"
role: "operator"
- name: "readonly-key"
key: "your-viewer-secret"
role: "viewer"
```
密钥通过 `Authorization: Bearer ` 头部或 `?api_key=` 查询参数传递。无效密钥返回 `401`；有效密钥但角色不足则返回 `403`，并在响应正文中包含所需角色。
**向后兼容** -- 旧版单 `api_key` 字段仍然有效，并被视为管理员角色。如果既未设置 `rbac` 也未设置 `api_key`，则身份验证被禁用。
所有变更性 API 调用（启动会话、修改配置、管理目标）都会记录审计日志，包括密钥名称、角色和远程地址。
### Python 利用库
当 Python 3 可用时，三个 Python 利用脚本会被自动发现并注册为利用模块：
| 脚本 | 描述 |
| -------- | ------------- |
| `sqli_fuzzer.py` | 7 种 SQL 注入技术，多个注入点 |
| `path_traversal.py` | 16+ 种编码绕过，12 个敏感文件 |
| `credential_stuffer.py` | 31 组凭据，JSON/表单编码 |
### OpenTelemetry 追踪收集器
位于 `/v1/traces` 的真正兼容 OTLP 的 HTTP 收集器，接收跨度并检测：
- 错误跨度中的 SQL 错误（SQL 注入）
- 异常延迟 > 5 秒（基于时间的 SQL 注入）
- URL 中的路径遍历模式
- HTTP 500 突增
- Web 处理程序生成的 shell 进程
### eBPF 探针（Linux）
用于内核级监控的真实 BPF 追踪点程序：
- `file_open.c` -- `sys_enter_openat` 上的追踪点，监控对敏感文件的访问
- `exec_monitor.c` -- `sys_enter_execve` 上的追踪点，检测意外的进程执行
- 使用 `cilium/ebpf` 和 perf 缓冲区读取的 Go 加载器
- 回退到容器审计钩子的 macOS 桩
### gRPC 插件架构
通过 gRPC 支持所有模块类型的进程外插件。Proto 契约在 `api/proto/uam.proto` 中定义，生成的 Go 桩在 `api/gen/uam/v1/` 中。插件可以用任何支持 gRPC 的语言编写。
**四种插件服务：**
- `SensorPlugin` -- 蓝队传感器（Start、Stop、StreamTelemetry 服务器流式 RPC）
- `ExploitPlugin` -- 红队利用模块（Execute、Info）
- `ReconPlugin` -- 侦察模块（Scan）
- `RemediationPlugin` -- 补丁生成（GeneratePatch）
**功能：**
- 远程适配器（`RemoteSensor`、`RemoteExploitModule`、`RemoteReconModule`、`RemoteRemediationEngine`）将 gRPC 客户端包装为本地接口——编排器将它们与进程内模块同等对待
- 基于文件的插件注册表（`--plugins-dir` 中的 `.plugin` 描述符）
- 自动连接：启动时加载描述符，远程插件被拨号和注册
- 仪表盘 API：`GET /api/v1/plugins` 列出所有注册的插件（本地 + 远程）及其元数据
- 插件脚本的 SHA-256 校验和验证（可选，通过配置）
- gRPC 连接的 TLS 支持（通过 `plugins.tls_ca_file` 配置 CA 证书，不安全回退）
**插件描述符格式**（`.plugin` 文件）：
```
name=my-exploit
kind=exploit
addr=localhost:50052
target_type=infrastructure
```
**重新生成 proto 桩**（编辑 `uam.proto` 后）：
```
# 31. Then, remediate using real attack events from that session -> 然后，使用该会话中的真实攻击事件进行修复
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
# 32. Re-run all sessions every 5 minutes -> 每 5 分钟重新运行所有会话
protoc --go_out=api/gen --go_opt=paths=source_relative \
--go-grpc_out=api/gen --go-grpc_opt=paths=source_relative \
--proto_path=api/proto uam.proto
```
### YAML 配置
通过 YAML 外部化所有设置的配置：
```
nats:
url: nats://localhost:4222
concurrent: true
validate_patches: true
dry_run: false
run_mode: both # red | blue | both
watch:
enabled: false
interval: "5m" # Go duration format (5m, 1h, 30s, 2h30m)
dashboard:
enabled: true
port: 8080
# api_key: "single-shared-key" # legacy single key (treated as admin)
rbac: # multi-key RBAC (overrides api_key)
keys:
- name: admin-key
key: "change-me-admin"
role: admin
- name: ops-key
key: "change-me-ops"
role: operator
- name: viewer-key
key: "change-me-viewer"
role: viewer
targets:
- id: my-k8s-cluster
name: Production K8s
type: kubernetes
endpoint: ~/.kube/config
- id: my-webapp
name: Internal Portal
type: application
endpoint: https://portal.corp.local
- id: staging-ssh
name: Staging Jump Box
type: ssh
endpoint: admin@10.0.1.50
metadata:
ssh_key_path: ~/.ssh/id_rsa
ssh_port: "22"
- id: aws-staging
name: AWS Staging Account
type: aws
metadata:
aws_profile: staging
aws_region: us-east-1
- id: redis-host
name: Cache Server
type: network
endpoint: 10.0.2.100
- id: my-container
name: App Container
type: container
metadata:
container_label: "uam-target=infra" # auto-discovers running container ID
sensors:
ebpf:
enabled: true
watch_files: ["/etc/shadow", "/etc/passwd"]
otel:
enabled: true
chaining:
enabled: true
modules: # opt-out: all default to true
kubernetes: true
ssh: true
aws: true
container: true
network: true
osint: true # OSINT recon (theHarvester, amass)
fingerprint: true # service fingerprinting + CVE lookup
web_advanced: true # advanced web app attacks (API fuzzing, SSRF)
api_fuzzing: true # API endpoint fuzzing
credential_attack: true # credential spraying + hash cracking
post_exploit: true # lateral movement, persistence, exfiltration
nuclei: true # Nuclei vulnerability scanner (requires nuclei binary)
reporting:
format: text # text | json | markdown | all
compliance: [] # pci-dss, hipaa, soc2, nist, cis
plugins:
dir: "" # directory containing .plugin descriptor files
tls_ca_file: "" # CA certificate for gRPC TLS connections
checksums: # optional: SHA-256 checksums for Python exploit scripts
sqli_fuzzer.py: "a1b2c3..."
path_traversal.py: "d4e5f6..."
# 33. Continuous blue-only scan every hour -> 每小时持续进行仅蓝队扫描
```
### 真实世界目标支持
UAM 支持跨越基础设施、应用程序、云和网络层的 8 种目标类型。模块受工具门控：如果未安装所需的 CLI 工具，模块将被优雅地跳过。`webapp` 是 `application` 的别名——两者使用相同的目标类型，但具有多个专用模块。
| 目标类型 | CLI 标志 | 所需工具 | 侦察 | 利用 | 后渗透 | 修复 |
| ------------- | ---------- | ---------------- | ------- | --------- | -------------- | ------------- |
| 基础设施 | `infra` | podman/docker | 文件权限、SUID、端口、OSINT、指纹识别 | 敏感文件读取 | 持久化、泄露 | AppArmor 配置文件 |
| 应用程序 | `app` / `webapp` | nikto、sqlmap、nuclei（可选） | HTTP 端点、SQL 注入探测、安全头部、爬行、OSINT | SQL 注入、XSS、路径遍历、SSRF、API 模糊测试、Nuclei 扫描 | 泄露 | WAF 规则、ModSecurity 规则 |
| 平台 | `platform` | | CI/CD、云元数据、IAM | 凭据填充、流水线投毒 | 持久化 | Terraform 片段 |
| Kubernetes | `kubernetes` | kubectl | 命名空间、RBAC、Pod、Secret、网络策略 | RBAC 提升、Secret 列表 | 横向移动 | K8s NetworkPolicy |
| SSH | `ssh` | ssh、ssh-audit（可选） | Banner、sudo、SUID、sshd_config、OSINT | 权限提升、密钥收集、凭据攻击 | 横向移动、持久化 | sshd_config 加固 |
| AWS | `aws` | aws | IAM、S3、EC2、IMDS | IAM 提升、S3 泄露、IMDS 收集 | 泄露 | IAM 拒绝策略 |
| 容器 | `container` | podman/docker | Capabilities、seccomp、挂载、命名空间 | Docker 套接字逃逸、Secret 收集 | 横向移动、持久化 | Seccomp 配置文件、加固策略 |
| 网络 | `network` | nmap（可选） | 端口扫描、服务检测、Banner、高级协议分析 | 默认凭据探测、协议模糊测试、服务利用 | 横向移动 | 防火墙规则（iptables） |
## 项目结构
```
.
├── .github/workflows/ # CI/CD pipelines
│ ├── unit-tests.yml # Unit tests + lint
│ ├── integration-tests.yml # End-to-end with Docker Compose
│ └── build.yml # Cross-platform build + Docker images
├── cmd/uam/ # Entry point
│ ├── main.go # CLI entry point, config loading, setupAndRun
│ ├── run.go # Run + remediate subcommands, module registration
│ ├── target.go # Target add/list/remove subcommands
│ └── helpers.go # Target aliases, filtering, resolution, reporting
├── api/
│ ├── proto/ # Protobuf service definitions
│ │ └── uam.proto
│ └── gen/uam/v1/ # Generated Go stubs (protoc-gen-go + protoc-gen-go-grpc)
│ ├── uam.pb.go # Message types (TargetProfile, AttackEvent, etc.)
│ └── uam_grpc.pb.go # gRPC client/server stubs for all 4 plugin services
├── configs/
│ └── default.yaml # Default YAML configuration
├── internal/
│ ├── orchestrator/ # Session lifecycle, attack chaining, patch validation
│ │ ├── orchestrator.go # Core struct, setters, RunAll, StartSession, sensors
│ │ ├── session.go # Session execution, event handlers, RemediateFromSession
│ │ ├── persistence.go # Session load/save, GetSession, GetAllSessions
│ │ ├── chaining.go # Attack chain decision engine
│ │ └── validator.go # Patch validation (closed loop)
│ ├── broker/ # NATS message broker
│ ├── events/ # Event router and publish helpers
│ ├── dashboard/ # Embedded HTTP server + SSE dashboard
│ │ ├── server.go # Core types, constructor, Start, CORS middleware
│ │ ├── handlers.go # All HTTP/REST handlers
│ │ ├── events.go # Session/event management, watch state, SSE broadcast
│ │ ├── helpers.go # JSON errors, type validation, persistence utilities
│ │ └── index.html # Dark-themed SPA with resizable sidebar
│ ├── plugins/ # gRPC plugin hosting (uses generated stubs from api/gen/)
│ │ ├── grpc_server.go # Plugin server, service impls, proto ↔ types converters
│ │ ├── grpc_client.go # Remote*Module adapters (sensor, exploit, recon, remediation)
│ │ ├── registry.go # Plugin registry, discovery, remote connection
│ │ └── verify.go # SHA-256 checksum verification
│ ├── blueteam/
│ │ ├── ebpf/ # eBPF sensors
│ │ │ ├── file_sensor.go # Container audit hook sensor
│ │ │ ├── bpf_loader.go # Linux: real cilium/ebpf loader
│ │ │ ├── bpf_loader_stub.go # macOS: no-op stub
│ │ │ └── probes/ # C BPF programs
│ │ │ ├── file_open.c # sys_enter_openat tracepoint
│ │ │ └── exec_monitor.c # sys_enter_execve tracepoint
│ │ ├── otel/ # OpenTelemetry sensors
│ │ │ ├── http_sensor.go # HTTP request log poller
│ │ │ └── collector.go # OTLP trace collector + anomaly detection
│ │ ├── policy/ # Rule-based policy engine
│ │ ├── sensor/ # Platform + behavior sensors
│ │ │ ├── platform_sensor.go # Platform audit log monitor
│ │ │ ├── behavior_sensor.go # Runtime behavior anomaly detection
│ │ │ └── postexploit_sensor.go # Post-exploitation activity detector
│ │ ├── ssh/ # SSH sensors (auth, credential)
│ │ ├── network/ # Network sensors (flow, packet)
│ │ ├── webapp/ # Web app sensors (request, advanced)
│ │ └── container/ # Container sensors (escape, privilege)
│ ├── redteam/
│ │ ├── recon/ # Recon modules
│ │ │ ├── infra_recon.go # Container recon (files, SUID, ports)
│ │ │ ├── app_recon.go # HTTP endpoint discovery + SQLi probing
│ │ │ ├── platform_recon.go # CI/CD, cloud metadata, IAM scanning
│ │ │ ├── k8s_recon.go # Kubernetes RBAC, pods, network policies
│ │ │ ├── webapp_recon.go # Advanced web app crawl + security headers (application type)
│ │ │ ├── ssh_recon.go # SSH banner, sudo, sshd_config analysis
│ │ │ ├── aws_recon.go # AWS IAM, S3, EC2, IMDS scanning
│ │ │ ├── container_recon.go # Capabilities, seccomp, mounts, namespaces
│ │ │ ├── network_recon.go # Port scan + service detection (nmap/fallback)
│ │ │ ├── network_advanced_recon.go # Protocol analysis + service fingerprinting
│ │ │ ├── osint_recon.go # OSINT gathering (theHarvester, amass, WHOIS)
│ │ │ └── fingerprint_recon.go # Service fingerprinting + CVE lookup
│ │ ├── exploit/ # Exploit modules
│ │ │ ├── infra_exploit.go # File read exploit
│ │ │ ├── app_exploit.go # SQLi + path traversal
│ │ │ ├── platform_exploit.go # Credential stuffing + pipeline poisoning
│ │ │ ├── k8s_exploit.go # RBAC escalation + secret listing
│ │ │ ├── webapp_exploit.go # SQLi, XSS, traversal, SSRF (application type)
│ │ │ ├── webapp_advanced_exploit.go # API fuzzing + advanced injection
│ │ │ ├── ssh_exploit.go # Privilege escalation + key harvesting
│ │ │ ├── aws_exploit.go # IAM escalation + S3 exfil + IMDS
│ │ │ ├── container_exploit.go # Docker socket escape + secret harvesting
│ │ │ ├── network_exploit.go # Default credential probes
│ │ │ ├── network_advanced_exploit.go # Protocol fuzzing + service exploitation
│ │ │ ├── credential_exploit.go # Credential spraying + hash cracking
│ │ │ ├── nuclei_exploit.go # Nuclei vulnerability scanner integration
│ │ │ ├── api_fuzzer.go # API endpoint fuzzing
│ │ │ └── python_runner.go # Python subprocess runner + discovery
│ │ └── postexploit/ # Post-exploitation modules
│ │ ├── lateral_movement.go # SSH key reuse, credential pivoting, network hopping
│ │ ├── persistence.go # Cron jobs, SSH keys, systemd services, shell profiles
│ │ └── exfiltration.go # DNS tunneling, HTTP staging, cloud upload simulation
│ └── remediation/ # Polyglot patch synthesizer
│ └── synthesizer.go # AppArmor, WAF, Seccomp, Terraform, K8s,
│ # ModSecurity, sshd_config, firewall rules
├── pkg/
│ ├── types/ # Shared types, validation, and structured errors
│ ├── config/ # YAML config loader + target management
│ ├── container/ # Podman/Docker runtime abstraction
│ ├── crypto/ # AES-256-GCM encryption for session data at rest
│ ├── cvedb/ # CVE database client for vulnerability lookups
│ ├── metrics/ # Prometheus-compatible counters and histograms
│ ├── tools/ # External tool detection (kubectl, nmap, nuclei, etc.)
│ └── logging/ # Structured logging (slog) with configurable levels
├── scripts/
│ ├── run.sh # One-command startup (infra + dashboard)
│ └── exploits/ # Python exploit scripts
│ ├── sqli_fuzzer.py
│ ├── path_traversal.py
│ └── credential_stuffer.py
├── deployments/
│ ├── docker-compose.yml # NATS + target containers
│ ├── targets/
│ │ ├── vulnerable-infra/ # Ubuntu with weak permissions
│ │ └── vulnerable-app/ # Express API with SQLi
│ └── k8s/ # Kubernetes manifests
│ ├── deployment.yaml
│ └── network-policy.yaml
└── output/ # Session result JSON artifacts
```
## 测试
```
# 34. Fast red team sweep every 30 seconds (testing) -> 每 30 秒进行快速红队扫描（测试）
go test ./...
# 35. 1. Create a PostgreSQL database -> 1. 创建一个 PostgreSQL 数据库 – Keep PostgreSQL in English.
go test -v -race ./...
# 36. 2. Set the connection string (or add database.dsn to config YAML) -> 2. 设置连接字符串（或将 database.dsn 添加到配置 YAML） – Keep database.dsn and YAML in English.
go test ./internal/orchestrator/... -v
# 37. 3. Run UAM -- tables are auto-created on first run -> 3. 运行 UAM -- 表在首次运行时自动创建
go test -coverprofile=coverage.out ./...
go tool cover -func=coverage.out
```
**测试覆盖率**（19 个套件中的 376 个测试）：
| 包 | 测试数 | 覆盖内容 |
| --------- | ------- | ---------------- |
| `pkg/types` | 49 | 评分卡计算、JSON 序列化、验证、结构化错误、目标类型 |
| `pkg/config` | 23 | 默认值、YAML 加载、错误用例、目标解析、目标管理、模块配置 |
| `pkg/cvedb` | 10 | CVE 数据库查询、缓存、错误处理 |
| `pkg/metrics` | 12 | Prometheus 计数器、直方图、文本输出 |
| `pkg/crypto` | 14 | AES-256-GCM 加密/解密、密钥派生、错误用例 |
| `internal/remediation` | 7 | 所有目标类型的补丁生成 |
| `internal/events` | 12 | 事件路由器、处理器注册、幂等订阅、发布助手 |
| `internal/orchestrator` | 46 | 完整会话生命周期、顺序/并发运行、多阶段链式攻击、后渗透集成 |
| `internal/blueteam/otel` | 17 | 所有 5 个异常检测器、HTTP 处理器、边缘用例 |
| `internal/blueteam/policy` | 7 | 所有策略规则、部分匹配、默认操作 |
| `internal/blueteam/sensor` | 13 | 行为传感器、后渗透传感器、异常检测 |
| `internal/blueteam/webapp` | 7 | Web 应用传感器、请求分析 |
| `internal/dashboard` | 54 | 会话管理、事件缓冲区、HTTP 端点、SSE、目标 CRUD、配置、插件 API |
| `internal/plugins` | 15 | 注册表、发现、远程连接、插件描述符 |
| `internal/redteam/exploit` | 28 | 所有利用模块、试运行、凭据攻击、API 模糊测试、网络高级 |
| `internal/redteam/recon` | 30 | 所有侦察模块、OSINT、指纹识别、网络高级 |
| `internal/redteam/postexploit` | 10 | 横向移动、持久化、泄露技术 |
| `internal/store` | 10 | 文件存储、postgres 存储、组合存储 |
| `internal/reporting` | 12 | 报告生成、合规格式化 |
### 38. Query session history directly -> 直接查询会话历史
GitHub Actions 工作流在推送到 `main` 和 PR 时自动运行：
| 工作流 | 文件 | 功能 |
| ---------- | ------ | -------------- |
| **单元测试** | `.github/workflows/unit-tests.yml` | `go test -race`、`go vet`、`gofmt` 检查、覆盖率报告 |
| **集成测试** | `.github/workflows/integration-tests.yml` | 启动完整的 Docker Compose 堆栈并对真实目标运行 UAM（仅红队、仅蓝队、完整流水线、试运行） |
| **构建** | `.github/workflows/build.yml` | 跨平台二进制构建（Linux + macOS）、Docker 镜像构建 |
## 插件架构
所有红队和蓝队能力都在 `pkg/types/interfaces.go` 中定义为 Go 接口。添加新模块只需实现一个接口——无需更改编排器。
### 添加红队模块
实现 `ExploitModule`：
```
type ExploitModule interface {
Name() string
TargetType() TargetType
Execute(ctx context.Context, target TargetProfile, sessionID string) (*AttackEvent, error)
}
```
在 `main.go` 中注册：
```
orch.RegisterExploit(mymodule.NewMyExploit())
```
或者通过实现 `api/proto/uam.proto` 中的 `ExploitPlugin` 服务作为 gRPC 插件部署——无需对 UAM 本身进行代码更改，支持任何语言。
### 添加蓝队传感器
实现 `Sensor`：
```
type Sensor interface {
Name() string
TargetType() TargetType
Start(ctx context.Context, sessionID string) error
Stop() error
}
```
传感器将 `TelemetryEvent` 消息发布到 NATS `uam.telemetry` 主题。编排器会自动获取它们。
### 添加修复生成器
实现 `PatchGenerator` 接口并为其目标类型在 `Synthesizer` 中注册。合成器根据 `TargetType` 路由到正确的生成器。
## 包含的目标
### 目标 1：易受攻击的 Ubuntu 容器（基础设施）
- 全局可读的 `/etc/shadow`
- SUID 二进制文件（`/usr/bin/find`）
- `/root/.env` 和 `/root/.ssh/id_rsa` 中的敏感数据
- 带有弱密码的测试用户
**攻击**：对 `/etc/shadow` 的未授权文件读取
**检测**：eBPF 文件访问传感器通过审计钩子捕获读取
**修复**：生成拒绝访问敏感文件的 AppArmor 配置文件
**验证**：在 `chmod 600` 后重新运行文件读取——确认访问被拒绝
### 目标 2：易受攻击的 Express API（应用程序）
- `/api/users/:id`、`/api/users/search`、`/api/login` 中的 SQL 注入
- `/api/files` 中的路径遍历
- 响应中的详细 SQL 错误消息
**攻击**：针对 `/api/users/search` 的基于 UNION 的 SQL 注入
**检测**：OTel HTTP 传感器和追踪收集器匹配 SQL 注入模式
**修复**：生成阻止 SQL 注入负载的 WAF JSON 规则
**验证**：重新运行 SQL 注入负载——确认 WAF 阻止了请求
### 目标 3：平台 / CI-CD（平台）
- CI/CD 端点（Jenkins、GitLab）
- 云元数据端点
- 带有默认凭据的登录端点
**攻击**：凭据填充和流水线投毒
**检测**：平台审计日志传感器检测未授权的 API 调用和配置更改
**修复**：生成用于 IAM 加固的 Terraform 片段
## 输出
每个会话在 `./output/` 中生成一个结构化 JSON 文件，包含（当设置 `UAM_ENCRYPTION_KEY` 时，可选通过 AES-256-GCM 静态加密）：
- 和元数据
- 会话血缘（`run_mode`、修复会话的 `parent_session_id`）
- 完整事件时间线（攻击、遥测、修复、验证、错误）
- 生成的补丁内容（AppArmor 配置文件、WAF 规则、Seccomp、Terraform、K8s NetworkPolicy、ModSecurity 规则、sshd_config、防火墙规则）
- 评分：检测率、修复率、总体分数
- 补丁验证结果（PASSED/FAILED）
## 技术栈
| 组件 | 技术 |
| --- | --- |
| 核心引擎 | Go（使用 `log/slog` 结构化日志） |
| 消息代理 | NATS JetStream |
| 基础设施传感器 | eBPF（C 追踪点 + Go `cilium/ebpf` 加载器） |
| 应用程序传感器 | 兼容 OpenTelemetry 的 OTLP 追踪收集器 |
| 平台传感器 | HTTP 审计日志监控 |
| 容器运行时 | Podman（主要）/ Docker（回退） |
| 目标环境 | Podman/Docker Compose、Kubernetes |
| 利用脚本 | Go + Python 3（自动发现）+ 外部工具（nmap、nikto、sqlmap、ssh-audit、nuclei） |
| 插件系统 | 带可选 TLS 的 gRPC（进程外扩展） |
| 指标 | 兼容 Prometheus（零依赖计数器 + 直方图） |
| 加密 | AES-256-GCM，带 PBKDF2 密钥派生（会话数据静态加密） |
| 配置 | YAML |
| 仪表盘 | 嵌入式 HTTP + SSE（暗色主题 SPA） |
| 易受攻击的应用 | Node.js / Express / SQLite |
## 设计原则
- **与目标无关**：编排器不知道如何攻击或防御——模块知道。添加 AWS 支持意味着添加模块，而不是更改核心。
- **事件驱动**：红队和蓝队之间没有阻塞调用。所有状态通过 NATS 流动。
- **闭环验证**：补丁在原始利用对其失败之前不被信任。
- **试运行安全**：每个利用模块通过 `DryRunnable` 接口支持试运行模式——无风险审计。
- **工具门控**：需要外部工具（kubectl、nmap、aws、nuclei）的模块，如果工具未安装，将被自动跳过。
- **可配置模块**：单个能力模块（OSINT、指纹识别、后渗透、Nuclei 等）可通过 YAML 配置启用/禁用——默认全部启用的退出模型。
- **幂等修复**：每个生成的补丁（AppArmor、WAF、Seccomp、Terraform、K8s NetworkPolicy、sshd_config、防火墙规则）均可安全重复应用。
- **运行时无关**：通过容器运行时抽象层同时支持 Podman 和 Docker。
- **输入验证**：所有目标端点在使用前都经过类型检查——SSH 拒绝 shell 元字符，网络验证 CIDR/host:port，URL 需要 http(s)。
- **弹性**：会话超时并优雅取消，原子文件写入确保崩溃安全，结构化错误包含操作上下文便于调试。
- **可扩展**：gRPC 插件接口（带 TLS）允许使用任何语言进行进程外扩展，无需接触 UAM 核心。插件脚本的 SHA-256 校验和验证。
- **可观测**：跨所有事件的关联 ID、Prometheus 指标、通过 `slog` 可配置的结构化日志、带 SSE 的实时仪表盘和全面的会话工件。
- **静态安全**：可选 AES-256-GCM 加密用于包含敏感发现结果的会话输出文件。
## 免责声明
此工具仅用于**授权安全测试和教育目的**。用户全权负责在测试任何系统前获得适当授权。未经授权访问计算机系统是非法的。作者对误用此软件不承担任何责任。
在运行 UAM 对抗任何目标之前，始终获得系统所有者的书面许可。如有疑问，请使用 `--dry-run` 标志进行只读审计。
## 许可证
MIT - 详情参见 [LICENSE](LICENSE)。
标签：CISA项目, Docker镜像, EVTX分析, FTP漏洞扫描, GPT, PyRIT, Python工具, 可扩展架构, 多智能体系统, 威胁模拟, 子域名突变, 安全编排, 对抗性安全, 持续监控, 插件系统, 日志审计, 模块化设计, 混合加密, 渗透测试框架, 漏洞修复, 漏洞管理, 用户代理, 目标无关, 红队攻击, 结构化查询, 网络安全, 网络安全培训, 自主操作, 自动化修复, 自动化安全, 蓝队防御, 请求拦截, 调试插件, 逆向工具, 防御, 隐私保护