浅析JavaScript Obfuscator(二)
* 距离上次发文已经过去整整两年了,JavaScript Obfuscator版本都升级到了v5.3.0,让我们来看看它都进行了哪些优化调整和功能升级。JavaScript Obfuscator ToolJavaScript Obfuscator官网目前主推的是付费版 VM Obfuscation(虚拟机字节码混淆) 。不过,我们还是先聚焦于它免费开源部分的混淆工具来分析。首先,快速过一遍v5.3
* 距离上次发文已经过去整整两年了,JavaScript Obfuscator版本都升级到了v5.3.0,让我们来看看它都进行了哪些优化调整和功能升级。
JavaScript Obfuscator Tool
JavaScript Obfuscator官网目前主推的是付费版 VM Obfuscation(虚拟机字节码混淆) 。不过,我们还是先聚焦于它免费开源部分的混淆工具来分析。
首先,快速过一遍v5.3.0版本的混淆选项差异 (为了与前文进行对比,这里所涉及的混淆选项指的是官方Playground中的显式配置项,而非源代码中的参数变量) :
- 基础
- [新增] Target (目标环境)
设置混淆后代码的目标执行环境,默认为Browser
- [新增] Strict Mode (严格模式)
控制混淆器如何处理JavaScript严格模式,默认为Auto
- [新增] Seed (种子)
设置随机生成器的种子值,用于创建可重复的结果,默认为0
- [新增] Ignore Imports (忽略导入)
阻止对require导入的混淆,默认为false
- Domain Lock (域名锁定,
v2.9.0版本已有但未显式展示)
限制混淆代码只能在特定域名下运行
- Redirect URL (重定向URL,
v2.9.0版本已有但未显式展示)
指定锁定域名验证失败时重定向跳转URL
- Source Map (源代码映射,
v2.9.0版本已有但未显式展示)
生成混淆代码的源代码映射,默认为false
- 字符串变换
- [变更] String Array Threshold (字符串数组阈值)
指定字符串值放入字符串数组的比例,默认从0.8改为0.75
- [新增] Unicode Escape Sequence (Unicode转义序列)
将字符串转换为Unicode转义序列,默认为false
- [新增] Force Transform Strings (强制变换字符串)
强制将匹配正则的字符串放入字符串数组
- [新增] Reserved Strings (保留字符串)
跳过匹配正则的字符串变换
- 标识符变换
- [新增] Reserved Names (保留名称)
跳过匹配正则的标识符混淆
- 其他变换
与v2.9.0版本一致
四种预设模式仍维持不变,我们还是以Crypto-JS的md5.js作为混淆示例先来分析一下新版本的默认级别都有哪些变化。
默认级别混淆变化
变化一:代码结构重排
在v2.9.0版本中,混淆后代码的三个核心函数按如下顺序排列:
- 字符串数组定义函数
- 索引复位取值函数
- 数组洗牌IIFE
也就是先定义数组,再定义取值方式,最后打乱数组,符合正常的阅读和理解顺序。
而在v5.3.0版本中,顺序变成了:
- 索引复位取值函数
- 数组洗牌IIFE
- 主体业务代码
- 字符串数组定义函数
// 1. 取值函数
function _0x517b(_0x3ecde7, _0x5eb75e) { ... }
// 2. 洗牌IIFE
(function(_0x130dcc, _0x3b860e) { ... }(_0x427e, 0xa7660),
// 3. 主体业务代码
function(_0x33934a) { ... }(Math));
// 4. 字符串数组定义函数
function _0x427e() { ... }可以看到,最明显的区别是字符串数组定义函数被移到了底部。
这里利用JavaScript的函数声明提升特性:function声明会被提升到作用域顶部。因此在最顶部的取值函数中调用暂末定义的字符串数组定义函数也能正常工作。
这种顺序打乱增加了阅读时的跳转成本,打破了自上而下的线性阅读习惯。
变化二:取值函数结构简化
在v2.9.0版本中,取值函数采用了闭包自重赋值的设计:
function _0x3126(_0x30a9d6, _0x49b9ba) {
var _0x10e724 = _0x10e7();
return _0x3126 = function(_0x3126ad, _0x475b54) {
_0x3126ad = _0x3126ad - 0x1aa;
var _0x45a84 = _0x10e724[_0x3126ad];
return _0x45a84;
}, _0x3126(_0x30a9d6, _0x49b9ba);
}第一次调用时,它会获取字符串数组并缓存在闭包变量中,然后用一个新的内部函数替换掉自身,后续调用直接走内部函数,从而避免重复初始化。
而v5.3.0版本中的取值函数简化成了直接调用的形式:
function _0x517b(_0x3ecde7, _0x5eb75e) {
_0x3ecde7 = _0x3ecde7 - 0x142;
var _0x427ec7 = _0x427e();
var _0x517b7b = _0x427ec7[_0x3ecde7];
return _0x517b7b;
}但保留了字符串数组定义函数的自重赋值作为缓存,理论上来说性能并不会有太大影响。
变化三:明文字符串增多
由于String Array Threshold默认值从0.8降至0.75,因此v5.3.0版本默认级别的混淆输出中会保留更多的明文字符串 (阈值是概率性的,加上源代码中字符串出现的位置和次数影响,实际可能更明显) ,但换来的是更好的运行性能。
变化四:洗牌函数复杂度提升
洗牌函数的核心逻辑没有变化,但v5.3.0版本中默认级别用于判断停止条件的parseInt运算表达式从10项增加到了12项:
// v2.9.0:10个parseInt值参与运算
var _0x11c77c = -parseInt(...)/0x1 + -parseInt(...)/0x2 + parseInt(...)/0x3*(-parseInt(...)/0x4) + parseInt(...)/0x5*(-parseInt(...)/0x6) + parseInt(...)/0x7 + parseInt(...)/0x8*(parseInt(...)/0x9) + parseInt(...)/0xa;
// v5.3.0:12个parseInt值参与运算
var _0x52be37 = -parseInt(...)/0x1*(parseInt(...)/0x2) + parseInt(...)/0x3*(-parseInt(...)/0x4) + parseInt(...)/0x5*(parseInt(...)/0x6) + -parseInt(...)/0x7 + -parseInt(...)/0x8*(parseInt(...)/0x9) + -parseInt(...)/0xa + -parseInt(...)/0xb*(-parseInt(...)/0xc);更多的运算项意味着手动计算停止条件更加复杂,导致数组的最终位移量更难预测。
字符串数组取值
默认级别的字符串数组取值过程几乎不变,我们同样来验证一下,还是以Hasher对象的extend方法的取值为例:
var _0x5bc011 = _0x1b3f2f[_0x2d9843(0x15b)] = _0x373a54[_0x2d9843(0x143)]({
'_doReset': function() { ... },
'_doProcessBlock': function(_0x21c1ed, _0x317f90) { ... },
// ...
});其中_0x373a54[_0x2d9843(0x143)]就是Hasher.extend()的调用,这里的_0x2d9843是取值函数_0x517b的别名。
将偏移量0x143复位后得到0x143 - 0x142 = 1,即取字符串数组的第2项。在未洗牌的原始数组中,第2项是'WordArray',结果不对,说明洗牌已经介入。
经过浏览器控制台执行后,可以获取到最终洗牌后的字符串数组:
['lib', 'extend', '882edqeVN', '_createHelper', '1044246fYkfZm', 'Hasher', 'abs', 'length', 'words', '3987890bNTHjI', '28bukumL', '32139cqmPYg', '11lGfqvc', '_data', 'algo', '_createHmacHelper', 'sin', '440UReQRP', 'clone', 'WordArray', '212031ThcGfI', '278MvSrfh', 'sigBytes', '6469NLKUUP', 'HmacMD5', 'MD5', '27816036AZQfwQ', '_hash', '40325cQBsVq']此时的第2项为'extend',正是我们期望的结果。
现在,我们接前文继续分析其他三种预设级别的混淆特点。
Low级别混淆特点
相比默认级别,Low级别启用了两个选项:
- Disable Console Output (禁用控制台输出)
- Self Defending (自我保护)
这两个功能并不影响混淆后代码的业务逻辑,而是以注入额外代码的形式存在,目的在于增加动态调试的难度。
特点一:禁用控制台输出
这个功能会劫持全局的console对象,将常用的七个方法全部替换为空函数,从而阻止通过控制台日志进行调试分析。
具体实现可以参阅其官方源代码中的ConsoleOutputDisableTemplate模板:
const {consoleLogDisableFunctionName} = {callControllerFunctionName}(this, function () {
{globalVariableTemplate}
const consoleObject = (that.console = that.console || {});
const methods = ['log', 'warn', 'info', 'error', 'exception', 'table', 'trace'];
for (let index = 0; index < methods.length; index++) {
const func = {callControllerFunctionName}.constructor.prototype.bind({callControllerFunctionName});
const methodName = methods[index];
const originalFunction = consoleObject[methodName] || func;
func.__proto__ = {callControllerFunctionName}.bind({callControllerFunctionName});
func.toString = originalFunction.toString.bind(originalFunction);
consoleObject[methodName] = func;
}
});在混淆输出中,它首先通过GlobalVariableTemplate获取全局对象:
var _0x1b15f9 = Function('return (function() ' + '{}.constructor("return this")( )' + ');');
_0x5efd9b = _0x1b15f9();这是一种跨环境获取全局对象的技巧,可以在浏览器中返回
window,在NodeJS中返回global。
再依次遍历['log', 'warn', 'info', 'error', 'exception', 'table', 'trace']这七个方法,将每个方法替换为CallsController (调用控制器) 的constructor.prototype.bind()生成的空函数。
注意,这里还做了一个伪装:通过func.toString = originalFunction.toString.bind(originalFunction)让替换后的函数在调用toString()时仍然返回原始函数的字符串表示,避免被简单的typeof或toString检测发现。
这段代码外面还套了一层CallsController (即下面代码中的_0x19fbdd) :
_0x19fbdd = (function() {
var _0x8da059 = !![];
return function(_0x263c4c, _0x35874b) {
var _0x11d855 = _0x8da059
? function() {
if (_0x35874b) {
var _0x294cec = _0x35874b['apply'](_0x263c4c, arguments);
return _0x35874b = null, _0x294cec;
}
}
: function() {};
return _0x8da059 = ![], _0x11d855;
};
}()),CallsController是一个一次性执行门控,通过闭包变量_0x8da059确保传入的函数只会被执行一次,后续调用直接返回空函数。
这样即使该段代码被多次引用,也只会在首次运行时生效。
特点二:自我保护
JavaScript Obfuscator自我保护的核心思路非常巧妙,它将混淆后的代码与compact (单行压缩输出) 绑定,一旦有人对代码进行格式化 (如美化、换行、缩进) ,就会触发保护机制,导致代码陷入死循环。
实际上,源代码中SelfDefendingRule会强制将compact设为true,确保输出必须是压缩的单行代码:
export const SelfDefendingRule: TOptionsNormalizerRule = (options: IOptions): IOptions => {
if (options.selfDefending) {
options = {
...options,
compact: true,
selfDefending: true
};
}
return options;
};然后我们来看看SelfDefendingTemplate模板到底是如何实现全局保护的:
const {selfDefendingFunctionName} = {callControllerFunctionName}(this, function () {
return {selfDefendingFunctionName}
.toString()
.search('(((.+)+)+)+$')
.toString()
.constructor({selfDefendingFunctionName})
.search('(((.+)+)+)+$');
});原理其实非常简单,首先通过toString()获取函数自身的源代码字符串,再对该字符串执行search('(((.+)+)+)+$')匹配。
其中的正则表达式(((.+)+)+)+$是一个典型的 ReDoS(正则表达式拒绝服务) 模式,它通过嵌套量词使得正则引擎在匹配失败时产生灾难性的回溯。
小贴士:正则中的量词指的是类似
+、*、{n,m}等表示重复次数的符号。
关键在于:当代码保持压缩的单行形式时,.能匹配除换行符外的所有字符,整个字符串可以被快速匹配成功;但一旦代码被美化添加了换行符,.在遇到换行时匹配中断,触发嵌套量词的指数级回溯,CPU直接被打满,页面卡死。
同样,这段注入代码也由另一个独立的CallsController包裹,确保了只执行一次。
Medium级别混淆特点
Medium级别是混淆强度的一次质变。
相比Low级别,它一口气启用了大量混淆选项:
- String Array Encoding (字符串数组编码) :
Base64 - String Array Wrappers (字符串数组包装器) :
Function - Split Strings (字符串分割)
- Transform Object Keys (变换对象键)
- Numbers To Expressions (数字转表达式)
- ontrol Flow Flattening (平坦化控制流)
- Dead Code Injection (死代码注入)
特点一:字符串数组Base64编码
低级别的字符串数组中存储的是明文字符串,而Medium级别启用了Base64编码,数组中的值变成了这样:
['y0PxBNu', 'shnft20', 'qNDPvee', ...]而且其内部使用的是自定义字母表,取值函数会嵌入一个解码逻辑,类似基于atob的重新实现:
var _0x195421 = function (_0x2d5b98) {
var _0x2e75fb = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/=';
// charAt + charCodeAt 逐字符解码
};特点二:字符串数组包装器函数
Medium级别引入了包装器函数,在取值函数外面又多套了一层间接调用。
其配置参数stringArrayWrappersCount表示每个作用域会生成的包装器个数,stringArrayWrappersParametersMaxCount表示每个包装器的参数个数。
在混淆输出中我们可以看到类似这样的写法:
function _0x2800d6(_0x577b04, _0x5959c1, _0xacb22, _0x768c25) {
return _0x1b9d(_0xacb22 - 0x1dd, _0x5959c1);
}
function _0x586c9e(_0x5ecb2a, _0x40c6d7, _0x2aae12, _0x1d23be) {
return _0x1b9d(_0x2aae12 - -0x291, _0x40c6d7);
}它们虽然有4个参数,但实际只使用了其中两个,一个是数组的偏移索引 (且偏移量不固定) ,另一个是对应的值 (Base64编码中为索引相关参数) 。
多余参数为纯粹的混淆噪音,用来增加逆向分析时的认知负担。
特点三:字符串分割
字符串分割会将较长的字符串字面量拆分成多个短片段后用+拼接,参数splitStringsChunkLength表示分割的字符长度。
这一特点在控制流平坦化的执行序列字符串中也有很多体现:
var _0x140e83 = ('2|0|4|1|3|' + '5')['split']('|');原本的'2|0|4|1|3|5'被切成了'2|0|4|1|3|'和'5'两段 (按Medium级别splitStringsChunkLength参数所设定的长度10进行分割) 。
虽然,字符串拆分本身不改变逻辑,但对于需要在混淆压缩代码中快速搜索定位的分析者来说,会让完整匹配变得更加困难。
特点四:变换对象键
这是混淆体积膨胀最明显的贡献者之一。
它会将函数中的运算操作和函数调用提取到一个代理对象中,所有操作都通过这个对象的属性间接执行。
在混淆输出中,我们通常可以看到一个巨大的对象:
var _0x2e2407 = {
'WkFDT': function (_0x7c850c, _0x46ec39) { return _0x7c850c + _0x46ec39; },
'QvpyT': function (_0x137178, _0x5d5f69) { return _0x137178 + _0x5d5f69; },
'xYKRy': function (_0x31d05e, _0x3e8d25) { return _0x31d05e | _0x3e8d25; },
'DFdBP': function (_0xa54bca, _0x16c2e9) { return _0xa54bca << _0x16c2e9; },
'PaTxT': function (_0x2c4a29, _0x5d8ea2) { return _0x2c4a29 >>> _0x5d8ea2; },
'cJWnu': function (_0x4a7e13, _0x3dd6b6) { return _0x4a7e13 & _0x3dd6b6; },
// ... 还有上百个属性
};这些属性分为两类:
- 运算符代理:将
+、|、<<、>>>、&等二元运算包装成函数 - 值代理:直接存储字符串值的引用
于是,原来简单直观的:
(M_offset_i << 8 | M_offset_i >>> 24) & 0x00ff00ff就变成了:
_0x2e2407['cJWnu'](
_0x2e2407['xYKRy'](
_0x2e2407['DFdBP'](_0x323639, 0x8),
_0x2e2407['PaTxT'](_0x323639, 0x18)
),
0xff00ff
)每一步运算都需要先查找属性名对应的操作,极大地降低了代码的可读性。而随机的属性名更是让静态分析无从下手。
特点五:数字转表达式
所有的数字字面量都被替换成了等价的数学表达式。
比如简单的数字0:
(-0x43b * -0x4 + -0x18ec + 0x800)可以验算一下:0x10ec - 0x18ec + 0x800 = 0。
这些表达式在运行时通常不会影响性能 (JavaScript引擎会对常量表达式进行折叠优化) ,但对分析者来说,每个数字都需要手动计算一遍才能确认其真实值,也是一个不小的工作量。
特点六:平坦化控制流
平坦化控制流是对代码结构,尤其是主题业务代码破坏最大的变换。
它将原本有层次的if-else、顺序执行等控制流打散后,塞进一个庞大的while-switch结构中,用字符串分割的执行序列来控制代码块的执行顺序。
典型的变换结果如下:
var _0x140e83 = ('8|5|0|11|2|10|3|6|1|9|7|4')['split']('|'),
_0xf0d7d8 = -0x43b * -0x4 + -0x18ec + 0x800; // 索引0
while (!![]) {
switch (_0x140e83[_0xf0d7d8++]) {
case '0':
// 代码块
continue;
case '1':
// 代码块
continue;
// ...
case '11':
// 代码块
continue;
// ...
}
break;
}原来按0, 1, 2, ...自然顺序执行的代码,现在需要按8, 5, 0, 11, 2, 10, 3, 6, 1, 9, 7, 4的顺序在switch中跳转执行。
而Medium级别的controlFlowFlatteningThreshold=0.75参数意味着约75%的代码块会被这样处理。
特点七:死代码注入
死代码注入会在控制流中插入永远不会被执行的假代码块。参数deadCodeInjectionThreshold=0.4表示约40%的代码块会伴随死代码。
这些死代码并非随机乱码,而是从原始代码中已有的真实代码块复制而来,并替换了其中的变量名。因此它们看起来与真实代码非常相似,具有很强的干扰性。
一个典型的死代码注入模式是通过永假条件来引入的:
if (_0x2e2407['WkFDT'](_0x1a3c5f, _0xSomeValue)) {
// 死代码 - 拷贝自源代码中的某个真实代码块
} else {
// 真实代码
}在混淆输出中,if语句的数量从低级别跳增几倍甚至数十倍,其中很大一部分就是死代码注入的产物,这使得分析者必须通过实际执行代码或进行较完整的数据流分析才能区分出真假。
High级别混淆特点
High级别是JavaScript Obfuscator最高强度的预设,它在Medium级别的基础上,进一步强化了几个关键维度:
- Debug Protection (调试保护)
- 字符串数组编码从Base64升级为RC4
- 更小的
splitStringsChunkLength和各种拉满的Threshold
混淆后的代码量通常是原始代码的几十倍。
特点一:调试保护
Debug Protection通过注入反调试代码来对抗开发者工具。它由两部分组成:
- 递归
debugger语句注入
看看源代码中的DebuggerTemplate模板:
if (typeof counter === 'string') {
return (function (arg) {}.constructor('while (true) {}').apply('counter'));
} else {
if (('' + counter / counter)['length'] !== 1 || counter % 20 === 0) {
(function () { return true; }.constructor('debu' + 'gger').call('action'));
} else {
(function () { return false; }.constructor('debu' + 'gger').apply('stateObject'));
}
}这段代码的核心是通过Function.constructor动态创建并执行debugger语句 (else分支) 。
counter变量是传入的递归调用计数器,从0开始每次递归时递增,并通过counter % 20 === 0条件控制递归触发debugger的频率。
如果分析者尝试在调试器中修改counter为字符串,代码会立即进入while (true) {}的死循环,让浏览器标签页彻底卡死。
- 定时器持续触发
DebugProtectionFunctionIntervalTemplate模板配合setInterval参数定期调用调试保护函数:
(function () {
// ...
that.setInterval(debugProtectionFunctionName, 4000);
})();意味着即使分析者在某一时刻绕过了debugger断点,过几秒又会被再次触发。这使得在不修改代码的情况下,分析者几乎无法正常使用开发者工具的调试功能。
需要注意的是:在High级别的混淆输出中,debugger、setInterval等关键字本身也会被RC4加密存入字符串数组,进一步增加了静态分析的难度。
特点二:字符串数组RC4加密
这是High级别相较Medium级别最核心的区别。
Base64编码本质上是一种可逆的简单变换,只要识别出字母表就能批量解码,而RC4是一种流密码,解密需要密钥。
RC4加解密算法的原理和实现我就不在这里赘述了,感兴趣的同学可以翻我之前的《带你学加密之RC4》进行了解。
经过RC4加密后的字符串数组也因此变得完全不可读:
['WRXHW5meBW', 'WQfFW53cKSko', 'jNxcQgmG', 'pgldS8orW5a', ...]特点三:字符串数组包装器与密钥传递
混淆输出中的RC4取值函数需要传入两个关键参数:
function _0x5287(_0x1d31c2, _0x5ecbed) {
// _0x1d31c2: 数组索引
// _0x5ecbed: RC4解密密钥
// ...
}而包装器函数的作用就是从多个参数中筛选出索引和密钥,传递给底层的RC4解密函数:
function _0x1416ed(_0x5d7b65, _0x458e25, _0x35538d, _0x2bc00c, _0x17891c) {
return _0x5287(_0x17891c - -0x99, _0x458e25);
}
function _0xea50ba(_0x2652d3, _0x37302c, _0x348e18, _0x3786ba, _0x1187a0) {
return _0x5287(_0x2652d3 - -0x13f, _0x3786ba);
}High级别的包装器函数参数数量变得更多,且取值位置不固定,这使得分析者必须先识别出每个包装器函数使用的具体参数位置,区分哪个是密钥,从而找到密钥的实际值后才能进行批量解密字符串数组。
通过粗略统计,示例的混淆输出中一共有400多个这样的包装器函数,每个函数的参数映射关系都需要单独分析,极大地增加了自动化批量解密的难度。
特点四:阈值全开
相比Medium级别,High级别的各项阈值全部都拉到了极致:
stringArrayThreshold = 1:所有字符串都被替换为数组引用,不再保留任何明文字符串controlFlowFlatteningThreshold = 1:所有符合条件的代码块都进行平坦化处理deadCodeInjectionThreshold = 1:每个代码块都会伴随死代码注入splitStringsChunkLength = 5:字符串被切得更碎
同时,取值函数中还集成了字符串数组专属的自我保护机制,它通过三个原型方法构建了一个精巧的『检测-判断-破坏』链条:
- 初始化
const StatesClass = function (${rc4BytesIdentifier}) {
this.${rc4BytesIdentifier} = ${rc4BytesIdentifier}; // 保存字符串数组包装函数引用
this.${statesIdentifier} = [1, 0, 0]; // 状态数组
this.${newStateIdentifier} = function(){return 'newState';}; // 用于检测的目标函数
this.${firstStateIdentifier} = '\x5cw+\x20*\x5c(\x5c)\x20*{\x5cw+\x20*'; // 正则前半部分
this.${secondStateIdentifier} = '[\x27|\x22].+[\x27|\x22];?\x20*}'; // 正则后半部分
};- 检测入口
StatesClass.prototype.${checkStateIdentifier} = function () {
const regExp = new RegExp(this.${firstStateIdentifier} + this.${secondStateIdentifier});
const expression = regExp.test(this.${newStateIdentifier}.toString())
? --this.${statesIdentifier}[1]
: --this.${statesIdentifier}[0];
return this.${runStateIdentifier}(expression);
};- 代码未被格式化时,正则
\w+ *\(\) *{\w+ *['|"].+['|"];? *}完整匹配,statesIdentifier下标1的值从0递减为-1,变为[1, -1, 0] - 代码被格式化后,
newStateIdentifier.toString()返回含换行符的多行代码字符串导致正则匹配失败,statesIdentifier下标0的值从1递减为0,变为[0, 0, 0]
- 状态判断
StatesClass.prototype.${runStateIdentifier} = function (${stateResultIdentifier}) {
if (!Boolean(~${stateResultIdentifier})) {
return ${stateResultIdentifier};
}
return this.${getStateIdentifier}(this.${rc4BytesIdentifier});
};按位取反~的妙用:
- 匹配成功时传入
-1,~(-1) = 0,因此!Boolean(0) = true,正常退出 - 匹配失败时传入
0,~0 = -1,因此!Boolean(-1) = false,触发破坏机制
- 破坏机制
StatesClass.prototype.${getStateIdentifier} = function (${rc4BytesIdentifier}) {
for (let i = 0, len = this.${statesIdentifier}.length; i < len; i++) {
this.${statesIdentifier}.push(Math.round(Math.random()));
len = this.${statesIdentifier}.length;
}
return ${rc4BytesIdentifier}(this.${statesIdentifier}[0]);
};循环中每次push()后都会更新len为新的数组长度,导致循环条件i < len永远为真,形成死循环。
值得注意的是,即使假设死循环被绕过能执行到末尾的return语句,由于statesIdentifier下标0的值发生了变化,它传入rc4BytesIdentifier后也可能会导致其错误索引,影响后续RC4解密等代码逻辑,相当于做了一个双保险。
说在最后的话
从JavaScript Obfuscator四个级别的增强递进来看,作者是真的有站在逆向分析者的角度对其常见行为和思维惯性等方面来进行思考和设计 (挖坑) 。
虽然,现在已经更多向虚拟机字节码混淆、WebAssembly编译等更高级的前端代码保护技术发展,但是传统的混淆思路还是值得我们深入学习和借鉴的。
参考
详解JS混淆器v5.3.0四大预设级别差异,涵盖结构重排、RC4加密、控制流平坦化及反调试等核心机制。
由 AI 根据全文自动生成,仅供参考,以原文为准