2019 强网杯 WriteUp

🏛️ 组织架构

  • 指导单位：中央网信办网络安全协调局

  • 主办单位：河南省互联网信息办公室、郑州市人民政府、信息工程大学

  • 支持/协办单位：教育部网络空间安全专业教学指导委员会

  • 承办单位：郑州市高新区管委会

🥇 线下赛最终排名（前三名及部分高校）

  • 冠军：腾讯 eee 战队（腾讯安全）

  • 亚军：0×300 战队（长亭科技）

  • 季军：TsingQian 战队（清华大学-奇安信联合研究中心）

  • 总排名第六：白泽战队（复旦大学）

  • 总排名第十五：Nebula 战队（中国科学技术大学）

Misc

强网先锋-打野（Steg 隐写）

Reverse

强网先锋_AD（签到）

Base64 解码即可

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

Crypto

强网先锋-辅助（共素数攻击）

题目中的关键代码，它只重新生成了 p，但是没有重新生成 q

1
2
p = getPrime(1024)
n = p * q
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
from math import gcd

def long_to_bytes(n):
    return n.to_bytes((n.bit_length() + 7) // 8, "big")

def bytes_to_long(b):
    return int.from_bytes(b, "big")


c1 = 2482083893746618248544426737023750400124543452082436334398504986023501710639402060949106693279462896968839029712099336235976221571564642900240827774719199533124053953157919850838214021934907480633441577316263853011232518392904983028052155862154264401108124968404098823946691811798952747194237290581323868666637357604693015079007555594974245559555518819140844020498487432684946922741232053249894575417796067090655122702306134848220257943297645461477488086804856018323986796999103385565540496534422406390355987976815450744535949785073009043007159496929187184338592859040917546122343981520508220332785862546608841127597

n1 = 14967030059975114950295399874185047053736587880127990542035765201425779342430662517765063258784685868107066789475747180244711352646469776732938544641583842313791872986357504462184924075227433498631423289187988351475666785190854210389587594975456064984611990461126684301086241532915267311675164190213474245311019623654865937851653532870965423474555348239858021551589650169602439423841160698793338115204238140085738680883313433574060243600028500600824624358473403059597593891412179399165813622512901263380299561019624741488779367019389775786547292065352885007224239581776975892385364446446185642939137287519945974807727

c2 = 3829060039572042737496679186881067950328956133163629908872348108160129550437697677150599483923925798224328175594483217938833520220087230303470138525970468915511111320396185482564783975435346354440035776909781158407636044986403819840648379609630039348895415045723208843631191252142600667607807479954194447237061080618370787672720344741413537975922184859333432197766580150534457001196765621678659952108010596273244230812327182786329760844037149719587269632133595149294067490955644893402708720284179715002149224068928828656515326446881791228638008572889331511945042911372915003805505412099102954073299010951896955362470

n2 = 14624662628725820618622370803948630854094687814338334827462870357582795291844925274690253604919535785934208081825425541536057550227048399837243392490762167733083030368221240764693694321150104306044125934201699430146970466657410999261630825931178731857267599750324918610790098952520113593130245010530961350592735239454337631927669542026935873535964487595433984902529960726655481696404006628917922241666148082741874033756970724357470539589848548704573091633917869387239324447730587545472564561496724882799495186768858324490838169123077051890332313671220385830444331578674338014080959653201802476516237464651809255679979

e = 65537

# 1. 计算公共因子
q = gcd(n1, n2)

print("[+] gcd(n1, n2) =", q)
print("[+] q bit length =", q.bit_length())

assert q != 1
assert n1 % q == 0
assert n2 % q == 0

# 2. 分解 n1
p1 = n1 // q

print("[+] p1 bit length =", p1.bit_length())

# 3. 计算 phi
phi1 = (p1 - 1) * (q - 1)

assert gcd(e, phi1) == 1

# 4. 求私钥 d
d = pow(e, -1, phi1)

# 5. 解密
m = pow(c1, d, n1)

flag = long_to_bytes(m)

print("[+] flag =", flag)

# 6. 顺手验证第二组已知明文
known_m = bytes_to_long(b"1" * 32)
assert pow(known_m, e, n2) == c2
print("[+] known plaintext check passed")