整合營銷服務商
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
電腦端+手機端+微信端=數據同步管理
免費咨詢熱線：
著大數據時代的發展，各個公司的數據保護意識越來越強，大家都在想盡辦法保護自家產品的數據不輕易被爬蟲爬走。由于網頁是提供信息和服務的重要載體，所以對網頁上的信息進行保護就成了至關重要的一個環節。
網頁是運行在瀏覽器端的，當我們瀏覽一個網頁時，其 HTML 代碼、 JavaScript 代碼都會被下載到瀏覽器中執行。借助瀏覽器的開發者工具，我們可以看到網頁在加載過程中所有網絡請求的詳細信息，也能清楚地看到網站運行的 HTML 代碼和 JavaScript 代碼，這些代碼中就包含了網站加載的全部邏輯，如加載哪些資源、請求接口是如何構造的、頁面是如何渲染的等等。正因為代碼是完全透明的，所以如果我們能夠把其中的執行邏輯研究出來，就可以模擬各個網絡請求進行數據爬取了。
然而，事情沒有想象得那么簡單。隨著前端技術的發展，前端代碼的打包技術、混淆技術、加密技術也層出不窮，借助于這些技術，各個公司可以在前端對 JavaScript 代碼采取一定的保護，比如變量名混淆、執行邏輯混淆、反調試、核心邏輯加密等，這些保護手段使得我們沒法很輕易地找出 JavaScript 代碼中包含的的執行邏輯。
在前幾章的案例中，我們也試著爬取了各種形式的網站。其中有的網站的數據接口是沒有任何驗證或加密參數的，我們可以輕松模擬并爬取其中的數據；但有的網站稍顯復雜，網站的接口中增加了一些加密參數，同時對 JavaScript 代碼采取了上文所述的一些防護措施，當時我們沒有直接嘗試去破解，而是用 Selenium 等類似工具來實現模擬瀏覽器執行的方式來進行“所見即所得“的爬取。其實對于后者，我們還有另外一種解決方案，那就是直接逆向 JavaScript 代碼，找出其中的加密邏輯，從而直接實現該加密邏輯來進行爬取。如果加密邏輯實在過于復雜，我們也可以找出一些關鍵入口，從而實現對加密邏輯的單獨模擬執行和數據爬取。這些方案難度可能很大，比如關鍵入口很難尋找，或者加密邏輯難以模擬，可是一旦成功找到突破口，我們便可以不用借助于 Selenium 等工具進行整頁數據的渲染而實現數據爬取，這樣爬取效率會大幅提升。
本章我們首先會對 JavaScript 防護技術進行介紹，然后介紹一些常用的 JavaScript 逆向技巧，包括瀏覽器工具的使用、Hook 技術、AST 技術、特殊混淆技術的處理、WebAssembly 技術的處理。了解了這些技術，我們可以更從容地應對 JavaScript 防護技術。
我們在爬取網站的時候，會遇到一些情況需要分析一些接口或 URL 信息，在這個過程中，我們會遇到各種各樣類似加密的情形，比如說：
這些情況呢，基本上都是網站為了保護其本身的一些數據不被輕易抓取而采取的一些措施，我們可以把它歸類為兩大類：
這一節我們就來了解下這兩類技術的基本原理和一些常見的示例。知己知彼，百戰不殆，了解了這些技術的實現原理之后，我們才能更好地去逆向其中的邏輯，從而實現數據爬取。
當今大數據時代，數據已經變得越來越重要，網頁和 App 現在是主流的數據載體，如果其數據的 API 沒有設置任何保護措施，在爬蟲工程師解決了一些基本的反爬如封 IP、驗證碼的問題之后，那么數據還是可以被輕松爬取到的。
那么，有沒有可能在 URL/API 層面或 JavaScript 層面也加上一層防護呢？答案是可以。
網站運營者首先想到防護措施可能是對某些數據接口的參數進行加密，比如說對某些 URL 的一些參數加上校驗碼或者把一些 id 信息進行編碼，使其變得難以閱讀或構造；或者對某些 API 請求加上一些 token、sign 等簽名，這樣這些請求發送到服務器時，服務器會通過客戶端發來的一些請求信息以及雙方約定好的秘鑰等來對當前的請求進行校驗，如果校驗通過，才返回對應數據結果。
比如說客戶端和服務端約定一種接口校驗邏輯，客戶端在每次請求服務端接口的時候都會附帶一個 sign 參數，這個 sign 參數可能是由當前時間信息、請求的 URL、請求的數據、設備的 ID、雙方約定好的秘鑰經過一些加密算法構造而成的，客戶端會實現這個加密算法構造 sign，然后每次請求服務器的時候附帶上這個參數。服務端會根據約定好的算法和請求的數據對 sign 進行校驗，如果校驗通過，才返回對應的數據，否則拒絕響應。
當然登錄狀態的校驗也可以看作是此類方案，比如一個 API 的調用必須要傳一個 token，這個 token 必須用戶登錄之后才能獲取，如果請求的時候不帶該 token，API 就不會返回任何數據。
倘若沒有這種措施，那么基本上 URL 或者 API 接口是完全公開可以訪問的，這意味著任何人都可以直接調用來獲取數據，幾乎是零防護的狀態，這樣是非常危險的，而且數據也可以被輕易地被爬蟲爬取。因此對 URL/API 參數一些加密和校驗是非常有必要的。
接口加密技術看起來的確是一個不錯的解決方案，但單純依靠它并不能很好地解決問題。為什么呢？
對于網頁來說，其邏輯是依賴于 JavaScript 來實現的，JavaScript 有如下特點：
由于這兩個原因，至使 JavaScript 代碼是不安全的，任何人都可以讀、分析、復制、盜用，甚至篡改。
所以說，對于上述情形，客戶端 JavaScript 對于某些加密的實現是很容易被找到或模擬的，了解了加密邏輯后，模擬參數的構造和請求也就是輕而易舉了，所以如果 JavaScript 沒有做任何層面的保護的話，接口加密技術基本上對數據起不到什么防護作用。
如果你不想讓自己的數據被輕易獲取，不想他人了解 JavaScript 邏輯的實現，或者想降低被不懷好意的人甚至是黑客攻擊。那么就需要用到 JavaScript 壓縮、混淆和加密技術了。
這里壓縮、混淆和加密技術簡述如下：
下面我們對上面的技術分別予以介紹。
現在絕大多數網站的數據一般都是通過服務器提供的 API 來獲取的，網站或 App 可以請求某個數據 API 獲取到對應的數據，然后再把獲取的數據展示出來。但有些數據是比較寶貴或私密的，這些數據肯定是需要一定層面上的保護。所以不同 API 的實現也就對應著不同的安全防護級別，我們這里來總結下。
為了提升接口的安全性，客戶端會和服務端約定一種接口校驗方式，一般來說會使用到各種加密和編碼算法，如 Base64、Hex 編碼，MD5、AES、DES、RSA 等對稱或非對稱加密。
舉個例子，比如說客戶端和服務器雙方約定一個 sign 用作接口的簽名校驗，其生成邏輯是客戶端將 URL Path 進行 MD5 加密然后拼接上 URL 的某個參數再進行 Base64 編碼，最后得到一個字符串 sign，這個 sign 會通過 Request URL 的某個參數或 Request Headers 發送給服務器。服務器接收到請求后，對 URL Path 同樣進行 MD5 加密，然后拼接上 URL 的某個參數，也進行 Base64 編碼也得到了一個 sign，然后比對生成的 sign 和客戶端發來的 sign 是否是一致的，如果是一致的，那就返回正確的結果，否則拒絕響應。這就是一個比較簡單的接口參數加密的實現。如果有人想要調用這個接口的話，必須要定義好 sign 的生成邏輯，否則是無法正常調用接口的。
當然上面的這個實現思路比較簡單，這里還可以增加一些時間戳信息增加時效性判斷，或增加一些非對稱加密進一步提高加密的復雜程度。但不管怎樣，只要客戶端和服務器約定好了加密和校驗邏輯，任何形式加密算法都是可以的。
這里要實現接口參數加密就需要用到一些加密算法，客戶端和服務器肯定也都有對應的 SDK 實現這些加密算法，如 JavaScript 的 crypto-js，Python 的 hashlib、Crypto 等等。
但還是如上文所說，如果是網頁的話，客戶端實現加密邏輯如果是用 JavaScript 來實現，其源代碼對用戶是完全可見的，如果沒有對 JavaScript 做任何保護的話，是很容易弄清楚客戶端加密的流程的。
因此，我們需要對 JavaScript 利用壓縮、混淆等方式來對客戶端的邏輯進行一定程度上的保護。
這個非常簡單，JavaScript 壓縮即去除 JavaScript 代碼中的不必要的空格、換行等內容或者把一些可能公用的代碼進行處理實現共享，最后輸出的結果都壓縮為幾行內容，代碼可讀性變得很差，同時也能提高網站加載速度。
如果僅僅是去除空格換行這樣的壓縮方式，其實幾乎是沒有任何防護作用的，因為這種壓縮方式僅僅是降低了代碼的直接可讀性。如果我們有一些格式化工具可以輕松將 JavaScript 代碼變得易讀，比如利用 IDE、在線工具或 Chrome 瀏覽器都能還原格式化的代碼。
比如這里舉一個最簡單的 JavaScript 壓縮示例，原來的 JavaScript 代碼是這樣的：
function echo(stringA, stringB) {
const name="Germey";
alert("hello " + name);
}壓縮之后就變成這樣子：
function echo(d, c) {
const e="Germey";
alert("hello " + e);
}可以看到這里參數的名稱都被簡化了，代碼中的空格也被去掉了，整個代碼也被壓縮成了一行，代碼的整體可讀性降低了。
目前主流的前端開發技術大多都會利用 Webpack、Rollup 等工具進行打包，Webpack、Rollup 會對源代碼進行編譯和壓縮，輸出幾個打包好的 JavaScript 文件，其中我們可以看到輸出的 JavaScript 文件名帶有一些不規則字符串，同時文件內容可能只有幾行內容，變量名都是一些簡單字母表示。這其中就包含 JavaScript 壓縮技術，比如一些公共的庫輸出成 bundle 文件，一些調用邏輯壓縮和轉義成冗長的幾行代碼，這些都屬于 JavaScript 壓縮。另外其中也包含了一些很基礎的 JavaScript 混淆技術，比如把變量名、方法名替換成一些簡單字符，降低代碼可讀性。
但整體來說，JavaScript 壓縮技術只能在很小的程度上起到防護作用，要想真正提高防護效果還得依靠 JavaScript 混淆和加密技術。
JavaScript 混淆是完全是在 JavaScript 上面進行的處理，它的目的就是使得 JavaScript 變得難以閱讀和分析，大大降低代碼可讀性，是一種很實用的 JavaScript 保護方案。
JavaScript 混淆技術主要有以下幾種：
總之，以上方案都是 JavaScript 混淆的實現方式，可以在不同程度上保護 JavaScript 代碼。
在前端開發中，現在 JavaScript 混淆主流的實現是 javascript-obfuscator (https://github.com/javascript-obfuscator/javascript-obfuscator) 和 terser (https://github.com/terser/terser) 這兩個庫，其都能提供一些代碼混淆功能，也都有對應的 Webpack 和 Rollup 打包工具的插件，利用它們我們可以非常方便地實現頁面的混淆，最終可以輸出壓縮和混淆后的 JavaScript 代碼，使得 JavaScript 代碼可讀性大大降低。
下面我們以 javascript-obfuscator 為例來介紹一些代碼混淆的實現，了解了實現，那么自然我們就對混淆的機理有了更加深刻的認識。
javascript-obfuscator 的官網地址為：https://obfuscator.io/，其官方介紹內容如下：
A free and efficient obfuscator for JavaScript (including ES2017). Make your code harder to copy and prevent people from stealing your work.
它是支持 ES8 的免費、高效的 JavaScript 混淆庫，它可以使得你的 JavaScript 代碼經過混淆后難以被復制、盜用，混淆后的代碼具有和原來的代碼一模一樣的功能。
怎么使用呢？首先，我們需要安裝好 Node.js 12.x 版本及以上，確保可以正常使用 npm 命令，具體的安裝方式可以參考：https://setup.scrape.center/nodejs。
接著新建一個文件夾，比如 js-obfuscate，然后進入該文件夾，初始化工作空間：
npm init這里會提示我們輸入一些信息，創建一個 package.json 文件，這就完成了項目初始化了。
接下來我們來安裝 javascript-obfuscator 這個庫：
npm i -D javascript-obfuscator稍等片刻，即可看到本地 js-obfuscate 文件夾下生成了一個 node_modules 文件夾，里面就包含了 javascript-obfuscator 這個庫，這就說明安裝成功了，文件夾結構如圖所示：
接下來我們就可以編寫代碼來實現一個混淆樣例了，如新建一個 main.js 文件，內容如下：
const code=`
let x='1' + 1
console.log('x', x)
`;
const options={
compact: false,
controlFlowFlattening: true,
};
const obfuscator=require("javascript-obfuscator");
function obfuscate(code, options) {
return obfuscator.obfuscate(code, options).getObfuscatedCode();
}
console.log(obfuscate(code, options));在這里我們定義了兩個變量，一個是 code，即需要被混淆的代碼，另一個是混淆選項，是一個 Object。接下來我們引入了 javascript-obfuscator 這庫，然后定義了一個方法，傳入 code 和 options，來獲取混淆后的代碼，最后控制臺輸出混淆后的代碼。
代碼邏輯比較簡單，我們來執行一下代碼：
node main.js輸出結果如下：
var _0x53bf=["log"];
(function (_0x1d84fe, _0x3aeda0) {
var _0x10a5a=function (_0x2f0a52) {
while (--_0x2f0a52) {
_0x1d84fe["push"](_0x1d84fe["shift"]());
}
};
_0x10a5a(++_0x3aeda0);
})(_0x53bf, 0x172);
var _0x480a=function (_0x4341e5, _0x5923b4) {
_0x4341e5=_0x4341e5 - 0x0;
var _0xb3622e=_0x53bf[_0x4341e5];
return _0xb3622e;
};
let x="1" + 0x1;
console[_0x480a("0x0")]("x", x);看到了吧，那么簡單的兩行代碼，被我們混淆成了這個樣子，其實這里我們就是設定了一個「控制流平坦化」的選項。整體看來，代碼的可讀性大大降低，也大大加大了 JavaScript 調試的難度。
好，那么我們來跟著 javascript-obfuscator 走一遍，就能具體知道 JavaScript 混淆到底有多少方法了。
注意：由于這些例子中，調用 javascript-obfuscator 進行混淆的實現是一樣的，所以下文的示例只說明 code 和 options 變量的修改，完整代碼請自行補全。
這里 javascript-obfuscator 也提供了代碼壓縮的功能，使用其參數 compact 即可完成 JavaScript 代碼的壓縮，輸出為一行內容。默認是 true，如果定義為 false，則混淆后的代碼會分行顯示。
示例如下：
const code=`
let x='1' + 1
console.log('x', x)
`;
const options={
compact: false,
};這里我們先把代碼壓縮 compact 選項設置為 false，運行結果如下：
let x="1" + 0x1;
console["log"]("x", x);如果不設置 compact 或把 compact 設置為 true，結果如下：
var _0x151c=["log"];
(function (_0x1ce384, _0x20a7c7) {
var _0x25fc92=function (_0x188aec) {
while (--_0x188aec) {
_0x1ce384["push"](_0x1ce384["shift"]());
}
};
_0x25fc92(++_0x20a7c7);
})(_0x151c, 0x1b7);
var _0x553e=function (_0x259219, _0x241445) {
_0x259219=_0x259219 - 0x0;
var _0x56d72d=_0x151c[_0x259219];
return _0x56d72d;
};
let x="1" + 0x1;
console[_0x553e("0x0")]("x", x);可以看到單行顯示的時候，對變量名進行了進一步的混淆，這里變量的命名都變成了 16 進制形式的字符串，這是因為啟用了一些默認壓縮和混淆配置導致的。總之我們可以看到代碼的可讀性相比之前大大降低了。
變量名混淆可以通過在 javascript-obfuscator 中配置 identifierNamesGenerator 參數實現，我們通過這個參數可以控制變量名混淆的方式，如 hexadecimal 則會替換為 16 進制形式的字符串，在這里我們可以設定如下值：
該參數的值默認為 hexadecimal。
我們將該參數修改為 mangled 來試一下：
const code=`
let hello='1' + 1
console.log('hello', hello)
`;
const options={
compact: true,
identifierNamesGenerator: "mangled",
};運行結果如下：
var a=["hello"];
(function (c, d) {
var e=function (f) {
while (--f) {
c["push"](c["shift"]());
}
};
e(++d);
})(a, 0x9b);
var b=function (c, d) {
c=c - 0x0;
var e=a[c];
return e;
};
let hello="1" + 0x1;
console["log"](b("0x0"), hello);可以看到這里的變量命名都變成了 a、b 等形式。
如果我們將 identifierNamesGenerator 修改為 hexadecimal 或者不設置，運行結果如下：
var _0x4e98=["log", "hello"];
(function (_0x4464de, _0x39de6c) {
var _0xdffdda=function (_0x6a95d5) {
while (--_0x6a95d5) {
_0x4464de["push"](_0x4464de["shift"]());
}
};
_0xdffdda(++_0x39de6c);
})(_0x4e98, 0xc8);
var _0x53cb=function (_0x393bda, _0x8504e7) {
_0x393bda=_0x393bda - 0x0;
var _0x46ab80=_0x4e98[_0x393bda];
return _0x46ab80;
};
let hello="1" + 0x1;
console[_0x53cb("0x0")](_0x53cb("0x1"), hello);可以看到選用了 mangled，其代碼體積會更小，但 hexadecimal 其可讀性會更低。
另外我們還可以通過設置 identifiersPrefix 參數來控制混淆后的變量前綴，示例如下：
const code=`
let hello='1' + 1
console.log('hello', hello)
`;
const options={
identifiersPrefix: "germey",
};運行結果如下：
var germey_0x3dea=["log", "hello"];
(function (_0x348ff3, _0x5330e8) {
var _0x1568b1=function (_0x4740d8) {
while (--_0x4740d8) {
_0x348ff3["push"](_0x348ff3["shift"]());
}
};
_0x1568b1(++_0x5330e8);
})(germey_0x3dea, 0x94);
var germey_0x30e4=function (_0x2e8f7c, _0x1066a8) {
_0x2e8f7c=_0x2e8f7c - 0x0;
var _0x5166ba=germey_0x3dea[_0x2e8f7c];
return _0x5166ba;
};
let hello="1" + 0x1;
console[germey_0x30e4("0x0")](germey_0x30e4("0x1"), hello);可以看到混淆后的變量前綴加上了我們自定義的字符串 germey。
另外 renameGlobals 這個參數還可以指定是否混淆全局變量和函數名稱，默認為 false。示例如下：
const code=`
var $=function(id) {
return document.getElementById(id);
};
`;
const options={
renameGlobals: true,
};運行結果如下：
var _0x4864b0=function (_0x5763be) {
return document["getElementById"](_0x5763be);
};可以看到這里我們聲明了一個全局變量 $，在 renameGlobals 設置為 true 之后，$ 這個變量也被替換了。如果后文用到了這個 $ 對象，可能就會有找不到定義的錯誤，因此這個參數可能導致代碼執行不通。
如果我們不設置 renameGlobals 或者設置為 false，結果如下：
var _0x239a=["getElementById"];
(function (_0x3f45a3, _0x583dfa) {
var _0x2cade2=function (_0x28479a) {
while (--_0x28479a) {
_0x3f45a3["push"](_0x3f45a3["shift"]());
}
};
_0x2cade2(++_0x583dfa);
})(_0x239a, 0xe1);
var _0x3758=function (_0x18659d, _0x50c21d) {
_0x18659d=_0x18659d - 0x0;
var _0x531b8d=_0x239a[_0x18659d];
return _0x531b8d;
};
var $=function (_0x3d8723) {
return document[_0x3758("0x0")](_0x3d8723);
};可以看到，最后還是有 $ 的聲明，其全局名稱沒有被改變。
字符串混淆，即將一個字符串聲明放到一個數組里面，使之無法被直接搜索到。我們可以通過控制 stringArray 參數來控制，默認為 true。
我們還可以通過 rotateStringArray 參數來控制數組化后結果的的元素順序，默認為 true。還可以通過 stringArrayEncoding 參數來控制數組的編碼形式，默認不開啟編碼，如果設置為 true 或 base64，則會使用 Base64 編碼，如果設置為 rc4，則使用 RC4 編碼。另外可以通過 stringArrayThreshold 來控制啟用編碼的概率，范圍 0 到 1，默認 0.8。
示例如下：
const code=`
var a='hello world'
`;
const options={
stringArray: true,
rotateStringArray: true,
stringArrayEncoding: true, // 'base64' 或 'rc4' 或 false
stringArrayThreshold: 1,
};運行結果如下：
var _0x4215=["aGVsbG8gd29ybGQ="];
(function (_0x42bf17, _0x4c348f) {
var _0x328832=function (_0x355be1) {
while (--_0x355be1) {
_0x42bf17["push"](_0x42bf17["shift"]());
}
};
_0x328832(++_0x4c348f);
})(_0x4215, 0x1da);
var _0x5191=function (_0x3cf2ba, _0x1917d8) {
_0x3cf2ba=_0x3cf2ba - 0x0;
var _0x1f93f0=_0x4215[_0x3cf2ba];
if (_0x5191["LqbVDH"]===undefined) {
(function () {
var _0x5096b2;
try {
var _0x282db1=Function(
"return\x20(function()\x20" +
"{}.constructor(\x22return\x20this\x22)(\x20)" +
");"
);
_0x5096b2=_0x282db1();
} catch (_0x2acb9c) {
_0x5096b2=window;
}
var _0x388c14="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
_0x5096b2["atob"] ||
(_0x5096b2["atob"]=function (_0x4cc27c) {
var _0x2af4ae=String(_0x4cc27c)["replace"](/=+$/, "");
for (
var _0x21400b=0x0,
_0x3f4e2e,
_0x5b193b,
_0x233381=0x0,
_0x3dccf7="";
(_0x5b193b=_0x2af4ae["charAt"](_0x233381++));
~_0x5b193b &&
((_0x3f4e2e= _0x21400b % 0x4 ? _0x3f4e2e * 0x40 + _0x5b193b : _0x5b193b),
_0x21400b++ % 0x4)
? (_0x3dccf7 +=String["fromCharCode"](
0xff & (_0x3f4e2e >> ((-0x2 * _0x21400b) & 0x6))
))
: 0x0
) {
_0x5b193b=_0x388c14["indexOf"](_0x5b193b);
}
return _0x3dccf7;
});
})();
_0x5191["DuIurT"]=function (_0x51888e) {
var _0x29801f=atob(_0x51888e);
var _0x561e62=[];
for (
var _0x5dd788=0x0, _0x1a8b73=_0x29801f["length"];
_0x5dd788 < _0x1a8b73;
_0x5dd788++
) {
_0x561e62 += "%" +
("00" + _0x29801f["charCodeAt"](_0x5dd788)["toString"](0x10))[
"slice"
](-0x2);
}
return decodeURIComponent(_0x561e62);
};
_0x5191["mgoBRd"]={};
_0x5191["LqbVDH"]=!![];
}
var _0x1741f0=_0x5191["mgoBRd"][_0x3cf2ba];
if (_0x1741f0===undefined) {
_0x1f93f0=_0x5191["DuIurT"](_0x1f93f0);
_0x5191["mgoBRd"][_0x3cf2ba]=_0x1f93f0;
} else {
_0x1f93f0=_0x1741f0;
}
return _0x1f93f0;
};
var a=_0x5191("0x0");可以看到這里就把字符串進行了 Base64 編碼，我們再也無法通過查找的方式找到字符串的位置了。
如果將 stringArray 設置為 false 的話，輸出就是這樣：
var a="hello\x20world";字符串就仍然是明文顯示的，沒有被編碼。
另外我們還可以使用 unicodeEscapeSequence 這個參數對字符串進行 Unicode 轉碼，使之更加難以辨認，示例如下：
const code=`
var a='hello world'
`;
const options={
compact: false,
unicodeEscapeSequence: true,
};運行結果如下：
var _0x5c0d=["\x68\x65\x6c\x6c\x6f\x20\x77\x6f\x72\x6c\x64"];
(function (_0x54cc9c, _0x57a3b2) {
var _0xf833cf=function (_0x3cd8c6) {
while (--_0x3cd8c6) {
_0x54cc9c["push"](_0x54cc9c["shift"]());
}
};
_0xf833cf(++_0x57a3b2);
})(_0x5c0d, 0x17d);
var _0x28e8=function (_0x3fd645, _0x2cf5e7) {
_0x3fd645=_0x3fd645 - 0x0;
var _0x298a20=_0x5c0d[_0x3fd645];
return _0x298a20;
};
var a=_0x28e8("0x0");可以看到，這里字符串被數字化和 Unicode 化，非常難以辨認。
在很多 JavaScript 逆向的過程中，一些關鍵的字符串可能會作為切入點來查找加密入口。用了這種混淆之后，如果有人想通過全局搜索的方式搜索 hello 這樣的字符串找加密入口，也沒法搜到了。
我們可以通過設置 selfDefending 參數來開啟代碼自我保護功能。開啟之后，混淆后的 JavaScript 會以強制一行形式顯示，如果我們將混淆后的代碼進行格式化或者重命名，該段代碼將無法執行。
示例如下：
const code=`
console.log('hello world')
`;
const options={
selfDefending: true,
};運行結果如下：
var _0x26da=["log", "hello\x20world"];
(function (_0x190327, _0x57c2c0) {
var _0x577762=function (_0xc9dabb) {
while (--_0xc9dabb) {
_0x190327["push"](_0x190327["shift"]());
}
};
var _0x35976e=function () {
var _0x16b3fe={
data: { key: "cookie", value: "timeout" },
setCookie: function (_0x2d52d5, _0x16feda, _0x57cadf, _0x56056f) {
_0x56056f=_0x56056f || {};
var _0x5b6dc3=_0x16feda + "=" + _0x57cadf;
var _0x333ced=0x0;
for (
var _0x333ced=0x0, _0x19ae36=_0x2d52d5["length"];
_0x333ced < _0x19ae36;
_0x333ced++
) {
var _0x409587=_0x2d52d5[_0x333ced];
_0x5b6dc3 +=";\x20" + _0x409587;
var _0x4aa006=_0x2d52d5[_0x409587];
_0x2d52d5["push"](_0x4aa006);
_0x19ae36=_0x2d52d5["length"];
if (_0x4aa006 !==!![]) {
_0x5b6dc3 +="=" + _0x4aa006;
}
}
_0x56056f["cookie"]=_0x5b6dc3;
},
removeCookie: function () {
return "dev";
},
getCookie: function (_0x30c497, _0x51923d) {
_0x30c497= _0x30c497 ||
function (_0x4b7e18) {
return _0x4b7e18;
};
var _0x557e06=_0x30c497(
new RegExp(
"(?:^|;\x20)" +
_0x51923d["replace"](/([.$?*|{}()[]\/+^])/g, "$1") +
"=([^;]*)"
)
);
var _0x817646=function (_0xf3fae7, _0x5d8208) {
_0xf3fae7(++_0x5d8208);
};
_0x817646(_0x577762, _0x57c2c0);
return _0x557e06 ? decodeURIComponent(_0x557e06[0x1]) : undefined;
},
};
var _0x4673cd=function () {
var _0x4c6c5c=new RegExp(
"\x5cw+\x20*\x5c(\x5c)\x20*{\x5cw+\x20*[\x27|\x22].+[\x27|\x22];?\x20*}"
);
return _0x4c6c5c["test"](_0x16b3fe["removeCookie"]["toString"]());
};
_0x16b3fe["updateCookie"]=_0x4673cd;
var _0x5baa80="";
var _0x1faf19=_0x16b3fe["updateCookie"]();
if (!_0x1faf19) {
_0x16b3fe["setCookie"](["*"], "counter", 0x1);
} else if (_0x1faf19) {
_0x5baa80=_0x16b3fe["getCookie"](null, "counter");
} else {
_0x16b3fe["removeCookie"]();
}
};
_0x35976e();
})(_0x26da, 0x140);
var _0x4391=function (_0x1b42d8, _0x57edc8) {
_0x1b42d8=_0x1b42d8 - 0x0;
var _0x2fbeca=_0x26da[_0x1b42d8];
return _0x2fbeca;
};
var _0x197926=(function () {
var _0x10598f=!![];
return function (_0xffa3b3, _0x7a40f9) {
var _0x48e571=_0x10598f
? function () {
if (_0x7a40f9) {
var _0x2194b5=_0x7a40f9["apply"](_0xffa3b3, arguments);
_0x7a40f9=null;
return _0x2194b5;
}
}
: function () {};
_0x10598f=![];
return _0x48e571;
};
})();
var _0x2c6fd7=_0x197926(this, function () {
var _0x4828bb=function () {
return "\x64\x65\x76";
},
_0x35c3bc=function () {
return "\x77\x69\x6e\x64\x6f\x77";
};
var _0x456070=function () {
var _0x4576a4=new RegExp(
"\x5c\x77\x2b\x20\x2a\x5c\x28\x5c\x29\x20\x2a\x7b\x5c\x77\x2b\x20\x2a\x5b\x27\x7c\x22\x5d\x2e\x2b\x5b\x27\x7c\x22\x5d\x3b\x3f\x20\x2a\x7d"
);
return !_0x4576a4["\x74\x65\x73\x74"](
_0x4828bb["\x74\x6f\x53\x74\x72\x69\x6e\x67"]()
);
};
var _0x3fde69=function () {
var _0xabb6f4=new RegExp(
"\x28\x5c\x5c\x5b\x78\x7c\x75\x5d\x28\x5c\x77\x29\x7b\x32\x2c\x34\x7d\x29\x2b"
);
return _0xabb6f4["\x74\x65\x73\x74"](
_0x35c3bc["\x74\x6f\x53\x74\x72\x69\x6e\x67"]()
);
};
var _0x2d9a50=function (_0x58fdb4) {
var _0x2a6361=~-0x1 >> (0x1 + (0xff % 0x0));
if (_0x58fdb4["\x69\x6e\x64\x65\x78\x4f\x66"]("\x69"===_0x2a6361)) {
_0xc388c5(_0x58fdb4);
}
};
var _0xc388c5=function (_0x2073d6) {
var _0x6bb49f=~-0x4 >> (0x1 + (0xff % 0x0));
if (
_0x2073d6["\x69\x6e\x64\x65\x78\x4f\x66"]((!![] + "")[0x3]) !==_0x6bb49f
) {
_0x2d9a50(_0x2073d6);
}
};
if (!_0x456070()) {
if (!_0x3fde69()) {
_0x2d9a50("\x69\x6e\x64\u0435\x78\x4f\x66");
} else {
_0x2d9a50("\x69\x6e\x64\x65\x78\x4f\x66");
}
} else {
_0x2d9a50("\x69\x6e\x64\u0435\x78\x4f\x66");
}
});
_0x2c6fd7();
console[_0x4391("0x0")](_0x4391("0x1"));如果我們將上述代碼放到控制臺，它的執行結果和之前是一模一樣的，沒有任何問題。
如果我們將其進行格式化，然后貼到到瀏覽器控制臺里面，瀏覽器會直接卡死無法運行。這樣如果有人對代碼進行了格式化，就無法正常對代碼進行運行和調試，從而起到了保護作用。
控制流平坦化其實就是將代碼的執行邏輯混淆，使其變得復雜難讀。其基本思想是將一些邏輯處理塊都統一加上一個前驅邏輯塊，每個邏輯塊都由前驅邏輯塊進行條件判斷和分發，構成一個個閉環邏輯，導致整個執行邏輯十分復雜難讀。
比如說這里有一段示例代碼：
console.log(c);
console.log(a);
console.log(b);代碼邏輯一目了然，依次在控制臺輸出了 c、a、b 三個變量的值，但如果把這段代碼進行控制流平坦化處理后，代碼就會變成這樣：
const s="3|1|2".split("|");
let x=0;
while (true) {
switch (s[x++]) {
case "1":
console.log(a);
continue;
case "2":
console.log(b);
continue;
case "3":
console.log(c);
continue;
}
break;
}可以看到，混淆后的代碼首先聲明了一個變量 s，它的結果是一個列表，其實是 ["3", "1", "2"]，然后下面通過 switch 語句對 s 中的元素進行了判斷，每個 case 都加上了各自的代碼邏輯。通過這樣的處理，一些連續的執行邏輯就被打破了，代碼被修改為一個 switch 語句，原本我們可以一眼看出的邏輯是控制臺先輸出 c，然后才是 a、b，但是現在我們必須要結合 switch 的判斷條件和對應 case 的內容進行判斷，我們很難再一眼每條語句的執行順序了，這就大大降低了代碼的可讀性。
在 javascript-obfuscator 中我們通過 controlFlowFlattening 變量可以控制是否開啟控制流平坦化，示例如下：
const options={
compact: false,
controlFlowFlattening: true,
};使用控制流平坦化可以使得執行邏輯更加復雜難讀，目前非常多的前端混淆都會加上這個選項。但啟用控制流平坦化之后，代碼的執行時間會變長，最長達 1.5 倍之多。
另外我們還能使用 controlFlowFlatteningThreshold 這個參數來控制比例，取值范圍是 0 到 1，默認 0.75，如果設置為 0，那相當于 controlFlowFlattening 設置為 false，即不開啟控制流扁平化 。
無用代碼即不會被執行的代碼或對上下文沒有任何影響的代碼，注入之后可以對現有的 JavaScript 代碼的閱讀形成干擾。我們可以使用 deadCodeInjection 參數開啟這個選項，默認為 false。
比如這里有一段代碼：
const a=function () {
console.log("hello world");
};
const b=function () {
console.log("nice to meet you");
};
a();
b();這里就聲明了方法 a 和 b，然后依次進行調用，分別輸出兩句話。
但經過無用代碼注入處理之后，代碼就會變成類似這樣的結果：
const _0x16c18d=function () {
if (!![[]]) {
console.log("hello world");
} else {
console.log("this");
console.log("is");
console.log("dead");
console.log("code");
}
};
const _0x1f7292=function () {
if ("xmv2nOdfy2N".charAt(4) !==String.fromCharCode(110)) {
console.log("this");
console.log("is");
console.log("dead");
console.log("code");
} else {
console.log("nice to meet you");
}
};
_0x16c18d();
_0x1f7292();可以看到，每個方法內部都增加了額外的 if else 語句，其中 if 的判斷條件還是一個表達式，其結果是 true 還是 false 我們還不太一眼能看出來，比如說 _0x1f7292 這個方法，它的 if 判斷條件是：
"xmv2nOdfy2N".charAt(4) !==String.fromCharCode(110)在不等號前面其實是從字符串中取出指定位置的字符，不等號后面則調用了 fromCharCode 方法來根據 ascii 碼轉換得到一個字符，然后比較兩個字符的結果是否是不一樣的。前者經過我們推算可以知道結果是 n，但對于后者，多數情況下我們還得去查一下 ascii 碼表才能知道其結果也是 n，最后兩個結果是相同的，所以整個表達式的結果是 false，所以 if 后面跟的邏輯實際上就是不會被執行到的無用代碼，但這些代碼對我們閱讀代碼起到了一定的干擾作用。
因此，這種混淆方式通過混入一些特殊的判斷條件并加入一些不會被執行的代碼，可以對代碼起到一定的混淆干擾作用。
在 javascript-obfuscator 中，我們可以通過 deadCodeInjection 參數控制無用代碼的注入，配置如下：
const options={
compact: false,
deadCodeInjection: true,
};另外我們還可以通過設置 deadCodeInjectionThreshold 參數來控制無用代碼注入的比例，取值 0 到 1，默認是 0.4。
如果是一個對象，可以使用 transformObjectKeys 來對對象的鍵值進行替換，示例如下：
const code=`
(function(){
var object={
foo: 'test1',
bar: {
baz: 'test2'
}
};
})();
`;
const options={
compact: false,
transformObjectKeys: true,
};輸出結果如下：
var _0x7a5d=["bar", "test2", "test1"];
(function (_0x59fec5, _0x2e4fac) {
var _0x231e7a=function (_0x46f33e) {
while (--_0x46f33e) {
_0x59fec5["push"](_0x59fec5["shift"]());
}
};
_0x231e7a(++_0x2e4fac);
})(_0x7a5d, 0x167);
var _0x3bc4=function (_0x309ad3, _0x22d5ac) {
_0x309ad3=_0x309ad3 - 0x0;
var _0x3a034e=_0x7a5d[_0x309ad3];
return _0x3a034e;
};
(function () {
var _0x9f1fd1={};
_0x9f1fd1["foo"]=_0x3bc4("0x0");
_0x9f1fd1[_0x3bc4("0x1")]={};
_0x9f1fd1[_0x3bc4("0x1")]["baz"]=_0x3bc4("0x2");
})();可以看到，Object 的變量名被替換為了特殊的變量，使得可讀性變差，這樣我們就不好直接通過變量名進行搜尋了，這也可以起到一定的防護作用。
可以使用 disableConsoleOutput 來禁用掉 console.log 輸出功能，加大調試難度，示例如下：
const code=`
console.log('hello world')
`;
const options={
disableConsoleOutput: true,
};運行結果如下：
var _0x3a39=[
"debug",
"info",
"error",
"exception",
"trace",
"hello\x20world",
"apply",
"{}.constructor(\x22return\x20this\x22)(\x20)",
"console",
"log",
"warn",
];
(function (_0x2a157a, _0x5d9d3b) {
var _0x488e2c=function (_0x5bcb73) {
while (--_0x5bcb73) {
_0x2a157a["push"](_0x2a157a["shift"]());
}
};
_0x488e2c(++_0x5d9d3b);
})(_0x3a39, 0x10e);
var _0x5bff=function (_0x43bdfc, _0x52e4c6) {
_0x43bdfc=_0x43bdfc - 0x0;
var _0xb67384=_0x3a39[_0x43bdfc];
return _0xb67384;
};
var _0x349b01=(function () {
var _0x1f484b=!![];
return function (_0x5efe0d, _0x33db62) {
var _0x20bcd2=_0x1f484b
? function () {
if (_0x33db62) {
var _0x77054c=_0x33db62[_0x5bff("0x0")](_0x5efe0d, arguments);
_0x33db62=null;
return _0x77054c;
}
}
: function () {};
_0x1f484b=![];
return _0x20bcd2;
};
})();
var _0x19f538=_0x349b01(this, function () {
var _0x7ab6e4=function () {};
var _0x157bff;
try {
var _0x5e672c=Function(
"return\x20(function()\x20" + _0x5bff("0x1") + ");"
);
_0x157bff=_0x5e672c();
} catch (_0x11028d) {
_0x157bff=window;
}
if (!_0x157bff[_0x5bff("0x2")]) {
_0x157bff[_0x5bff("0x2")]=(function (_0x7ab6e4) {
var _0x5a8d9e={};
_0x5a8d9e[_0x5bff("0x3")]=_0x7ab6e4;
_0x5a8d9e[_0x5bff("0x4")]=_0x7ab6e4;
_0x5a8d9e[_0x5bff("0x5")]=_0x7ab6e4;
_0x5a8d9e[_0x5bff("0x6")]=_0x7ab6e4;
_0x5a8d9e[_0x5bff("0x7")]=_0x7ab6e4;
_0x5a8d9e[_0x5bff("0x8")]=_0x7ab6e4;
_0x5a8d9e[_0x5bff("0x9")]=_0x7ab6e4;
return _0x5a8d9e;
})(_0x7ab6e4);
} else {
_0x157bff[_0x5bff("0x2")][_0x5bff("0x3")]=_0x7ab6e4;
_0x157bff[_0x5bff("0x2")][_0x5bff("0x4")]=_0x7ab6e4;
_0x157bff[_0x5bff("0x2")]["debug"]=_0x7ab6e4;
_0x157bff[_0x5bff("0x2")][_0x5bff("0x6")]=_0x7ab6e4;
_0x157bff[_0x5bff("0x2")][_0x5bff("0x7")]=_0x7ab6e4;
_0x157bff[_0x5bff("0x2")][_0x5bff("0x8")]=_0x7ab6e4;
_0x157bff[_0x5bff("0x2")][_0x5bff("0x9")]=_0x7ab6e4;
}
});
_0x19f538();
console[_0x5bff("0x3")](_0x5bff("0xa"));此時，我們如果執行這個代碼，發現是沒有任何輸出的，這里實際上就是將 console 的一些功能禁用了。
我們知道，在 JavaScript 代碼中如果加入 debugger 這個關鍵字，那么在執行到該位置的時候控制它就會進入斷點調試模式。如果在代碼多個位置都加入 debugger 這個關鍵字，或者定義某個邏輯來反復執行 debugger，那就會不斷進入斷點調試模式，原本的代碼無法就無法順暢地執行了。這個過程可以稱為調試保護，即通過反復執行 debugger 來使得原來的代碼無法順暢執行。
其效果類似于執行了如下代碼：
setInterval(()=> {
debugger;
}, 3000);如果我們把這段代碼粘貼到控制臺，它就會反復地執行 debugger 語句進入斷點調試模式，從而干擾正常的調試流程。
在 javascript-obfuscator 中可以使用 debugProtection 來啟用調試保護機制，還可以使用 debugProtectionInterval 來啟用無限 Debug ，使得代碼在調試過程中會不斷進入斷點模式，無法順暢執行，配置如下：
const options={
debugProtection: true,
debugProtectionInterval: true,
};混淆后的代碼會不斷跳到 debugger 代碼的位置，使得整個代碼無法順暢執行，對 JavaScript 代碼的調試形成一定的干擾。
我們還可以通過控制 domainLock 來控制 JavaScript 代碼只能在特定域名下運行，這樣就可以降低代碼被模擬或盜用的風險。
示例如下：
const code=`
console.log('hello world')
`;
const options={
domainLock: ["cuiqingcai.com"],
};這里我們使用了 domainLock 指定了一個域名叫做 cuiqingcai.com，也就是設置了一個域名白名單，混淆后的代碼結果如下：
var _0x3203=[
"apply",
"return\x20(function()\x20",
"{}.constructor(\x22return\x20this\x22)(\x20)",
"item",
"attribute",
"value",
"replace",
"length",
"charCodeAt",
"log",
"hello\x20world",
];
(function (_0x2ed22c, _0x3ad370) {
var _0x49dc54=function (_0x53a786) {
while (--_0x53a786) {
_0x2ed22c["push"](_0x2ed22c["shift"]());
}
};
_0x49dc54(++_0x3ad370);
})(_0x3203, 0x155);
var _0x5b38=function (_0xd7780b, _0x19c0f2) {
_0xd7780b=_0xd7780b - 0x0;
var _0x2d2f44=_0x3203[_0xd7780b];
return _0x2d2f44;
};
var _0x485919=(function () {
var _0x5cf798=!![];
return function (_0xd1fa29, _0x2ed646) {
var _0x56abf=_0x5cf798
? function () {
if (_0x2ed646) {
var _0x33af63=_0x2ed646[_0x5b38("0x0")](_0xd1fa29, arguments);
_0x2ed646=null;
return _0x33af63;
}
}
: function () {};
_0x5cf798=![];
return _0x56abf;
};
})();
var _0x67dcc8=_0x485919(this, function () {
var _0x276a31;
try {
var _0x5c8be2=Function(_0x5b38("0x1") + _0x5b38("0x2") + ");");
_0x276a31=_0x5c8be2();
} catch (_0x5f1c00) {
_0x276a31=window;
}
var _0x254a0d=function () {
return {
key: _0x5b38("0x3"),
value: _0x5b38("0x4"),
getAttribute: (function () {
for (var _0x5cc3c7=0x0; _0x5cc3c7 < 0x3e8; _0x5cc3c7--) {
var _0x35b30b=_0x5cc3c7 > 0x0;
switch (_0x35b30b) {
case !![]:
return (
this[_0x5b38("0x3")] +
"_" +
this[_0x5b38("0x5")] +
"_" +
_0x5cc3c7
);
default:
this[_0x5b38("0x3")] + "_" + this[_0x5b38("0x5")];
}
}
})(),
};
};
var _0x3b375a=new RegExp("[QLCIKYkCFzdWpzRAXMhxJOYpTpYWJHPll]", "g");
var _0x5a94d2="cuQLiqiCInKYkgCFzdWcpzRAaXMi.hcoxmJOYpTpYWJHPll"
[_0x5b38("0x6")](_0x3b375a, "")
["split"](";");
var _0x5c0da2;
var _0x19ad5d;
var _0x5992ca;
var _0x40bd39;
for (var _0x5cad1 in _0x276a31) {
if (
_0x5cad1[_0x5b38("0x7")]==0x8 &&
_0x5cad1[_0x5b38("0x8")](0x7)==0x74 &&
_0x5cad1[_0x5b38("0x8")](0x5)==0x65 &&
_0x5cad1[_0x5b38("0x8")](0x3)==0x75 &&
_0x5cad1[_0x5b38("0x8")](0x0)==0x64
) {
_0x5c0da2=_0x5cad1;
break;
}
}
for (var _0x29551 in _0x276a31[_0x5c0da2]) {
if (
_0x29551[_0x5b38("0x7")]==0x6 &&
_0x29551[_0x5b38("0x8")](0x5)==0x6e &&
_0x29551[_0x5b38("0x8")](0x0)==0x64
) {
_0x19ad5d=_0x29551;
break;
}
}
if (!("~" > _0x19ad5d)) {
for (var _0x2b71bd in _0x276a31[_0x5c0da2]) {
if (
_0x2b71bd[_0x5b38("0x7")]==0x8 &&
_0x2b71bd[_0x5b38("0x8")](0x7)==0x6e &&
_0x2b71bd[_0x5b38("0x8")](0x0)==0x6c
) {
_0x5992ca=_0x2b71bd;
break;
}
}
for (var _0x397f55 in _0x276a31[_0x5c0da2][_0x5992ca]) {
if (
_0x397f55["length"]==0x8 &&
_0x397f55[_0x5b38("0x8")](0x7)==0x65 &&
_0x397f55[_0x5b38("0x8")](0x0)==0x68
) {
_0x40bd39=_0x397f55;
break;
}
}
}
if (!_0x5c0da2 || !_0x276a31[_0x5c0da2]) {
return;
}
var _0x5f19be=_0x276a31[_0x5c0da2][_0x19ad5d];
var _0x674f76=!!_0x276a31[_0x5c0da2][_0x5992ca] &&
_0x276a31[_0x5c0da2][_0x5992ca][_0x40bd39];
var _0x5e1b34=_0x5f19be || _0x674f76;
if (!_0x5e1b34) {
return;
}
var _0x593394=![];
for (var _0x479239=0x0; _0x479239 < _0x5a94d2["length"]; _0x479239++) {
var _0x19ad5d=_0x5a94d2[_0x479239];
var _0x112c24=_0x5e1b34["length"] - _0x19ad5d["length"];
var _0x51731c=_0x5e1b34["indexOf"](_0x19ad5d, _0x112c24);
var _0x173191=_0x51731c !==-0x1 && _0x51731c===_0x112c24;
if (_0x173191) {
if (
_0x5e1b34["length"]==_0x19ad5d[_0x5b38("0x7")] ||
_0x19ad5d["indexOf"](".")===0x0
) {
_0x593394=!![];
}
}
}
if (!_0x593394) {
data;
} else {
return;
}
_0x254a0d();
});
_0x67dcc8();
console[_0x5b38("0x9")](_0x5b38("0xa"));這段代碼就只能在指定域名 cuiqingcai.com 下運行，不能在其他網站運行。這樣的話，如果一些相關 JavaScript 代碼被單獨剝離出來，想在其他網站運行或者使用程序模擬運行的話，運行結果只有是失敗，這樣就可以有效降低被代碼被模擬或盜用的風險。
另外還有一些特殊的工具包，如使用 aaencode、jjencode、jsfuck 等工具對代碼進行混淆和編碼。
示例如下：
var a=1jsfuck 的結果：
[][(![]+[])[!+[]+!![]+!![]]+([]+{})[+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]][([]+{})[!+[]+!![]+!![]+!![]+!![]]+([]+{})[+!![]]+([][[]]+[])[+!![]]+(![]+[])[!+[]+!![]+!![]]+(!![]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+[]]+([]+{})[!+[]+!![]+!![]+!![]+!![]]+(!![]+[])[+[]]+([]+{})[+!![]]+(!![]+[])[+!![]]]([][(![]+[])[!+[]+!![]+!![]]+([]+{})[+!![]]+(!![]+[])[+!![]]+(!![]+[])[+[]]][([]+{})[!+[]+!![]+!![]+!![]+!![]]+([]+{})[+!![]]+([][[]]+[])[+!![]]+
...
([]+{})[+!![]]+(!![]+[])[+!![]]]((!![]+[])[+!![]]+([][[]]+[])[!+[]+!![]+!![]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!![]]+([][[]]+[])[+!![]]+([]+{})[!+[]+!![]+!![]+!![]+!![]+!![]+!![]]+(![]+[])[!+[]+!![]]+([]+{})[+!![]]+([]+{})[!+[]+!![]+!![]+!![]+!![]]+(+{}+[])[+!![]]+(!![]+[])[+[]]+([][[]]+[])[!+[]+!![]+!![]+!![]+!![]]+([]+{})[+!![]]+([][[]]+[])[+!![]])(!+[]+!![]+!![]+!![]+!![]))[!+[]+!![]+!![]]+([][[]]+[])[!+[]+!![]+!![]])(!+[]+!![]+!![]+!![]+!![])(([]+{})[+[]])[+[]]+(!+[]+!![]+!![]+[])+([][[]]+[])[!+[]+!![]])+([]+{})[!+[]+!![]+!![]+!![]+!![]+!![]+!![]]+(+!![]+[]))(!+[]+!![]+!![]+!![]+!![]+!![]+!![]+!![])aaencode 的結果：
?ω??=/｀ｍ′）? ~┻━┻ / ['_']; o=(???)=_=3; c=(?Θ?)=(???)-(???); (?Д?)=(?Θ?)=(o^_^o)/ (o^_^o);(?Д?)={?Θ?: '_' ,?ω?? : ((?ω??==3) +'_') [?Θ?] ,???? :(?ω??+ '_')[o^_^o -(?Θ?)] ,?Д??:((???==3) +'_')[???] }; (?Д?) [?Θ?]=((?ω??==3) +'_') [c^_^o];(?Д?) ['c']=((?Д?)+'_') [ (???)+(???)-(?Θ?) ];(?Д?) ['o']=((?Д?)+'_') [?Θ?];(?o?)=(?Д?) ['c']+(?Д?) ['o']+(?ω?? +'_')[?Θ?]+ ((?ω??==3) +'_') [???] + ((?Д?) +'_') [(???)+(???)]+ ((???==3) +'_') [?Θ?]+((???==3) +'_') [(???) - (?Θ?)]+(?Д?) ['c']+((?Д?)+'_') [(???)+(???)]+ (?Д?) ['o']+((???==3) +'_') [?Θ?];(?Д?) ['_']=(o^_^o) [?o?] [?o?];(?ε?)=((???==3) +'_') [?Θ?]+ (?Д?) .?Д??+((?Д?)+'_') [(???) + (???)]+((???==3) +'_') [o^_^o -?Θ?]+((???==3) +'_') [?Θ?]+ (?ω?? +'_') [?Θ?]; (???)+=(?Θ?); (?Д?)[?ε?]='\'; (?Д?).?Θ??=(?Д?+ ???)[o^_^o -(?Θ?)];(o???o)=(?ω?? +'_')[c^_^o];(?Д?) [?o?]='\"';(?Д?) ['_'] ( (?Д?) ['_'] (?ε?+(?Д?)[?o?]+ (?Д?)[?ε?]+(?Θ?)+ ((o^_^o) +(o^_^o))+ ((o^_^o) +(o^_^o))+ (?Д?)[?ε?]+(?Θ?)+ (???)+ (?Θ?)+ (?Д?)[?ε?]+(?Θ?)+ ((o^_^o) +(o^_^o))+ ((o^_^o) - (?Θ?))+ (?Д?)[?ε?]+(???)+ (c^_^o)+ (?Д?)[?ε?]+(?Θ?)+ (???)+ (?Θ?)+ (?Д?)[?ε?]+(???)+ (c^_^o)+ (?Д?)[?ε?]+((???) + (o^_^o))+ ((???) + (?Θ?))+ (?Д?)[?ε?]+(???)+ (c^_^o)+ (?Д?)[?ε?]+((o^_^o) +(o^_^o))+ (?Θ?)+ (?Д?)[?o?])(?Θ?))((?Θ?)+(?Д?)[?ε?]+((???)+(?Θ?))+(?Θ?)+(?Д?)[?o?]);jjencode 的結果：
$=~[];$={___:++$,$$$$:(![]+"")[$],__$:++$,$_$_:(![]+"")[$],_$_:++$,$_$$:({}+"")[$],$$_$:($[$]+"")[$],_$$:++$,$$$_:(!""+"")[$],$__:++$,$_$:++$,$$__:({}+"")[$],$$_:++$,$$$:++$,$___:++$,$__$:++$};$.$_=($.$_=$+"")[$.$_$]+($._$=$.$_[$.__$])+($.$$=($.$+"")[$.__$])+((!$)+"")[$._$$]+($.__=$.$_[$.$$_])+($.$=(!""+"")[$.__$])+($._=(!""+"")[$._$_])+$.$_[$.$_$]+$.__+$._$+$.$;$.$$=$.$+(!""+"")[$._$$]+$.__+$._+$.$+$.$$;$.$=($.___)[$.$_][$.$_];$.$($.$($.$$+"\""+"\"+$.__$+$.$$_+$.$$_+$.$_$_+"\"+$.__$+$.$$_+$._$_+"\"+$.$__+$.___+$.$_$_+"\"+$.$__+$.___+"=\"+$.$__+$.___+$.__$+"\"")())();可以看到，通過這些工具，原本非常簡單的代碼被轉化為一些幾乎完全不可讀的代碼，但實際上運行效果還是相同的。這些混淆方式比較另類，看起來雖然沒有什么頭緒，但實際上找到規律是非常好還原的，其沒有真正達到強力混淆的效果。
以上便是對 JavaScript 混淆方式的介紹和總結。總的來說，經過混淆的 JavaScript 代碼其可讀性大大降低，同時防護效果也大大增強。
隨著技術的發展，WebAssembly 逐漸流行起來。不同于 JavaScript 混淆技術， WebAssembly 其基本思路是將一些核心邏輯使用其他語言（如 C/C++ 語言）來編寫，并編譯成類似字節碼的文件，并通過 JavaScript 調用執行，從而起到二進制級別的防護作用。
WebAssembly 是一種可以使用非 JavaScript 編程語言編寫代碼并且能在瀏覽器上運行的技術方案，比如借助于我們能將 C/C++ 利用 Emscripten 編譯工具轉成 wasm 格式的文件， JavaScript 可以直接調用該文件執行其中的方法。
WebAssembly 是經過編譯器編譯之后的字節碼，可以從 C/C++ 編譯而來，得到的字節碼具有和 JavaScript 相同的功能，運行速度更快，體積更小，而且在語法上完全脫離 JavaScript，同時具有沙盒化的執行環境。
比如這就是一個基本的 WebAssembly 示例：
WebAssembly.compile(
new Uint8Array(
`
00 61 73 6d 01 00 00 00 01 0c 02 60 02 7f 7f 01
7f 60 01 7f 01 7f 03 03 02 00 01 07 10 02 03 61
64 64 00 00 06 73 71 75 61 72 65 00 01 0a 13 02
08 00 20 00 20 01 6a 0f 0b 08 00 20 00 20 00 6c
0f 0b`
.trim()
.split(/[\s\r\n]+/g)
.map((str)=> parseInt(str, 16))
)
).then((module)=> {
const instance=new WebAssembly.Instance(module);
const { add, square }=instance.exports;
console.log("2 + 4=", add(2, 4));
console.log("3^2=", square(3));
console.log("(2 + 5)^2=", square(add(2 + 5)));
});這里其實是利用 WebAssembly 定義了兩個方法，分別是 add 和 square，可以分別用于求和和開平方計算。那這兩個方法在哪里聲明的呢？其實它們被隱藏在了一個 Uint8Array 里面，僅僅查看明文代碼我們確實無從知曉里面究竟定義了什么邏輯，但確實是可以執行的，我們將這段代碼輸入到瀏覽器控制臺下，運行結果如下：
2 + 4=6
3^2=9
(2 + 5)^2=49由此可見，通過 WebAssembly 我們可以成功將核心邏輯“隱藏”起來，這樣某些核心邏輯就不能被輕易找出來了。
所以，很多網站越來越多使用 WebAssembly 技術來保護一些核心邏輯不被輕易被人識別或破解，可以起到更好的防護效果。
以上，我們就介紹了接口加密技術和 JavaScript 的壓縮、混淆技術，也對 WebAssembly 技術有了初步的了解，知己知彼方能百戰不殆，了解了原理，我們才能更好地去實現 JavaScript 的逆向。
本節代碼：https://github.com/Python3WebSpider/JavaScriptObfuscate。
由于本節涉及一些專業名詞，部分內容參考來源如下：
https://github.com/lrusso/JavaScriptObfuscator
// 在線轉換地址
https://lrusso.github.io/JavaScriptObfuscator/JavaScriptObfuscator.htmhttps://github.com/aemkei/jsfuckhttps://github.com/terser/terserhttps://github.com/mishoo/UglifyJS如何混淆代碼的：同terser
https://jscrambler.com/
// webpack
https://jscrambler.com/blog/protect-your-code-while-using-webpack在線轉換工具，官方文檔介紹購買后可以提供API，或提供私有化部署
http://www.jshaman.com/http://stunnix.com/store/
// 安裝向導
http://stunnix.com/support/doc/jo/install-guide.shtml
// 使用教程
https://www.cnblogs.com/zzugyl/p/4204387.html當然還有其它的混淆工具，好多熱度也不高或者N多年沒有維護，這里就不一一列舉了。
通過對比，這里著重介紹這兩個terser，UglifyJS
現在基本都是vue、react項目，都會使用webpack、vite等管理工具，所以terser，UglifyJS也是以插件的形式放到webpack、vite統一配置使用。
https://webpack.docschina.org/plugins/terser-webpack-plugin/npm install terser-webpack-plugin --save-devhttps://v4.webpack.js.org/plugins/uglifyjs-webpack-plugin/npm install uglifyjs-webpack-plugin --save-devnpm install rollup-plugin-terser --save-devimport { defineConfig } from 'vite';
import { terser } from 'rollup-plugin-terser';
export default defineConfig({
plugins: [terser()],
});https://github.com/getkey/rollup-plugin-obfuscator
https://github.com/javascript-obfuscator/javascript-obfuscatornpm install --save-dev rollup-plugin-obfuscator javascript-obfuscator
or
yarn add --dev rollup-plugin-obfuscator javascript-obfuscator
如果打包報錯，試一下
yarn add javascript-obfuscator -D4、在vite.config.ts中配置
import { defineConfig } from 'vite'
import vue from '@vitejs/plugin-vue'
import obfuscator from 'rollup-plugin-obfuscator';
export default defineConfig({
// base: "",
build: {
minify: 'esbuild', // 默認
},
esbuild: {
drop: ['console', 'debugger'],//打包去除
},
plugins: [
vue(),
obfuscator({
global:false,
// options配置項實際為 javascript-obfuscator 選項，具體可查看https://github.com/javascript-obfuscator/javascript-obfuscator
options: {
compact: true,
controlFlowFlattening: true,
controlFlowFlatteningThreshold: 0.75,
numbersToExpressions: true,
simplify: true,
stringArrayShuffle: true,
splitStrings: true,
splitStringsChunkLength: 10,
rotateUnicodeArray: true,
deadCodeInjection: true,
deadCodeInjectionThreshold: 0.4,
debugProtection: false,
debugProtectionInterval: 2000,
disableConsoleOutput: true,
domainLock: [],
identifierNamesGenerator: "hexadecimal",
identifiersPrefix: "",
inputFileName: "",
log: true,
renameGlobals: true,
reservedNames: [],
reservedStrings: [],
seed: 0,
selfDefending: true,
sourceMap: false,
sourceMapBaseUrl: "",
sourceMapFileName: "",
sourceMapMode: "separate",
stringArray: true,
stringArrayEncoding: ["base64"],
stringArrayThreshold: 0.75,
target: "browser",
transformObjectKeys: true,
unicodeEscapeSequence: true,
domainLockRedirectUrl: "about:blank",
forceTransformStrings: [],
identifierNamesCache: null,
identifiersDictionary: [],
ignoreImports: true,
optionsPreset: "default",
renameProperties: false,
renamePropertiesMode: "safe",
sourceMapSourcesMode: "sources-content",
stringArrayCallsTransform: true,
stringArrayCallsTransformThreshold: 0.5,
stringArrayIndexesType: ["hexadecimal-number"],
stringArrayIndexShift: true,
stringArrayRotate: true,
stringArrayWrappersCount: 1,
stringArrayWrappersChainedCalls: true,
stringArrayWrappersParametersMaxCount: 2,
stringArrayWrappersType: "variable",
}
})
]
})————————————
昔聞洞庭水，今上岳陽樓。
吳楚東南坼，乾坤日夜浮。
親朋無一字，老病有孤舟。
戎馬關山北，憑軒涕泗流。
- 登岳陽樓 【唐】杜甫
相信各位讀者對秒表都不陌生，智能手機上通常都有這樣一款軟件
來自我的小米手機的截圖
有一天心血來潮，便想要“復刻”一個命令行版本的秒表程序——主要是想嘗試一下新學會的、“原地更新”的技能，而不是一行接一行地輸出。程序的運行效果如下
那么這是怎么做的呢？
要實現一個秒表，首先要知道從開始計時至今過了多久。在*nix 系統中，表示時刻的事實標準是Epoch Time[1]，在shell腳本中要獲取 Epoch Time 可以用date命令。再用首尾時刻相減便得到了期間流逝的秒數了，示例代碼如下
begin_at=$(date '+%s')
# 睡個覺
end_at=$(date '+%s')
((interval=${end_at} - ${begin_at}))雙圓括號是一種在shell腳本中執行算術運算的語法，其它語法可以參見Math in Shell Scripts[2]。
有了interval中存儲的總秒數后，換算成時分秒便是輕而易舉的事情，示例代碼如下
((hours=${interval} / 3600))
((minutes=(${interval} % 3600) / 60))
((seconds=(${interval} % 3600) % 60))hh:mm:ss的意思是分別用兩個十進制數字顯示時分秒，并以冒號分隔它們。如果有任何一個單位的數值小于 10，便用字符0填充左側的空白。按這個格式，凌晨 1 點 2 分 3 秒便會顯示為01:02:03。
要在命令行中打印字符串，最容易想到的便是echo命令，只可惜它不能方便地實現填充字符0的需求。
強人所難也不是不行，示例代碼如下
hours=1
minutes=2
seconds=3
if [ "${hours}" -lt '10' ];
then
echo -n "0${hours}"
else
echo -n "${hours}"
fi
echo -n ':'
if [ "${minutes}" -lt '10' ];
then
echo -n "0${minutes}"
else
echo -n "${minutes}"
fi
echo -n ':'
if [ "${seconds}" -lt '10' ];
then
echo -n "0${seconds}"
else
echo -n "${seconds}"
fi更優雅的方法是用printf命令來自動填充左側的字符0
printf "%02d:%02d:%02d" ${hours} ${minutes} ${seconds}printf命令類似于 C 語言中的printf函數——它也支持打印轉義的字符，下文會提到。
今年以來我在斷斷續續地看Build Your Own Text Editor[3]，學習如何開發文本編輯器。在這本小冊子的第三章[4]中，作者講述了如何使用終端的轉義序列（escape sequence）來控制屏幕上顯示的東西——這正是秒表程序所需要的。
例如，在終端輸出轉義序列\x1b[2J可以清空屏幕，效果如下
為了覆蓋已經打印出來的時分秒，需要：
查閱《VT100 User Guide》第三章[5]可以知道
更優雅的方法甚至連轉義序列也不需要，只要用tput命令即可，示例代碼如下
echo -n '11:22:33'
tput cr
tput el
echo '44:55:66'關于cr和el，以及更多可以傳給tput命令的參數，可以參見terminfo的man文檔。
這大概是整個程序中最簡單的需求了
while [ 1 -eq 1 ]
do
# 此處可以為所欲為
sleep 0.5
done至此，完整的秒表程序就可以實現出來了
#!/bin/bash
# 秒表，以hh:mm:ss的格式展示數據
begin_at=$(date '+%s')
while [ 1 -eq 1 ]
do
end_at=$(date '+%s')
# 算術運算：http://faculty.salina.k-state.edu/tim/unix_sg/bash/math.html
((interval=${end_at} - ${begin_at}))
((hours=${interval} / 3600))
((minutes=(${interval} % 3600) / 60))
((seconds=(${interval} % 3600) % 60))
tput cr
tput el
printf "%02d:%02d:%02d" ${hours} ${minutes} ${seconds}
sleep 0.5
done運行后的效果正如本文開頭的 GIF 所示。
全文完。
[1]
Epoch Time: https://en.wikipedia.org/wiki/Unix_time
[2]
Math in Shell Scripts: http://faculty.salina.k-state.edu/tim/unix_sg/bash/math.html
[3]
Build Your Own Text Editor: https://viewsourcecode.org/snaptoken/kilo/index.html
[4]
第三章: https://viewsourcecode.org/snaptoken/kilo/03.rawInputAndOutput.html#clear-the-screen
[5]
《VT100 User Guide》第三章: https://vt100.net/docs/vt100-ug/chapter3.html
*請認真填寫需求信息，我們會在24小時內與您取得聯系。
