JavaScript逆向爬虫教程-------基础篇之JavaScript混淆原理

目录

• 一、常量的混淆原理
• 1.1 对象属性的两种访问方式
• 1.2 十六进制字符串
• 1.3 Unicode字符串
• 1.4 字符串的ASCII码混淆
• 1.5 字符串常量加密
• 1.6 数值常量加密
• 二、增加 JS 逆向者的工作量
• 2.1 数组混淆
• 2.2 数组乱序
• 2.3 花指令
• 2.4 jsfuck
• 三、代码执行流程的防护原理
• 3.1 流程平坦化
• 3.2 逗号表达式混淆
• 四、其他代码防护方案
• 4.1 eval加密
• 4.2 内存爆破
• 4.3 检测代码是否格式化

一、常量的混淆原理

示例代码：

	Date.prototype.format = function (formatStr) { let str = formatStr; let Week = ['日', '一', '二', '三', '四', '五', '六']; str = str.replace(/yyyy|YYYY/, this.getFullYear()); // console.log(str); str = str.replace(/MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1) .toString() : '0' + (this.getMonth() + 1)); // console.log(str); str = str.replace(/dd|DD/, this.getDate() > 9 ? this.getDate().toString() : '0' + this.getDate()); // console.log(str); return str; } // console.log(new Date()); // 2022-04-25T05:25:36.856Z console.log(new Date().format('yyyy-MM-dd')); //2024-05-01 console.log(new Date().getFullYear()) //2024 console.log(new Date().getMonth()) //4 当前月份为结果+1 //输出结果 2022-04-25

上面的代码用于格式化时间，这段代码整体上来讲逻辑简单清晰，即在 Date 的原型对象上，增加了一个 format 方法，当实例化一个 Date 对象后，就可以直接调用从 Date 原型对象上继承过来的 format 方法。上面代码没有经过任何处理，任何查看脚本的开发者 （js0基础的不算，嘿嘿） 都可以清楚地理解本段代码内容，假如这是某网站开发人员编写的一段关键代码，那么在代码发布后，很容易被第三方破解利用，从而引发安全问题，因此学习 JS 代码的防护技术就显得格外重要了。

ps：学习 JavaScript 混淆原理是非常有必要的，原因：

1. 学好 AST 混淆和还原 JavaScript 代码的基础
2. 招聘要求，越来越多的招聘要求爬虫人员懂 JavaScript 防护技术（逆向是越来越卷了）

1.1 对象属性的两种访问方式

示例代码：

	let person = { 'name': 'amo', 'age': 18, 'address': '重庆市红鼎国际', eat: function () { console.log(this.name + '~eating') } } // ①: person.name，name是一个标识符，必须明确出现在代码中，不能进行加密与拼接 console.log(person.name) person.eat() // ②: person['name']，该种方式name是一个字符串，既然是字符串，访问的时候就可以进行加密与拼接 // 在js混淆中一般会选择用这种方式来访问属性，操作空间更大 console.log(person['name']) person['eat']()

访问对象的方法也可以通过 **

	[]

** 的方式，因为对象的方法可以看作特殊的属性，它是一种值为函数的属性。将 **

	一、常量的混淆原理

** 中的示例代码可以转换为如下形式：

	let window = globalThis; // Date.prototype.format = function (formatStr) { Date['prototype']['format'] = function (formatStr) { let str = formatStr; let Week = ['日', '一', '二', '三', '四', '五', '六']; // str = str.replace(/yyyy|YYYY/, this.getFullYear()); str = str['replace'](/yyyy|YYYY/, this['getFullYear']()); // console.log(str); // str = str.replace(/MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1) // .toString() : '0' + (this.getMonth() + 1)); str = str['replace'](/MM/, (this['getMonth']() + 1) > 9 ? (this['getMonth']() + 1) ['toString']() : '0' + (this['getMonth']() + 1)); // console.log(str); // str = str.replace(/dd|DD/, this.getDate() > 9 ? this.getDate().toString() : '0' + this.getDate()); str = str['replace'](/dd|DD/, this['getDate']() > 9 ? this['getDate']()['toString']() : '0' + this['getDate']()); // console.log(str); return str; } // console.log(new Date()); // 2022-04-25T05:25:36.856Z console.log(new window['Date']()['format']('yyyy-MM-dd')); //2024-05-01 console.log(new window['Date']()['getFullYear']()) //2024 console.log(new window['Date']()['getMonth']()) //4 当前月份为结果+1 //输出结果 2022-04-25

Date 是 JS 的内置对象，在 JS 中，很多内置对象都是 window 的属性 （上面的代码由于笔者是在 node.js 中运行的，故将 window 指向了 globalThis）， 所以 JS 中的内置对象和客户端 JS 中的 DOM 对于 JS 的防护与逆向极为重要。在真实浏览器环境中，代码中定义的全局变量 （var） 都是全局对象 window 的属性，定义的全局函数都是全局对象 window 的方法，全局对象的属性或者方法在调用时，可以省略全局对象名，例如：

	window.btoa('a')

等同于

	btoa('a')

，如果要把

	btoa

变为字符串，前面就必须加 window，如上面的示例代码：**

	new window['Date']()

**

1.2 十六进制字符串

改变对象属性的访问方式后，代码的阅读性仍然较高，要继续进行复杂化处理。因为 JS 中的字符串支持以十六进制形式表示，所以可以用十六进制形式代替原有的字符串。如：

	amo

，可以表示成

	'\x61\x6d\x6f'

，其中字符

	a

转换为字节，再用十六进制表示就是

	61

（字符

	a

的 Hex 形式的 ASCII 码 ）。**ps：在 JavaScript 中，使用

	\x十六进制

来定义一个十六进制的字符串字面量。** 可以使用以下代码，完成十六进制字符串的转换。

	function charToHex(characters) { let hexString = '' for (let i = 0; i < characters.length; i++) { // ①: charCodeAt()方法用来取出字符串中对应索引字符的ASCII码 // ②: toString(16)转换为十六进制 const hexCode = characters[i].charCodeAt(0).toString(16); // ③与\x进行拼接 hexString += `\\x${hexCode}` } return hexString; } // 示例代码 const codes = 'amoGood'; const hexString = charToHex(codes); console.log(hexString)

将 **

	1.1 对象属性的两种访问方式

** 中的代码转换为如下形式：

	let window = globalThis; // Date.prototype.format = function (formatStr) { // Date['prototype']['format'] = function (formatStr) { Date['\x70\x72\x6f\x74\x6f\x74\x79\x70\x65']['\x66\x6f\x72\x6d\x61\x74'] = function (formatStr) { let str = formatStr; let Week = ['日', '一', '二', '三', '四', '五', '六']; // str = str.replace(/yyyy|YYYY/, this.getFullYear()); // str = str['replace'](/yyyy|YYYY/, this['getFullYear']()); str = str['\x72\x65\x70\x6c\x61\x63\x65'](/yyyy|YYYY/, this['\x67\x65\x74\x46\x75\x6c\x6c\x59\x65\x61\x72']()); // console.log(str); // str = str.replace(/MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1) // .toString() : '0' + (this.getMonth() + 1)); // str = str['replace'](/MM/, (this['getMonth']() + 1) > 9 ? (this['getMonth']() + 1) // ['toString']() : '0' + (this['getMonth']() + 1)); str = str['\x72\x65\x70\x6c\x61\x63\x65'](/MM/, (this['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1) > 9 ? (this['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1) ['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() : '0' + (this['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1)); // console.log(str); // str = str.replace(/dd|DD/, this.getDate() > 9 ? this.getDate().toString() : '0' + this.getDate()); // str = str['replace'](/dd|DD/, this['getDate']() > 9 ? this['getDate']()['toString']() : '0' // + this['getDate']()); str = str['\x72\x65\x70\x6c\x61\x63\x65'](/dd|DD/, this['\x67\x65\x74\x44\x61\x74\x65']() > 9 ? this['\x67\x65\x74\x44\x61\x74\x65']()['\x74\x6f\x53\x74\x72\x69\x6e\x67']() : '0' + this['\x67\x65\x74\x44\x61\x74\x65']()); return str; } // console.log(new Date()); // 2022-04-25T05:25:36.856Z console.log(new window['\x44\x61\x74\x65']()['\x66\x6f\x72\x6d\x61\x74']('yyyy-MM-dd')); //2024-05-01 console.log(new window['\x44\x61\x74\x65']()['\x67\x65\x74\x46\x75\x6c\x6c\x59\x65\x61\x72']()) //2024 console.log(new window['\x44\x61\x74\x65']()['\x67\x65\x74\x4d\x6f\x6e\x74\x68']()) //4 当前月份为结果+1 //输出结果 2022-04-25

这种混淆方式很容易被还原，不会大量应用，只用在无法加密的字符串上。十六进制字符串的还原方法很简单，把字符串放到控制台中输出即可。

1.3 Unicode字符串

在 JavaScript 中，可以使用 Unicode 编码来定义字符串。Unicode 编码通常以

	\u

开头，后跟四位十六进制数，不足四位的补0。例如，表示字母

	"A"

的 Unicode 编码是

	\u0041

。以下是使用 Unicode 编码定义字符串的示例：

	let unicodeString1 = '\u0061\u006d\u006f'; // 定义一个包含"amo"的字符串 console.log(unicodeString1); // 输出: amo let unicodeString2 = '\u91cd\u5e86\u5e02\u7ea2\u9f0e\u56fd\u9645'; //定义一个包含"重庆市红鼎国际"的字符串 console.log(unicodeString2); // 输出: 重庆市红鼎国际

可以使用以下代码完成 Unicode 转换：

	function charToUnicode(characters) { let unicodeString = '' for (let i = 0; i < characters.length; i++) { // ①: charCodeAt()方法用来取出字符串中对应索引字符的ASCII码 // ②: toString(16)转换为十六进制 const hexCode = characters[i].charCodeAt(0).toString(16); // ③与\x进行拼接 unicodeString += hexCode.length < 4 ? `\\u00${hexCode}` : `\\u${hexCode}` } return unicodeString; }

JS 中的标识符也支持 Unicode 形式表示，因此之前代码中的 format、Week、str、formatStr、window 等都支持以 Unicode 形式表示，将 将 **

	1.2 十六进制字符串

** 中的代码转换为如下形式 （只处理部分代码） ：

	let window = globalThis; Date['\u0070\u0072\u006f\u0074\u006f\u0074\u0079\u0070\u0065'] ['\x66\x6f\x72\x6d\x61\x74'] = function (formatStr) { let \u0073\u0074\u0072 = \u0066\u006f\u0072\u006d\u0061\u0074\u0053\u0074\u0072; let \u0057\u0065\u0065\u006b = ['\u65e5', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d']; \u0057\u0065\u0065\u006b = \u0073\u0074\u0072['\x72\x65\x70\x6c\x61\x63\x65'](/yyyy|YYYY/, this['\x67\x65\x74\x46\x75\x6c\x6c\x59\x65\x61\x72']()); \u0057\u0065\u0065\u006b = \u0057\u0065\u0065\u006b['\x72\x65\x70\x6c\x61\x63\x65'](/MM/, (this['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1) > 9 ? (this['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1) ['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() : '0' + (this['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1)); \u0057\u0065\u0065\u006b = \u0057\u0065\u0065\u006b['\x72\x65\x70\x6c\x61\x63\x65'](/dd|DD/, this['\x67\x65\x74\x44\x61\x74\x65']() > 9 ? this['\x67\x65\x74\x44\x61\x74\x65']()['\x74\x6f\x53\x74\x72\x69\x6e\x67']() : '0' + this['\x67\x65\x74\x44\x61\x74\x65']()); return \u0057\u0065\u0065\u006b; } // console.log(new Date()); // 2022-04-25T05:25:36.856Z console.log(new \u0077\u0069\u006e\u0064\u006f\u0077 ['\x44\x61\x74\x65']()['\x66\x6f\x72\x6d\x61\x74']('yyyy-MM-dd')); //2024-05-01 console.log(new window['\x44\x61\x74\x65']()['\x67\x65\x74\x46\x75\x6c\x6c\x59\x65\x61\x72']()) //2024 console.log(new window['\x44\x61\x74\x65']()['\x67\x65\x74\x4d\x6f\x6e\x74\x68']()) //4 当前月份为结果+1 //输出结果 2022-04-25

在使用

	\u0073\u0074\u0072

定义变量后，依然能够使用对应的 str 来引用变量。在实际 JS 混淆应用中，标识符一般不会替换成 Unicode 形式，因为要还原它十分容易。通常的混淆方式是替换成没有语义，但看上去又很相似的名字，如：

	_0x278843,_0x278844

和

	_0x257799

，或是由大写字母 O、小写字母 o、以及数字 0 组成的名字，Oo00Oo0、Oo00O0o 和 oO000Oo，注意标识符不允许以数字开头，与十六进制字符串一样，把字符串放到控制台中输出即可还原。

1.4 字符串的ASCII码混淆

使用以下代码将一个字符串转换为字节数组：

	function stringToBytes(str) { const encoder = new TextEncoder(); // 创建TextEncoder实例 return encoder.encode(str); // 将字符串转换为字节 } // 使用例子 const str = "amo"; const bytes = stringToBytes(str); console.log(bytes)

	'yyyy-MM-dd'

字符串转换为字节数组是

	[121,121,121,121,45,77,77,45,100,100]

，因此代码中的

	'yyyy-MM-dd'

，可以表示为：

	//String.fromCharCode()方法将Unicode值转换为字符 接受的是可变长度的数值类型的参数 //String.fromCharCode()方法接收的参数类型并非数组，如果想要传递数组，可以使用String.fromCharCode.apply String.fromCharCode.apply(null,[121, 121, 121, 121, 45, 77, 77, 45, 100, 100]))

ASCII 码混淆不仅用来做字符串混淆，还可以用来做代码混淆。以下面这段代码为例：

	Date.prototype.format = function (formatStr) { let str = formatStr; let Week = ['日', '一', '二', '三', '四', '五', '六']; // str = str.replace(/yyyy|YYYY/, this.getFullYear()); // 字符串的ASCII码混淆 等同于上面的代码 str = str.replace(/yyyy|YYYY/, this.getFullYear()); eval(String.fromCharCode.apply(null, [ 115, 116, 114, 32, 61, 32, 115, 116, 114, 46, 114, 101, 112, 108, 97, 99, 101, 40, 47, 121, 121, 121, 121, 124, 89, 89, 89, 89, 47, 44, 32, 116, 104, 105, 115, 46, 103, 101, 116, 70, 117, 108, 108, 89, 101, 97, 114, 40, 41, 41, 59 ] )) // 由于str = str.replace(/yyyy|YYYY/, this.getFullYear());变成了字符串，故执行需要依赖于eval函数 str = str.replace(/MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1) .toString() : '0' + (this.getMonth() + 1)); // console.log(str); str = str.replace(/dd|DD/, this.getDate() > 9 ? this.getDate().toString() : '0' + this.getDate()); // console.log(str); return str; } // console.log(new Date()); // 2022-04-25T05:25:36.856Z console.log(new Date().format('yyyy-MM-dd')); //2024-05-01 console.log(new Date().getFullYear()) //2024 console.log(new Date().getMonth()) //4 当前月份为结果+1

1.5 字符串常量加密

字符串常量加密的核心思想是，先把字符串加密得到密文，然后在使用前调用对应的解密去解密得到明文，代码中仅出现解密函数和密文，当然也可以使用不同的加密方法去加密字符串，再调用不同的解密函数去解密。示例代码：

	Date.prototype.format = function (formatStr) { let str = formatStr; str = str['replace'](/yyyy|YYYY/, this['getFullYear']()); console.log(str) } new Date().format('yyyy'); //2024

将上述代码中的所有字符串进行加密，此处仅为了演示，故采用最简单的 Base64 编码，如下：

	console.log(btoa('replace')) // cmVwbGFjZQ== console.log(btoa('getFullYear')) // Z2V0RnVsbFllYXI= console.log(btoa('yyyy')) // eXl5eQ==

处理后的代码为：

	Date.prototype.format = function (formatStr) { let str = formatStr; // 字符串加密后，需要把对应的解密函数也放入代码中，才能正常运行 // btoa: 用来编码，atob: 用来解码 这里使用的是node.js中自带的，在实际的混淆应用中，还是自己实现比较好 str = str[atob('cmVwbGFjZQ==')](/yyyy|YYYY/, this[atob('Z2V0RnVsbFllYXI=')]()); console.log(str) } new Date().format(atob('eXl5eQ==')); //2024

在实际混淆应用中，标识符必须处理成没有语义的，不然很容易就定位到关键代码。此外，建议减少使用系统自带的函数，自己去实现相应的函数，因为不管如何混淆，最终执行过程中，系统函数的名字是固定的，通过 Hook 技术极易定位到关键代码。根据写法的不同，代码中有一些字符串常量没法加密和拼接，如以下代码：

	let person = { // 'name': 'amo', //正确写法 // '\x6e\x61\x6d\x65': 'amo', //正确写法 // '\x6e\x61\x6d\x65': 'amo', //正确写法 '\u006e\u0061\u006d\u0065': 'amo', //正确写法 // atob('bmFtZQ=='): 'amo', //直接报错 'age': 18, 'address': '重庆市红鼎国际', eat: function () { console.log(this.name + '~eating') } } console.log(person.name) console.log(btoa('name')) let person2 = {} let str = 'na' person2[str + 'me'] = 'Amo' console.log(person2.name) // 用这种方式给对象增加属性，属性名可以加密和拼接

1.6 数值常量加密

算法加密过程中，会使用一些固定的数值常量，如 MD5 中的常量 0x67452301、0xefcdab89、0x98badcfe 和 0x10325476，以及 sha1 中的常量 0x67452301、0xefcdab89、0x98badcfe、0x10325476 和 0xc3d2e1f0。因此，在标准算法逆向中，会通过搜索这些数值常量，来定位代码关键位置，或者确定使用的是哪个算法。当然，在代码中不一定会写十六进制形式，如 0x67452301，在代码中可能会写成十进制的 1732584193。为了安全起见，可以把这些数值常量也进行简单加密。可以利用位异或的特性来加密。例如，如果

	a^b=c

，那么

	c^b=a

。以 sha1 算法中的 0xc3d2e1f0 常量为例，

	0xc3d2e1f0^0x12345678=0xd1e6b788

，那么在代码中可以用

	0xd1e6b788^0x12345678

来代替 0xc3d2e1f0，其中 0x12345678 可以理解成密钥，它可以随机生成。上述方法中两个数字进行位异或，实际上就是一个二项式。

小结：混淆方案不一定是单一使用，各种方案之间可以结合使用。

二、增加 JS 逆向者的工作量

在 一、常量的混淆原理 中介绍了一部分的混淆手段，现在我们应该对 JS 混淆有了一定的认识，但实际上只是处理了一些常量，防护力度并不高。混淆的目的是为了增加破解的难度和时间，因此本小节从这方面入手，继续介绍更加深入的内容。

2.1 数组混淆

之前的示例代码中，在改变对象属性的访问方式后，产生了很多原本没有的字符串。虽然在前面的介绍中，已经对它们做了一系列的处理，但是遇到有混淆逆向经验的逆向开发者，破解这里的混淆十分容易，本小节的方案是将所有的字符串都提取到一个数组中，然后在需要引用字符串的地方，全部都以数组下标的方式访问数组成员。例如：

	let bigArr = ['Date', 'getTime', 'log']; console[bigArr[2]](new window[bigArr[0]]()[bigArr[1]]()); console.log(new window.Date().getTime()) // 1714585619000

这里展示的代码，阅读难度已经大大增加。当代码为上千行，数组提取的字符串也有上千个。在代码中要引用字符串时，全都以

	bigArr[1001]

和

	bigArr[1002]

访问，就会大大增加理解难度，不容易建立对应关系。在其他静态编程语言中，同一个数组只能存放同一种类型。但是 JavaScript 语法灵活，同一个数组中，可以同时存放各种类型，如布尔值、字符串、数值、数组、对象和函数等。例如：

	let bigArr = [ false, 'Amo', 1314520, [13, 14, 520], {'name': 'amo', 'age': 18}, function () { console.log('hello') } ] console.log(bigArr[0]) console.log(bigArr[1]) console.log(bigArr[2]) console.log(bigArr[3]) console.log(bigArr[4]) bigArr[5]()

因此，可以把代码中的一部分函数以及字符串提取到大数组中。为了安全，通常会对提取到数组中的字符串进行加密处理，把代码处理成字符串就可以进行加密了。对于之前格式化日期的函数，改写为以下形式：

	let window = globalThis; let bigArr = ['\u65e5', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', 'cmVwbGFjZQ==', 'Z2V0TW9udGg=', 'dG9TdHJpbmc=', 'Z2V0RGF0ZQ==', 'RGF0ZQ==', ''['constructor']['fromCharCode']]; Date.\u0070\u0072\u006f\u0074\u006f\u0074\u0079\u0070\u0065['\x66\x6f\x72\x6d\x61\x74'] = function (formatStr) { let \u0073\u0074\u0072 = \u0066\u006f\u0072\u006d\u0061\u0074\u0053\u0074\u0072; let Week = [bigArr[0], bigArr[1], bigArr[2], bigArr[3], bigArr[4], bigArr[5], bigArr[6]]; eval(bigArr[12][atob('YXBwbHk=')](null, [ 115, 116, 114, 32, 61, 32, 115, 116, 114, 46, 114, 101, 112, 108, 97, 99, 101, 40, 47, 121, 121, 121, 121, 124, 89, 89, 89, 89, 47, 44, 32, 116, 104, 105, 115, 46, 103, 101, 116, 70, 117, 108, 108, 89, 101, 97, 114, 40, 41, 41, 59 ] )) str = str[atob(bigArr[7])](/MM/, (this[atob(bigArr[8])]() + 1) > 9 ? (this[atob(bigArr[8])]() + 1) [atob(bigArr[9])]() : '0' + (this[atob(bigArr[8])]() + 1)); str = str[atob(bigArr[7])](/dd|DD/, this[atob(bigArr[10])]() > 9 ? this[atob(bigArr[10])]()[atob(bigArr[9])]() : '0' + this[atob(bigArr[10])]()); return str; } console.log(new \u0077\u0069\u006e\u0064\u006f\u0077[atob(bigArr[11])]()['\x66\x6f\x72\x6d\x61\x74'] ('\u0079\u0079\u0079\u0079\u002d\u004d\u004d\u002d\u0064\u0064')); //2024-05-02 console.log(new \u0077\u0069\u006e\u0064\u006f\u0077[atob(bigArr[11])]() ['\x67\x65\x74\x46\x75\x6c\x6c\x59\x65\x61\x72']()) //2024 console.log(new \u0077\u0069\u006e\u0064\u006f\u0077[atob(bigArr[11])]() ['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1) //5 当前月份为结果+1

这段代码在不使用动态调试，也不使用 AST 的情况下，可读性非常差，但是 JS 代码混淆仍可继续。

2.2 数组乱序

观察 **

	2.1 数组混淆

** 小节中处理后的代码，数组成员与被引用的地方是一一对应的。如引用

	bigArr[12]

的地方，需要的是

	String.fromCharCode

函数，而该数组中下标为 12 的成员，也是这个函数。将数组顺序打乱可以解决这个问题，不过在数组顺序混乱后，本身的代码也引用不到正确的数组成员。此处的解决方案是，在代码中内置一段还原顺序的代码。可以使用以下代码打乱数组顺序：

	let bigArr = ['\u65e5', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', 'cmVwbGFjZQ==', 'Z2V0TW9udGg=', 'dG9TdHJpbmc=', 'Z2V0RGF0ZQ==', 'RGF0ZQ==', ''['constructor']['fromCharCode']]; (function (arr, num) { let foo = function (nums) { while (--nums) { // 弹出数组的最后一个元素并将其追加到数组的首位 arr.unshift(arr.pop()); } } foo(++num); })(bigArr, 0x20); console.log(bigArr)

在这段代码中，有一个自执行的匿名函数，实参部分传入的是数组和一个任意数值，在这个函数内部通过对数组进行弹出和压入操作来打乱顺序，除此之外，只要控制台输出，Unicode 处理后的字符串就变成原来的中文，这就是之前说的十六进制字符串和 Unicode 都很容易被还原。

	String.fromCharCode

函数被移动到了下标为

	5

的地方，但代码处引用的仍是

	bigArr[12]

，所以需要把还原数组顺序的函数放入代码中，还原数组顺序的代码逆向编写即可，如下所示：

	(function (arr, num) { let foo = function (nums) { while (--nums) { // 移除数组的第一个元素并将其追加到数组的尾部 arr.push(arr.shift()); } } foo(++num); })(bigArr, 0x20); console.log(bigArr)

ps：还原数组顺序中的函数用到的字符串，不能再提取到 bigArr 中。

2.3 花指令

添加一些没有意义却可以混淆视听的代码，是花指令的核心。这里介绍一种比较简单的花指令实现方式，举个例子：

	str = str.replace(/MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1) .toString() : '0' + (this.getMonth() + 1));

把

	this.getMonth() + 1

这个二项式改为如下形式：

	function _0x20ab1fxe1(a, b) { return a + b; } // _0x20ab1fxe1(this.getMonth(), 1) str = str.replace(/MM/, _0x20ab1fxe1(this.getMonth(), 1) > 9 ? _0x20ab1fxe1(this.getMonth(), 1) .toString() : '0' + _0x20ab1fxe1(this.getMonth(), 1));

本质是把二项式拆开成三部分：二项式的左边、二项式的右边和运算符。二项式的左边和右边作为另外一个函数的两个参数，二项式的运算符作为该函数的运行逻辑。这个函救本身是没有意义的，但它能瞬间增加代码量，从而增加 JavaScript 逆向者的工作量。二项式转变为函数时，进行多级嵌套，代码如下：

	function _0x20ab1fxe1(a, b) { return a + b; } function _0x20ab1fxe2(a, b) { return _0x20ab1fxe1(a, b); } // _0x20ab1fxe2(this.getMonth(), 1) str = str.replace(/MM/, _0x20ab1fxe2(this.getMonth(), 1) > 9 ? _0x20ab1fxe2(this.getMonth(), 1) .toString() : '0' + _0x20ab1fxe2(this.getMonth(), 1));

这个案例较为简单，但是在实际混淆中，代码可能有几千行，函数定义部分与调用部分往往相差甚远。另外具有相同运算符的二项式，并不是一定要调用相同的函数，如把

	'0'+(this.getMonth()+1)

这个二项式改为如下所示代码：

	function _0x20ab1fxe1(a, b) { return a + b; } function _0x20ab1fxe2(a, b) { return _0x20ab1fxe1(a, b); } function _0x20ab1fxe3(a, b) { return a + b; } function _0x20ab1fxe4(a, b) { return _0x20ab1fxe3(a, b); } str = str.replace(/MM/, _0x20ab1fxe2(this.getMonth(), 1) > 9 ? _0x20ab1fxe2(this.getMonth(), 1) .toString() : _0x20ab1fxe4('0', _0x20ab1fxe1(this.getMonth(), 1)));

上面介绍的是二项式转变为函数的花指令，其实函数调用表达式也可以处理成类似的花指令。代码如下：

	function _0x20ab1fxe7(a, b, c) { return a.apply(b, c); } str = _0x20ab1fxe7(str.replace, str, [ /MM/, (this.getMonth() + 1) > 9 ? (this.getMonth() + 1) .toString() : '0' + (this.getMonth() + 1)]);

花指令的生成方案，并不是只有这些。文章后续还会演示另外一种插入花指令的方式。

2.4 jsfuck

样例参考：https://jsfuck.com/
jsfuck 也可以算是一种编码，它能把 JS 代码转化成只用 6 个字符就可以表示的代码并可以正常执行，这 6 个字符分别是

	(、+、!、[、]、)

。转换后的 JS 代码难以阅读，可作为简单的保密措施，如数值常量

	8

转成 jsfuck 后为：

	[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]][([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(+(!+[]+!+[]+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([]+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]][([][[]]+[])[+!+[]]+(![]+[])[+!+[]]+((+[])[([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(![]+[])[!+[]+!+[]]+(![]+[])[+!+[]]+(!![]+[])[+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]+[])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]]](!+[]+!+[]+!+[]+[!+[]+!+[]])+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]])()([!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]+!+[]]+[])

接下来介绍 jsfuck 的基本原理，

	+

是 JS 中的一个算术运算符，当它作为一元运算符使用时代表强转为数值类型，

	[]

在 JS 中表示空数组，因此

	+[]

等于0，

	!+[]

等同于

	!0

，JS 是一种弱类型的语言，弱类型并不是代表没有类型，是指 JS 引擎会在适当的时候，自动完成类型的隐式转换。

	!

是 JS 中的取反，这时需要一个布尔值，在 JS 中，七种值为假值，其余均为真值，这七种值分别是

	false,undefined,null,0,-0,NaN,""

。因此，

	0

转换为布尔值为 false，再取反就是 true，也就是 **

	!+[]

=== true** 。又如

	!![]

，数组转换成布尔值为 true，然后两次取反，依旧等于 true。JS 中的

	+

作为二元运算符时，假如有一边是字符串，就代表着拼接；两边都没有字符串，就代表着数值相加，true 转换为数值等于1，剩余的部分原理相同，不再赘述。在实际开发中，jsfuck 的应用有限，只会应用于 JS 文件中的一部分代码，主要原因是它的代码量非常庞大且还原它较为容易，例如，把上述代码直接输入控制台运行，就会输出 **

	8

** 。一些网站之所以用它进行加密，是因为个别情况下，把整段 jsfuck 代码输入控制台运行会报错，尤其是当它跟别的代码混杂时。

ps,半淘汰加壳器系列： AAEncode、JJEncode、jsfuck，关于 AAEncode、JJEncode、jsfuck 具体的还原方式，笔者会在后续实战的文章中进行详细演示，这里就不再进行赘述。

三、代码执行流程的防护原理

经过 一、常量的混淆原理 和 二、增加 JS 逆向者的工作量 两节的处理，虽然代码已经被混淆得

	面目全非

了，但是执行流程还是跟原先一样。因此，本节从代码的执行流程入手，介绍更深入的代码防护方案。

3.1 流程平坦化

在一般的代码开发中，会有很多的流程控制相关代码，即代码中有很多分支，这些分支会具有一定的层级关系，在流程平坦化混淆中，会用到 switch 语句，因为 switch 语句中的 case 块是平级的，而且调换 case 块的前后顺序并不影响代码原先的执行逻辑。为了方便理解，这里举一个简单的例子，代码如下：

	function test1() { var a = 1000; var b = a + 2000; var c = b + 3000; var d = c + 4000; var e = d + 5000; var f = e + 6000; return f; } console.log(test1());

混淆 test1 函数中的代码，代码如下：

	function test3() { // ①：构造一个分发器，里面记录了代码执行的真实顺序。并把字符串通过split分割成一个数组 var arr = 'z|t|y|u|a|d|7|c'.split('|'); var index = 0; // ② 因为switch语句一次只能计算一次，故需要一个循环 while (!![]) { // ③ index作为计数器，每次递增，按顺序引用数组中的每一个成员 // switch中把表达式的值与每个case的值进行对比(这里是===的匹配，不进行类型转换) switch (arr[index++]) { case 'a': var e = d + 5000; break; case 't': var b = a + 2000; break; case 'y': var c = b + 3000; break; case 'd': var f = e + 6000; break; case 7: var g = 100000; g = g + a + b + c + d; break; case 'c': return f; case 'z': var a = 1000; break; case 'u': var d = c + 4000; break; } } } console.log(test3());

在了解了简单的案例后，对 **

	2.1 数组混淆

** 一节中的代码做进一步混淆，处理后的代码如下：

	let window = globalThis; let bigArr = ['\u65e5', '\u4e00', '\u4e8c', '\u4e09', '\u56db', '\u4e94', '\u516d', 'cmVwbGFjZQ==', 'Z2V0TW9udGg=', 'dG9TdHJpbmc=', 'Z2V0RGF0ZQ==', 'RGF0ZQ==', ''['constructor']['fromCharCode']]; Date.\u0070\u0072\u006f\u0074\u006f\u0074\u0079\u0070\u0065['\x66\x6f\x72\x6d\x61\x74'] = function (formatStr) { // 定义分发器 let arr = 'z|t|y|u|a|d|7|c'.split('|'); let index = 0; let str = '' while (!![]) { //需要多次计算，故使用循环 switch (arr[index++]) { // 依次引用数组中的每一个成员 case 'a': str = str[atob(bigArr[7])](/dd|DD/, this[atob(bigArr[10])]() > 9 ? this[atob(bigArr[10])]()[atob(bigArr[9])]() : '0' + this[atob(bigArr[10])]()); break; case 't': let Week = [bigArr[0], bigArr[1], bigArr[2], bigArr[3], bigArr[4], bigArr[5], bigArr[6]]; break; case 'y': eval(bigArr[12][atob('YXBwbHk=')](null, [ 115, 116, 114, 32, 61, 32, 115, 116, 114, 46, 114, 101, 112, 108, 97, 99, 101, 40, 47, 121, 121, 121, 121, 124, 89, 89, 89, 89, 47, 44, 32, 116, 104, 105, 115, 46, 103, 101, 116, 70, 117, 108, 108, 89, 101, 97, 114, 40, 41, 41, 59 ] )) break; case 'd': console.log('~amo') break; // case '7': case 7: console.log('~jerry') break; case 'c': return str; case 'z': str = \u0066\u006f\u0072\u006d\u0061\u0074\u0053\u0074\u0072; break; case 'u': str = str[atob(bigArr[7])](/MM/, (this[atob(bigArr[8])]() + 1) > 9 ? (this[atob(bigArr[8])]() + 1) [atob(bigArr[9])]() : '0' + (this[atob(bigArr[8])]() + 1)); break; } } } console.log(new \u0077\u0069\u006e\u0064\u006f\u0077[atob(bigArr[11])]()['\x66\x6f\x72\x6d\x61\x74'] ('\u0079\u0079\u0079\u0079\u002d\u004d\u004d\u002d\u0064\u0064')); //2024-05-02 console.log(new \u0077\u0069\u006e\u0064\u006f\u0077[atob(bigArr[11])]() ['\x67\x65\x74\x46\x75\x6c\x6c\x59\x65\x61\x72']()) //2024 console.log(new \u0077\u0069\u006e\u0064\u006f\u0077[atob(bigArr[11])]() ['\x67\x65\x74\x4d\x6f\x6e\x74\x68']() + 1) //5 当前月份为结果+1

JS 语法比较灵活，case 后面跟的值可以是字符/字符串，也可以是数值还可以是对象或者数组。

3.2 逗号表达式混淆

逗号运算符的主要作用是把多个表达式或语句连接成一个复合语句。**

	3.1 流程平坦化

** 中的 test1() 函数等价于：

	function test1() { let a, b, c, d, e, f; return a = 1000, b = a + 2000, c = b + 3000, d = c + 4000, e = d + 5000, f = e + 6000, f; } console.log(test1())

return 语句后通常只能跟一个表达式，它会返回这个表达式计算后的结果，但是逗号运算符可以把多个表达式连接成一个复合语句，因此上述代码中，return 语句的使用也是没有问题的，它会返回最后一个表达式计算后的结果，但是前面的表达式依然会执行。上述案例只是单纯的连接语句，没有混淆力度。下面再介绍一个案例，代码如下：

	var a = (a = 1000, a += 2000); // 使用let会报错 console.log(a)

第一行代码中，括号代表这是一个整体，也就是把

	(a=1000,a+=2000)

整体赋值给 a 变量，这个整体返回的结果和 return 语句是一样的，会先执行 a=1000，然后执行 a+=2000，再把结果赋值给 a 变量，最终 a 变量的值为 3000。明白了上述原理后，再介绍逗号运算符的混淆，以本节中的 test1 函数为例，处理思路如下：

	// ① 执行 a=1000，再执行 a+2000，代码可以改为 (a=1000,a+2000) // ② 接着赋值给b，代码可以改为 b=(a=1000,a+2000) // ③ 执行 b+3000，代码可以改为 (b=(a=1000,a+2000),b+3000) // ④ 接着赋值给 c，代码可以改为 c=(b=(a=1000,a+2000),b+3000) // ⑤ 执行 c+4000，代码可以改为 (c=(b=(a=1000,a+2000),b+3000),c+4000) // 以此类推....

处理后的代码为：

	function test2() { let a, b, c, d, e, f; return f = (e = (d = (c = (b = (a = 1000, a += 2000), b += 3000), c += 4000), d + 5000), e + 6000) } console.log(test2())

这段代码有一个声明一系列变量的语句，这个语句很多余，可以放到参数列表上，这样就不需要

	let

声明了。另外，既然逗号运算符连接多个表达式，只会返回最后一个表达式计算后的结果，那么可以在最后一个表达式之前插入不影响结果的花指令。最终处理后的代码如下：

	function test2(a, b, c, d, e, f) { // return f = (e = (d = (c = (b = (a = 1000, a + 50, b + 60, c + 70, a += 2000), d + 80, b += 3000), e + 90, c += 4000), f + 100, d + 5000), e + 6000) } console.log(test2())

	a + 50, b + 60, c + 70,d + 80,e + 90,f + 100

这些花指令并无实际意义，不影响原先的代码逻辑，test2() 虽有 6 个参数，但是不传参也可以调用，只不过各参数的初始值为 undefined。逗号表达式混淆不仅能处理赋值表达式，还能处理调用表达式、成员表达式等。考虑下面这个案例：

	let obj = { 'name': 'amo', add: function (a, b) { return a + b; } } function sub(a, b) { return a - b; } function test() { let a = 1000; let b = sub(a, 3000) + 1; let c = b + obj.add(b, 2000); return c + obj.name } console.log(test());

上述案例中的代码，可以处理成如下形式：

	let obj = { 'name': 'amo', add: function (a, b) { return a + b; } } function sub(a, b) { return a - b; } function test(a, b, c) { return c = (b = (a = 1000, sub)(a, 3000) + 1, b + (0, obj).add(b, 2000)), c + (0,obj).name; } console.log(test());

首先提升变量声明到函数参数中，

	b = (a = 1000, sub)(a,3000) + 1

中的

	(a = 1000,sub)

可以整体返回 sub 函数，然后直接调用，计算的结果加 1 后赋值给 b(等号的运算符优先级很低)。同理，如果 sub 函数改为

	obj.add

的话，可以处理成

	(a=1000,obj.add)(a,3000)

或者

	(a=1000,obj).add(a,3000)

，第2种方法是调用表达式在等号右边的情况，例如 test 函数中的第3条语里面的

	b+obj.add(b,2000)

，可以对

	obj.add

进行包装，处理成

	b+(0,obj.add)(b,2000)

或者

	b+(0,obj).add(b,2000)

，括号中的0可以是其他花指令。

最后介绍逗号表达式混淆的还原技巧，在逗号表达式混淆中，通常需要使用括号来分组，定位到最里面的那个括号，一般就是第一条语句，然后从里到外，一层层地根据括号对应关系，还原语句顺序，如果用 AST 还原逗号表达式混淆，就不用这么麻烦地找对应关系：几行代码就可以解决问题，在后续的文章中笔者会对 AST 进行详细地介绍。

四、其他代码防护方案

4.1 eval加密

加密的代码格式化后如下所示：

	eval(function (p, a, c, k, e, r) { e = function (c) { return c.toString(36) }; if ('0'.replace(0, e) == 0) { while (c--) r[e(c)] = k[c]; k = [function (e) { return r[e] || e } ]; e = function () { return '[2-8a-f]' }; c = 1 } ; while (c--) if (k[c]) p = p.replace(new RegExp('\\b' + e(c) + '\\b', 'g'), k[c]); return p }('7.prototype.8=function(a){b 2=a;b Week=[\'日\',\'一\',\'二\',\'三\',\'四\',\'五\',\'六\'];' + '2=2.4(/c|YYYY/' + ',3.getFullYear());2=2.4(/d/,(3.5()+1)>9?(3.5()+1).e():\'0\'+(3.5()+1));' + '2=2.4(/f|DD/,3.6()>9?' + '3.6().e():\'0\'+3.6());return 2};console.log(new 7().8(\'c-d-f\'));', [], 16, '||str|this|replace|getMonth|getDate|Date|format||formatStr|var|yyyy|MM|toString|dd' .split('|'), 0, {}));

这段代码的一个 eval() 函数，它用来把一段字符串当作 JS 代码来执行，也就是说，传给 eval() 的参数是一段字符串。但在上述代码中，传给 eval() 函数的参数是一个自执行的匿名函数，这说明，这个匿名函数执行后会返回一段字符串，并且用 eval() 执行这段字符串，执行效果与 eval 加密前的代码效果等同，那就可以把这个匿名函数理解成是一个解密函数了，由此可见，eval 加密其实和 eval 关系不大，eval 只是用来执行解密出来的代码。

再来观察传给这个匿名函数的实参部分，观察第1个实参p和第4个实参k，可以看出处理方式很简单，提取原始代码中的一部分标识符，然后用它自己的符号占位，最后再对应替换回去就解密了，最后介绍 eval 解密，这个比较容易，既然这个自执行的匿名函数就是解密函数，把上述代码中的 eval 删去，剩余代码在控制台中执行，就得到原始代码。

4.2 内存爆破

内存爆破是在代码中加入死代码，正常情况下这段代码不执行，当检测到函数被格式化或者函数被 Hook，就跳转到这段代码并执行，直到内存溢出，浏览器会提示 Out of Memory 程序崩溃。内存爆破的代码如下所示：

	let d = [0x1, 0x1, 0x1] function b() { for (let i = 0x0, c = d.length; i < c; i++) { d.push(Math.round(Math.random())); c = d.length; } }

这段代码中的 for 循环是一个死循环，但它的形式不像 while(true) 这样明显，尤其是代码混淆以后，更具有迷惑性，这段代码其实是从以下这段代码简化而来：

	const _0x447a = ['push', 'length']; const _0x3774 = function (_0x447aa4, _0x377412) { _0x447aa4 = _0x447aa4 - 0x0; let _0x2a002f = _0x447a[_0x447aa4]; return _0x2a002f; }; let d = [0x1, 0x1, 0x1]; function b() { for (let _0x514f9d = 0x0, _0x1c3f88 = d[_0x3774('0x1')]; _0x514f9d < _0x1c3f88; _0x514f9d++) { d[_0x3774('0x0')](Math['round'](Math['random']())); _0x1c3f88 = d['length']; } }

for 循环的结束条件是

	_0x514f9d < _0x1c3f88

，其中

	_0x1c3f88

的初始化值是数组的长度，看着像是一个遍历数组的操作，但是在循环中，又往数组中 push 了成员，接着又重新给

	_0x1c3f88

赋值为数组的长度，这时这段代码就永远不会结束了，直到内存溢出。

4.3 检测代码是否格式化

检测的思路很简单，在 JS 中，函数是可以转为字符串的，因此可以选择一个函数转为字符串，然后跟内置的字符串对比或者用正则匹配，函数转为字符串很简单，代码如下：

	function add(a, b) { return a + b; } console.log(add + ''); console.log(add.toString()) // 未格式化:function add(a, b) {return a + b;} // 格式化: // function add(a, b) { // return a + b; // }

在 Chrome 开发者工具中，把代码格式化后，会产生一个后缀为

	:formatted

的文件，之后在这个文件中设置断点，触发断点后，会停在这个文件中，但是，这时把某个函数转为字符串，取到的依然是格式化之前的代码。上述检测方法检测不到这种情况，那么，上述检测方法的应用场景是什么？在算法逆向中，分析完算法，为了得到想要的结果，就需要实现这个算法，简单的算法一般可以直接调用现成的加密库，复杂的算法就会选择直接修改原文件，然后运行得到结果，把格式化后的代码保存成一个本地文件，这时某个函数转为字符串，取到的就是格式化后的结果了，是否触发格式化检测，关键是看原文件中是否有格式化，接着把 4.2 内存爆破 小节中的内存爆破代码加入其中，检测到格式化就跳转到内存爆破代码中执行，程序会崩溃。

原文地址