一、常見反調(diào)試手段識別

1. debugger 死循環(huán)（阻塞調(diào)試器）

樣例代碼：

while (true) {
  debugger;
}

原理：

• 每次執(zhí)行到 debugger 語句，如果 DevTools 打開，將自動觸發(fā)斷點(diǎn)。

• 如果在死循環(huán)中，調(diào)試器會被頻繁打斷，卡死頁面或無法操作。

特征識別：

• 出現(xiàn)在自執(zhí)行函數(shù)中 (function(){...})()，或者 setInterval、setTimeout 里。

• 常與加密代碼混合，隱藏在核心邏輯附近。

應(yīng)對方法：

• 打開 Chrome DevTools → 設(shè)置 → 關(guān)閉 "暫停于異常" 和自動斷點(diǎn)。

• 手動刪除 debugger，或用 Babel/AST 腳本批量清除：

traverse(ast, {
  DebuggerStatement(path) {
    path.remove();
  }
});

2. 時(shí)間延遲檢測（檢測調(diào)試耗時(shí)）

樣例代碼：

const start = Date.now();
for (let i = 0; i < 1e8; i++) {}
const end = Date.now();
if (end - start > 500) {
  alert("你調(diào)試我了！");
}

原理：

• 調(diào)試器中手動打斷點(diǎn)，會暫停腳本執(zhí)行。

• 利用 Date.now() 或 performance.now() 計(jì)算耗時(shí)，如果超過閾值，說明你在調(diào)試。

特征識別：

• Date.now()、performance.now() 出現(xiàn)多次用于比對時(shí)間差。

• 常用于函數(shù)入口、加密函數(shù)前后。

應(yīng)對方法：

• 重寫時(shí)間函數(shù)，返回恒定時(shí)間：

Date.now = () => 123456789;
performance.now = () => 100;

• 或刪除時(shí)間差判斷代碼段（使用 AST 或腳本）

3. 函數(shù)串?dāng)_檢測（檢測函數(shù)是否被 hook）

樣例代碼：

const realAlert = alert;
alert = function () {
  console.log("你調(diào)試了嗎？");
  return realAlert.apply(this, arguments);
};

原理：

• 檢測是否篡改了系統(tǒng)函數(shù)，例如 alert、console、eval 等。

• 調(diào)試器經(jīng)常 hook 函數(shù)，攻擊者利用此邏輯檢測調(diào)試行為。

特征識別：

• 檢測 alert, eval, console.log 等函數(shù)是否被改寫。

• Function.prototype.toString() 經(jīng)常聯(lián)合使用，判斷函數(shù)體內(nèi)容是否 [native code]

應(yīng)對方法：

• 恢復(fù)原始函數(shù)：

alert = window.__proto__.alert;
console.log = window.__proto__.console.log;

• 用 Proxy 包裝函數(shù)，同時(shí)偽裝 toString() 輸出。

4. Function.prototype.toString 檢測（偽裝函數(shù)原型）

樣例代碼：

if (alert.toString().indexOf('[native code]') === -1) {
  throw new Error('你修改了 alert 函數(shù)！');
}

原理：

• JS 中原生函數(shù) toString() 會返回 [native code]。

• 一旦你對 alert 之類做了 hook 或包裝，這一特征就消失。

反制手段：

• 偽裝 toString 輸出：

alert = new Proxy(alert, {
  apply: function(target, thisArg, argumentsList) {
    return target.apply(thisArg, argumentsList);
  }
});
alert.toString = function() {
  return "function alert() { [native code] }";
};

5. window.console 檢測

樣例代碼：

if (!window.console || typeof console.log !== "function") {
  throw new Error("console 被篡改！");
}

原理：

• 某些調(diào)試工具會臨時(shí)修改 console 行為。

• 檢測 console 存在性和完整性也是一種反調(diào)試手段。

解決方式：

• 恢復(fù)原始 console 對象。

• 或偽造 console 對象結(jié)構(gòu)（手動定義全套方法）。

6. 異常捕獲干擾調(diào)試

樣例代碼：

try {
  throw new Error("調(diào)試干擾");
} catch (e) {
  debugger;
}

原理：

• 在 try-catch 中故意嵌入 debugger、死循環(huán)或跳轉(zhuǎn)邏輯，擾亂調(diào)試節(jié)奏。

• 有的框架會在異常棧中判斷調(diào)試器是否存在。

應(yīng)對方案：

• 修改 try-catch 中間代碼，繞開 debugger。

• 用 AST 替換整個(gè)異常處理段。

7. 堆棧跟蹤干擾（檢測調(diào)試器存在）

樣例代碼：

function checkStack() {
  try {
    throw new Error();
  } catch (e) {
    if (e.stack.indexOf("Debugger") !== -1) {
      alert("發(fā)現(xiàn)調(diào)試器");
    }
  }
}

原理：

• 拋異常時(shí)，Error.stack 會包含調(diào)用堆棧信息。

• 如果你在 Chrome DevTools 設(shè)置了斷點(diǎn)，可能會在 stack 中體現(xiàn)。

應(yīng)對：

• 重寫 Error 構(gòu)造函數(shù)或其 stack 屬性，返回空堆棧。

8. requestAnimationFrame 反調(diào)試

樣例代碼：

let lastTime = performance.now();
function checkDebugger() {
  let now = performance.now();
  if (now - lastTime > 100) {
    alert("調(diào)試器卡住了瀏覽器");
  }
  lastTime = now;
  requestAnimationFrame(checkDebugger);
}
requestAnimationFrame(checkDebugger);

原理：

• requestAnimationFrame 頻率非常高（約每16ms執(zhí)行一次），調(diào)試器會明顯卡頓，時(shí)間差變大。

應(yīng)對方法：

• 重寫 requestAnimationFrame，屏蔽檢測邏輯。

• 或 hook performance.now() 偽造時(shí)間。

9. 全局函數(shù)自毀 / 還原干擾

樣例代碼：

(function(){
  Function = null;
})();

原理：

• 故意銷毀 JS 全局函數(shù)，阻止我們運(yùn)行 eval / Function 等調(diào)試代碼。

應(yīng)對方法：

• 在中斷點(diǎn)處提前 window.Function = Function 備份

• 或直接改寫函數(shù)覆蓋邏輯，讓其失效

總結(jié)

二、JavaScript 混淆手法

混淆的目標(biāo)是讓代碼變得：

• 難讀（降低可讀性）

• 難調(diào)試（隱藏執(zhí)行流程）

• 難還原（阻礙逆向）

1. 字符串拆分拼接

原始代碼：

var key = "secretKey";

混淆后代碼示例：

var _0x1a2b = "sec" + "ret" + "Key";

甚至更復(fù)雜：

var a = "s";
var b = "e";
var c = b + "c";
var d = a + c + "ret" + "Key";  // 最終是 "secretKey"

混淆目的：

• 隱藏字符串字面量，防止關(guān)鍵詞命中（如 w、sign、token 等）。

識別與還原方法：

• 手動打斷點(diǎn)查看變量值（或用 console.log 打印）

• 或者用 AST 腳本靜態(tài)還原拼接結(jié)果（字符串折疊優(yōu)化）：

traverse(ast, {
  BinaryExpression(path) {
    if (path.node.operator === "+" &&
        t.isStringLiteral(path.node.left) &&
        t.isStringLiteral(path.node.right)) {
      path.replaceWith(
        t.stringLiteral(path.node.left.value + path.node.right.value)
      );
    }
  }
});

2. base64 編碼隱藏字符串

混淆代碼示例：

var data = atob("c2VjcmV0S2V5");  // "secretKey"

原理：

• 用 Base64 編碼字符串后解碼執(zhí)行，達(dá)到隱藏真實(shí)內(nèi)容的目的。

• 通常與 eval, Function, new Image() 等組合使用。

混淆目的：

• 防止明文暴露關(guān)鍵字（如 UA、token、cookie、sign 等）

識別特征：

• atob()、btoa()、Buffer.from(...).toString(...) 出現(xiàn)

• 明文字符串為 4 的倍數(shù)長度，末尾常有 = 填充符

還原方式：

• 瀏覽器或腳本執(zhí)行：

console.log(atob("c2VjcmV0S2V5"));

3. eval / Function 動態(tài)執(zhí)行

示例 1（eval）：

eval("console." + "log('hello')");

示例 2（Function）：

var code = "return 5 + 5;";
var fn = new Function(code);
console.log(fn()); // 輸出 10

原理：

• 動態(tài)執(zhí)行字符串拼接后的代碼，防止靜態(tài)分析。

• 通常與字符串拼接、base64 一起使用。

特征識別：

• 出現(xiàn) eval(), new Function(), setTimeout(code, 0) 等動態(tài)執(zhí)行語句。

• 動態(tài)生成的代碼中常含混淆函數(shù)調(diào)用、加密入口、hook 代碼。

還原與處理：

1）打補(bǔ)丁替換 eval 為 console.log：

eval = console.log;  // 打印出真實(shí)代碼

2）攔截 Function：

window.Function = function(code) {
  console.log("[HOOKED FUNCTION]:", code);
  return () => {};
};

3）使用 AST 替換 eval：

traverse(ast, {
  CallExpression(path) {
    if (path.node.callee.name === 'eval') {
      path.node.callee.name = 'console.log';
    }
  }
});

4. 數(shù)組 + 索引跳轉(zhuǎn)（Control Flow Flattening）

混淆代碼示例：

var _0xabc = [
  "log",         // 索引 0
  "Hello",       // 索引 1
  "console",     // 索引 2
];

(function(arr) {
  var a = arr[2]; // "console"
  var b = arr[0]; // "log"
  var c = arr[1]; // "Hello"
  window[a][b](c);  // => console.log("Hello")
})(_0xabc);

或者極端一點(diǎn)：

var arr = ["\x63\x6f\x6e\x73\x6f\x6c\x65", "\x6c\x6f\x67"];
window[arr[0]][arr[1]]("hi");

原理：

• 字符串存入數(shù)組，索引讀取，打亂順序。

• 控制流 flatten：真實(shí)執(zhí)行路徑隱藏在數(shù)組索引組合里。

特征識別：

• 有大數(shù)組存放字符串

• 數(shù)組通過索引訪問，變量命名毫無意義（如 _0xabc[1]）

• 出現(xiàn) “mapping 函數(shù)”：例如 _0xabc = function(i){ return arr[i]; }

還原方法：

• 手動記錄數(shù)組內(nèi)容 → 替換索引值

• 使用 Babel AST 掃描，把數(shù)組取值還原成字符串

• 工具推薦：

  • de4js：https://lelinhtinh.github.io/de4js/

  • 自寫還原腳本處理全局映射數(shù)組

總結(jié)

三、AST 抽象語法樹分析

AST（抽象語法樹） 是程序源代碼的結(jié)構(gòu)化、樹狀表示。

在 JavaScript 中，一段代碼：

var a = "hello";

會被轉(zhuǎn)換為一個(gè) AST 樹結(jié)構(gòu)，描述這段代碼的結(jié)構(gòu)，比如：VariableDeclaration -> VariableDeclarator -> Identifier + Literal

它并不是運(yùn)行代碼，而是「代碼結(jié)構(gòu)本身」的抽象。

在 JS 混淆還原、定位加密函數(shù)、批量清理垃圾邏輯時(shí)，AST 是最強(qiáng)的靜態(tài)分析工具：

Babel 是 JS 編譯領(lǐng)域的核心工具，它能：

•  解析 JS 源碼為 AST（@babel/parser）

•  遍歷和修改 AST（@babel/traverse）

•  將 AST 重新生成代碼（@babel/generator）

1. Babel AST 操作的基本流程

安裝依賴（Node 環(huán)境）

npm install @babel/parser @babel/traverse @babel/generator

1）將代碼解析成 AST

const parser = require('@babel/parser');
const code = 'var a = "he" + "llo";';

const ast = parser.parse(code, {
  sourceType: 'module'
});

2）遍歷 AST 并修改

const traverse = require('@babel/traverse').default;
const t = require('@babel/types');

traverse(ast, {
  BinaryExpression(path) {
    if (
      path.node.operator === '+' &&
      t.isStringLiteral(path.node.left) &&
      t.isStringLiteral(path.node.right)
    ) {
      // 替換拼接表達(dá)式為結(jié)果字符串
      path.replaceWith(
        t.stringLiteral(path.node.left.value + path.node.right.value)
      );
    }
  }
});

3）生成新代碼

const generate = require('@babel/generator').default;
const output = generate(ast);
console.log(output.code); // var a = "hello";

2. 實(shí)戰(zhàn)：還原混淆數(shù)組+索引跳轉(zhuǎn)代碼

示例混淆代碼：

var _0xabc = ["se", "cret", "Key"];
var key = _0xabc[0] + _0xabc[1] + _0xabc[2];

還原目標(biāo)：把 _0xabc[0] 直接替換成 "se" 等，變成：

var key = "secretKey";

解法思路：

• 找出數(shù)組聲明內(nèi)容，建立索引映射

• 遍歷代碼中所有的 MemberExpression（屬性訪問）

• 如果是 _0xabc[0]，直接替換成 "se" 的字符串字面量

Babel 腳本：

const parser = require('@babel/parser');
const traverse = require('@babel/traverse').default;
const generate = require('@babel/generator').default;
const t = require('@babel/types');

const code = `
var _0xabc = ["se", "cret", "Key"];
var key = _0xabc[0] + _0xabc[1] + _0xabc[2];
`;

const ast = parser.parse(code);

let mapping = {};

traverse(ast, {
  VariableDeclarator(path) {
    if (
      t.isIdentifier(path.node.id) &&
      t.isArrayExpression(path.node.init)
    ) {
      const arrName = path.node.id.name;
      const elements = path.node.init.elements;
      mapping[arrName] = elements.map(e => e.value);
    }
  },

  MemberExpression(path) {
    const obj = path.node.object;
    const prop = path.node.property;

    if (
      t.isIdentifier(obj) &&
      mapping[obj.name] &&
      t.isNumericLiteral(prop)
    ) {
      const value = mapping[obj.name][prop.value];
      path.replaceWith(t.stringLiteral(value));
    }
  }
});

const output = generate(ast);
console.log(output.code);

3. 輔助工具推薦

總結(jié)

AST 是在面對 JS 混淆與參數(shù)還原時(shí)，最強(qiáng)的“靜態(tài)分析武器”，一旦掌握，就能自動還原大量加密、反調(diào)試邏輯，讓 JS 逆向效率質(zhì)變！

四、定位核心參數(shù)生成函數(shù)

在爬蟲、逆向場景中，服務(wù)端通常要求提交一些“加密參數(shù)”：

• 常見名稱有：w、sign、token、auth、xyz、m、h 等

• 這些參數(shù)通過 JS 中隱藏/混淆的函數(shù)生成，是反爬的關(guān)鍵一環(huán)

我們的任務(wù)是定位并還原這些函數(shù)！

1. 典型例子

例如某請求：

POST /api/check
headers:
  w: "e72fa5b18d320...（加密值）"

需要搞清楚：

• 誰生成了 w？

• w 用了哪些參數(shù)（時(shí)間戳、cookie、UA、行為數(shù)據(jù)）？

• 生成函數(shù)是否被混淆？

• 是否用了動態(tài)執(zhí)行（eval、Function）？

• 是否跑在 WebWorker 或 iframe 中？

2. 定位思路總覽

3. 最常用方式詳解

【方法 1】關(guān)鍵字搜索法（適用于未嚴(yán)重混淆）

搜索：

"w="
"sign="
"form.append"
"headers"
"return {"

例子：

var t = get_w(UA, timestamp);
formData.append("w", t);

通過定位 get_w()，再深入分析。

【方法 2】hook fetch / XMLHttpRequest 攔截入?yún)?/strong>

// hook fetch
window.fetch = new Proxy(window.fetch, {
  apply(target, thisArg, args) {
    console.log("[fetch]", args);
    return Reflect.apply(target, thisArg, args);
  }
});

// hook XHR
const open = XMLHttpRequest.prototype.open;
const send = XMLHttpRequest.prototype.send;
XMLHttpRequest.prototype.open = function () {
  this._url = arguments[1];
  return open.apply(this, arguments);
};
XMLHttpRequest.prototype.send = function (body) {
  console.log("[XHR]", this._url, body);
  return send.apply(this, arguments);
};

CryptoJS.MD5(xxx)
CryptoJS.AES.encrypt
btoa()
encodeURIComponent()

CryptoJS.MD5 = function (arg) {
  console.log("[MD5]", arg);
  return originalMD5(arg); // 原函數(shù)
}

Function.prototype.call = new Proxy(Function.prototype.call, {
  apply(target, thisArg, args) {
    console.log("[CALL]", thisArg, args);
    return Reflect.apply(target, thisArg, args);
  }
});

var w = a.b(c, d);  // 參數(shù)生成函數(shù)

const parser = require("@babel/parser");
const traverse = require("@babel/traverse").default;
const fs = require("fs");

const code = fs.readFileSync("./encrypt.js").toString();
const ast = parser.parse(code);

traverse(ast, {
  CallExpression(path) {
    const { callee } = path.node;
    if (
      callee.type === "Identifier" &&
      callee.name === "get_w"  // 可替換成你猜測的函數(shù)名
    ) {
      console.log("Found w generator:", path.toString());
    }
  }
});

function gen_w(ts, cookie, ua) {
  var str = ts + "|" + cookie + "|" + ua;
  return btoa(str);
}

let w = gen_w(Date.now(), document.cookie, navigator.userAgent);