[原创]打破传统AI逆向的新思路多Agent、自主管理上下文 - 逆向思路-AI 工具与工作流-看雪安全社区

[原创]打破传统AI逆向的新思路多Agent、自主管理上下文 - 逆向思路

发表于: 2026-4-30 21:56 17382

[原创]打破传统AI逆向的新思路多Agent、自主管理上下文 - 逆向思路

BitWarden

2026-4-30 21:56

17382

# 前言
本人使用AI逆向和AI开发已经两年时间。从纯粹网页时代的GPT辅助逆向到Claude3.5，到后面的AI爆发时代的GLM5.1，Claude4.7等等。看到很多人用ai逆向的思路和手法还是过于局限和原始（纯粹的流式对话）。想分享一些新思路。作者本身是做算法逆向还原，所以文章就以我自己的方向为主进行抛砖引玉。如何高效的逆向。（本文章零AI注水请放心食用，除开绘图使用了AI）
# AI逆向过程中难点
在AI逆向中结合经验我认为存在一下几个问题：
1. 传统的以古法为主导，Ai辅助的一种工作模式。会导致工作效率不高大量的工作都是古法进行的。比如前期的定位，前期的勘探等等。希望的是AI为主导，人只做决策。这样可以同时进行多个任务。
2. 上下文管理太弱。AI逆向经常会出现一个问题就是，人再通过N轮对话后，发现定位或者已经拿到了我们想要东西的（核心算法点位，风控协议的点位等等）。但是在链路上可能会存在一些相关联的信息，才能吧整个工作完成。或者一个对话不够的情况下会有N次压缩。然后发现信息丢失，需要再次回头去看这些辅助信息，这样也很低效。
3. AI逆向是发散太强。当我们给了一个指令后，AI通过思维链，工具调用后可能已经偏离了正确的轨道。逆向很多时候会有N个的路径需要去看，去逆向分析。AI走了一条错误的路径后，我们总是要打断纠正，往往大量的时间还是浪费在叮他的思维链中了，并没有真正的解放出来。并且打断后很有可能由于上下文的问题导致这些分析路径都丢失了，中途如果出现意外情况，在启动一个窗口几乎是从头再来。
4. Ai逆向不知道正确的逆向手法，虽然认识汇编，但是不懂汇编如何转高级代码。很有可能用了一个低效的方法再去逆向分析。并且逆向过程中极其依赖IDA F5，极易产生错误。尤其是在精度极高的算法还原下很有可能就是0.2%的精度问题，导致无法完成任务。这个问题国产模型最为严重。猜测还是训练集对这类太少了。虽然claude 4.7有改善。
5. 爆上下文问题。AI在读取较大函数或者是汇编的时候会产生上下文爆掉的情况，虽然有No mcp这种工具但是由于AI的自身的问题，没法关注1w行汇编。claude的注意力机制一般都是前和最后。
# 如何解决
这几个问题也是苦恼我很久了。结合总结了一套方法：
1. 构建一套上下文管理机制，任何Ai的产出必须要规范管理。
2. 必须要有明确的方向，以及要避免模糊的提示词输入。在基模比较好的情况下可以让Ai拆解用户，进行多轮自主的信息了解，从制定方案进行分析定位。
3. 多Agent隔离。好处是隔离上下文防止爆掉。避免汇编污染AI的决策。同时可以使用多个模型的进行操作，类似Git上很火的ohmycode这种项目。
4. 半自动化的决策，必须要有HOOK来打断ai的，在特定情况下需要让人工进行决策，不然完全野蛮的发散。
# 框架设计
基于上面思考我设计了一套逆向RE的工程框架，只要参与大型的逆向工程我会使用我这套框架来进行。设计图如下：
 ![图片描述](upload/attach/202604/992284_D9YKR8KGU3PW72C.webp)
设计了一套多Agent的框架，由主脑来进行决策还任务的派发。主Agent直接与用户进行交互，拆解用户的语义分析，并且指挥下面的小弟干活。并且吧上下文管理，逆向分析，审查。拆分成几个Agent完成，如果说后续任务复杂度增加，已经继续增加我们的子agent，继续拆分细化任务。
 ![图片描述](upload/attach/202604/992284_F9B9ZYT2XXFXYBW.webp)

# 上下文管理设计
我吧Ai产物分成两个部分：
1. AI分析过程中的还原信息如：类信息，成员信息，函数信息，函数的高精度反汇编，结构体等等。（.artifacts）
2. AI分析过程中的逆向路径，思维链都进行存储。防止二次返工。（.investigations）
用图解释一下：
 ![图片描述](upload/attach/202604/992284_32G4AEV9JRJ5A2C.webp)
有考虑用sqllite或者rag的那种向量数据库管理，但是笔者认为这些方式都太重，而且存在大量的工具调用，sql生成。对于逆向来说不是很好，原因是浪费token，并且如果在国产模型上做这么多复杂会不会出现漂移问题这里需要打个问号了。

具体设计是这样的：
```text
<project>/
├── CLAUDE.md                    ← init 从模板拷贝（项目自包含）
├── .mcp.json                    ← 项目级 MCP 注册（IDA / frida / dbg-*）
├── README.md
│
├── .artifacts/                  ═══ AI 产物 ═══
│   ├── index.yaml                   主索引（地址 → 路径）
│   ├── <binary>/                    每个目标 binary 一个目录
│   │   ├── classes/
│   │   │   └── <Class>/
│   │   │       ├── class.yaml             类元数据
│   │   │       └── methods/
│   │   │           ├── speak.yaml         主文件 = 当前活跃
│   │   │           ├── speak.v1.yaml      历史版本
│   │   │           └── speak.b1.yaml      fan-out 分支
│   │   └── functions/
│   │       └── 0x140xxxxx.yaml            未归类函数
│   └── cross_refs/
│       ├── index.yaml                     跨引用内部索引
│       └── xref_001.yaml                  单条跨引用
│
└── .investigations/             ═══ AI 思考过程 ═══
    ├── 000-定位-<binary>/           Phase 1 产出
    │   ├── 任务.md
    │   ├── 发现*.md
    │   └── 待挖清单.md
    └── 001-<任务名>/                Phase 2 任务
        ├── 任务.md                      任务简报（Phase 0 写）
        ├── 假设A-*.md                   多假设并行
        ├── 假设B-*.md
        └── 结论.md                      结案后写
```
并且设计了如下几种文件格式用来存储我们的逆向中的信息：
```yaml
schema_version: 1

# 1) 项目里有哪些目标 binary
binaries:
  - name: foo.dll
    sha256: 8f3a2b1c00000000000000000000000000000000000000000000000000000000
    arch: x64
  - name: bar.exe
    sha256: a12b3c4d00000000000000000000000000000000000000000000000000000000
    arch: x64

# 2) 每个分析过的地址，当前文件在哪（核心）
addresses:
  'foo.dll:0x1400077c0':
    path: 'foo.dll/classes/Animal/methods/speak.yaml'
    kind: method                    # method | function
  'foo.dll:0x140007740':
    path: 'foo.dll/classes/Animal/methods/get_age.yaml'
    kind: method
  'foo.dll:0x140007550':
    path: 'foo.dll/functions/0x140007550.yaml'
    kind: function                  # 还没归类
  'bar.exe:0x140003200':
    path: 'bar.exe/functions/0x140003200.yaml'
    kind: function

# 3) 已识别的类（轻量列表）
classes:
  - id: 'foo.dll:Animal'
    path: 'foo.dll/classes/Animal/'
  - id: 'foo.dll:Dog'
    path: 'foo.dll/classes/Dog/'
```
由一个树形结构，一个主索引，我们的具体的逆向信息。
一共有四类产物：class类文件，方法文件， 未归类函数或者说是面向过程中用到的。

类文件格式：
| 字段 | 含义 |
|---|---|
| `类名` | RTTI 真名优先，无 RTTI 用 `Class_140xxxx` 临时名 |
| `状态` | status 值（见第五节） |
| `版本` | 时间线版本号 |
| `大小` | sizeof(类) 字节数 |
| `vtable` | 虚表地址 + 槽位数；无虚函数则 null |
| `父类` | 直接继承的基类列表，无继承则 [] |
| `字段` | 成员变量列表（偏移、类型、名字、初值、证据） |
| `方法清单` | 方法名引用列表（详情在 `methods/<name>.yaml`） |

方法文件格式：
| 字段 | 含义 |
|---|---|
| `类` | 所属类名 |
| `方法名` | `speak` / `Animal` / `~Animal` |
| `地址` | 函数地址（十六进制字符串） |
| `状态` | status 值 |
| `版本` | 时间线版本号 |
| `签名` | 推断出的 C++ 签名 |
| `证据` | 判别依据列表 |
| `C 源码` | 反编译出的 C 代码（多行字符串） |

未归类函数：
| 字段 | 含义 |
|---|---|
| `地址` | 函数地址 |
| `状态` | status 值（一般是 draft 或 candidate） |
| `版本` | 时间线版本号 |
| `签名` | 推断出的签名（不确定时填 `???`） |
| `证据` | 判别依据列表 |
| `C 源码` | 反编译出的 C 代码 |

# status 状态机
这里介绍一下status 值，这个实际上就是我们的逆向的置信度，在AI逆向中，任何ai逆向的产出都是不可靠的，都是存在置信度的如果一旦100%信任你肯定会出大问题。所以我们需要给每个结果打上一个置信度，当有足够证据多维度验证后才能是可信的。否则agent在阅读这些信息的都是有一定的怀疑态度去对待。这个状态的更改是由审查agent负责 + 半人工的方式完成的。(这一步主要是解决幻觉问题)

所以设计了如下几个状态：
| 状态 | 含义 | 谁能写 |
|---|---|---|
| `draft` | AI 单线程初稿，未经验证 | worker |
| `wip` | 正在分析中，尚未完成 | worker |
| `candidate` | fan-out 候选 / judge 选中待审 | worker / judge 选 |
| `confirmed` | 已经过用户拍板的最终结论 | **仅用户** |
| `rejected` | 经验证或拍板被驳回 | judge / 审查 / 用户 |
| `superseded` | 被新版本取代（历史归档常用） | librarian / agent 升级新版本时 |

常见的流程是这样的：
```
[worker / fan-out 产出]
   状态: candidate
       ↓
[审查 agent 独立审查]
   读：candidate yaml + 关联 .investigations/ 推理
   出：同意 / 不同意 / 需补证据
       ↓
[主 agent 转给用户]
   附带审查意见
       ↓
[用户拍板]
   confirmed   /   rejected   /   保持 candidate（要求补证据再审）
```
最后给我们的不同的agent上不同的权限，但是confirmed一定要有人来审查，也就是意味着这个点完全没有问题。
```
- worker 自己产出的最高只能是 `draft` 或 `candidate`
- judge 评判 fan-out 后只出意见，不直接改 status
- 审查 agent** 只输出审查意见，不直接改 status
- `confirmed` 必须由用户亲自拍板 —— AI 永远写不到这一档
```
# 跨文件关联分析
在上面设计的情况下，我们是一个单一的一对一管理。但是我们知道逆向一般都是多个so或者dll进行的互相引入的，所以这种引入如何解决？
用一个cross_refs文件来管理跨dll之间的关系表达：
格式如下：
| 字段 | 含义 |
|---|---|
| `编号` | 形如 `xref_001` |
| `状态` | status 值 |
| `版本` | 时间线版本号 |
| `从` | 引用发起方（binary + 地址） |
| `到` | 引用目标（binary + 类 + 方法 + 地址） |
| `关系类型` | 调用 / 引用虚表 / 引用数据 / 字符串引用 / 继承 |
| `证据` | 判别依据 |

举例一下：
```yaml
编号: xref_001
状态: confirmed
版本: 1
从:
  binary: bar.exe
  地址: '0x140003200'
到:
  binary: foo.dll
  目标类型: 方法
  类: Animal
  方法名: speak
  地址: '0x1400077c0'
关系类型: 调用
证据: 间接调用 [rcx+8]，rcx 在 0x14000312A 处加载 Animal::vftable（??_7Animal@@6B@）
```
# 版本管理
由于我们不可能一轮对话就可以吧一个任务完成，所以这里存在一个版本迭代问题。当我们逆向的第一版是这样的， 但是由于各种问题导致我们推翻了我们之前的分析过程和逆向过程。但是不确定第二个方向是对的情况下，就需要对版本进行管理。
格式如下：
| 命名 | 含义 | 何时产生 |
|---|---|---|
| `<name>.yaml` | **当前活跃版本**（主文件，索引指向这个） | 总是存在 |
| `<name>.v1.yaml`<br>`<name>.v2.yaml`<br>`<name>.vN.yaml` | **时间线历史版本**（已被新版本替代） | 升级新版本时，旧主文件改名为 `.vN` |
| `<name>.b1.yaml`<br>`<name>.b2.yaml`<br>`<name>.bN.yaml` | **fan-out 分支候选**（同时刻互斥假设） | scout 出 N 候选 → 主 agent 派 N 个 worker → 各产出一个 `.bN` 文件 |

真实的情况是这样的：
```text
classes/Animal/methods/
├── speak.yaml          ← 当前主文件（v3 内容，confirmed，从 b3 复制来）
├── speak.v1.yaml       ← 第一次分析（status: rejected，把它当成普通函数）
├── speak.v2.yaml       ← 第二次分析（status: superseded，识别为 Animal::speak 但还原不准）
├── speak.b1.yaml       ← fan-out 候选 1（djb2 假设，status: rejected）
├── speak.b2.yaml       ← fan-out 候选 2（strcmp 假设，status: rejected）
└── speak.b3.yaml       ← fan-out 候选 3（CRC32 假设，status: superseded，已被 speak.yaml 取代为活跃）
```
# 文件迁移机制
通常笔者遇到的都是大型商业软件的逆向，所以遇到面向过程的的极少都是面向对象的设计模型。传统那几种吧。所以逆向到最后一定是一个类方法，虚方法等等。这里面就存在一个 最早期的函数到面向过程的转行问题，比如一个核心算法，他最后肯定是一个类，不是一个函数。在我们的上下文管理中就存在从函数状态的上下文到类对象的迁移过程。设计是这样的：
```
1. 写新位置 `classes/<X>/methods/<name>.yaml`，加上 `类` 和 `方法名` 两个字段
2. 更新主索引 `addresses` 里对应那条：
   - `path` 改为新位置
   - `kind` 从 `function` 改为 `method`
3. 更新类的 `class.yaml`**，在 `方法清单` 数组里加上 `<name>`
4. 删除旧位置** `functions/<addr>.yaml`
```
主要是做文件的迁移吧之前的旧文件删除，迁移到对应的类下面.

# AI思维分析上下文管理
这个部分是非常杂的所以不能做那么精细化的区分。
这里拿一个真实项目举例：
 ![图片描述](upload/attach/202604/992284_4BXAC36956J3S23.webp)
从任务出发到最后的定位总结分析 整套链路。
设计如下:

```
---
编号: 001
任务: 分析 foo.dll 的 USB HID 协议
任务类型: 协议分析       # 还原 / debug / patch / 协议分析 / 行为分析 / ...
模式档位: 轻量          # 轻量 / 重量（重量启动前必须用户同意）
状态: 进行中            # 进行中 / 已结案 / 已放弃
创建时间: 2026-04-30
更新时间: 2026-04-30
---
```
# knowledge 设计
在说完我们的上下文管理后，讲一下在我自己的任务中存在的高精度还原问题。
首先我蒸馏我自己，将所有的最基础的RE和编译原理进行蒸馏成一个知识库。
 ![图片描述](upload/attach/202604/992284_4M2UPK38AKAKT6T.webp)
INDEX是整个知识库的索引目录，用来读取Agent遇到问题的时候所需要的知识。
# Skills
上面我说过AI是不懂逆向的，他懂的是F5以及汇编，不明白如何还原一个类或者一个算法。
所以这里我整理了两个skills，一个是类分析和lift也就是我说的人肉f5.
 ![图片描述](upload/attach/202604/992284_TXTER3KEBKDBK44.webp)
这个位置就是我们需要技能，ai不会的，但是人为指点后就可以完成的事情。比如脱壳，去花等等。。。。
# lift skills
在高精度的还原，我们人是通过汇编的骨架还原。流程如下：
```
步骤 1  骨架还原          控制流壳（if/while/for/switch），条件和函数体用占位符
   ↓
步骤 2  逐行机械翻译       asm → C 伪代码，变量名直接用寄存器名（不识别不优化）
   ↓
步骤 3  签名草稿           从调用方视角推断调用约定 + 参数个数（待修正）
   ↓
步骤 4  优化              约定寄存器识别 / 折叠中间寄存器 / 内存操作分类 / lea 处理
   ↓
步骤 5  语义折叠           识别算法模式 + 改有意义变量名 + 修正签名
```
这里产物一定是一个cpp文件，也就是对应上面的上下文的产物管理的部分。

# Class-identify Skill
由于我工作中大量需要设计类和对象的整个项目的工程化的评估，我需要有一个系统的评估技能。根据我自己的业务制作了一个Skills
```
工作流（简版）：
1. **RTTI 优先** → 有 RTTI 的话整套继承图、类名、虚函数表都能直接拿到
2. **没 RTTI 时用户给起点** → 用户给某个 ctor / thiscall 方法的地址作为分析起点
3. **通过 vtable 列虚方法**
4. **thiscall 偏移聚类列非虚方法**
5. **配合方法体粗还原汇总 `[this+N]` 偏移得成员清单**
输出强制 yaml schema
```
# 测试成功
这里我拿我之前网页AI时期的半古法分析的一个的帖子作为测试（Gtuner软件协议分析可以去看我自己的其他文章），看我这套东西是否能跑通。
 ![图片描述](upload/attach/202604/992284_JQXWQWQC7J7UASY.webp)
 ![图片描述](upload/attach/202604/992284_XZQJF3JG6TNWS2B.webp)
 ![图片描述](upload/attach/202604/992284_6UECSB3JVRJAR79.webp)
 ![图片描述](upload/attach/202604/992284_Q3YXRGBVNWV58EJ.webp)
最后产物：
 ![图片描述](upload/attach/202604/992284_3XAHD3ZQZ92H7HZ.webp)
 ![图片描述](upload/attach/202604/992284_E4YG7TG43FW5PNG.webp)
几乎是没用我多少时间，全程agent就自主完成了，中间打断了我四次（打了一把游戏agent就完成了）
# 结尾
针对我自己的工作目前就这样设计的，目前还有动态调试的部分没有讲如何融入进来。这里主要是讲解设计，虽然我会把我的工程发到附件里面去，但是不推荐直接使用，可以利用我这种设计打造属于自己的"逆向工程sln"。这里推荐使用opencode，可以把主脑配置到deep seek v4，干活可以使用glm5.1，这样可以使用国产甚至是内网模型来完成工作，不再受制于claude 虽然它目前还是最强的。感谢您看到这里了，如果觉得有帮助可以点个赞吗？对于有啥意见和感受都可以在评论区讨论。笔者也是科锐毕业，这里也感谢科锐感谢钱老师，里面算法还原部分SKILL设计灵感是从以前科锐课程中笔记总结出来，古法经验和AI时代结合才是正解。

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

最后于 2026-6-12 16:11 被BitWarden编辑，原因：修复错别字

上传的附件：

re-projects.7z （31.80kb，486次下载）

收藏・71

点赞・61

打赏

赞赏记录

参与人

雪币

留言

时间

尤瑟努

你的帖子非常有用，感谢分享！

2026-9-13 10:08

wx_SoYoung

谢谢你的细致分析，受益匪浅！

2026-9-6 06:52

mb_qqnashwi

感谢你分享这么好的资源！

2026-9-2 15:59

git_29575booksnature

这个讨论对我很有帮助，谢谢！

2026-8-27 23:45

bananaships

为你点赞！

2026-8-24 15:24

mo_ming

期待更多优质内容的分享，论坛有你更精彩！

2026-8-6 15:31

mb_dvagoefd

期待更多优质内容的分享，论坛有你更精彩！

2026-7-18 15:48

mb_ebuwcbxc

感谢你的积极参与，期待更多精彩内容！

2026-7-14 13:26

seeooo

期待更多优质内容的分享，论坛有你更精彩！

2026-7-8 08:28

xichang13

这个讨论对我很有帮助，谢谢！

2026-7-7 17:16

Gamer_Lee6

感谢你分享这么好的资源！

2026-6-25 15:20

从黎明到衰落

这个讨论对我很有帮助，谢谢！

2026-6-24 11:19

散修韩立

谢谢你的细致分析，受益匪浅！

2026-6-23 00:20

Vn小帆

期待更多优质内容的分享，论坛有你更精彩！

2026-6-22 11:50

AGSFGBKILO

感谢你分享这么好的资源！

2026-6-22 01:07

hackroad

这个讨论对我很有帮助，谢谢！

2026-6-19 16:47

gegon

非常支持你的观点！

2026-6-19 09:23

Hedgehog555

为你点赞！

2026-6-18 22:28

3bbdyg

感谢你的积极参与，期待更多精彩内容！

2026-6-5 09:18

mb_gatolgsc

感谢你分享这么好的资源！

2026-6-1 12:49

番茄丶

为你点赞！

2026-6-1 08:20

zzzhangyu

为你点赞！

2026-5-27 16:28

wx_code_258

这个讨论对我很有帮助，谢谢！

2026-5-25 15:39

lgnorantlu

为你点赞！

2026-5-25 12:14

Lnju

谢谢你的细致分析，受益匪浅！

2026-5-24 00:18

AcheronHana

感谢你分享这么好的资源！

2026-5-23 16:46

SX_DomOne

感谢你的贡献，论坛因你而更加精彩！

2026-5-21 19:54

belikewater

谢谢你的细致分析，受益匪浅！

2026-5-21 16:32

mb_arjunooq

为你点赞！

2026-5-19 20:52

OverCL0ck

期待更多优质内容的分享，论坛有你更精彩！

2026-5-19 12:37

spman

你的帖子非常有用，感谢分享！

2026-5-16 09:28

之安

谢谢你的细致分析，受益匪浅！

2026-5-15 16:56

边缘

感谢你的贡献，论坛因你而更加精彩！

2026-5-15 11:33

周游列国

谢谢你的细致分析，受益匪浅！

2026-5-14 18:13

CongYuNian

为你点赞！

2026-5-13 14:27

iamshy

感谢你的贡献，论坛因你而更加精彩！

2026-5-13 14:19

ysh9527

你的分享对大家帮助很大，非常感谢！

2026-5-12 11:52

九月心情

非常支持你的观点！

2026-5-11 22:44

maxfire

感谢你的积极参与，期待更多精彩内容！

2026-5-11 15:21

clz3216

感谢你的积极参与，期待更多精彩内容！

2026-5-9 20:11

Valdoivre

感谢你的积极参与，期待更多精彩内容！

2026-5-9 16:58

缪江

你的帖子非常有用，感谢分享！

2026-5-8 19:48

mb_rrvlrvbk

你的帖子非常有用，感谢分享！

2026-5-8 16:43

xxrinkoss

非常支持你的观点！

2026-5-7 17:57

零_721409

感谢你的贡献，论坛因你而更加精彩！

2026-5-7 15:14

烧板侠

感谢你的贡献，论坛因你而更加精彩！

2026-5-7 11:44

dsfa

为你点赞！

2026-5-7 11:08

念空

你的分享对大家帮助很大，非常感谢！

2026-5-7 10:45

MemberA

感谢你的贡献，论坛因你而更加精彩！

2026-5-5 22:54

程序原

感谢你的积极参与，期待更多精彩内容！

2026-5-5 21:20

mb_iesvmzqc

感谢你的贡献，论坛因你而更加精彩！

2026-5-4 23:22

wx_funcrever

期待更多优质内容的分享，论坛有你更精彩！

2026-5-3 15:59

我的小拇指啊

你的分享对大家帮助很大，非常感谢！

2026-5-3 12:55

x_req

感谢你的贡献，论坛因你而更加精彩！

2026-5-2 19:59

Harpe

非常支持你的观点！

2026-5-2 13:09

新气象

感谢你分享这么好的资源！

2026-5-1 21:31

a0yark

感谢你的积极参与，期待更多精彩内容！

2026-5-1 20:53

cr_lgdx

感谢你的积极参与，期待更多精彩内容！

2026-5-1 16:23

孤独的街

为你点赞！

2026-5-1 16:01

atom2024

你的分享对大家帮助很大，非常感谢！

2026-5-1 11:12

东方玻璃

谢谢你的细致分析，受益匪浅！

2026-4-30 22:48

最新回复 (25) 1 2 ▶
淡然他徒弟雪币： 5589 活跃值： (7253) 能力值： ( LV10，RANK：160 ) 在线值：发帖 23 回帖 296 粉丝 124 关注私信	淡然他徒弟 1 2 楼 mark，学习了 2026-4-30 22:16 0
Imxz 雪币： 112 活跃值： (9405) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 750 粉丝 9 关注私信	Imxz 3 楼 tql 2026-5-1 14:42 0
Ankeys 雪币： 718 能力值： ( LV1，RANK：0 ) 在线值：发帖 2 回帖 96 粉丝 5 关注私信	Ankeys 4 楼看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架子上来,相比于直接连个ida-mcp然后扔给他一句话,让他从汇编层面分析逻辑,需要花费更多的时间和Token. 这个问题楼主是怎么解决的 2026-5-3 12:56 1
初学者有毅力雪币： 190 活跃值： (1506) 能力值： ( LV3，RANK：26 ) 在线值：发帖 7 回帖 53 粉丝 1 关注私信	初学者有毅力 5 楼这是对早期AI有效果,,现在AI已经很聪明了,,过多的引导只会让AI陷入迷茫,AI会遵守你的规程导致没办法发挥的出AI最大的想象力,聪明反被聪明误! 2026-5-3 14:24 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 6 楼初学者有毅力这是对早期AI有效果,,现在AI已经很聪明了,,过多的引导只会让AI陷入迷茫,AI会遵守你的规程导致没办法发挥的出AI最大的想象力,聪明反被聪明误! 最后于 2026-6-12 16:14 被BitWarden编辑，原因： 2026-5-3 17:14 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 7 楼 Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架 ... 最后于 2026-6-12 16:14 被BitWarden编辑，原因： 2026-5-3 17:21 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 8 楼 Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架 ... 最后于 2026-5-3 17:26 被BitWarden编辑，原因： 2026-5-3 17:24 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 9 楼 Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架 ... 最后于 2026-6-12 16:13 被BitWarden编辑，原因： 2026-5-3 17:42 0
wx_Lilac_176 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 4 粉丝 0 关注私信	wx_Lilac_176 10 楼有尝试做基准测试吗？这样一套 agent，相比直接用 coding agent（codex/cc/cursor）真的更强大吗？ 2026-5-4 09:34 0
lixianhuei 雪币： 1688 活跃值： (2335) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 128 粉丝 0 关注私信	lixianhuei 11 楼 666 2026-5-5 17:12 0
Ankeys 雪币： 718 能力值： ( LV1，RANK：0 ) 在线值：发帖 2 回帖 96 粉丝 5 关注私信	Ankeys 12 楼 BitWarden Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的 ... 如果说打算使用国产模型,或者社区开源模型的话,那搞这样一套工程结构那确实必不可少了.那这套系统最后是如何验证产出的呢,人工check结果嘛 2026-5-6 09:11 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 13 楼 Ankeys 如果说打算使用国产模型,或者社区开源模型的话,那搞这样一套工程结构那确实必不可少了.那这套系统最后是如何验证产出的呢,人工check结果嘛肯定是业务交付啊。最后于 2026-5-6 14:10 被BitWarden编辑，原因： 2026-5-6 14:06 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 14 楼。最后于 2026-5-6 14:10 被BitWarden编辑，原因： 2026-5-6 14:07 0
XieCZ1337 雪币： 200 活跃值： (235) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 14 粉丝 5 关注私信	XieCZ1337 15 楼 1 最后于 2026-5-30 17:15 被XieCZ1337编辑，原因： 2026-5-7 23:23 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 16 楼 XieCZ1337 1 我也有这样的想法，完全脱离opencode做一个逆向的cli，动态静态一起做，还可以人工介入。是一个方向。周围有朋友已经在做了，很成熟。 2026-5-7 23:32 0
XieCZ1337 雪币： 200 活跃值： (235) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 14 粉丝 5 关注私信	XieCZ1337 17 楼 BitWarden 我也有这样的想法，完全脱离opencode做一个逆向的cli，动态静态一起做，还可以人工介入。是一个方向。周围有朋友已经在做了，很成熟。完全脱离AI编辑器不一定很好,因为调试器本身还负责插件/脚本/反反调试等工作,在设计阶段给专门的AGENT编辑器提供接口就好了,其实我的方案是调试器GUI里内嵌它的CLI,同时渲染CLI和GUI,这样AI能够得到完整的上下文和也可以和人工真正地协作,同时设计一些脚本命令MCP,让AI可以调MCP做某些重复的任务,同时CLI命令行设计得能够精确操作,最后,脚本系统也是很重要的。 2026-5-8 00:07 0
做好事不留名雪币： 121 活跃值： (1745) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 24 粉丝 1 关注私信	做好事不留名 18 楼支持皇神 2026-5-11 18:27 0
阿耿雪币： 55 活跃值： (1363) 能力值： ( LV2，RANK：10 ) 在线值：发帖 12 回帖 80 粉丝 1 关注私信	阿耿 19 楼初学者有毅力这是对早期AI有效果,,现在AI已经很聪明了,,过多的引导只会让AI陷入迷茫,AI会遵守你的规程导致没办法发挥的出AI最大的想象力,聪明反被聪明误! 确实是这样，一个会话时间越长，对应的这个上下文会不断的精简压缩，最后就产生幻觉了，不管什么模型目前都存在这个问题。 2026-5-13 16:28 0
mb_yyvcbkli 雪币： 149 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 54 粉丝 0 关注私信	mb_yyvcbkli 20 楼学习一下先进经验 2026-5-16 08:58 0
mudebug 雪币： 12364 活跃值： (9900) 能力值： ( LV3，RANK：20 ) 在线值：发帖 10 回帖 334 粉丝 64 关注私信	mudebug 21 楼感谢大佬分享，一直不懂ai怎么跑逆向，现在了解大概了 knowledge 方便发一个简单模板吗最后于 2026-5-16 10:21 被mudebug编辑，原因： 2026-5-16 10:15 0
sabason 雪币： 22 活跃值： (1283) 能力值： ( LV2，RANK：10 ) 在线值：发帖 8 回帖 52 粉丝 2 关注私信	sabason 22 楼 66 2026-5-18 10:49 0
海带雪币： 427 活跃值： (2110) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 83 粉丝 11 关注私信	海带 23 楼学习 2026-5-18 18:57 0
Freax 雪币： 5155 活跃值： (2509) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 73 粉丝 1 关注私信	Freax 24 楼 d:\x86skills\.claude\knowledge\INDEX.md 有demo吗，看压缩包里面没有 2026-6-15 20:27 0
散修韩立雪币： 180 活跃值： (90) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	散修韩立 25 楼膜拜大神. 你遇到的问题我几乎也都遇到过. 我们最早就放弃了ida f5产生的c代码, 感觉质量很低. 然后直接从汇编生成. 然后对照汇编和c, 发现有遗漏, 也就是llm只能对开头和结尾处理的比较好, 对中间结果处理的不太行. 查找原因, 才发现是经典的"Lost In The Middle"问题. 我们想到的方法是用cfg来分片, 沿着cfg收集数据流, 避免片间依赖问题. 我们先生成一种叫做c--的东西, 只有if和goto, 然后恢复语义的时候通过cfg很容易把循环, 分支语句恢复. 我们遇到的难题是数据结构的恢复, 比较困难, 现在还在探索中. 不知能不能加一下大神的联系方式 2026-6-23 00:19 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

BitWarden

发帖

回帖

120

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (25) 1 2 ▶
淡然他徒弟雪币： 5589 活跃值： (7253) 能力值： ( LV10，RANK：160 ) 在线值：发帖 23 回帖 296 粉丝 124 关注私信	淡然他徒弟 1 2 楼 mark，学习了 2026-4-30 22:16 0
Imxz 雪币： 112 活跃值： (9405) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 750 粉丝 9 关注私信	Imxz 3 楼 tql 2026-5-1 14:42 0
Ankeys 雪币： 718 能力值： ( LV1，RANK：0 ) 在线值：发帖 2 回帖 96 粉丝 5 关注私信	Ankeys 4 楼看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架子上来,相比于直接连个ida-mcp然后扔给他一句话,让他从汇编层面分析逻辑,需要花费更多的时间和Token. 这个问题楼主是怎么解决的 2026-5-3 12:56 1
初学者有毅力雪币： 190 活跃值： (1506) 能力值： ( LV3，RANK：26 ) 在线值：发帖 7 回帖 53 粉丝 1 关注私信	初学者有毅力 5 楼这是对早期AI有效果,,现在AI已经很聪明了,,过多的引导只会让AI陷入迷茫,AI会遵守你的规程导致没办法发挥的出AI最大的想象力,聪明反被聪明误! 2026-5-3 14:24 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 6 楼初学者有毅力这是对早期AI有效果,,现在AI已经很聪明了,,过多的引导只会让AI陷入迷茫,AI会遵守你的规程导致没办法发挥的出AI最大的想象力,聪明反被聪明误! 最后于 2026-6-12 16:14 被BitWarden编辑，原因： 2026-5-3 17:14 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 7 楼 Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架 ... 最后于 2026-6-12 16:14 被BitWarden编辑，原因： 2026-5-3 17:21 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 8 楼 Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架 ... 最后于 2026-5-3 17:26 被BitWarden编辑，原因： 2026-5-3 17:24 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 9 楼 Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的资源浪费,很多其实没那么复杂的分析,也会被强行靠到整个架 ... 最后于 2026-6-12 16:13 被BitWarden编辑，原因： 2026-5-3 17:42 0
wx_Lilac_176 雪币： 0 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 4 粉丝 0 关注私信	wx_Lilac_176 10 楼有尝试做基准测试吗？这样一套 agent，相比直接用 coding agent（codex/cc/cursor）真的更强大吗？ 2026-5-4 09:34 0
lixianhuei 雪币： 1688 活跃值： (2335) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 128 粉丝 0 关注私信	lixianhuei 11 楼 666 2026-5-5 17:12 0
Ankeys 雪币： 718 能力值： ( LV1，RANK：0 ) 在线值：发帖 2 回帖 96 粉丝 5 关注私信	Ankeys 12 楼 BitWarden Ankeys 看完感觉整体都是在讲一个逆向的Harness设计,不知道理解的是不是到位了. 我之前也尝试过做类似的工程结构,但是实际搞下来发现会有很严重的 ... 如果说打算使用国产模型,或者社区开源模型的话,那搞这样一套工程结构那确实必不可少了.那这套系统最后是如何验证产出的呢,人工check结果嘛 2026-5-6 09:11 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 13 楼 Ankeys 如果说打算使用国产模型,或者社区开源模型的话,那搞这样一套工程结构那确实必不可少了.那这套系统最后是如何验证产出的呢,人工check结果嘛肯定是业务交付啊。最后于 2026-5-6 14:10 被BitWarden编辑，原因： 2026-5-6 14:06 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 14 楼。最后于 2026-5-6 14:10 被BitWarden编辑，原因： 2026-5-6 14:07 0
XieCZ1337 雪币： 200 活跃值： (235) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 14 粉丝 5 关注私信	XieCZ1337 15 楼 1 最后于 2026-5-30 17:15 被XieCZ1337编辑，原因： 2026-5-7 23:23 0
BitWarden 雪币： 2473 活跃值： (1910) 能力值： ( LV8，RANK：120 ) 在线值：发帖 10 回帖 53 粉丝 70 关注私信	BitWarden 2 16 楼 XieCZ1337 1 我也有这样的想法，完全脱离opencode做一个逆向的cli，动态静态一起做，还可以人工介入。是一个方向。周围有朋友已经在做了，很成熟。 2026-5-7 23:32 0
XieCZ1337 雪币： 200 活跃值： (235) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 14 粉丝 5 关注私信	XieCZ1337 17 楼 BitWarden 我也有这样的想法，完全脱离opencode做一个逆向的cli，动态静态一起做，还可以人工介入。是一个方向。周围有朋友已经在做了，很成熟。完全脱离AI编辑器不一定很好,因为调试器本身还负责插件/脚本/反反调试等工作,在设计阶段给专门的AGENT编辑器提供接口就好了,其实我的方案是调试器GUI里内嵌它的CLI,同时渲染CLI和GUI,这样AI能够得到完整的上下文和也可以和人工真正地协作,同时设计一些脚本命令MCP,让AI可以调MCP做某些重复的任务,同时CLI命令行设计得能够精确操作,最后,脚本系统也是很重要的。 2026-5-8 00:07 0
做好事不留名雪币： 121 活跃值： (1745) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 24 粉丝 1 关注私信	做好事不留名 18 楼支持皇神 2026-5-11 18:27 0
阿耿雪币： 55 活跃值： (1363) 能力值： ( LV2，RANK：10 ) 在线值：发帖 12 回帖 80 粉丝 1 关注私信	阿耿 19 楼初学者有毅力这是对早期AI有效果,,现在AI已经很聪明了,,过多的引导只会让AI陷入迷茫,AI会遵守你的规程导致没办法发挥的出AI最大的想象力,聪明反被聪明误! 确实是这样，一个会话时间越长，对应的这个上下文会不断的精简压缩，最后就产生幻觉了，不管什么模型目前都存在这个问题。 2026-5-13 16:28 0
mb_yyvcbkli 雪币： 149 能力值： ( LV1，RANK：0 ) 在线值：发帖 0 回帖 54 粉丝 0 关注私信	mb_yyvcbkli 20 楼学习一下先进经验 2026-5-16 08:58 0
mudebug 雪币： 12364 活跃值： (9900) 能力值： ( LV3，RANK：20 ) 在线值：发帖 10 回帖 334 粉丝 64 关注私信	mudebug 21 楼感谢大佬分享，一直不懂ai怎么跑逆向，现在了解大概了 knowledge 方便发一个简单模板吗最后于 2026-5-16 10:21 被mudebug编辑，原因： 2026-5-16 10:15 0
sabason 雪币： 22 活跃值： (1283) 能力值： ( LV2，RANK：10 ) 在线值：发帖 8 回帖 52 粉丝 2 关注私信	sabason 22 楼 66 2026-5-18 10:49 0
海带雪币： 427 活跃值： (2110) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 83 粉丝 11 关注私信	海带 23 楼学习 2026-5-18 18:57 0
Freax 雪币： 5155 活跃值： (2509) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 73 粉丝 1 关注私信	Freax 24 楼 d:\x86skills\.claude\knowledge\INDEX.md 有demo吗，看压缩包里面没有 2026-6-15 20:27 0
散修韩立雪币： 180 活跃值： (90) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 1 粉丝 0 关注私信	散修韩立 25 楼膜拜大神. 你遇到的问题我几乎也都遇到过. 我们最早就放弃了ida f5产生的c代码, 感觉质量很低. 然后直接从汇编生成. 然后对照汇编和c, 发现有遗漏, 也就是llm只能对开头和结尾处理的比较好, 对中间结果处理的不太行. 查找原因, 才发现是经典的"Lost In The Middle"问题. 我们想到的方法是用cfg来分片, 沿着cfg收集数据流, 避免片间依赖问题. 我们先生成一种叫做c--的东西, 只有if和goto, 然后恢复语义的时候通过cfg很容易把循环, 分支语句恢复. 我们遇到的难题是数据结构的恢复, 比较困难, 现在还在探索中. 不知能不能加一下大神的联系方式 2026-6-23 00:19 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

[原创]打破传统AI逆向的新思路 多Agent、自主管理上下文 - 逆向思路

[原创]打破传统AI逆向的新思路多Agent、自主管理上下文 - 逆向思路