JS: https://p-pc-weboff.byteimg.com/tos-cn-i-9r5gewecjs/bdms_1.0.1.19_fix.js
有时候会加载这个js:https://lf-c-flwb.bytetos.com/obj/rc-client-security/web/stable/1.0.1.19-fix.01/bdms.js
旧版xb的js: https://lf-c-flwb.bytetos.com/obj/rc-client-security/c-webmssdk/1.0.0.20/webmssdk.es5.js
msToken, 固定184位类base64字符串, 由接口
https://mssdk.bytedance.com/web/common 返回Cookie值
a_bogus, 固定192位类base64字符串
fp, verifyFp: 52位形如”verify_mt499c8g_KCNeG1mY_pfdS_4oBY_82h9_u5CfPWiAh8Gl”的值 取自缓存 s_v_web_id的值
JSVMP代码分析
XHR断点包含签名”a_bogus”的接口,定位跟栈到关键生成逻辑在bdms_1.0.1.19_fix.js中。

分析 bdms_1.0.1.19_fix.js 核心部分代码,整体分析,不必扣细节理解每一行。
| 变量 | 作用 |
|---|---|
Z = [] | 常量字符串池。初始化时把所有字符串字面量解码后存入此数组,字节码通过下标 Z[x] 引用,从而避免明文字符串。 |
z = [] | 函数表。每个元素是一个函数的字节码与元信息 [code, 参数个数, 严格模式标志, 异常处理表]。 |
V = new Map | 函数对象 → [字节码, 闭包变量] 的映射。解释器靠它识别”这个普通函数其实是 VM 内部函数”,以便做帧切换而不是走原生 apply。 |
Y = new Map | 函数索引 → 包装函数 的映射,做缓存,避免重复创建同一函数对象。 |
J(t, r, e, n) —— 加载器与执行入口
第一次调用时(Z.length || 为假)触发一个 IIFE 完成一次性初始化:
- Base64 解码
atob(t),前 4 字节是 magic/头,第 4–7 字节求和取e % 256作为解密密钥; - 从加密字符串常量中解码实际的字符串常量数组Z和函数表z。
初始化只跑一次,之后直接 X(z[t], r, e, n) 执行第 t 个函数。所以 J = 反序列化 + 启动。

然后通过J函数执行业务逻辑

虚拟机执行器/解释器X进一步下发到指令分发循环d()函数中.
D(t, r) —— 函数对象工厂
var n = function() { return X(e, this, arguments, r) };V.set(n, [e, r]); // 标记为 VM 内部函数把函数表第 t 项包装成真实可调用的 JS 函数。调用时进入解释器 X;同时登记到 V,使 VM 内部调用能识别它并切换执行帧而非走 apply(性能优化 + 语义保真)。
X(t, r, e, n) —— VM 解释器(核心)
参数:t 函数定义、r this、e arguments、n 闭包变量。
主循环:do { try { d() } catch(t) { f=3; l=t } } while(y()) —— 取指执行,靠 y() 决定下一步走向。
-
g(t,r,e,n)—— 帧初始化 建立 arguments 对象与作用域链。严格模式下把形参直接映射到实参槽位;非严格模式用Object(r)作 this、为每个形参定义 getter/setter 代理到s(实现 arguments 与形参的绑定联动)。 -
d()—— 指令分派(取指执行) 一个用二分 if-else 树实现的巨型分派器(等价 switch,但更难阅读、对 jump table 友好)。约 77 个操作码。
每条指令自取操作数(从 v 栈或紧跟在 opcode 后的 o[a++] 立即数),执行后更新 p/a。操作码 0(调用)是亮点:若被调函数在 V 中,就 h.push([当前帧]) 并 g(...) 切换帧,形成”VM 内调用”;否则用原生 n.apply,结果压栈。
y()—— 控制流与异常派发
异常表项是 [start, catchStart, finallyStart, end] 四元组,实现 try/catch/finally/with 的精确区域控制。
b(t, r)—— 全局变量引用代理 返回一个Object.create(null)对象,其属性t的 getter/setter 代理到globalThis[t],严格模式下未定义会抛ReferenceError。用于支持eval/with/全局变量引用语义。

在指令分发循环d()函数中,执行解释器。 d()函数是一个巨大的嵌套if else循环,使用控制流平坦化混淆,增加逻辑分析难度。 核心就是d()函数执行的。
整体运行流程:
- 传入 base64 + 压缩 + 异或加密的字节码字符串;
J()首次调用时反序列化 → 填充Z(字符串池)和z(函数表);J()调X(z[0], ...)启动主函数;d()逐条取指执行,遇到函数定义用D()造真实函数对象,遇到调用按是否在V中决定帧切换或原生调用;y()处理跳转/返回/异常,维持调用栈与异常表语义;- 执行结束
l即为返回值(或抛出)。
简言之:J 是装载机、X 是 CPU、d 是指令译码执行单元、y 是中断/异常控制器、Z/z 是只读数据段、V/Y 是函数表与闭包管理、W/K/_ 是反序列化工具。原始 JS 的语法、作用域、异常、this、arguments 绑定等语义,都被这套栈式虚拟机完整重放。

简易demo
用类似vmp的方式实现一个add函数,理解运行逻辑。
// ============ 1. 指令集定义(opcode 常量) ============const OP = { LOAD_ARG: 0, // 操作数: 参数下标 —— 把第 n 个实参压栈 LOAD_CONST: 1,// 操作数: 常量池下标 —— 把 Z[idx] 压栈 ADD: 2, // 无操作数 —— 弹出 b、a,压入 a+b RET: 3, // 无操作数 —— 返回栈顶};
// ============ 2. 只读数据段 ============// Z: 常量池(本例 add 没用到常量,留一个示例值)const Z = [42];
// z: 函数表。每项 = [字节码, 参数个数, 函数名]// function add(a, b) { return a + b } 编译结果:// LOAD_ARG 0 // 压入 a// LOAD_ARG 1 // 压入 b// ADD // a + b// RET // 返回栈顶const z = [ [ [ OP.LOAD_ARG, 0, OP.LOAD_ARG, 1, OP.ADD, OP.RET, ], 2, // 参数个数 'add', // 函数名 ],];
// ============ 3. VM 解释器 ============// t: 函数定义 [code, argc, name];args: 实参数组function X(t, args) { const o = t[0]; // 字节码数组 let a = 0; // 指令指针 PC const v = []; // 操作数栈 let p = -1; // 栈顶指针(-1 表示空栈)
for (;;) { const op = o[a++]; // 取指令 switch (op) { case OP.LOAD_ARG: { const idx = o[a++]; // 取立即数操作数 v[++p] = args[idx]; // 压栈 break; } case OP.LOAD_CONST: { const idx = o[a++]; v[++p] = Z[idx]; break; } case OP.ADD: { const b = v[p--]; // 弹出 b const a2 = v[p--]; // 弹出 a v[++p] = a2 + b; // 压入结果 break; } case OP.RET: { return v[p--]; // 返回栈顶 } default: throw new Error('unknown opcode: ' + op); } }}
// ============ 4. 函数对象工厂(把 VM 函数包成真实 JS 函数) ============function D(index) { const def = z[index]; return function () { return X(def, arguments); };}
// ============ 5. 运行 ============/*function add(a,b){ return a+b;}*/const add = D(0); // 拿到 z[0] 对应的 addconsole.log('add(3, 5) =', add(3, 5)); // 8console.log('add(10, 20) =', add(10, 20)); // 30还原流程
先还原d()函数的分发树,每个opcode对应的操作数。
根据z函数表中的指令集与之对应的操作数,还原函数。
补充额外变量值
整体每个vm函数出入参数和返回值
z[107] 是一个hook XHR request对象,会在其中调用z[103] => z[150] vm函数进行签名。 最后通过z[130]自定义base64编码返回最终的加密值。

y() 函数入口添加日志点(日志点会打印所有,过量可能会导致控制台卡死) 防止卡死可以添加条件或者限制只打印某两次断点之间的。
PS:出入参都写在y()函数下无法直接体现函数调用顺序。
"z[index] = %d\n字节码长度 = %d\nparams = %o\nreturn = %o", z.map(x => x[0]).indexOf(o), a, s[1], l
分离调用与返回可以清晰调用堆栈。先调用z[103] vm 函数内部再调用 z[150]
// g() 函数入口调用信息日志点"[call:z[%d]]\nparams = %o\nscope = %o", z.indexOf(t), Array.from(e), n
// y() 函数入口返回信息日志点"[return:z[%d]]\nparams = %o\nreturn = %o", z.map(x => x[0]).indexOf(o), Array.from(s[1]), l
分析opcode, 还原表,每个函数的细致行为
逐条对照解释器 d() 的分支,静态分析每个opcode的行为语义,还原 0~76 号 opcode 的语义与操作数格式,形成一个 OPS 表(助记符 + 操作数 + 注释模板),例如:
| opcode | 助记符 | 语义 |
|---|---|---|
| 0 | CALL n | 调用(VM 函数递归进入解释器 / JS 函数 apply) |
| 38 / 46 | PUSHI n / PUSHNUM Zn | 压立即数 / 常量池数字 |
| 54 / 74 / 61 | STORE / LOAD / LDREF d,s | scope 链读写 |
| 63 | CLOSURE fn | 创建闭包(绑定当前 scope) |
| 39 | NEWARR n | 弹出 n 个值组成数组 |
| 70 | XOR | 异或 |
| 17/23/31/41/71 | 条件跳转 | 多种真假值/相等跳转 |
| 然后根据OPS表与函数表以及常量池Z,编写反汇编器,反汇编关键函数从字节码形式转为伪代码形式。 |
==============================================================================z[129] params=0 strict=True tryEntries=[] len=12 scope slots: [0]=parent scope, [1]=arguments, [2..1]=params============================================================================== 0: CLOSURE 130 ; push closure z[130] 2: STORE 1,1 ; scope^1[1] = pop() 5: CLOSURE 131 ; push closure z[131] 7: STORE 1,2 ; scope^1[2] = pop() 10: UNDEF ; push undefined 11: RETURN ; return pop()浏览器侧实际每个vm函数的参数与返回值日志,对比验证还原伪代码为真实代码。
在字符串常量池中定位到了”a_bogus”在索引220位置,就可以hook数组Z的getter方法,在取220时索引时断点,定位到取值位置。
利用条件断点,在不修改源码的情况下,实现条件日志,即:当索引x=220时才输出日志,避免大量日志扰乱分析。
原理就是条件断点会执行该表达式,但是console.log()始终返回undefined为false,只会执行console输出日志,而不会发生断点。
位置:v[++p] = Z[x];
(x === 220 && console.log('命中 Z[220]:', v))在220发生断点后,在d()函数循环初始出开始记录下面日志信息,一直至下次x=220的断点。
console.table({ PC: a, // 在字节码里的位置(反汇编定位用) op: t, // 哪条指令 operand: x, // 操作数(常量下标/槽号/跳转偏移,视 opcode 而定) constVal: Z[x], // 操作数还原成明文 stackBefore: v.slice(0, p+1), // 执行前的栈 this: c, // 上下文})
通常有个操作,就是在指定位置断点后,然后在控制台执行JS注入,但是这操作就比较繁琐,那么借助条件断点,就可以在不使用替换修改源代码的情况下,实现指定位置注入。
window.___x === undefind && console.log("注入JS,只执行一次"), window.___x = null// 新增日志点 位置:U[x] = v[p--]
'[53 写作用域] 上溯%d层 slot[%d] <= %o scope=%o', o[a-2], x, v[p], U
主动调用vm函数,对比验证还原
受时间戳和随机数的影响,相同参数下每次结果不一,影响对比还原验证。 Hook固定影响因子。
(function () { // 🎯 设定你要固定的时间 const fixedTime = new Date('2026-08-24T22:30:00').getTime();
// 保存原始构造函数 const NativeDate = window.Date;
// 2️⃣ 覆盖 new Date() 和 Date() 的行为 function MockedDate(...args) { // 无参调用时返回固定时间 if (args.length === 0) { return new NativeDate(fixedTime); } // 有参数时保持正常行为 return new NativeDate(...args); }
// 保留静态方法 MockedDate.now = () => fixedTime; MockedDate.parse = NativeDate.parse; MockedDate.UTC = NativeDate.UTC; MockedDate.prototype = NativeDate.prototype;
// 1️⃣ 覆盖 Date.now()(挂在原生上,防止别处已缓存引用) NativeDate.now = () => fixedTime;
// 替换全局 Date window.Date = MockedDate;
// 备份原函数(可选,用于恢复) const originalRandom = Math.random;
// 重写为固定返回值 Math.random = function() { return 0.123456789; // 每次调用都返回这个固定值 };
// 伪装成原生函数 Math.random.toString = function() { return "function random() { [native code] }"; };})();这样每次都能得到一个固定值。
// X() 函数入口globalThis.__vm = { z: z, Z: Z, D: D, V: V, Y: Y, X: X },false
// 调用z[103], z[150]__vm.Y.get(103)("device_platform=webapp&aid=6383&…&msToken=xxx", null, undefined);
__vm.Y.get(150)(1, 0, 8, "device_platform=webapp&aid=6383&…&msToken=xxx", "", navigator.userAgent, 6241, 6383, "1.0.1.19-fix.01")
在 hook Math.random() 方法返回固定值:0.123456789以及固定时间到(时间戳始终为该时间):2026-08-24T22:30:00的条件下// 还需要在相同的浏览器环境下,刷新后可能就变了,环境也参与了计算
返回固定值:'xJsfkFWjQqmjFd/b8CGhStHlOCy/rB8yk-iOboPPexP9LqMYC8P5Qxt8noLhsDVkrYpkiH17KxF/bExcZ4X0p9nkzmkku27WJT5CV8vo/qN6YUJBgHDze0vzowBe8YsoaQ9IilR5XsBN1fOUIH50lpQGy5To-5bkbNMUp2y9tEWXDCSkin3iOCk2NyGqkj=='结果
整体算法流程如下
环境指纹 + 三重 SM3 摘要特征字节 → 定序 50 字节载荷 → XOR 校验 → 插随机字节 → 改版 RC4 → 自定义 Base64
验证测试 有的接口不验证a_bogus的值,不携带也可以。(个人主页) 有的只验证是否携带,但是不验证签名值。(评论)

搜索接口/aweme/v1/web/search/item/强制校验a_bogus, 且一旦使用了错误值,很容易触发风控旋转验证码,不通过该验证使用正确的a_bogus也无法获取搜索数据。

其他
验证码相关接口:
https://rmc.bytedance.com/verifycenter/captcha/v2
https://verify.zijieapi.com/captcha/get
https://verify.zijieapi.com/captcha/verify
fp与verifyFp的值算法比较简单
import time, random
C = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" # 62 进制字符表
def gen_fp(now_ms=None): # 1) 时间戳转 36 进制(小写),对应 Date.now().toString(36) n = int(time.time()*1000) if now_ms is None else now_ms ts = "" while n: ts = "0123456789abcdefghijklmnopqrstuvwxyz"[n % 36] + ts n //= 36
# 2) 36 位数组,先填固定结构位(UUID v4 骨架) r = [None]*36 for i in (8, 13, 18, 23): r[i] = "_" # 分隔符 r[14] = "4" # version = 4
# 3) 随机填充空位;位置 19 为 variant 位,限定 8/9/A/B for i in range(36): if r[i] is None: o = int(random.random()*62) # 0 | Math.random()*62 r[i] = C[(o & 3) | 8 if i == 19 else o]
return "verify_" + ts + "_" + "".join(r)
ac_signature: https://zhuanlan.zhihu.com/p/628218062