JS `Dead Code Injection` (死代码注入) 与 `Unreachable Code Elimination` (死代码消除) 反制

各位听众，早上好/下午好/晚上好！我是今天的讲师，很高兴能和大家一起聊聊JS安全里一对相爱相杀的小冤家：死代码注入和死代码消除的反制。

咱们今天不搞那些玄乎的概念，直接上干货，用大白话把这俩家伙扒个精光！

Part 1: 死代码注入 (Dead Code Injection) 是个啥？

简单说，死代码注入就是往你的JS代码里塞一堆没用的、永远不会执行的代码。这些代码就像病毒一样，悄悄地藏在你的代码里，干扰分析，增加破解的难度。

为啥要搞死代码注入？

混淆代码，增加逆向难度： 想象一下，你的代码本来只有100行，注入1000行死代码，逆向工程师看到就头大，得先花时间把这些没用的代码剔除出去，才能真正分析你的逻辑。
对抗静态分析： 静态分析工具会扫描你的代码，找出潜在的漏洞。死代码注入可以迷惑这些工具，让它们误判，从而绕过检测。
反调试： 有些死代码可以用来检测调试器，一旦发现调试器，就触发一些反调试的逻辑。

死代码注入的常见套路：

永远为假的条件语句：

if (false) {
    // 这段代码永远不会执行
    console.log("This will never be printed.");
    alert("Gotcha!"); // 干扰分析
}

if (1 > 2) {
    // 另一个例子
    let uselessVariable = "This is a useless variable";
    console.log(uselessVariable);
}

永远无法到达的代码块：

function someFunction() {
    return; // 函数直接返回了

    // 这段代码永远不会执行
    console.log("This is unreachable.");
    throw new Error("Unreachable code");
}

复杂的但无意义的运算：

let x = 10;
let y = x * 0 + 5 - 5 + x * 0; // 结果总是0，但看起来好像很复杂
let z = x + y; // z 等于 x
console.log(z); // 只使用了 z 的值，但 y 的计算是多余的。

无效的循环：

for (let i = 0; i < 0; i++) { // 循环条件一开始就不满足
    console.log("This loop will never run.");
}

包含死代码的函数：

function deadCodeFunction(param) {
  if (typeof param === 'undefined') {
    return;
  }

  if (false) {
    console.log('This is dead code');
    // 一堆复杂的无用代码
    let a = 1;
    let b = 2;
    let c = a + b;
    console.log(c);
  }

  console.log('Function executed with param:', param);
}

deadCodeFunction('alive'); // 调用时传入参数，避免进入死代码区域

Part 2: 死代码消除 (Unreachable Code Elimination) 是个啥？

死代码消除，顾名思义，就是把代码里那些永远不会执行的部分给咔嚓掉。这是编译器和优化器常用的手段，目的是精简代码，提高性能。

为啥要搞死代码消除？

提高代码执行效率： 减少了需要解析和执行的代码量。
减小代码体积： 减少了文件大小，加快加载速度。
简化代码分析： 去掉了干扰，让代码更容易理解和维护。

死代码消除的常见场景：

if (false) 里的代码： 编译器一眼就能看出 false 永远是 false，所以 if 里的代码直接扔掉。
return 语句后面的代码： 函数执行到 return 就结束了，后面的代码自然是死代码。
从未被调用的函数： 如果一个函数定义了，但从来没有被调用过，那它就是死函数，可以安全地移除。

Part 3: 死代码注入 vs. 死代码消除：矛与盾的较量

现在，矛盾来了！一边费尽心思注入死代码，另一边想方设法消除死代码。这就像猫捉老鼠的游戏，永远不会停止。

死代码注入对抗死代码消除：

注入更复杂的死代码： 不再是简单的 if (false)，而是用复杂的逻辑运算、函数调用等来迷惑优化器。
动态生成死代码： 在运行时动态生成死代码，让静态分析工具难以发现。
利用浏览器的特性： 利用某些浏览器的特性，让一些原本应该被消除的死代码得以保留。

死代码消除对抗死代码注入：

更强大的静态分析： 使用更先进的静态分析技术，识别出复杂的死代码模式。
动态分析： 在运行时分析代码的执行情况，找出从未被执行的代码。
机器学习： 利用机器学习算法，学习死代码的特征，从而更准确地识别和消除死代码。

Part 4: 如何反制死代码消除？ (注入更顽固的死代码)

既然死代码消除这么厉害，那我们怎么才能让注入的死代码更顽固，更难被消除呢？这里给大家分享几个技巧：

不透明谓词 (Opaque Predicates)：

这种技术使用一些表达式，它们的值在编译时是已知的，但在运行时很难或不可能确定。换句话说，就是制造一些看起来很复杂的条件，但实际上结果是固定的。

function opaquePredicate() {
  let x = Math.random();
  let y = Math.random();

  // 这个条件看起来很复杂，但结果总是 true 或总是 false
  if (x * x + y * y >= 0) {
    // 这段代码会被执行
    console.log("Opaque predicate is true");
  } else {
    // 这段代码永远不会被执行，但可以用来迷惑分析器
    console.log("Opaque predicate is false");
  }
}

opaquePredicate();

更高级的不透明谓词可以依赖于全局状态或其他难以预测的因素，使静态分析更加困难。

基于控制流的死代码注入：

这种方法通过修改代码的控制流来插入死代码。例如，可以使用 try...catch 语句或复杂的条件语句来创建永远不会到达的代码块。

function controlFlowInjection() {
  try {
    // 故意抛出一个异常
    throw new Error("Intentional error");
  } catch (e) {
    // 捕获异常后，执行一些代码
    console.log("Exception caught");
  } finally {
    // 在 finally 块中插入死代码
    if (false) {
      console.log("This will never be printed");
    }
    console.log("Finally block executed");
  }
}

controlFlowInjection();

finally 块中的 if (false) 语句永远不会执行，但它仍然可以迷惑代码分析器。

基于数据的死代码注入：

这种方法使用一些数据结构或变量来控制死代码的执行。例如，可以使用一个全局变量来决定是否执行某个代码块。
```
let deadCodeFlag = false; // 全局变量

function dataFlowInjection() {
  if (deadCodeFlag) {
    // 这段代码只有当 deadCodeFlag 为 true 时才会执行
    console.log("This is dead code");
  } else {
    console.log("This is alive code");
  }
}

dataFlowInjection(); // 默认情况下，deadCodeFlag 为 false，所以执行 "alive code"
```
虽然这个例子很简单，但可以扩展到更复杂的场景，例如使用一个包含多个标志位的对象，或者从服务器动态获取标志位的值。

多态死代码注入：

利用JS的动态特性，生成看起来相似但行为不同的代码块。

function polymorphicInjection(condition) {
  let codeBlock1 = () => { console.log("Code Block 1"); };
  let codeBlock2 = () => { console.log("Code Block 2"); };

  let selectedCode = condition ? codeBlock1 : codeBlock2;
  selectedCode();

  // 注入死代码
  if (!condition) {
    codeBlock1(); // 这段代码永远不会执行
  } else {
    codeBlock2(); // 这段代码永远不会执行
  }
}

polymorphicInjection(true); // 实际只执行了 Code Block 1
polymorphicInjection(false); // 实际只执行了 Code Block 2

虽然看起来 codeBlock1 和 codeBlock2 都会被执行，但实际上只有根据 condition 选择的代码块会被执行。另一个代码块变成了死代码，但由于多态性，很难被静态分析工具发现。

利用 try…catch 机制：

function tryCatchInjection() {
  try {
    // 有意制造异常，但 catch 块是空的
    throw new Error("Intentional Exception");
  } catch (e) {
    // catch 块是空的
  } finally {
    // 在 finally 块中注入死代码
    if (false) {
      console.log("This is unreachable code in finally block");
    }
  }
}

tryCatchInjection();

尽管 catch 块是空的，finally 块中的死代码仍然可能存在，因为它始终会被执行，即使 try 块中抛出了异常。

利用 Proxy 对象：

function proxyInjection() {
  let target = {};
  let handler = {
    get: function(target, prop, receiver) {
      // 在 get 陷阱中注入死代码
      if (false) {
        console.log("This is dead code in Proxy get");
      }
      return Reflect.get(...arguments);
    }
  };

  let proxy = new Proxy(target, handler);
  proxy.someProperty; // 访问属性
}

proxyInjection();

即使从未访问 someProperty，get 陷阱中的死代码仍然可能被注入，从而增加代码的复杂性。

Part 5: 安全建议：防御死代码注入

虽然我们一直在讨论如何注入死代码，但作为一名负责任的开发者，我们也应该了解如何防御死代码注入。

代码审查： 定期进行代码审查，检查代码中是否存在可疑的、无意义的代码块。
使用静态分析工具： 使用静态分析工具，自动检测代码中的死代码。
代码混淆： 使用代码混淆工具，将代码变得难以理解，从而增加死代码注入的难度。
安全开发流程： 建立完善的安全开发流程，从源头上减少死代码注入的可能性。

总结

死代码注入和死代码消除是一场永无止境的攻防战。掌握这些技术，可以帮助我们更好地保护自己的代码，同时也能更好地理解和分析别人的代码。

特性	死代码注入 (Dead Code Injection)	死代码消除 (Unreachable Code Elimination)
目的	混淆代码，增加逆向难度	优化代码，提高性能
手段	插入无用代码，迷惑分析器	移除无用代码，简化代码
对抗	注入更复杂的死代码，动态生成	使用更强大的分析工具，动态分析，机器学习
防御死代码注入	代码审查，静态分析，代码混淆

希望今天的讲座对大家有所帮助！谢谢大家！咱们下次再见！

发表回复 取消回复

发表回复取消回复