XTEA

概述

XTEA 由剑桥大学计算机实验室的戴维·惠勒（David Wheeler） 和罗杰·李约瑟（Roger Needham） 设计。算法于 1997 年在一份未发表的技术报告中首次提出，并且没有申请任何专利，属于公共领域

核心参数

参数 详情
算法类型 对称分组密码（Symmetric Block Cipher）
分组大小 64位（8字节）
密钥长度 128位（16字节）
推荐轮数 64轮（即32个周期）
结构 Feistel网络结构

工作原理

XTEA的加密过程可以概括为以下步骤：

  • 密钥初始化：将 128 位的密钥分成四个 32 位的子密钥 K[0] 到 K[3]

  • 数据分组：将 64 位的明文分成左右两个 32 位的部分 V0 和 V1

  • 迭代加密：算法会进行多轮（推荐 64 轮）迭代。每一轮的核心运算是：

    • 使用加法、异或和移位操作

    • 每轮都会使用一个由固定常量 DELTA 和轮数计算出的动态值 SUM 来选择并使用不同的子密钥

  • 一个关键的固定常量是 DELTA = 0x9E3779B9

  • 输出密文：完成所有轮次后，V0 和 V1 组合成的 64 位数据即为密文

解密过程与加密过程对称，使用相同的密钥但以相反的顺序执行操作

实战案例

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