更喜欢原始HTTP？直接用curl调用API：```bash
curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit \
  -H "Content-Type: application/json" \
  -d '{"input": {"repo_url": "https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application"}}'

每个发现都包含一个**判定**（`confirmed` / `likely` / `inconclusive` / `not_exploitable`）、一个包含完整污点追踪的**证据对象**以及确切的代码位置。而不是“这可能是个问题”。SEC-AF 追踪从源头到汇点的数据，并证明其是否真正可被利用。

> 完整基准测试输出（30 个发现）：[`exampl/dvga-benchmark-result.json`](https://github.com/agent-field/sec-af/blob/HEAD/exampl/dvga-benchmark-result.json) | 性能分析：[`exampl/benchmark-analysis.json`](https://github.com/agent-field/sec-af/blob/HEAD/exampl/benchmark-analysis.json)

## 基准测试：DVGA

我们使用 SEC-AF 对 [Damn Vulnerable GraphQL Application](https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application) 进行了测试，这是一个故意存在漏洞的应用，包含 21 个有文档的安全场景。

| 指标 | 值 |
|---|---|
| 原始发现 | 106 |
| 经过 AI 去重后 | 61 |
| **经过对抗验证** | **28 确认** |
| 不确定（需要人工审查） | 1 |
| 不可利用（正确拒绝） | 1 |
| 噪音降低 | 94% |
| DAG 边（推理器调用） | 82 |
| 代理调用 | ~166–255 |
| 执行的策略 | 11 |
| 挂钟时间 | ~78 min |
| 预估成本（Kimi K2.5） | ~$0.18–$0.90 |

<details>
<summary><strong>细分：按类别的 30 个已验证发现</strong></summary>

| 类别 | 数量 | 示例 |
|---|---|---|
| 缺少身份验证 | 8 | ImportPaste, delete_all_pastes, system_debug, CreateUser, file upload |
| 命令注入 | 4 | `os.popen(cmd)` 通过 ImportPaste, system_debug, system_diagnostics |
| SQL 注入 | 3 | 未净化的 `filter` 在 `resolve_pastes`中，LIKE 模式注入，登录 |
| 身份验证绕过 | 3 | JWT 签名禁用，JWT 授权绕过，密码认证缺陷 |
| 明文凭据 | 3 | 明文密码存储，明文比较，诊断中的密码 |
| SSRF | 2 | ImportPaste 突变遵循服务器端用户提供的 URL |
| 业务逻辑/URL 净化 | 2 | URL 净化不足，未认证的批量删除 |
| DoS/资源耗尽 | 3 | 用户/审计查询缺少分页，不受控制的 simulate_load |
| 配置/机密 | 2 | 硬编码 JWT/Flask 机密，生产环境启用调试模式 |

</details>

<details>
<summary><strong>设计模式：AI 原生安全分析如何工作</strong></summary>

SEC-AF 应用了若干架构模式，这些模式通过组合多个聚焦的 AI 代理而非运行单一整体扫描来实现。这些模式解决了 AI 驱动的安全分析中的基本挑战。

**1. 对抗性代理张力（HUNT vs. PROVE）**

大多数 AI 安全工具询问单个模型“这有漏洞吗？”并接受答案。SEC-AF 在结构上将_发现_代理与_反驳_代理分开。狩猎者被激励去寻找漏洞；验证者被激励去反驳它们。每个发现通过一个 4 代理验证链——追踪器重建数据流，净化分析器寻找狩猎者可能遗漏的缓解措施，利用假设器构建具体攻击场景，判定代理权衡所有冲突证据。代理之间的这种对抗张力是推动 94% 噪音降低的原因——架构本身编码了怀疑。

**2. 信号级联与渐进式缩小**

管道不会将所有发现倾倒给用户，而是在每个阶段压缩信号：106 个原始发现 → 61 个经过 AI 去重 → 30 个经过对抗验证。每个阶段都是一个过滤器。这反映了人类安全团队分类的方式——先广泛发现，然后逐步严格审查。关键洞察是每个过滤器都是_不同类型_的 AI 推理：语义相似性用于去重，污点分析用于验证，利用构建用于确认。

**3. 通过上下文修剪实现信息经济**

LLM 在给予无关上下文时会产生更多幻觉。SEC-AF 仅路由每个代理所需的信息：注入狩猎器接收修剪到数据流图和输入入口点的侦察上下文，而加密狩猎器接收依赖树和密钥管理模式。验证器接收仅包含其特定验证方法所需字段的投影发现视图。这种按策略的上下文修剪减少了幻觉和成本——代理无法被它们从未看到的信息混淆。

**4. 流式阶段重叠**

传统管道顺序运行：完成侦察，然后开始狩猎，然后开始验证。SEC-AF 通过 `asyncio.Queue` 重叠阶段——狩猎器在侦察输出到达时开始消费，去重在每个狩猎器完成时处理发现。验证器在后面的狩猎器仍在运行时开始验证第一批去重的发现。这种流式架构减少了挂钟时间而不牺牲信号级联——每个发现仍然通过每个过滤器，只是更早。

**5. 通过 AI 门控实现动态路由**

管道基于运行时发现的内容自适应。AI 门控检查侦察输出并选择激活哪些狩猎策略——带有 JWT 认证的 Flask 应用触发与带有 gRPC 的 Go 微服务不同的狩猎器。一个单独的 CWE 扩展门控根据检测到的技术栈动态扩大漏洞目标列表。可达性门控评估依赖漏洞是否具有可利用的调用路径，然后才在不可达代码上浪费验证资源。

**6. 编码代理的引导式自主性**

SEC-AF 通过 AgentField  harness 在编码代理（Claude Code, OpenCode, Codex）之上运行。而不是给代理一个单一的巨大提示，每个推理器提供阶段感知的引导式自主性：代理接收狭窄的任务定义、扁平输出模式（2-4 个字段）和策略特定的上下文。代理在这些边界内拥有完全的自主性——它可以读取文件、追踪代码和自由推理——但 harness 约束了其输出的_形状_。这防止了自主代理偏离任务或产生非结构化结果的常见失败模式。

**7. 可组合推理器 DAG 与完全可观察性**

每个代理调用都通过 AgentField 控制平面流动，创建审计的完整有向无环图。你可以看到哪个狩猎器发现了哪个发现，每次验证花费了多长时间，验证者生成了什么证据，以及管道在哪里花费了时间。添加一个新的漏洞类就是一个文件——一个新的狩猎器。编排器发现它，向其路由上下文，并将其发现集成到现有的去重 → 验证 → 修复管道中。DAG 就是架构。

</details>

<details>
<summary><strong>它遗漏了什么（以及原因）</strong></summary>

遗漏的 9 个场景主要是 **GraphQL 协议级攻击**：批量查询、深度递归、别名滥用、字段重复、内省暴露。这些需要运行时/DAST 分析。SEC-AF 目前以 SAST 为重点。协议级检测在路线图上。

</details>

## 工作原理

SEC-AF 建立在 [Composite Intelligence](https://github.com/Agent-Field/agentfield) 理念之上：不依赖单个整体式 LLM 调用，而是将多个聚焦、引导的 LLM 调用组合成一个**推理器 DAG**，其中架构本身编码了智能（有关此模式的深入探讨，请参阅 [The Atomic Unit of Intelligence](https://www.santoshkumarradha.com/writing/atomic-unit-of-intelligence)）。每个 LLM 调用处理一个小型、定义明确的任务，具有扁平的 Pydantic 模式（2-4 个属性）。编排器管理上下文流、并行性和动态路由。

### 架构：推理器调用图（DAG）

每个阶段都是一个 `@reasoner`，通过 AgentField 控制平面调用子推理器，总计约 ~200-300 个代理同步工作以处理一个查询：

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7491/d3e99c5c9b7067b17005f71ecb0f7c7abeb9d7fc8843d33938de9f755f416b7b.png" alt="SEC-AF 信号级联管道 — RECON → HUNT → DEDUP → PROVE → OUTPUT" width="100%" />
</p>

### 信号级联管道

每个阶段缩小信号。原始发现通过逐步严格的关卡进行过滤：

| 阶段 | 目的 | 并行度 |
|---|---|---|
| **RECON** | 映射架构、依赖、数据流、安全上下文 | 三路并行（架构 + 依赖 + 配置），然后两路（数据流 + 安全） |
| **HUNT** | 运行 10 多个专门的策略狩猎器 | 信号量限制并行（默认 4 并发），增量去重 |
| **PROVE** | 对抗验证：尝试**反驳**每个发现 | 信号量限制并行（默认 3 并发） |
| **REMEDIATION** | 为已确认/疑似发现生成修复建议 | 信号量限制并行（默认 3 并发） |

### 为什么是多推理器架构

大多数 AI 安全工具运行一个大的提示，希望 LLM 能正确完成。SEC-AF 将问题分解为约 258 个聚焦的代理调用，每个调用具有扁平模式（2-4 个字段）和狭窄的任务。架构编码了推理策略，而不是提示（有关此为何重要的原因，请参阅 [The Atomic Unit of Intelligence](https://www.santoshkumarradha.com/writing/atomic-unit-of-intelligence)）。

- **多个聚焦代理 > 一个强大的代理。** 单个 LLM 调用不能同时映射架构、追踪数据流、狩猎注入、验证可利用性和建议修复。SEC-AF 将每个任务分配给一个专门的推理器，一个做好一件事。编排器处理组合、并行性和上下文路由。
- **对抗验证，而非确认偏差。** PROVE 阶段针对每个发现运行 4 个子代理，目标相反：追踪器重建数据流，净化分析器寻找阻塞，利用假设器构建攻击，判定代理权衡所有证据。代理之间的这种张力比询问单个模型“这可以被利用吗？”产生更高的置信度。
- **通过 AI 门控实现动态路由。** 系统在运行时自适应。AI 门控检查侦察输出并选择激活哪些狩猎策略。一个单独的门控根据检测到的栈扩展 CWE 目标列表。带有 JWT 认证的 Flask 应用获得与带有 gRPC 的 Go 微服务不同的狩猎器。
- **渐进式信号缩小。** 106 个原始发现变为 61 个去重后，然后 30 个对抗验证后——94% 的噪音降低。每个阶段都是一个过滤器。管道压缩噪音，它不仅仅检测漏洞并倾倒。
- **信息经济。** 每个代理只看到它需要的内容。狩猎器接收修剪到其策略的侦察上下文。验证器接收具有最少字段的投影发现视图。这减少了幻觉，降低了成本，并使每个 LLM 调用保持专注。
- **增量流式处理。** 去重作为消费者运行，而狩猎器仍在产生结果。发现指纹在每个狩猎器完成时被去重，然后最终的语义传递捕获跨策略重复项。管道是流式的，而不是批处理的。

## 对比

> 声明来源于官方文档和定价页面。如果有误，[请提交 issue](https://github.com/Agent-Field/sec-af/issues)。

| | SEC-AF | Nullify | Snyk Code | Semgrep | CodeQL |
|---|---|---|---|---|---|
| **方法** | **AI 原生** | **AI 原生** | **AI 辅助** | **基于规则** | **基于规则** |
| | 多推理器 DAG · LLM 推理代码 | 自主安全劳动力 | DeepCode AI 引擎 | 模式 + 污点匹配 | 语义分析 + 数据流 |
| **开源** | ✅ Apache 2.0 | ❌ 专有 | ❌ 专有 | 引擎：LGPL-2.1 · Pro 规则：专有 | 查询：MIT · 引擎：专有 |
| **已验证发现** | ✅ 对抗 PROVE 阶段 · 每个发现带判定 + 证据 | ✅ 利用证明生成 | ❌ 优先级分数（不透明）· 无利用证明 | ❌ 仅模式匹配 | ❌ 静态分析告警 |
| **每个发现的证据** | 带污点传播的数据流追踪 | 利用路径 + 重现步骤 | 显示源到汇的流向 | - | 路径查询显示数据流 |
| **架构** | 可组合推理器 DAG，完全可观察 | 整体代理 | 单次通过引擎 | 规则引擎 | 查询引擎 |
| **并行度** | ✅ 并行狩猎器、验证器、修复器，增量去重 | 未记录 | 未记录 | ✅ 规则并行 | ✅ 查询并行 |
| **评分** | ✅ 已发布的复合公式 | 内部 | 不透明优先级分数 | 内部 | - |
| **SARIF** | ✅ 原生 2.1.0 | 未记录 | ✅ | ✅ | ✅ 原生 |
| **合规映射** | PCI-DSS, SOC2, OWASP, HIPAA, ISO27001 | 未记录 | 仅平台合规 | OWASP 规则可用 | - |
| **语言** | 任何 LLM 支持的语言 | 未记录 | 14+ | 35+（基于解析器） | 10 |
| **价格** | **免费 · 开源**（~$0.18–$0.90/审计 LLM 成本） | **$6,000/月** | $25-105/月/开发者 | OSS 引擎：免费使用 · Pro：$30/月/贡献者 | 公共仓库免费 · $49/月/提交者 (GHAS) |

**SEC-AF 最强的方面**：带有证据对象的已验证发现、透明评分、合规映射、具有完整 DAG 可观察性的可组合多代理架构，以及完全开源。

**其他工具更强的方面**：Semgrep 和 CodeQL 拥有经过多年实战测试的规则覆盖，涵盖 35 多种语言。Snyk 拥有深入的 IDE/SCA 集成。Nullify 添加了运行时云上下文和自动修复活动。SEC-AF 较新，目前最强的方面是 AI 驱动的代码级分析。

> **相同架构，不同领域：** [Contract-AF](https://github.com/Agent-Field/contract-af) 将对抗性 HUNT→PROVE 应用于法律合同——代理生成代理以查找单个 LLM 遗漏的条款交互。

### 为什么多代理架构很重要

传统安全扫描器是整体式的：一个引擎，一次通过，一套规则。SEC-AF 的多推理器架构提供了结构性优势：

- **专业化**：每个狩猎器都是一个引导的 LLM 专家——注入狩猎器的推理方式不同于加密狩猎器。架构在路由中编码领域知识，而不仅仅在提示中。
- **可组合性**：通过添加一个狩猎器文件来添加新的漏洞类。编排器自动发现并运行它。无需更改管道。
- **对抗验证**：PROVE 阶段在结构上与 HUNT 分离。狩猎器试图发现漏洞；验证者试图反驳它们。这种对抗张力减少了误报。
- **可观察性**：每个推理器调用都流经控制平面，创建完整的 DAG。你可以精确地看到哪个狩猎器发现了哪个发现，每个阶段花费了多长时间，以及 LLM 在每个步骤推理了什么。
- **成本效率**：上下文修剪和模式视图意味着每个 LLM 调用只接收所需的上下文。一个完整的标准深度审计，包含 30 个已验证发现，在 LLM 调用中估计花费约 $0.18–$0.90（通过 OpenRouter 的 Kimi K2.5）。

## 快速开始

### 安装到 AgentField（`af install`）

已经运行了 [AgentField](https://github.com/Agent-Field/agentfield) 控制平面？直接从 GitHub 安装 SEC-AF — 无需克隆，无需本地设置：```bash
af install https://github.com/Agent-Field/sec-af
af run sec-af

刚接触 AgentField？首先使用 `curl -fsSL https://agentfield.ai/install.sh | bash` 安装控制平面，或者使用下面的 Docker / Railway 选项。

### 本地 (Docker Compose)```bash
git clone https://github.com/Agent-Field/sec-af.git && cd sec-af
cp .env.example .env          # Add OPENROUTER_API_KEY
docker compose up --build

轮询结果：```bash
curl http://localhost:8080/api/v1/executions/<execution_id>

**第二步 — 创建并激活虚拟环境**```bash
python3 -m venv .venv
source .venv/bin/activate

**步骤 4 — 配置环境变量**```bash
cp .env.example .env

可选 — 设置自定义工作目录以避免权限问题：```
SEC_AF_WORKSPACES_DIR=~/.sec-af/workspaces

默认情况下，它运行在 `http://localhost:8080` 上。

**步骤 6 — 启动 SEC-AF 代理**（在另一个终端中，激活 venv）```bash
python3 main.py

## API

<details>
<summary><strong>完整请求选项</strong></summary>```bash
curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "repo_url": "https://github.com/org/repo",
      "branch": "main",
      "depth": "thorough",
      "severity_threshold": "high",
      "scan_types": ["sast", "sca", "secrets", "config"],
      "output_formats": ["sarif", "json", "markdown"],
      "compliance_frameworks": ["pci-dss", "soc2", "owasp", "hipaa"],
      "max_cost_usd": 15.0,
      "max_provers": 30,
      "max_duration_seconds": 1800,
      "include_paths": ["src/"],
      "exclude_paths": ["tests/", "vendor/"]
    }
  }'