02 逆向工程入门指北#

文件提示：

现在，用 IDA 打开本题的附件，开始我们的第一个挑战吧！

P.S. 附件使用C++编写，有很多正常人看不懂的东西，不过或许 shift+F12 能帮到你？

moectf{open_your_IDA_and_start_reverse_engineering!!}

03 base#

IDA打开，找到main函数

查看sub_140001070函数

是一个完全遵循Base64编码的标准算法流程

使用strcmp函数，将 sub_140001070 返回的字符串v7与一个硬编码的字符串**“bW9lY3Rme1kwdV9DNG5fRzAwZF9BdF9CNDVlNjQhIX0=“**进行比较。

moectf{Y0u_C4n_G00d_At_B45e64!!}

10 A cup of tea#

搜索main函数无果，shift6+F12搜索字符串

我们看到主函数在sub_1400162E0里，继续点击

v5是密钥，v6是数组，加密逻辑在sub_14001109B里

每一轮使用 delta（这里是 1131796）和 key 进行混淆，逆解密

1
from typing import List, Tuple
2

3
DELTA = 1131796  # 0x114514 as seen in the binary (decimal 1131796)
4

5
def u32(x: int) -> int:
6
    return x & 0xFFFFFFFF
7

8
def tea_decrypt_block(v0: int, v1: int, k: List[int], rounds: int = 32) -> Tuple[int, int]:
9
    v0 = u32(v0)
10
    v1 = u32(v1)
11
    k = [u32(x) for x in k]
12
    sum_ = u32(DELTA * rounds)
13
    for _ in range(rounds):
14
        v1 = u32(v1 - (((v0 >> 5) + k[3]) ^ (sum_ + v0) ^ ((v0 << 4) + k[2])))
15
        v0 = u32(v0 - (((v1 >> 5) + k[1]) ^ (sum_ + v1) ^ ((v1 << 4) + k[0])))
16
        sum_ = u32(sum_ - DELTA)
17
    return v0, v1
18

19
def tea_encrypt_block(v0: int, v1: int, k: List[int], rounds: int = 32) -> Tuple[int, int]:
20
    v0 = u32(v0)
21
    v1 = u32(v1)
22
    k = [u32(x) for x in k]
23
    sum_ = 0
24
    for _ in range(rounds):
25
        sum_ = u32(sum_ + DELTA)
26
        v0 = u32(v0 + (((v1 >> 5) + k[1]) ^ (sum_ + v1) ^ ((v1 << 4) + k[0])))
27
        v1 = u32(v1 + (((v0 >> 5) + k[3]) ^ (sum_ + v0) ^ ((v0 << 4) + k[2])))
28
    return v0, v1
29

30
def words_to_bytes_le(words: List[int]) -> bytes:
31
    return b"".join(w.to_bytes(4, "little") for w in words)
32

33
def main():
34
    key = [289739801, 427884820, 1363251608, 269567252]
35
    v6 = [
36
        2026214571,
37
        578894681,
38
        1193947460,
39
        -229306230,
40
        73202484,
41
        961145356,
42
        -881456792,
43
        358205817,
44
        -554069347,
45
        119347883,
46
        0,
47
    ]
48
    v6_u = [u32(x) for x in v6]
49
    ciphertext_words = v6_u[:10]
50
    plaintext_words = []
51
    for i in range(0, len(ciphertext_words), 2):
52
        p0, p1 = tea_decrypt_block(ciphertext_words[i], ciphertext_words[i+1], key)
53
        plaintext_words.extend([p0, p1])
54
    pt_bytes = words_to_bytes_le(plaintext_words)
55
    flag = pt_bytes.split(b"\x00", 1)[0].decode('utf-8', errors='replace')
56
    print("Recovered flag string:", flag)
57

58
    re_cipher_words = []
59
    for i in range(0, len(plaintext_words), 2):
60
        c0, c1 = tea_encrypt_block(plaintext_words[i], plaintext_words[i+1], key)
61
        re_cipher_words.extend([c0, c1])
62
    print("Verification success?", re_cipher_words == ciphertext_words)
63

64
if __name__ == '__main__':
65
    main()

moectf{h3r3_4_cuP_0f_734_f0R_y0U!!!!!!}

11 ezpy#

简单的pyc逆向

通过命令

1
uncompyle6 ezpy.pyc >ezpy.py

看到生成了ezpy.py

打开ezpy.py文件

实际就是 shift = 10 的凯撒加密，只要把目标字符串只要把目标字符串 “wyomdp{I0e_Ux0G_zim}” 逆向 Caesar -10 就行。

1
def caesar_cipher_decrypt(text, shift):
2
    result = []
3
    for char in text:
4
        if char.isalpha():
5
            if char.islower():
6
                new_char = chr((ord(char) - ord("a") - shift) % 26 + ord("a"))
7
            else:
8
                if char.isupper():
9
                    new_char = chr((ord(char) - ord("A") - shift) % 26 + ord("A"))
10
            result.append(new_char)
11
        else:
12
            result.append(char)
13
    return "".join(result)
14

15

16
if __name__ == "__main__":
17
    encrypted = "wyomdp{I0e_Ux0G_zim}"
18
    shift = 114514 % 26  # 实际等效移位量 = 10
19
    flag = caesar_cipher_decrypt(encrypted, shift)
20
    print("解密结果:", flag)

moectf{Y0u_Kn0W_pyc}

13 mazegame#

IDA打开，定位到主函数，是一个迷宫，需要找到从起始点 **(1, 1)** 到终点 **(32, 15)** 的一条有效路径

迷宫地图在sub_1400010E0函数里

提取出，并按顺序排好

1
11111111111111111111111111111111111111111111111111111111
2
10100000000000000010000011011101011111111101011100000111
3
10111010111111111010111011000001000001000001000101110111
4
10000010000010000010001011011111111101110111011101110111
5
10111111111011101110111011010000000000010100010001110111
6
10100000001000101000100011010101111111011101110101110111
7
10101011111110111011101011010101000001000000010101110111
8
10101010000010100000101011110101110101111101111111110111
9
10111010111010101111101011100101000100000101000101110111
10
10000010001010001000001011001111011111010101011101110111
11
11111011101011111011111111101000100000101100101001110111
12
10001010001000100010000010001010011000100010010011000001
13
10111010111110101010111011011001011111010101011101011101
14
10001010001000001010001011000101000100000101000101011101
15
11101011101111111011101011110101110111111101110101011101
16
10001000101000001010001011000100010100000101000101011101
17
10111111101011101110111011011111110101110111011101011101
18
10001000001000100000001011000100000100010000000101011001
19
11101011111011111111101011110101111101111111110101011011
20
10101000000010001000101011010100000001000100010101011011
21
10101111111110101010101011010111111111010101010101011011
22
10100000000000100010101011010000000000010001010101011011
23
10111111111111111110111011011111111111111111011101011011
24
10000000001111000000000011110111010000111100011111011011
25
11101111100000011011011111111010110111011101100001011011
26
11101111111111111011011111111101110111101101100001011011
27
10001000111111000010000011111010110111011101100001011011
28
10111010111111111010111011110111010000111101100001010011
29
10000010000010000010001011111111111111111101100001010111
30
10111111111011101110111011110001000110001101100001010001
31
10100000001000101000100011110111011101111101100001011101
32
10101011111110111011101011110001000101111101100001011101
33
10101010000010100000101011111101011101111101100001011101
34
10111010111010101111101011110001000110001101100001011101
35
10000010001010101000001011111111111111111101100001011101
36
11111011101011111011111110000000000000001101100001011101
37
10001010001000100010000011111111111111111100110011011101
38
10111010111110101010111010010000000011111110001111011101
39
10001010001000001010001010110111000001111110100101011101
40
11101011101111111011101000110011001111111100110111011101
41
10001000101000001010001011111111111111111111110111010001
42
10111111101011101110111010100001001100000000000011011011
43
10001000001000100000001011111111111101011101111001011011
44
10101011111011111111101011000000000001000100010111011011
45
10101000000010001000101010010111111111111111111111011011
46
10101111111110101010101010110111111111111111111101011011
47
10100000000000100010101011100000000000000000000011011011
48
10111111111111111110011011111111111111111111111011011011
49
10000011111111111111000010000000000000000000000000011001
50
11111011111111111111111111111111111111111111111111111101
51
11111011100001100110110111000000000000000000000111111101
52
11111011101111011010000111011111111111111111110111111101
53
11111011100001000010110110000111111111111111110000000001
54
11111011101111011010110111101111111111111111111111111111
55
11110000000000011000110000000000000000000000000000000011
56
11111111111111111111111111111111111111111111111111111111

用BFS算法寻路

1
from collections import deque
2

3
def find_maze_path(maze, start, end):
4
    # maze: 56x56的迷宫地图（'0'和'1'的二维列表）
5
    # start: 起点坐标 (x, y)
6
    # end: 终点坐标 (x, y)
7

8
    rows = len(maze)
9
    cols = len(maze[0])
10

11
    # 移动方向：上、下、左、右
12
    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)] # (dx, dy)
13

14
    # 队列用于BFS
15
    queue = deque([start])
16

17
    # 集合用于记录已访问的节点
18
    visited = {start}
19

20
    # 字典用于回溯路径
21
    parent = {start: None}
22

23
    while queue:
24
        current_x, current_y = queue.popleft()
25
        current_node = (current_x, current_y)
26

27
        # 检查是否到达终点
28
        if current_node == end:
29
            return reconstruct_path(parent, start, end)
30

31
        # 探索所有可能的移动方向
32
        for dx, dy in directions:
33
            next_x, next_y = current_x + dx, current_y + dy
34
            next_node = (next_x, next_y)
35

36
            # 检查移动是否有效
37
            if 0 <= next_x < cols and 0 <= next_y < rows and \
38
               maze[next_y][next_x] == '0' and next_node not in visited:
39

40
                visited.add(next_node)
41
                queue.append(next_node)
42
                parent[next_node] = current_node
43

44
    return None
45

46
def reconstruct_path(parent_map, start, end):
47
    path = []
48
    current = end
49
    while current:
50
        path.append(current)
51
        current = parent_map[current]
52

53
    path.reverse()
54

55
    instructions = []
56
    for i in range(len(path) - 1):
57
        x1, y1 = path[i]
58
        x2, y2 = path[i+1]
59

60
        if x2 > x1:
61
            instructions.append('D')
62
        elif x2 < x1:
63
            instructions.append('A')
64
        elif y2 > y1:
65
            instructions.append('S')
66
        elif y2 < y1:
67
            instructions.append('W')
68

69
    return "".join(instructions)
70

71
maze_map_strings = [
72
    "11111111111111111111111111111111111111111111111111111111",
73
    "10100000000000000010000011011101011111111101011100000111",
74
    "10111010111111111010111011000001000001000001000101110111",
75
    "10000010000010000010001011011111111101110111011101110111",
76
    "10111111111011101110111011010000000000010100010001110111",
77
    "10100000001000101000100011010101111111011101110101110111",
78
    "10101011111110111011101011010101000001000000010101110111",
79
    "10101010000010100000101011110101110101111101111111110111",
80
    "10111010111010101111101011100101000100000101000101110111",
81
    "10000010001010001000001011001111011111010101011101110111",
82
    "11111011101011111011111111101000100000101100101001110111",
83
    "10001010001000100010000010001010011000100010010011000001",
84
    "10111010111110101010111011011001011111010101011101011101",
85
    "10001010001000001010001011000101000100000101000101011101",
86
    "11101011101111111011101011110101110111111101110101011101",
87
    "10001000101000001010001011000100010100000101000101011101",
88
    "10111111101011101110111011011111110101110111011101011101",
89
    "10001000001000100000001011000100000100010000000101011001",
90
    "11101011111011111111101011110101111101111111110101011011",
91
    "10101000000010001000101011010100000001000100010101011011",
92
    "10101111111110101010101011010111111111010101010101011011",
93
    "10100000000000100010101011010000000000010001010101011011",
94
    "10111111111111111110111011011111111111111111011101011011",
95
    "10000000001111000000000011110111010000111100011111011011",
96
    "11101111100000011011011111111010110111011101100001011011",
97
    "11101111111111111011011111111101110111101101100001011011",
98
    "10001000111111000010000011111010110111011101100001011011",
99
    "10111010111111111010111011110111010000111101100001010011",
100
    "10000010000010000010001011111111111111111101100001010111",
101
    "10111111111011101110111011110001000110001101100001010001",
102
    "10100000001000101000100011110111011101111101100001011101",
103
    "10101011111110111011101011110001000101111101100001011101",
104
    "10101010000010100000101011111101011101111101100001011101",
105
    "10111010111010101111101011110001000110001101100001011101",
106
    "10000010001010101000001011111111111111111101100001011101",
107
    "11111011101011111011111110000000000000001101100001011101",
108
    "10001010001000100010000011111111111111111100110011011101",
109
    "10111010111110101010111010010000000011111110001111011101",
110
    "10001010001000001010001010110111000001111110100101011101",
111
    "11101011101111111011101000110011001111111100110111011101",
112
    "10001000101000001010001011111111111111111111110111010001",
113
    "10111111101011101110111010100001001100000000000011011011",
114
    "10001000001000100000001011111111111101011101111001011011",
115
    "10101011111011111111101011000000000001000100010111011011",
116
    "10101000000010001000101010010111111111111111111111011011",
117
    "10101111111110101010101010110111111111111111111101011011",
118
    "10100000000000100010101011100000000000000000000011011011",
119
    "10111111111111111110011011111111111111111111111011011011",
120
    "10000011111111111111000010000000000000000000000000011001",
121
    "11111011111111111111111111111111111111111111111111111101",
122
    "11111011100001100110110111000000000000000000000111111101",
123
    "11111011101111011010000111011111111111111111110111111101",
124
    "11111011100001000010110110000111111111111111110000000001",
125
    "11111011101111011010110111101111111111111111111111111111",
126
    "11110000000000011000110000000000000000000000000000000011",
127
    "11111111111111111111111111111111111111111111111111111111",
128
]
129
maze_map = [list(row) for row in maze_map_strings]
130

131
start_point = (1, 1)
132
end_point = (32, 15)
133

134
path_instructions = find_maze_path(maze_map, start_point, end_point)
135

136
if path_instructions:
137
    print("找到了路径!")
138
    print(path_instructions)
139
else:
140
    print("没有找到路径。")

moectf{SSDDDDWWDDSSDDDDSSDDSSSSDDWWDDWWDDWWWWDDDDSSSSAASSSSAAAASSAASSAAWWAAWWWWAAAASSDDSSAASSDDSSSSAAAASSDDDDDDWWWWDDDDSSDDDDWWDDWWAAWWDDDDSSSSSSSSSSSSAAASSSDDDSSSSAASSSSAAAASSAASSAAWWAAWWWWAAAASSDDSSAASSDDSSSSAAAASSDDDDDDWWWWDDDDSSDDDDWWDDWWAAWWDDDDSSSSSSSSSSSSAAAWAWWWAASSAAWWAASSAAAAAAAAAAWWWWAASSSSSSDDDDSSSSSSDDDDDDDDDWWDDDSSDDWWWDDDSSSDDDDDWWAWWDDDDDDDDDDDDDDDDDDDDSSDDDDDDDDWWWWAWWWWWWWWDWWWWWWWWWWWAAWWDWWWWWWWWWWDWWWWWWAAAASSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSAAAWWAAAAAAAAAAAAAAAAAAAWWWDDDDDDDDWWDDDDDDDDDDWWWAWAAWAWWWWWWWWWWWWWDDWWWWAASSAAWWAASSAAAAAAAAAAWWWWAAWWDDWWAAWWDWWWDWWWWDDDDDDDDDDSSDDDDSSSSDSDSSDDSSAASSAAAAWWAAAASSSSAAAAAAWWDDDDWWWWAAWWAWAASSDSSSDD}

17 Two cup of tea#

IDA打开定位主函数

数组v15是加密后的数据，v10是key，但经过函数处理的才是我们需要的

打开sub_140001070函数

它的作用就是：

生成/混淆出 XXTEA 所需的前半部分 key。

1
key = [final_low, final_high, 0x12345678, 0x9ABCDEF0];

之后是加密函数sub_1400015E0，是一个改造过的 XXTEA 解密实现，固定迭代 11 轮。

解密脚本

1
def xxtea_decrypt_uint32(v, key):
2
    n = len(v)
3
    delta = 0x9E3779B9
4
    q = 11  # 题里固定跑 11 轮
5
    sum_ = (q * delta) & 0xFFFFFFFF
6

7
    while q > 0:
8
        e = (sum_ >> 2) & 3
9
        for p in range(n-1, -1, -1):
10
            z = v[p-1] if p > 0 else v[-1]
11
            y = v[p]
12
            v[p] = (y - (((z >> 5 ^ (v[(p+1) % n] << 2)) + (v[(p+1) % n] >> 3 ^ (z << 4))) ^ ((sum_ ^ v[(p+1) % n]) + (key[(p & 3) ^ e] ^ z)))) & 0xFFFFFFFF
13
        sum_ = (sum_ - delta) & 0xFFFFFFFF
14
        q -= 1
15
    return v
16

17
# v15: main 函数里的常量数组（10个 32-bit）
18
v15 = [
19
    1566723124,
20
    -2044068179,
21
    -1659816037,
22
    -53136879,
23
    1175413710,
24
    -981373336,
25
    -28114771,
26
    167777774,
27
    -1744380997,
28
    -280353208
29
]
30

31

32
v15 = [x & 0xFFFFFFFF for x in v15]
33

34
# key 的两个部分
35
key_low  = 0x12345678
36
key_high = 0x9ABCDEF0
37
final_low  = 1667592045
38
final_high = 555837044
39

40

41
key = [final_low, final_high, key_low, key_high]
42

43
# 解密
44
dec = xxtea_decrypt_uint32(v15[:], key)
45
plain = b''.join(x.to_bytes(4, 'little') for x in dec)
46

47
print("解密结果：", plain.decode(errors="ignore"))

moectf{X7e4_And_xx7EA_I5_BeautifuL!!!!!}

19 rusty_sudoku#

shift+F12 查看字符串

点进去看到

通过交叉引用，定位到rusty_sudoku::main函数

分析函数以及在字符串中看到的提示，就是找到一个正确的9*9数独，再回到字符串视图页面，发现有一个未补全的数独，点进去看到完整的数独

使用在线工具

将 369184572185327694274956831632879415897541263541632789756213948918465327423798156 作为程序的输入

moectf{a8c79927d4e830c3fe52e79f410216a0}

01 speed#

IDA定位主函数，发现返回到WinMain函数里

打开该函数，这个函数注册了一个窗口，只显示1秒，就立即销毁，真正的逻辑在WndProc里

打开WndProc函数

加密算法为RC4，密钥 (key): “mylittlepony”

密文

1
def rc4_crypt(key: bytes, data: bytes) -> bytes:
2
    # simple RC4 (KSA + PRGA)
3
    S = list(range(256))
4
    j = 0
5
    # KSA
6
    for i in range(256):
7
        j = (j + S[i] + key[i % len(key)]) & 0xFF
8
        S[i], S[j] = S[j], S[i]
9
    # PRGA
10
    i = 0
11
    j = 0
12
    out = bytearray(len(data))
13
    for idx in range(len(data)):
14
        i = (i + 1) & 0xFF
15
        j = (j + S[i]) & 0xFF
16
        S[i], S[j] = S[j], S[i]
17
        K = S[(S[i] + S[j]) & 0xFF]
18
        out[idx] = data[idx] ^ K
19
    return bytes(out)
20

21
def main():
22
    key = b"mylittlepony"
23
    str_part = (0x07F1B3E885EF9160).to_bytes(8, "little")
24

25

26
    v25 = (0x2CD336BCB0464A89).to_bytes(8, "little")
27

28

29
    v26 = bytearray((0xEF5FC91642917EE1).to_bytes(8, "little"))
30

31

32
    overwrite = (0x739D40A4E356EF5F).to_bytes(8, "little")
33

34
    v26[6:6+8] = overwrite
35

36
    cipher_bytes = str_part + v25 + bytes(v26)
37

38
    plaintext = rc4_crypt(key, cipher_bytes)
39

40
    print("raw decrypted bytes:", plaintext)
41
    try:
42
        s = plaintext.decode("utf-8")
43
    except UnicodeDecodeError:
44
        s = plaintext.decode("utf-8", errors="ignore")
45
    print("decoded (utf-8, ignoring errors):")
46
    print(s)
47

48
if __name__ == "__main__":
49
    main()

moectf{Just_dyn@mic_d3bugg1ng}

04 catch#

定位主函数，

打开solve函数

看到提示，打开sub_114514()函数

发现是根据enc函数进行加密

flag字符串为

enc函数就是一个简单的异或

异或结果为

显然不是我么们的flag，回到刚才的提示flag就藏在项目里，我们查看字符串看到可疑对象

使用解码工具一键解码

Rot13解码: moectf{S4m3_Tr1ck_with_@flower_desuwa}

12 have_fun#

点开WinMain函数，是一个典型的 Win32 GUI 程序入口（WinMain）的反编译版

入口 WinMain 很模板化，实质逻辑都在 sub_140001210

分别查看sub_7FF681721420函数与DialogFunc函数，发现前者是空壳，真正的加密逻辑在DialogFunc里

输入长度为16

对每个字符做异或

把异或后的结果 v23 与目标常量比较

目标常量为[‘G’,‘E’,‘O’,‘I’,’^’,‘L’,‘Q’,‘b’,‘j’,’\’, 0x1E, ‘u’,‘L’, 0x7F,‘D’,‘W’]

解密

1
# 只需改这里：把 .rdata 里目标串的 16 个字节（低 8 位）填进来
2
target = [
3
    0x47, 0x45, 0x4F, 0x49, 0x5E, 0x4C, 0x51, 0x62,
4
    0x6A, 0x5C, 0x1E, 0x75, 0x4C, 0x7F, 0x44, 0x57
5
]
6

7
flag = ''.join(chr((b ^ 0x2A) & 0xFF) for b in target)
8
print(flag)  # -> moectf{H@v4_fUn}

moectf{H@v4_fUn}

07 ezandroid#

在AndroidManifest.xml找到android com.example.ezandroid.MainActivity

在源代码里按照路径打开com.example.ezandroid.MainActivity

是一个base64编码，字符串为bW9lY3Rme2FuZHJvaWRfUmV2ZXJzZV9JNV9lYXN5fQ==

moectf{android_Reverse_I5_easy}

18 ezandroid.pro#

用jdax打开这个apk文件

定位到AndroidManifest.xml，在其中找到android

按照此路径在源代码中打开

Java 层只做了长度检查（32）和 check(str) 的调用；真正判定逻辑在 native 库 libezandroidpro.so

把apk后缀名改为zip

在ida中打开libezandroidpro.so

定位到Java_com_example_ezandroidpro_MainActivity_check函数

是一个sm4—ECB加密，密钥是moectf2025!!!!!!

明文4EEB1EEF2914D79BFA8C5006332097ED2EF06C4A59CAE31C827A08D45CC649C0B971BF2EFBCB160E531A646DF7A6AC0B

moectf{SM4_Android_I5_Funing!!!}

05 upx#

用die打开有upx加壳

用upx脱壳

脱壳完成在ida中打开，定位主函数

字符串长度为35

加密过程

要加密的数据（按顺序）

脚本

1
def reverse_decrypt(encrypted_data):
2

3
    decrypted = []
4

5
    for i in range(len(encrypted_data)):
6
        if i == 0:
7
            # 第一个字符已知是 'm' (moectf的开头)
8
            first_char = ord('m')
9
            decrypted.append(first_char)
10
        else:
11
            # 使用链式XOR解密公式
12
            prev_encrypted = encrypted_data[i-1]  # 前一个加密字节
13
            prev_decrypted = decrypted[i-1]       # 前一个解密字节
14
            current_char = prev_encrypted ^ prev_decrypted ^ 0x21
15
            decrypted.append(current_char)
16

17
    return bytes(decrypted)
18

19
def encrypt_for_verification(plaintext):
20

21
    plaintext_bytes = plaintext.encode('ascii')
22
    encrypted = []
23

24
    for i in range(len(plaintext_bytes) - 1):
25
        # 加密公式: encrypted[i] = (plaintext[i] ^ 0x21) ^ plaintext[i+1]
26
        enc_byte = (plaintext_bytes[i] ^ 0x21) ^ plaintext_bytes[i+1]
27
        encrypted.append(enc_byte)
28

29
    return encrypted
30

31
def solve_moe_exe():
32

33
    print("=== moe.exe CTF题目解密算法 ===")
34
    print("题目类型: UPX脱壳 + 自定义XOR加密")
35
    print()
36

37

38
    complete_encrypted_data = [
39
        0x23, 0x2B, 0x27, 0x36, 0x33, 0x3C, 0x03, 0x48, 0x64, 0x0B, 0x1D, 0x76,
40
        0x7B, 0x10, 0x0B, 0x3A, 0x3F, 0x65, 0x76, 0x29, 0x15, 0x37, 0x1C, 0x0A,
41
        0x08, 0x21, 0x3E, 0x3C, 0x3D, 0x16, 0x0B, 0x24, 0x29, 0x24
42
    ]
43

44
    print(f"加密数据长度: {len(complete_encrypted_data)} 字节")
45
    print("加密数据 (16进制):")
46
    for i in range(0, len(complete_encrypted_data), 16):
47
        chunk = complete_encrypted_data[i:i+16]
48
        hex_str = ' '.join(f'{b:02X}' for b in chunk)
49
        print(f"  {hex_str}")
50
    print()
51

52
    # 执行解密
53
    print("开始解密...")
54
    decrypted_bytes = reverse_decrypt(complete_encrypted_data)
55

56
    # 转换为字符串
57
    try:
58
        decrypted_str = decrypted_bytes.decode('ascii')
59
        print(f"解密结果: {decrypted_str}")
60
    except UnicodeDecodeError:
61
        print("解密结果包含非ASCII字符，显示原始字节:")
62
        print(decrypted_bytes)
63
        return None
64

65
    # 检查并修正flag格式
66
    if decrypted_str.startswith('moectf{') and not decrypted_str.endswith('}'):
67
        # 手动添加结尾的'}'
68
        final_flag = decrypted_str + '}'
69
        print(f"修正后的flag: {final_flag}")
70
    else:
71
        final_flag = decrypted_str
72

73
    # 验证flag格式
74
    if final_flag.startswith('moectf{') and final_flag.endswith('}'):
75
        print("✅ Flag格式正确!")
76

77
        if 'upx' in final_flag.lower():
78
            print("🎯 包含UPX关键词，符合题目背景!")
79

80
        return final_flag
81
    else:
82
        print("❌ Flag格式不正确")
83
        return None
84

85
def demo_step_by_step():
86
    """
87
    演示解密过程的每一步
88
    """
89
    print("\n=== 逐步解密演示 ===")
90

91
    # 使用前10字节进行演示
92
    demo_data = [0x23, 0x2B, 0x27, 0x36, 0x33, 0x3C, 0x03, 0x48, 0x64, 0x0B]
93

94
    print("演示数据:", ' '.join(f'{b:02X}' for b in demo_data))
95
    print()
96

97
    decrypted = []
98

99
    for i in range(len(demo_data)):
100
        if i == 0:
101
            # 第一个字符
102
            char = ord('m')
103
            decrypted.append(char)
104
            print(f"步骤 {i+1}: 第一个字符已知 = 'm' (0x{char:02X})")
105
        else:
106
            # 后续字符的解密
107
            prev_encrypted = demo_data[i-1]
108
            prev_decrypted = decrypted[i-1]
109
            current_char = prev_encrypted ^ prev_decrypted ^ 0x21
110
            decrypted.append(current_char)
111

112
            char_display = chr(current_char) if 32 <= current_char <= 126 else f'\\x{current_char:02x}'
113
            print(f"步骤 {i+1}: {prev_encrypted:02X} ^ {prev_decrypted:02X} ^ 21 = {current_char:02X} ('{char_display}')")
114

115
    # 显示部分结果
116
    partial_result = bytes(decrypted).decode('ascii', errors='ignore')
117
    print(f"\n部分解密结果: {partial_result}")
118

119
def main():
120
    """
121
    主函数 - 执行完整的解密流程
122
    """
123
    print("moe.exe CTF题目完整解密算法")
124
    print("=" * 50)
125

126
    # 1. 执行解密
127
    final_flag = solve_moe_exe()
128

129
    if final_flag:
130
        print(f"\n🏆 最终Flag: {final_flag}")
131

132
        # 2. 演示解密步骤
133
        demo_step_by_step()
134

135
        print("\n" + "=" * 50)
136
        print("解密完成!")
137
        print(f"Flag: {final_flag}")
138
        print("题目类型: UPX脱壳 + 自定义XOR加密算法逆向")
139
        print("=" * 50)
140

141
        return final_flag
142
    else:
143
        print("\n❌ 解密失败")
144
        return None
145

146
if __name__ == "__main__":
147
    main()

moectf{Y0u_c4n_unp4ck_It_vvith_upx}

06 ez3#

ida中打开定位到主函数

flag长度为42

真正的加密逻辑在check（）

点开

脚本

1
#!/usr/bin/env python3
2
# -*- coding: utf-8 -*
3

4
MOD = 51966
5
MUL = 47806
6
XOR_VAL = 0x114514
7
LEN = 34
8

9
# expected 数组（你给出的值）
10
a = [
11
    0x0B1B0, 0x5678, 0x7FF2, 0xA332, 0xA0E8, 0x364C, 0x2BD4,
12
    0xC8FE, 0x4A7C, 0x18, 0x2BE4, 0x4144, 0x3BA6, 0xBE8C, 0x8F7E,
13
    0x35F8, 0x61AA, 0x2B4A, 0x6828, 0xB39E, 0xB542, 0x33EC, 0xC7D8,
14
    0x448C, 0x9310, 0x8808, 0xADD4, 0x3CC2, 0x796, 0xC940, 0x4E32,
15
    0x4E2E, 0x924A, 0x5B5C
16
]
17

18
def compute_b(ch: int, i: int, prev_b: int|None) -> int:
19
    tmp = MUL * (ch + i)
20
    if prev_b is not None:
21
        tmp ^= (prev_b ^ XOR_VAL)
22
    return tmp % MOD
23

24
# 优先级：'_' 最优，接着 数字，再字母，最后其他可打印字符
25
def candidate_priority(ch: int):
26
    c = chr(ch)
27
    if c == '_':
28
        return 0
29
    if c.isdigit():
30
        return 1
31
    if c.isalpha():
32
        return 2
33
    if 32 <= ch < 127:
34
        return 3
35
    return 4
36

37
def gen_candidates(pos: int, prev_b: int|None, byte_range=range(32,127)):
38
    t = a[pos]
39
    cands = []
40
    for ch in byte_range:
41
        if compute_b(ch, pos, prev_b) == t:
42
            cands.append(ch)
43
    # 按优先级排序（数字优先于字母）
44
    cands.sort(key=lambda x: (candidate_priority(x), x))
45
    return cands
46

47
# DFS 回溯，返回若干候选解（按优先级）
48
def dfs_find(byte_range=range(32,127), max_solutions=20):
49
    solutions = []
50
    stack = [(0, None, [])]  # pos, prev_b, bytes_list
51

52
    while stack and len(solutions) < max_solutions:
53
        pos, prev_b, cur = stack.pop()
54
        if pos == LEN:
55
            solutions.append(bytes(cur))
56
            continue
57

58
        cands = gen_candidates(pos, prev_b, byte_range)
59
        # 逆序压栈，确保优先级高的先弹出
60
        for ch in reversed(cands):
61
            new_b = compute_b(ch, pos, prev_b)
62
            stack.append((pos + 1, new_b, cur + [ch]))
63

64
    return solutions
65

66
def main():
67
    print("开始回溯求解（数字优先于字母）...")
68
    sols = dfs_find(range(32,127), max_solutions=20)
69
    if not sols:
70
        print("未在可打印 ASCII 找到解，请尝试全字节范围。")
71
        return
72

73
    for i, s in enumerate(sols):
74
        try:
75
            text = s.decode('ascii')
76
        except:
77
            text = s.decode('latin1')
78
        print(f"[{i}] 候选：{text}")
79
        print("    完整 flag:", "moectf{" + text + "}")
80

81
    print("\n建议第一个候选通常为正确结果：")
82
    best = sols[0].decode('ascii', errors='replace')
83
    print("最终 flag:", "moectf{" + best + "}")
84

85
if __name__ == "__main__":
86
    main()

moectf{Y0u_Kn0w_z3_S0Iv3r_N0w_a1f2bdce4a9}

16 A simple program#

ida中打开，定位到main函数

输入到str1中，并与str2对比，相等就输出correct，否则输出wrong，但这个主函数并没有什么校验函数，根据题目提示“falg就在主函数里”，查看字符串

上面的moectf是假的flag，下面的数据组就是校验数组，点开这个函数

正如我们所料，对这个数组的数据进行异或，写个脚本

1
ARR = [
2
    0x4E, 0x4C, 0x46, 0x40, 0x57, 0x45, 0x58, 0x7A, 0x13, 0x56,
3
    0x7C, 0x73, 0x17, 0x50, 0x50, 0x66, 0x47, 0x02, 0x02, 0x5E
4
]
5

6
flag = bytes(b ^ 0x23 for b in ARR).decode('ascii')
7
print(flag)  # moectf{Y0u_P4ssEd!!}

moectf{Y0u_P4ssEd!!}

08 flower#

IDA定位到主函数

点击slove函数，有栈堆不平衡

定位到这个位置，发现有花指令，还有函数边界问题

先修改花指令

之后修改函数边界对着冒红行摁u

之后正常反汇编，查看slove函数，找到最主要的一步

encode函数以及enc和key，其中正确的初始key很关键

脚本

1
import string
2

3
# enc 常量表（32 个）
4
enc = [
5
    0x4F, 0x1A, 0x59, 0x1F, 0x5B, 0x1D, 0x5D, 0x6F,
6
    0x7B, 0x47, 0x7E, 0x44, 0x6A, 0x07, 0x59, 0x67,
7
    0x0E, 0x52, 0x08, 0x63, 0x5C, 0x1A, 0x52, 0x1F,
8
    0x20, 0x7B, 0x21, 0x77, 0x70, 0x25, 0x74, 0x2B,
9
]
10

11
PRINTABLE = set(string.printable) - set("\r\n\t\x0b\x0c")
12

13
def decode_with_key(enc, key):
14
    # s[i] = enc[i] ^ (key + i)
15
    bs = [(e ^ ((key + i) & 0xFF)) & 0xFF for i, e in enumerate(enc)]
16
    return ''.join(chr(b) for b in bs)
17

18
def looks_good(s):
19
    # 1) 全可打印  2) 不含控制字符  3) 基本可读
20
    return all(ch in PRINTABLE for ch in s)
21

22
candidates = []
23
for key in range(256):
24
    inner = decode_with_key(enc, key)
25
    if looks_good(inner):
26
        candidates.append((key, inner))
27

28
# 输出候选 key 及解码结果
29
for key, inner in candidates:
30
    print(f"key=0x{key:02X} -> {inner}")
31

32
# 通常只有极少数候选；从可读性判断最佳那个

moectf{f0r3v3r_JuMp_1n_7h3_a$m_a9b35c3c}

14 upx_revenge#

我们只需要在4.24.后面插入UPX!就可以正常脱壳了

脱壳

IDA打开，分析主函数，最主要的在这

去分析sub_7FF6BA531230 sub_7FF6BA531300两个函数

sub_7FF6BA531230 是对标准表进行异或14，sub_7FF6BA531300是调用这个表进行Base64编码

异或后的表

1
GMLQOJPI^DXHZSBUT[ARCYV-KWEN]@F\\(>JD=MLZSIWPHGYAQBEOU)TNVurqpcjgmlhfnadkbisoetv(zyx,0w.4-2863q1)5?9+7

只需要输入的字符串用这个表进行Base64编码与硬字符串lY7bW=\ck?eyjX7]TZ\}CVbh\tOyTH6>jH7XmFifG]H7对比

脚本

1
standard_table = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
2

3
encoded = "lY7bW=\\ck?eyjX7]TZ\\}CVbh\\tOyTH6>jH7XmFifG]H7".replace("\\\\", "\\")  # 处理转义
4

5
# 生成自定义表
6
custom_table = ''.join(chr(ord(c) ^ 0xE) for c in standard_table)
7

8
# 创建映射: char -> index
9
char_to_index = {custom_table[i]: i for i in range(64)}
10

11
# 解码
12
flag_bytes = []
13
for i in range(len(encoded) // 4):
14
    group = encoded[i*4:i*4+4]
15
    indices = [char_to_index[c] for c in group]
16
    value = (indices[0] << 18) | (indices[1] << 12) | (indices[2] << 6) | indices[3]
17
    flag_bytes.append(value >> 16 & 0xFF)
18
    flag_bytes.append(value >> 8 & 0xFF)
19
    flag_bytes.append(value & 0xFF)
20

21
flag = ''.join(chr(b) for b in flag_bytes)
22

23
print("Flag:", flag)

moectf{Y0u_Re4l1y_G00d_4t_Upx!!!}

15 guess#

IDA打开，定位到主函数，无法反编译

定位到140001A5A，有花指令

改成单条无条件跳转，其余全部nop

ok，可以成功反编译

分析函数行为，是一个猜谜游戏，主要的逻辑在这里，看名字知道是RC4算法

点进去，主要逻辑在rc4_ksa和rc4_prga

分别点进去查看，先看ksa，比正常RC4相比密钥要加常数42

再看prga是一个标准的

接下来我们是找key和enc，shift+F12

脚本

1
from binascii import unhexlify
2

3
def rc4_with_plus42(data: bytes, key: bytes) -> bytes:
4
    # === KSA 带 +42 ===
5
    S = list(range(256))
6
    j = 0
7
    for i in range(256):
8
        k = (key[i % len(key)] + 42) & 0xFF
9
        j = (j + S[i] + k) & 0xFF
10
        S[i], S[j] = S[j], S[i]
11

12
    # === PRGA 标准 ===
13
    i = j = 0
14
    out = bytearray()
15
    for b in data:
16
        i = (i + 1) & 0xFF
17
        j = (j + S[i]) & 0xFF
18
        S[i], S[j] = S[j], S[i]
19
        K = S[(S[i] + S[j]) & 0xFF]
20
        out.append(b ^ K)
21
    return bytes(out)
22

23
enc_hex = "464DCF81DE6F2E16BE203F10565CCDBFF18CCD6A45967D20DC558FB76C0CC3AE07D154"
24
key_str = "moectf2025"
25

26
cipher = unhexlify(enc_hex)
27
plain = rc4_with_plus42(cipher, key_str.encode())
28

29
print("moectf{" + plain.decode(errors="ignore") + "}")

moectf{RrRRccCc44$$_w1th_fl0w3r!!_3c6a11b5}

09 2048_master_re#

这道题是一个窗口游戏题，有两种解题思路

一种是HOOK,另一种是直接逆向解密

先说逆向解密，在字符串中找到这个

点开，是一个flag校验函数，它从 flag.txt 中读取字符串，经过某种加密/变换后，与内置的字节数组 byte_495280 进行比对，若完全一致则返回 0（正确），否则返回 1（错误）。

去查看加密函数sub_401A81

sub_401898：按小端把明文每 4 字节打包成 uint32_t 数组，长度 Count=(len+3)//4，没有额外写入原始长度；

sub_401530：标准 BTEA/XXTEA，delta = 1050114489 (0x3E9779B9)，key 为 16 字节，索引 (p^e)&3；

sub_40195B：把 uint32_t[] 原样拆回字节（每个 dword → 两个 _WORD），最终输出字节数 a3 = 4Count。

脚本

1
from typing import List
2

3
DELTA = 0x3E9779B9
4

5
def to_u32_le_blocks(b: bytes) -> List[int]:
6
    pad = (-len(b)) % 4
7
    b += b'\x00' * pad
8
    return [int.from_bytes(b[i:i+4], 'little') for i in range(0, len(b), 4)]
9

10
def from_u32_le_blocks(v: List[int]) -> bytes:
11
    return b''.join(x.to_bytes(4, 'little') for x in v)
12

13
def btea(v: List[int], n: int, k: List[int]) -> None:
14
    """XXTEA/BTEA inplace; n>1 加密，n<-1 解密"""
15
    if n > 1:
16
        rounds = 6 + 52 // n
17
        _sum = 0
18
        z = v[n - 1]
19
        for _ in range(rounds):
20
            _sum = (_sum + DELTA) & 0xFFFFFFFF
21
            e = (_sum >> 2) & 3
22
            for p in range(n - 1):
23
                y = v[p + 1]
24
                v[p] = (v[p] + ((((z >> 5) ^ (y << 2)) + ((y >> 3) ^ (z << 4)))
25
                                ^ ((_sum ^ y) + (k[(p ^ e) & 3] ^ z)))) & 0xFFFFFFFF
26
                z = v[p]
27
            p = n - 1
28
            y = v[0]
29
            v[p] = (v[p] + ((((z >> 5) ^ (y << 2)) + ((y >> 3) ^ (z << 4)))
30
                            ^ ((_sum ^ y) + (k[(p ^ e) & 3] ^ z)))) & 0xFFFFFFFF
31
            z = v[p]
32
    elif n < -1:
33
        n = -n
34
        rounds = 6 + 52 // n
35
        _sum = (rounds * DELTA) & 0xFFFFFFFF
36
        y = v[0]
37
        while rounds > 0:
38
            e = (_sum >> 2) & 3
39
            for p in range(n - 1, 0, -1):
40
                z = v[p - 1]
41
                v[p] = (v[p] - ((((z >> 5) ^ (y << 2)) + ((y >> 3) ^ (z << 4)))
42
                                ^ ((_sum ^ y) + (k[(p ^ e) & 3] ^ z)))) & 0xFFFFFFFF
43
                y = v[p]
44
            p = 0
45
            z = v[n - 1]
46
            v[0] = (v[0] - ((((z >> 5) ^ (y << 2)) + ((y >> 3) ^ (z << 4)))
47
                            ^ ((_sum ^ y) + (k[(p ^ e) & 3] ^ z)))) & 0xFFFFFFFF
48
            y = v[0]
49
            _sum = (_sum - DELTA) & 0xFFFFFFFF
50
            rounds -= 1
51

52
# ==== 数据区 ====
53

54
# 全局密文 byte_495280（注意这里只取前 40 字节，其余是 0 padding，不参与校验）
55
cipher_bytes = bytes([
56
    0x35,0x79,0x77,0xCC,0x1B,0x13,0x41,0x34,
57
    0xF9,0xFF,0x9F,0x91,0xFF,0x5B,0x94,0x78,
58
    0x86,0x2A,0xAF,0xAE,0xD7,0x9E,0x31,0x4D,
59
    0x7A,0xC4,0xA5,0x51,0xD1,0xD9,0x6E,0x44,
60
    0x18,0x52,0x86,0x1B,0x42,0x8A,0xC9,0x63,
61
])
62

63
# key = "2048master2048ma" → 拆成 4 个小端 uint32
64
key_words = [
65
    int.from_bytes(b"2048", "little"),
66
    int.from_bytes(b"mast", "little"),
67
    int.from_bytes(b"er20", "little"),
68
    int.from_bytes(b"48ma", "little"),
69
]
70

71
# ==== 解密流程 ====
72
v = to_u32_le_blocks(cipher_bytes)
73
btea(v, -len(v), key_words)
74
plain = from_u32_le_blocks(v)
75

76
# 原始 flag 长度 = 37
77
flag = plain[:37].decode(errors="ignore")
78
print("Flag:", flag)

moectf{@_N1c3_cup_0f_XXL_te4_1n_2O48}