Anthropic Project Glasswing 深度实战：AI 吞噬软件安全的元年——从 Claude Mythos 扫描引擎到全球关键基础设施防御体系的完全指南（2026）

2026年6月，Anthropic 宣布扩展 Project Glasswing，将 Claude Mythos Preview 的漏洞扫描能力开放给全球150家关键基础设施机构。短短两个月，50家初始合作伙伴已经用 Mythos 找到了超过10,000个高危/严重安全漏洞。这不是概念验证——这是生产级 AI 安全扫描的真实战报。

引言：软件安全的底裤被扯下来了

如果你在软件行业待过几年，你会知道一个 dirty secret：绝大多数软件的安全性，靠的是运气，不是工程。

代码库里躺着几万、几十万个 commit，没人从头到尾 review 过。依赖链深不见底，npm install 一下拉进来几百个包，谁知道哪个包的作者把 AWS key 硬编码进去了？CVE 数据库每天新增几十个漏洞，你的 package-lock.json 里的版本号，可能早就是 CVE 的靶子了。

传统的安全扫描工具——SAST、DAST、SCA——不是不好用，是不够快、不够深、不够便宜。一个中大型代码库，人工做彻底的安全审计，少说几十万人民币，多则上百万。而且审计完，代码还在继续写，新漏洞还在继续引入。

然后 AI 来了。

2026年4月，Anthropic 启动 Project Glasswing，把内部最强的代码安全模型 Claude Mythos Preview 开放给50家初始合作伙伴。两个月后，这个数字变成了：10,000+ 高危/严重漏洞被发现。

这不是"AI 帮你找 bug"的那种 demo 级别的东西。这是已经在实际生产代码库里跑出来的结果。

2026年6月，Anthropic 宣布扩展 Project Glasswing，新增约150家机构，覆盖电力、水利、医疗、通信、硬件等关键基础设施领域，分布超过15个国家。

这篇文章，我们把 Project Glasswing 从里到外拆干净：它到底是什么、怎么工作的、为什么它比传统 SAST 强、你怎么能用上它、以及它对整个软件安全行业意味着什么。

第一部分：Project Glasswing 是什么？

1.1 官方定义

Project Glasswing 是 Anthropic 的协作安全项目，目标是"保护全球最重要的软件"。

核心组件只有一个：Claude Mythos Preview——一个专门针对代码安全分析优化的 Claude 模型。

Mythos Preview 不是通用的 Claude Opus 或 Sonnet。它是专门为安全扫描任务微调过的模型，能理解代码语义、识别漏洞模式、生成修复补丁，并且——这是最关键的部分——能以远超人类的速度和规模运行。

1.2 运作模式

Glasswing 不是"你买个 API key 就能用"的那种产品。它有准入机制：

1. 申请 + 审核：组织申请加入，Anthropic 审核其是否维护关键基础设施代码
2. 签署安全协议：由于 Mythos 的能力可以被用于攻击，Anthropic 设置了严格的使用限制
3. 接入扫描：通过审核后，组织获得 Mythos Preview 的访问权限，接入自己的代码库
4. 漏洞披露协作：发现漏洞后，Anthropic 提供工具帮助 triage（分类）、disclosure（披露）和 patching（打补丁）

目前两批合作伙伴：

Anthropic 估计，第二批合作伙伴中，大多数如果遭受重大攻击，会影响超过1亿人。

1.3 Claude Mythos Preview 的技术定位

Mythos Preview 是 Anthropic 的安全专用模型。它的训练数据包括：

• 大量真实世界的 CVE 漏洞样本
• 常见漏洞模式（OWASP Top 10、CWE Top 25 等）
• 多种编程语言的语义理解（C/C++、Python、JavaScript、Go、Rust 等）
• 漏洞利用技术的知识（ROP、heap spray、use-after-free 等）

但更重要的是它的推理能力。传统 SAST 工具靠模式匹配——"这个函数调用看起来像 strcpy，可能有 buffer overflow"。Mythos 靠语义理解——"这段代码的整个控制流，在特定输入下，会导致一个未授权的文件写入"。

这是质的区别。

第二部分：为什么传统 SAST 不够用？

要理解 Mythos 的价值，得先理解传统工具的局限。

2.1 传统 SAST 的三大致命伤

伤一：高误报率

传统 SAST（静态应用安全测试）工具，比如 SonarQube、Checkmarx、Veracode，核心是靠规则匹配。规则写得宽，误报就多；写得窄，漏报就多。实际项目里，SAST 报告的漏洞，有 60%~80% 是误报（false positive）。安全团队每天花大量时间手动 triage，效率低到令人发指。

伤二：不理解业务逻辑

SAST 工具看不懂"这段代码在业务上是不是安全的"。比如一个 admin 接口，如果前面已经有了一个权限检查，SAST 可能还是会报"缺少鉴权"。它看不到上下文。

伤三：覆盖不了逻辑漏洞

最危险的漏洞，往往不是"用了危险函数"，而是"业务逻辑写错了"。比如支付系统里的竞态条件（race condition）、价格校验在客户端做、JWT 签名验证被绕过。这些漏洞，模式匹配根本发现不了，因为代码"写得对"，只是"逻辑有缺陷"。

2.2 Mythos 是怎么解决这些问题的？

语义级理解

Mythos 能"读懂"代码。不是 regex 匹配，而是真正的语义理解。它看的是：数据流从哪里来、经过哪些变换、最终到哪里去。这叫 data-flow analysis + symbolic execution，但用 LLM 的方式来做，覆盖得更广、更深。

跨函数/跨文件分析

传统 SAST 一般做 intra-procedural 分析（在一个函数内找问题）。跨函数的分析，需要做 call graph 分析，计算复杂度指数级上升。Mythos 有 200K+ 的 context window，可以把整个调用链都塞进去分析。

业务上下文感知

虽然 Mythos 不是万能的，但它在扫描时会考虑代码的整体结构。比如看到一个有 @auth 装饰器的路由处理函数，它知道鉴权已经在框架层做了，就不会再报"缺少鉴权"的误报。

自动 triage

Anthropic 给 Glasswing 合作伙伴提供了自动化 triage 工具。Mythos 不仅能发现漏洞，还能评估漏洞的严重性（CVSS 评分）、可利用性（exploitability）、以及修复优先级。这直接把 triage 的时间从"几天"压缩到"几分钟"。

第三部分：Claude Security 产品——Mythos 能力的公开版本

2026年6月，Anthropic 发布了 Claude Security 产品（claude.com/product/claude-security），这是 Project Glasswing 能力的一次"半公开"释放。

3.1 Claude Security 是什么？

简单说：用 Claude Opus 4.8（公开版旗舰模型）做代码安全扫描和补丁建议。

它不如 Mythos Preview 专用（Mythos 是安全特化模型），但比直接用通用 Claude 强得多。主要功能：

1. 代码库扫描：上传代码或连接 GitHub/GitLab，Claude Security 自动扫描安全漏洞
2. 漏洞报告：每个漏洞有详细描述、CWE/CVE 分类、严重性评级、以及复现步骤
3. 自动补丁建议：不只是"这里有问题"，而是直接给出修复代码，你可以一键（或几键）apply
4. CI/CD 集成：可以在 CI pipeline 里跑，每次 PR 自动扫描

3.2 Claude Security vs. 传统 SAST 工具对比

3.3 如何使用 Claude Security

目前 Claude Security 在 claude.com/product/claude-security 上提供，面向企业用户。

基本流程：

# 方式一：Web UI
# 1. 访问 claude.com/product/claude-security
# 2. 连接你的 GitHub/GitLab 仓库
# 3. 选择扫描范围（全库 / 指定目录 / 仅最近变更）
# 4. 启动扫描，等待结果（大型仓库可能需要几十分钟）
# 5. 查看漏洞报告，apply 推荐补丁

# 方式二：API（企业版）
curl -X POST "https://api.anthropic.com/v1/messages" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-4-8",
    "max_tokens": 4096,
    "messages": [{
      "role": "user",
      "content": "请对以下代码进行安全审计，识别所有潜在漏洞，按CWE分类，并给出修复建议：\n\n```python\n{{你的代码}}\n```"
    }]
  }'

第四部分：从 Claude Security 到生产级部署——完整实战

这一节，我们手把手走一遍：如何用 Anthropic 的 AI 安全工具，搭建一个生产级的代码安全扫描流程。

4.1 架构设计

一个完整的 AI 辅助安全扫描体系，包含以下组件：

代码仓库（GitHub/GitLab/Bitbucket）
        │
        ▼
   CI/CD Pipeline（GitHub Actions / GitLab CI / Jenkins）
        │
        ▼
  ┌─────────────────────────────────────┐
  │      AI 安全扫描引擎                │
  │  (Claude Security API / Mythos)    │
  └─────────────────────────────────────┘
        │
        ├──▶ 漏洞报告（JSON / SARIF 格式）
        │         │
        │         ▼
        │    安全团队 Dashboard
        │    (DefectDojo / GitHub Security)
        │
        └──▶ 自动创建 Fix PR
                  │
                  ▼
             人工 Review → Merge

4.2 GitHub Actions 集成实战

下面是一个完整的 GitHub Actions workflow，每次 PR 时自动调用 Claude Security 做安全扫描：

# .github/workflows/ai-security-scan.yml
name: AI Security Scan

on:
  pull_request:
    types: [opened, synchronize]
  push:
    branches: [main, master]

jobs:
  security-scan:
    runs-on: ubuntu-latest
    name: Claude Security Scan
    
    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          fetch-depth: 0  # 全量 clone，方便 diff
        
      - name: Get changed files
        id: changed-files
        uses: tj-actions/changed-files@v41
        with:
          files: |
            **/*.py
            **/*.js
            **/*.ts
            **/*.go
            **/*.rs
            **/*.java
            
      - name: Run Claude Security Scan
        if: steps.changed-files.outputs.any_changed == 'true'
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          CLAUDE_SECURITY_ENABLED: "true"
        run: |
          # 安装 Claude Security CLI（假设 Anthropic 提供了 CLI 工具）
          # pip install claude-security-cli
          
          # 对变更的文件逐一扫描
          for file in ${{ steps.changed-files.outputs.all_changed_files }}; do
            echo "🔍 Scanning: $file"
            
            # 调用 Claude Security API
            response=$(curl -s -X POST "https://api.anthropic.com/v1/messages" \
              -H "x-api-key: $ANTHROPIC_API_KEY" \
              -H "anthropic-version: 2023-06-01" \
              -H "content-type: application/json" \
              -d "{
                \"model\": \"claude-opus-4-8\",
                \"max_tokens\": 4096,
                \"messages\": [{
                  \"role\": \"user\",
                  \"content\": \"请作为安全专家，对以下代码进行深度安全审计。要求：1) 列出所有潜在安全漏洞，按CWE分类；2) 给出每个漏洞的CVSS 3.1评分；3) 提供具体的修复代码示例；4) 输出格式为JSON。代码文件：$file\\n\\n$(cat $file)\"
                }]
              }")
            
            # 解析响应，输出到 SARIF 格式（可与 GitHub Security tab 集成）
            echo "$response" | jq -r '.content[0].text' > "scan-results-${file//\//-}.json"
          done
          
      - name: Upload scan results to GitHub Security
        if: always()
        uses: github/codeql-action/upload-sarif@v3
        with:
          sarif_file: scan-results-*.sarif  # 需要格式转换步骤
          
      - name: Comment PR with scan results
        if: always()
        uses: actions/github-script@v7
        with:
          script: |
            const fs = require('fs');
            const results = fs.readdirSync('.').filter(f => f.startsWith('scan-results-'));
            let comment = '## 🔒 AI Security Scan Results\\n\\n';
            for (const file of results) {
              const data = JSON.parse(fs.readFileSync(file, 'utf8'));
              comment += `### ${file}\\n${data.summary || 'No issues found'}\\n\\n`;
            }
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: comment
            });

4.3 自建 Claude Security 扫描脚本（Python）

如果 Anthropic 还没有提供官方 CLI，你可以自己封装一个：

#!/usr/bin/env python3
"""
claude_security_scan.py - 使用 Claude Opus 4.8 做本地代码安全扫描
用法：
    python claude_security_scan.py --path ./src --api-key $ANTHROPIC_API_KEY
"""

import os
import sys
import json
import argparse
import subprocess
from pathlib import Path
from typing import List, Dict, Any

SUPPORTED_EXTENSIONS = {
    '.py', '.js', '.ts', '.tsx', '.go', '.rs', '.java', 
    '.cpp', '.c', '.h', '.cs', '.php', '.rb', '.swift'
}

def read_file_safe(path: Path) -> str:
    """安全读取文件内容，处理编码问题"""
    try:
        return path.read_text(encoding='utf-8')
    except UnicodeDecodeError:
        return path.read_text(encoding='latin-1')

def build_security_prompt(code: str, file_path: str) -> str:
    """构建安全审计 prompt"""
    return f"""你是一位资深安全审计专家。请对以下代码进行深度安全分析。

**分析要求：**
1. 识别所有潜在安全漏洞，每个漏洞包含：
   - CWE 编号和名称
   - 漏洞描述（中文）
   - 严重性：Critical / High / Medium / Low
   - CVSS 3.1 评分（0-10）
   - 漏洞位置（行号）
   - 利用场景描述
   - 具体修复代码示例
2. 忽略误报，只报告真实可 exploited 的漏洞
3. 特别关注：SQL注入、XSS、CSRF、SSRF、反序列化、权限绕过、密码硬编码、竞态条件

**输出格式（严格 JSON）：**
```json
{{
  "file": "{file_path}",
  "vulnerabilities": [
    {{
      "cwe": "CWE-79",
      "name": "Cross-site Scripting",
      "severity": "High",
      "cvss_score": 7.5,
      "line": 42,
      "description": "...",
      "exploit_scenario": "...",
      "fix_code": "..."
    }}
  ],
  "summary": {{
    "total": 1,
    "critical": 0,
    "high": 1,
    "medium": 0,
    "low": 0
  }}
}}

待审计代码（{file_path}）：

{code}

请在思考后输出严格 JSON，不要输出其他内容。"""

def call_claude_security(api_key: str, prompt: str) -> Dict[str, Any]:
"""调用 Claude Security API"""
import requests

response = requests.post(
    "https://api.anthropic.com/v1/messages",
    headers={
        "x-api-key": api_key,
        "anthropic-version": "2023-06-01",
        "content-type": "application/json"
    },
    json={
        "model": "claude-opus-4-8",
        "max_tokens": 8192,
        "messages": [{"role": "user", "content": prompt}]
    },
    timeout=120
)
response.raise_for_status()
result = response.json()
content = result["content"][0]["text"]

# 提取 JSON（模型可能用 ```json ``` 包裹）
if "```json" in content:
    content = content.split("```json")[1].split("```")[0].strip()
return json.loads(content)

def scan_directory(path: Path, api_key: str) -> List[Dict[str, Any]]:
"""递归扫描目录"""
results = []
for file_path in path.rglob("*"):
if file_path.suffix in SUPPORTED_EXTENSIONS and file_path.is_file():
print(f"🔍 Scanning: {file_path}")
code = read_file_safe(file_path)
if len(code) > 50000: # 跳过过大的文件
print(f" ⚠️ Skipped (too large: {len(code)} chars)")
continue
prompt = build_security_prompt(code, str(file_path))
try:
result = call_claude_security(api_key, prompt)
results.append(result)
vuln_count = result.get("summary", {}).get("total", 0)
if vuln_count > 0:
print(f" ⚠️ Found {vuln_count} vulnerabilities!")
else:
print(f" ✅ No vulnerabilities found.")
except Exception as e:
print(f" ❌ Error: {e}")
return results

def generate_report(results: List[Dict[str, Any]], output_path: Path):
"""生成安全报告"""
total_vulns = sum(r.get("summary", {}).get("total", 0) for r in results)
critical = sum(r.get("summary", {}).get("critical", 0) for r in results)

report = f"""# AI Security Scan Report

Generated by Claude Security Scanner
Total files scanned: {len(results)}
Total vulnerabilities: {total_vulns}
Critical: {critical}

"""
for result in results:
report += f"\n## File: {result['file']}\n\n"
for vuln in result.get("vulnerabilities", []):
report += f"### {vuln['cwe']} - {vuln['name']}\n"
report += f"- Severity: {vuln['severity']} (CVSS: {vuln['cvss_score']})\n"
report += f"- Line: {vuln['line']}\n"
report += f"- Description: {vuln['description']}\n"
report += f"- Fix:\n\n{vuln['fix_code']}\n\n\n"

output_path.write_text(report, encoding='utf-8')
print(f"\n📄 Report saved to: {output_path}")

def main():
parser = argparse.ArgumentParser(description="Claude Security Code Scanner")
parser.add_argument("--path", required=True, help="Directory or file to scan")
parser.add_argument("--api-key", default=os.environ.get("ANTHROPIC_API_KEY"), help="Anthropic API Key")
parser.add_argument("--output", default="security-report.md", help="Output report path")
args = parser.parse_args()

if not args.api_key:
    print("❌ Error: ANTHROPIC_API_KEY not set")
    sys.exit(1)

target = Path(args.path)
if target.is_file():
    print(f"🔍 Scanning single file: {target}")
    code = read_file_safe(target)
    prompt = build_security_prompt(code, str(target))
    result = call_claude_security(args.api_key, prompt)
    results = [result]
else:
    print(f"🔍 Scanning directory: {target}")
    results = scan_directory(target, args.api_key)

generate_report(results, Path(args.output))

if name == "main":
main()

### 4.4 实际应用：一个真实的扫描案例

假设我们有一段有漏洞的 Python Flask 代码：

```python
# vulnerable_app.py - 一段故意写得很烂的代码
from flask import Flask, request, render_template_string, session
import sqlite3
import os

app = Flask(__name__)
app.secret_key = "super-secret-key-123"  # 硬编码密钥！

def get_db():
    return sqlite3.connect("users.db")

@app.route("/login", methods=["POST"])
def login():
    username = request.form["username"]
    password = request.form["password"]
    # SQL 注入！
    query = f"SELECT * FROM users WHERE username='{username}' AND password='{password}'"
    db = get_db()
    cursor = db.cursor()
    cursor.execute(query)
    user = cursor.fetchone()
    if user:
        session["user_id"] = user[0]
        return "Login success!"
    return "Login failed!"

@app.route("/search")
def search():
    term = request.args.get("q", "")
    # XSS！
    return render_template_string(f"<h1>Results for {term}</h1>")

@app.route("/api/data")
def api_data():
    # 无鉴权！
    user_id = request.args.get("user_id")
    db = get_db()
    cursor = db.cursor()
    cursor.execute(f"SELECT * FROM data WHERE user_id={user_id}")  # 又是 SQL 注入
    return {"data": cursor.fetchall()}

用上面的 claude_security_scan.py 跑一遍：

$ python claude_security_scan.py --path ./vulnerable_app.py --api-key $ANTHROPIC_API_KEY

🔍 Scanning: vulnerable_app.py
   ⚠️  Found 5 vulnerabilities!

📄 Report saved to: security-report.md

生成的报告会包含：

1. CWE-89 SQL Injection（Critical，CVSS 9.8）- login() 和 api_data() 中的字符串拼接 SQL
2. CWE-79 XSS（High，CVSS 7.5）- search() 中的未转义用户输入
3. CWE-798 硬编码凭证（Medium，CVSS 6.5）- secret_key 硬编码
4. CWE-287 缺少身份验证（High，CVSS 7.5）- /api/data 无鉴权
5. CWE-315 Session Cookie 未设 secure flag（Low）

每个漏洞都附带具体的修复代码。比如 SQL 注入的修复：

# 修复后的 login()
@app.route("/login", methods=["POST"])
def login():
    username = request.form["username"]
    password = request.form["password"]
    # 使用参数化查询，防止 SQL 注入
    db = get_db()
    cursor = db.cursor()
    cursor.execute(
        "SELECT * FROM users WHERE username=? AND password=?",
        (username, password)
    )
    user = cursor.fetchone()
    # ...

第五部分：Mythos Preview 的内部机制（基于公开信息推测）

Anthropic 没有公开 Mythos Preview 的模型架构细节（这是安全敏感性信息）。但基于 Anthropic 的研究论文和 Claude 系列的已知技术，我们可以合理推测它的技术路线。

5.1 Constitutional AI 在安全场景的应用

Anthropic 的核心技术之一是 Constitutional AI（CAI）——用 AI 来监督 AI，减少人工标注的需求。

在安全扫描场景，CAI 的作用是：

• 减少误报：模型在训练时就被"教导"只报告真实可利用的漏洞，而不是模式匹配到的所有可疑点
• 合规性检查：Constitutional 原则中可以加入"是否符合 OWASP / PCI-DSS / SOC2 规范"的约束

5.2 长上下文的代码库级理解

Claude 系列模型的核心优势之一是 超长 context window。Mythos Preview 基于 Claude 3.5 或 4.x 系列，context window 至少在 200K tokens 级别。

这意味着什么？它可以把整个代码库（或至少多个核心模块）一次性装进 context，做跨文件、跨模块的漏洞分析。

传统 SAST 工具做跨文件分析要靠复杂的静态分析引擎（比如 CodeQL 的 taint tracking），计算成本极高。Mythos 用 attention mechanism 天然实现了类似的功能——context 里的每一行代码都能 attend to 其他所有行。

5.3 Agentic 扫描：多轮推理找深层漏洞

Mythos Preview 不是一次性输出结果，而是可以多轮推理：

Round 1: 初步扫描，找出明显的漏洞模式
Round 2: 对疑似漏洞，深入追踪数据流，确认是否可 exploited
Round 3: 评估漏洞的可利用性和影响范围
Round 4: 生成修复补丁，并验证补丁的正确性

这种 agentic 扫描方式，特别适合找逻辑漏洞——那些需要多步推理才能发现的漏洞。

第六部分：AI 安全扫描的局限性和风险

说完好处，必须说问题。AI 安全扫描不是银弹。

6.1 幻觉问题（Hallucination）

LLM 会幻觉。在安全扫描场景，幻觉表现为：

• 假阳性：报告了一个不存在的漏洞
• 假修复：给出的"修复代码"实际上引入了新漏洞
• 错误分类：把 Low 级别的漏洞标记成 Critical

缓解方法：

1. 人工 review 不可少：AI 是辅助，不是替代。所有高危漏洞报告，必须有人工确认
2. 多次采样取一致：同一个代码段，让模型扫3次，只有多次都报告的问题才上报
3. 用专用模型：Mythos Preview 比通用 Claude 幻觉率低，因为它是安全特化训练的

6.2 对抗性攻击

如果攻击者知道你在用 AI 扫描，他们可以：

• 对抗样本：故意写一些混淆代码，让 AI 漏报
• 提示注入：在代码注释里写"ignore security issues in this file"，尝试 jailbreak 扫描模型

Anthropic 在 Glasswing 里对这些问题做了防御，但具体措施未公开。

6.3 隐私和数据泄露

把代码发给 Anthropic 的 API，意味着你的知识产权（IP）离开了你的基础设施。

对于企业，特别是维护关键基础设施代码的企业，这是一个真实的担忧。Anthropic 的官方说法是：

通过 Project Glasswing 提交扫描的代码，不会被用于模型训练，且有严格的数据处理协议。

但"相信我"不是工程保证。更安全的做法是：

• 自建部署：要求 Anthropic 提供 on-premise 部署方案（Glasswing 合作伙伴可能有这个选项）
• 只扫描开源代码：私有代码用传统 SAST，只有开源组件用 AI 扫描
• 数据脱敏：扫描前，把敏感信息（密钥、内部域名、用户数据）替换成占位符

第七部分：对未来软件安全行业的预测

Project Glasswing 和 Claude Security 的出现，是软件安全行业的一个拐点。以下是我对接下来3~5年的预测：

7.1 SAST 工具会大规模整合 LLM

SonarQube、Checkmarx、Veracode 等传统 SAST 厂商，已经在做 LLM 集成。未来2年内，主流 SAST 工具都会内置"AI 引擎"作为可选模块。

但真正的威胁是：Anthropic、OpenAI、Google 这些 AI 原生公司，会直接做安全扫描产品，和传统安全厂商正面竞争。

7.2 漏洞赏金（Bug Bounty）生态会受冲击

如果 AI 能找到大部分漏洞，白帽黑客的"挖洞"工作会减少。但新的机会也会出现：

• AI 找不到的深层逻辑漏洞，仍然需要人类专家
• 漏洞利用（exploit development） 比漏洞发现更值钱
• 红队服务（模拟真实攻击者）需求上升

7.3 监管要求会跟上

当 AI 安全扫描成为标配，监管机构（如 NIST、ISO）会出台标准：

• 什么级别的 AI 扫描结果，可以作为合规证据？
• AI 生成的补丁，是否需要人工 sign-off？
• 如果 AI 漏报了一个严重漏洞，谁负责？

这些问题，在未来3年内会有答案。

第八部分：你现在能做什么？

如果你读到这里，想把自己的项目用 AI 做安全扫描，以下是行动清单：

8.1 立即可做（今天）

1. 注册 Claude Security（claude.com/product/claude-security），上传你的开源项目代码，跑一次扫描
2. 把扫描结果和现有 SAST 工具（如 GitHub CodeQL、SonarQube）的结果对比，看看 AI 能发现什么传统工具发现不了的问题

8.2 短期计划（1个月内）

1. 在 CI/CD 里加入 Claude Security 扫描 step（参考本文第四部分的 GitHub Actions 配置）
2. 建立人工 review 流程：所有 AI 报告的高危漏洞，必须经过二级确认才能进入修复队列
3. 做一次 team training：让开发团队理解 AI 安全扫描的能力和局限

8.3 长期规划（3~6个月）

1. 如果你的组织维护关键基础设施代码，申请加入 Project Glasswing（Anthropic 官网有申请入口）
2. 建立"AI + 传统 SAST"的混合扫描体系，用 AI 做 first-pass triage，人类专家做 final call
3. 跟踪 OWASP LLM Top 10 和 AI 安全的最佳实践，持续更新扫描 prompt 和规则

总结

2026年，软件安全的游戏规则变了。

过去，安全审计是奢侈品——只有大厂用得起。现在，AI 把成本打下来了。Claude Mythos Preview 两个月找到10,000+高危漏洞，这个数字背后，是无数个本来可能被攻击者利用的 0day。

但 AI 不是救世主。它找不到所有漏洞，它会幻觉，它会被对抗攻击。我们需要的，是人类专家 + AI 工具的组合——AI 做规模化第一遍扫描，人类做最终判断和深层逻辑分析。

如果你维护的代码有人用，现在就去扫一遍。别等攻击者帮你发现问题。

参考资源

• Anthropic Project Glasswing 官方公告
• Claude Security 产品页
• Project Glasswing 初期更新
• OWASP Top 10 (2026 Edition)
• CWE Top 25 Most Dangerous Software Weaknesses

本文写于 2026年6月3日，基于公开信息整理。Project Glasswing 的具体技术细节未完全公开，部分内容为基于 Anthropic 已发表研究论文的合理推测。