JS `WebAssembly` (Wasm) `Binary Obfuscation` 与 `Deobfuscation`

各位好，今天咱们来聊聊 WebAssembly (Wasm) 的二进制混淆与反混淆，这可是一场猫鼠游戏，看看谁的道更高一筹。别担心，咱们尽量用大白话，把这事儿掰开了揉碎了讲明白。

Wasm 是啥？

首先，简单回顾一下 Wasm。你可以把它想象成一种轻量级的、可移植的字节码，浏览器可以直接执行，而且速度很快。它不是 JavaScript 的替代品，而是它的好伙伴，可以用来运行一些性能敏感的代码，比如游戏、音视频处理、加密解密等等。

为啥要混淆 Wasm？

Wasm 的二进制格式虽然不像源码那么直观，但如果你对 Wasm 结构比较熟悉，还是可以分析出一些关键逻辑的。对于一些商业应用或者需要保护知识产权的应用，我们肯定不希望自己的 Wasm 代码被轻易破解，这时候就需要用到混淆技术。

想象一下，你辛辛苦苦写了一个牛逼的算法，打包成 Wasm 部署到网页上，结果别人轻松一反编译，就把你的核心逻辑给偷走了，这谁受得了？所以，混淆 Wasm 代码，就像给你的代码穿上一层盔甲，增加破解难度。

混淆与反混淆，矛与盾的对抗

混淆和反混淆就像矛与盾，混淆是为了增加代码的复杂性，让反编译出来的代码难以理解，而反混淆则是试图还原代码的原始结构，让代码变得可读。

常见的 Wasm 混淆技术

接下来，我们来看看一些常见的 Wasm 混淆技术，以及如何利用工具或者手动进行混淆。

1. 控制流混淆 (Control Flow Obfuscation)

   控制流混淆是最常用的一种混淆方式，它通过改变代码的执行流程，增加代码的复杂度。

   • 基本块分割 (Basic Block Splitting)：将一个基本块分割成多个更小的基本块，并在它们之间插入无用的跳转指令。

     ;; 原始代码
     (func (export "add") (param i32 i32) (result i32)
       local.get 0
       local.get 1
       i32.add
     )
     
     ;; 混淆后的代码
     (func (export "add") (param i32 i32) (result i32)
       local.get 0
       local.get 1
       i32.add
       br L1
       L1:
       return
     )

     虽然上面的例子很简单，但是可以把 br L1 换成复杂的条件判断，让控制流更加混乱。

   • 不透明谓词 (Opaque Predicates)：插入一些永远为真或永远为假的条件判断，迷惑反编译器的分析。

     ;; 原始代码
     (func (export "is_positive") (param i32) (result i32)
       local.get 0
       i32.const 0
       i32.gt_s
     )
     
     ;; 混淆后的代码
     (func (export "is_positive") (param i32) (result i32)
       local.get 0
       i32.const 0
       i32.gt_s
       i32.const 10  ;; 插入一个常数
       i32.const 5   ;; 插入另一个常数
       i32.add       ;; 加法运算
       i32.const 15  ;; 插入预期结果
       i32.eq        ;; 判断结果是否等于预期值 (永远为真)
       if (result i32)
         local.get 0
         i32.const 0
         i32.gt_s
       else
         i32.const 0  ;; 插入一个永远不会执行的分支
       end
     )

     在这个例子中，i32.const 10、i32.const 5、i32.add、i32.const 15、i32.eq 这一系列操作的结果永远为真，但却可以迷惑反编译器，增加分析难度。

   • 虚假控制流 (Bogus Control Flow)：插入一些永远不会执行的代码块，增加代码的复杂度。

     ;; 原始代码
     (func (export "simple_func") (result i32)
       i32.const 42
     )
     
     ;; 混淆后的代码
     (func (export "simple_func") (result i32)
       i32.const 1
       if (result i32)
         i32.const 42
       else
         i32.const 100  ;; 永远不会执行
       end
     )

     这个例子中，i32.const 100 永远不会被执行，但是它会增加代码的复杂性，让反编译器难以分析。

2. 数据混淆 (Data Obfuscation)

   数据混淆通过改变数据的存储方式和访问方式，增加代码的复杂度。

   • 变量重命名 (Variable Renaming)：将变量名替换成无意义的名称，比如 a, b, c，或者一些随机字符串。

     这个很简单，就不上代码了，直接把有意义的变量名改成 a, b, c 就行了。

   • 常量替换 (Constant Substitution)：将常量替换成表达式，增加代码的复杂度。

     ;; 原始代码
     (func (export "get_constant") (result i32)
       i32.const 42
     )
     
     ;; 混淆后的代码
     (func (export "get_constant") (result i32)
       i32.const 50
       i32.const 8
       i32.sub
     )

     在这个例子中，i32.const 42 被替换成了 i32.const 50 和 i32.const 8 的减法运算，虽然结果一样，但是增加了代码的复杂度。

   • 数组分割与重组 (Array Splitting and Reassembling)：将数组分割成多个小数组，并在访问时进行重组。

     这个比较复杂，需要一些算法来实现，这里只给出一个概念性的例子：

     ;; 假设有一个数组 [1, 2, 3, 4, 5, 6]
     ;; 可以将其分割成两个数组 [1, 3, 5] 和 [2, 4, 6]
     ;; 在访问时，需要根据索引进行计算，才能得到正确的值

3. 指令替换 (Instruction Substitution)

   指令替换用功能相同的其他指令替换原始指令，增加代码的复杂度。

   • 算术指令替换 (Arithmetic Instruction Substitution)：比如用 x + 1 替换 x++。

   • 逻辑指令替换 (Logical Instruction Substitution)：比如用 !(x == 0) 替换 x != 0。

     ;; 原始代码
     (func (export "increment") (param i32) (result i32)
       local.get 0
       i32.const 1
       i32.add
     )
     
     ;; 混淆后的代码
     (func (export "increment") (param i32) (result i32)
       local.get 0
       i32.const -1
       i32.sub
       i32.const 2
       i32.add
     )

     在这个例子中，i32.const 1 和 i32.add 被替换成了 i32.const -1、i32.sub 和 i32.const 2、i32.add，虽然结果一样，但是增加了代码的复杂度。

4. 导入函数混淆 (Import Function Obfuscation)

   通过混淆导入函数的名称和调用方式，增加代码的复杂度。

   • 导入函数重命名 (Import Function Renaming)：将导入函数的名称替换成无意义的名称。

   • 间接调用 (Indirect Call)：通过函数表间接调用导入函数。

     ;; 原始代码
     (import "env" "console.log" (func $log (param i32)))
     (func (export "call_log") (param i32)
       local.get 0
       call $log
     )
     
     ;; 混淆后的代码
     (import "env" "console.log" (func $renamed_log (param i32)))
     (table funcref (elem $renamed_log))
     (func (export "call_log") (param i32)
       local.get 0
       i32.const 0
       call_indirect (type $void_i32)  ;; 假设 $void_i32 是 (type (func (param i32)))
     )

     在这个例子中，导入函数 console.log 被重命名为 renamed_log，并且通过函数表间接调用，增加了代码的复杂度。

5. 元数据混淆 (Metadata Obfuscation)

   修改 Wasm 模块的元数据，比如函数名、类型签名等，增加代码的复杂度。

   • 函数名重命名 (Function Renaming)：将函数名替换成无意义的名称。

   • 类型签名修改 (Type Signature Modification)：修改函数的参数类型和返回值类型。

     ;; 原始代码
     (func $add (export "add") (param i32 i32) (result i32)
       local.get 0
       local.get 1
       i32.add
     )
     
     ;; 混淆后的代码
     (func $renamed_func (export "add") (param i32 i32) (result i32)
       local.get 0
       local.get 1
       i32.add
     )

     在这个例子中，函数名 add 被重命名为 renamed_func，增加了代码的复杂度。

Wasm 混淆工具

• Binaryen: Binaryen 是一个由 WebAssembly 社区维护的编译器工具链，它提供了一些用于优化和转换 Wasm 模块的工具，可以用来实现一些简单的混淆技术。
• Wasm-opt: Wasm-opt 是 Binaryen 中的一个工具，可以用来优化 Wasm 模块，但是也可以通过一些技巧来实现混淆。
• 自定义工具: 可以根据自己的需求开发自定义的 Wasm 混淆工具。

Wasm 反混淆技术

既然有混淆，肯定就有反混淆。反混淆的目标就是尽可能地还原代码的原始结构，让代码变得可读。

1. 静态分析 (Static Analysis)

   静态分析是指在不运行代码的情况下，分析代码的结构和逻辑。

   • 控制流分析 (Control Flow Analysis)：分析代码的控制流图，尝试还原代码的执行流程。
   • 数据流分析 (Data Flow Analysis)：分析代码的数据流，尝试还原变量的含义。
   • 模式识别 (Pattern Recognition)：识别常见的混淆模式，并进行相应的处理。

2. 动态分析 (Dynamic Analysis)

   动态分析是指在运行代码的情况下，观察代码的行为。

   • 调试 (Debugging)：使用调试器单步执行代码，观察代码的执行流程和数据变化。
   • 插桩 (Instrumentation)：在代码中插入一些额外的代码，用于收集代码的运行信息。
   • 符号执行 (Symbolic Execution)：使用符号值代替具体值，模拟代码的执行过程，分析代码的各种可能路径。

3. 反编译器 (Decompiler)

   反编译器可以将 Wasm 字节码转换成可读的源代码，比如 C 语言或者 JavaScript。虽然反编译出来的代码可能不是完全还原原始代码，但是可以帮助我们理解代码的逻辑。

   • Wabt: Wabt (WebAssembly Binary Toolkit) 是一个由 WebAssembly 社区维护的工具链，它提供了一些用于处理 Wasm 模块的工具，其中包括一个反编译器 wasm2wat，可以将 Wasm 字节码转换成 WAT (WebAssembly Text Format) 文本格式。虽然 WAT 不是真正的源代码，但是比 Wasm 字节码更容易阅读。
   • Binaryen: Binaryen 也提供了一个反编译器，可以将 Wasm 字节码转换成 JavaScript 代码。

反混淆的难度

反混淆的难度取决于混淆的强度。如果混淆技术比较简单，那么反混淆也比较容易。如果混淆技术非常复杂，那么反混淆可能需要花费大量的时间和精力，甚至可能无法完全还原代码的原始结构。

一些反混淆的技巧

• 自动化工具: 使用自动化反混淆工具，可以简化反混淆的过程。
• 手动分析: 对于一些复杂的混淆技术，需要手动分析代码，才能理解代码的逻辑。
• 结合静态分析和动态分析: 结合静态分析和动态分析，可以更全面地了解代码的行为。
• 不断学习: 不断学习新的混淆技术和反混淆技术，才能保持竞争力。

代码示例：使用 Binaryen 进行简单的混淆和反混淆

# 安装 Binaryen (假设你已经安装了 Node.js 和 npm)
npm install -g binaryen

# 创建一个简单的 Wasm 模块 (add.wat)
cat <<EOF > add.wat
(module
  (func (export "add") (param i32 i32) (result i32)
    local.get 0
    local.get 1
    i32.add
  )
)
EOF

# 将 WAT 转换成 Wasm
wat2wasm add.wat -o add.wasm

# 使用 wasm-opt 进行简单的混淆 (例如，重命名函数)
wasm-opt add.wasm -O --rename-local-names -o add_obfuscated.wasm

# 将混淆后的 Wasm 转换成 WAT
wasm2wat add_obfuscated.wasm -o add_obfuscated.wat

# 查看混淆后的 WAT 代码
cat add_obfuscated.wat

你会发现函数名和局部变量名都被重命名了，这就是一个简单的混淆。

混淆与反混淆的未来

随着 WebAssembly 的发展，混淆技术和反混淆技术也会不断发展。未来的混淆技术可能会更加复杂，更加难以破解，而反混淆技术也会更加智能，更加高效。

总结

WebAssembly 的二进制混淆与反混淆是一场永无止境的猫鼠游戏。混淆是为了保护代码，反混淆是为了理解代码。掌握混淆技术和反混淆技术，可以帮助我们更好地保护自己的代码，也可以更好地理解别人的代码。

希望今天的讲座对大家有所帮助！记住，安全是一个持续的过程，而不是一个终点。不断学习，不断进步，才能在安全领域立于不败之地。下次再见！