有手就行系列——Cloudflare 5s 盾逆向实战（AST 反混淆 + 加密还原）

window._cf_chl_opt = {
    cvId: '3',
    cZone: 'fastlink.so',
    cType: 'interactive',       // 挑战类型：interactive / managed
    cRay: '9eb833680f13fcf8',   // 请求 Ray ID
    cH: 'j9_nAkRY.6cKOoF...',  // 挑战哈希
    cFPWv: 'g',                 // 路径前缀标识：g 或 b
    cITimeS: '1776059505',      // 服务器时间戳
    md: '...',                  // 挑战元数据（超长字符串）
    cTplC: 0,
    cTplO: 0,                   // 新增属性
    cTplV: 5,
    cTplB: '0',
    // ...
};

// null → [110, 117, 108, 108]  即 "null"
// true → [116, 114, 117, 101]  即 "true"
// string → 引号包裹 + UTF-8 编码 + JSON 转义处理
// object → {key:value} 递归，用 hasOwnProperty 遍历

// 硬编码的 RSA 公钥（实测 2025.08 和 2026.04 完全一致）
n = BigInt('0x00e9d3dca1328a49ad3403e4badda37a6a...')  // 128 字节模数
e = BigInt(65537)

// 生成 128 字节随机密钥 Lw
let Lw = new Uint8Array(128);
crypto.getRandomValues(Lw);
Lw[0] = 0;  // 确保 < n

// RSA 加密：LH = Lw^e mod n（快速幂）

// 动态生成后立即覆盖
Lw = new Uint8Array([0, 171, 50, 168, 12, 105, 110, 252, ...]);
LH = [109, 128, 145, 132, 21, 62, 137, 240, ...];

// 对第 i 个 8 字节块：
// 1. 生成两个 counter
counter1 = [0, 0, 0, 0, 0, 0, 0, i & 0xFF]
counter2 = [0, 0, 0, 0, 0, 0, 0, (i+1) & 0xFF]

// 2. TEA 加密 counter 生成密钥流
TEA_Encrypt(counter1, keySlice)   // → 8 字节
TEA_Encrypt(counter2, keySlice)   // → 8 字节

// 3. 拼成 16 字节作为密钥，再次 TEA 加密数据块
teaKey = counter1.concat(counter2)
TEA_Encrypt(dataBlock, teaKey)

P[1] << 16.02   // 等价于 P[1] << 16
F >>> 8.76      // 等价于 F >>> 8
255.45 & O      // 等价于 255 & O

~function (yG, JU, Jz, ...) {
  for (yG = I, function (J, T, DF, ya, l, D) {
    for (DF = { J: 1107, T: 1295, ... }, ya = I, l = J(); !![];) try {
      if (D = parseInt(ya(DF.J)) / 1 * (parseInt(ya(DF.T)) / 2) + ...) break;
      else l.push(l.shift())
    } catch (C) { l.push(l.shift()) }
  }(U, 471818), ...

// Babel AST 遍历：寻找 "xxx".split("!") 模式
traverse(ast, {
  AssignmentExpression(path) {
    const { left, right } = path.node;
    if (t.isCallExpression(right) &&
        right.callee.property?.name === "split" &&
        right.callee.object.value?.length > 100) {
      global.stringArray = right.callee.object.value.split(right.arguments[0].value);
      // 找到了，数组长度 1509
    }
  }
});

traverse(ast, {
  ReturnStatement(path) {
    const exprs = path.node.argument?.expressions;
    if (exprs?.length === 3 && exprs.slice(0,2).every(t.isAssignmentExpression)) {
      global.offsetIndex = exprs[0].right.right.value;  // 如 291
    }
  }
});

// 提取 shuffle 函数 + 辅助函数，本地 eval 执行
const runCode = `
let ${funcName} = function() {
   let arr = ${JSON.stringify(stringArray)};
   ${funcName} = () => arr;
   return arr;
};
${helperFunction}
!${shuffleCode}
${funcName}()
`;
stringArray = eval(runCode);  // 得到正确顺序

// 形式 A：通过中间变量映射
NK = { W: 1186, J: 735 }
obj[decode(NK.W)]  →  obj["addEventListener"]

// 形式 B：直接函数调用
yG(533)  →  "document"

traverse(ast, {
  CallExpression(path) {
    const { callee, arguments: args } = path.node;
    // yG(533) → 直接替换
    if (t.isIdentifier(callee) && args.length === 1 && t.isNumericLiteral(args[0])) {
      path.replaceWith(t.stringLiteral(decodeString(args[0].value)));
    }
  }
});

// 混淆前定义
'pXsvz': function(f, j) { return f & j; }
// 混淆后调用
J['pXsvz'](C, 255)  // 实际就是 C & 255

function isObfuscatedFunction(node) {
  return node.type === "FunctionExpression" &&
         node.body.body.length === 1 &&
         node.body.body[0].type === "ReturnStatement" &&
         ["BinaryExpression", "LogicalExpression", "UnaryExpression"]
           .includes(node.body.body[0].argument.type);
}

// 定义
'TqoiZ': function(n, P) { return n(P); }
// 调用
K['TqoiZ'](realFunc, arg1)  →  realFunc(arg1)

if (paramList.length - 1 === newExpr.arguments.length) {
  newExpr.callee = t.cloneNode(paramList[0], true);
  for (let i = 1; i < paramList.length; i++) {
    newExpr.arguments[i - 1] = t.cloneNode(paramList[i], true);
  }
  path.replaceWith(newExpr);
}

if ('abc' === 'def') { /* 垃圾代码 */ } else { /* 真实逻辑 */ }

traverse(ast, {
  IfStatement(path) {
    const { test, consequent, alternate } = path.node;
    if (t.isBinaryExpression(test) && bothSidesAreLiterals(test)) {
      const result = evaluateConstant(test);
      result ? path.replaceWithMultiple(consequent.body)
             : alternate ? path.replaceWithMultiple(alternate.body) : path.remove();
    }
  }
});

// 混淆后
for (c = "4|5|0|2|3|1".split('|'), J = 0; !![];) {
  switch (c[J++]) {
    case '0': step0(); continue;
    case '1': step1(); continue;
    // ...
  }
  break;
}
// 还原后，按 4→5→0→2→3→1 顺序展开
step4(); step5(); step0(); step2(); step3(); step1();

// 寄存器访问 (205次)
this.h[131 ^ this.g][3]
this.h[this.g ^ 234]

// 字节码读取
this.h[131 ^ this.g][1]["charCodeAt"](this.h[131 ^ this.g][0]++)

// 操作码分发
if (Q === 175) { /* 操作 A */ }
else if (24 !== Q) {
  if (101 === Q) { /* 操作 B */ }
} else { /* 操作 C */ }