WebAssembly

概述

WebAssembly（简称 Wasm）是一项为现代 Web 打造的底层、高性能、可移植的字节码格式。它允许使用 C、C++、Rust 等语言编写的代码，在浏览器中以接近原生应用的速度运行

核心优势

  • 🚄 高性能：Wasm 是一种紧凑的二进制格式，能被浏览器快速解码和编译为机器码。执行效率接近原生程序，非常适合处理计算密集型任务

  • 🛡️ 高安全性：Wasm 代码运行在一个内存安全的沙箱环境中。它无法直接访问系统内存或执行危险操作，并遵循浏览器同源策略，有效保障了用户安全

  • 🌍 可移植性：作为一套 “虚拟指令集架构”，Wasm 代码不依赖特定硬件或操作系统，编译一次即可在各种主流平台（Windows、macOS、Linux）和设备上运行

  • 🔧 语言无关性：它不偏爱任何特定编程语言，可作为 C++、Rust、Go、Python 等多种语言的通用编译目标，让开发者可以用熟悉的语言编写高性能 Web 应用

工作原理

  • 编写源码：开发者使用 C、C++、Rust 等语言编写程序逻辑

  • 编译为 Wasm：通过 Emscripten、wasm-ld 等工具链，将源码编译为 .wasm 的二进制字节码文件

  • 加载与执行：Web 应用通过 JavaScript API（如 WebAssembly.instantiateStreaming()）获取并实例化 Wasm 模块

  • 无缝互操作：实例化后，JavaScript 可以调用 Wasm 模块中的函数，Wasm 模块也能回调 JavaScript 函数或调用 Web API

实战案例

webassembly（WASM + XTEA）

pasted_1787337390400_2yzrch.png

WASM 不能直接使用 IDA 打开逆向，需要先转为 C

1
wasm2c webassembly.wasm -o webassembly.c

pasted_1787340390175_wjebfm.png

定位到 main() 函数

pasted_1787369910279_k1dkuj.png

关键是其中调用的 f15() 函数，在其中看到 var_i3 = 2654435769u;，十六进制是 0x9e3779b9，这是 XTEA/TEA 的经典 delta

函数开头将 Key[4] 设置为了 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 从内存地址 var_i0 开始，将连续的 16 字节（128 位）内存空间全部清零
var_i0 = var_l5;                     // 从局部变量 l5 获取内存偏移地址
var_j1 = 0ull;                       // 要存储的 64 位常量值（零）
i64_store(                           // 执行 64 位整数存储操作
    instance->w2c_env_memory,        // 目标线性内存的基址（来自环境模块）
    (u64)(var_i0),                   // 内存偏移地址（转换为 64 位）
    var_j1                           // 待写入的 64 位值（0）
);

i64_store(                           // 在偏移 +8 处存储另一个 64 位零值
    instance->w2c_env_memory,        // 线性内存基址
    (u64)(var_i0)+8,                 // 偏移地址后移 8 字节（连续存储第二个64位字段）
    var_j1                           // 值仍为 0
);

加密则是将 0-31 字节分成了四组分别进行 XTEA 加密（AI 给出的，代码太复杂了）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 第一组
offset 0
offset 4

// 第二组
offset 8
offset 12

// 第三组
offset 16
offset 20

// 第四组
offset 24
offset 28

代码最后则是在做异或处理，例如第 34 位

1
2
3
4
5
var_i1 = i32_load8_s(... +34u);

var_i2 = 99u;

var_i1 ^= var_i2;

将异或的数值提取出来

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
xor_table = [
    0xff,   # 0
    0xff,   # 1
    28,     # 2
    0xed,   # 3
    30,     # 4
    11,     # 5
    115,    # 6
    8,      # 7
    122,    # 8
    0xdf,   # 9
    0xb2,   # 10
    29,     # 11
    0xad,   # 12
    0xf2,   # 13
    0xea,   # 14
    0xa0,   # 15
    0xa2,   # 16
    83,     # 17
    23,     # 18
    0xb2,   # 19
    58,     # 20
    63,     # 21
    0xf0,   # 22
    0xe6,   # 23
    0xfa,   # 24
    68,     # 25
    0xd8,   # 26
    0xbe,   # 27
    82,     # 28
    123,    # 29
    0x80,   # 30
    48,     # 31
    98,     # 32
    98,     # 33
    99,     # 34
    98,     # 35
    57,     # 36
    125     # 37
]

编写脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
"""
f15 中发现：
   - 前 32 字节输入进入 XTEA 加密
   - key 为 16 字节全 0
   - XTEA 32 轮
   - 后 6 字节不参与加密
"""

import struct


DELTA = 0x9e3779b9

# uint32 最大范围，因为 C 中 unsigned int 溢出，Python 需要手动截断
MASK = 0xffffffff

key = [0, 0, 0, 0]

tmp = [
    149, 150, 104, 231,
    183, 85, 23, 201,
    173, 3, 30, 207,
    111, 197, 97, 75,
    2, 144, 253, 45,
    34, 237, 10, 147,
    48, 126, 201, 236,
    140, 150, 177, 224,
    101, 54, 56, 98,
    98, 125
]

# 转换成 byte，&0xff 恢复真实 byte
tmp = bytes([x & 0xff for x in tmp])


# ============================================================
# XTEA 解密函数
# ============================================================

def xtea_decrypt(v0, v1):
    """
    对应 wasm 中 f15 的 XTEA 逆过程

    输入:
        v0: 4字节
        v1: 4字节

    一个 block: 8 bytes

    XTEA: 64 bit block, 32 rounds
    """
    # 加密时 sum 从 0 开始，每轮 sum += delta
    # 解密需要从 delta*32 开始反推
    sum_ = (DELTA * 32) & MASK

    for _ in range(32):
        # 逆向第二步：对应 XTEA 中的 v1 += ...，现在反向 v1 -= ...
        v1 = (
            v1 -
            (
                (
                    (
                        (v0 << 4) ^ (v0 >> 5)
                    ) + v0
                ) ^ (
                    sum_ + key[(sum_ >> 11) & 3]
                )
            )
        ) & MASK

        # sum 反向减少 delta
        sum_ = (sum_ - DELTA) & MASK

        # 逆向第一步：对应 XTEA 中的 v0 += ...，现在反向 v0 -= ...
        v0 = (
            v0 -
            (
                (
                    (
                        (v1 << 4) ^ (v1 >> 5)
                    ) + v1
                ) ^ (
                    sum_ + key[sum_ & 3]
                )
            )
        ) & MASK

    return v0, v1

flag = b""

# 前 32 字节分成 4 个 XTEA block，每个 block: 4 bytes v0, 4 bytes v1
# WASM i32.load 默认 little endian，所以使用 "<2I"
for i in range(0, 32, 8):
    block = tmp[i:i+8]

    # 按照 wasm 内存方式解析
    v0, v1 = struct.unpack("<2I", block)

    # XTEA 解密
    v0, v1 = xtea_decrypt(v0, v1)

    # 重新按照 little endian 写回
    flag += struct.pack("<2I", v0, v1)

# ============================================================
# 后 6 字节
# ============================================================

# f15 中 offset 32~37 没有进入 XTEA，只是参与checksum，所以直接拼接
flag += tmp[32:]

# 输出最终 flag
print(flag)
print(flag.decode())

pasted_1787374944985_kx48wj.png